Kürzlich sagte ein Freund, dass er sagen wollte, dass er kürzlich Java lernte. Er verstand immer noch nicht objektorientierte Programmiersprachen. Um ihm zu helfen, schneller zu "transformieren", habe ich diesen Artikel geschrieben. Denn aus dem Aufbaustruktur. Die Ideen aller objektorientierten Programmiersprachen sind ähnlich, und diese drei Eigenschaften sind die Säulen im Denken. Als nächstes werde ich mich darauf konzentrieren, die drei Hauptmerkmale von Java zu erklären.
Eine objektorientierte Programmiersprache hat drei Hauptmerkmale: "Kapselung", "Vererbung" und "Polymorphismus".
Paket
Bei der objektorientierten Programmierung ist die Kapselung (Kapselung) buchstäblich die Bedeutung der Verpackung, dh die Verwendung abstrakter Datentypen zur Zusammenkapselung von Daten und datenbasierten Operationen zusammen, was sie zu einer untrennbaren unabhängigen Entität macht. In der Tat soll die Methoden und Daten zusammengefasst werden, damit das Objekt im Programm ausgeführt werden soll, um seine Schnittstelle zu veröffentlichen. Die Daten sind innerhalb des abstrakten Datentyps geschützt, verbergen interne Details so weit wie möglich und behalten nur einige externe Schnittstellen bei, damit sie die Außenseite kontaktiert. Mit anderen Worten, der Benutzer muss die Details innerhalb des Objekts nicht kennen (natürlich gibt es keine Möglichkeit, es zu wissen), aber auf das Objekt kann über die vom Objekt nach außen bereitgestellte Schnittstelle zugegriffen werden. In den Laien -Begriffen müssen andere Objekte, die an diese Schnittstellen angehängt sind, nicht um die Implementierung des Objekts zur Verwendung dieses Objekts kümmern. Das Konzept lautet: "Sag mir nicht, wie du es gemacht hast, mach es einfach."
Daher privatisiert die Kapselung die Eigenschaften eines Objekts und bietet einige Attribute Methoden, auf die die äußere Welt zugegriffen werden kann. Wenn wir nicht von der Außenwelt zugreifen möchten, müssen wir keine Methoden zur Verfügung stellen, um von der Außenwelt zugreifen zu können. Wenn eine Klasse jedoch keine Methoden für die Außenwelt zur Verfügung stellt, hat diese Klasse keine Bedeutung.
Zum Beispiel betrachten wir ein Objekt als Haus, und die schönen Hintergrundbilder wie Sofas, Fernseher, Klimaanlagen usw. sind alle private Eigenschaften des Hauses, aber wenn es keine Wandabdeckung gibt, gibt es überhaupt keine Privatsphäre! Aufgrund der blockierenden Wand können wir nicht nur unsere eigene Privatsphäre haben, sondern auch die Innenausstattung nach Belieben ändern, ohne andere zu beeinflussen. Aber wenn es keine Türen und Fenster gibt, was bedeutet dann eine dicht verpackte schwarze Box? Daher können andere auch die Landschaft durch Türen und Fenster innen sehen. Daher sind Türen und Fenster die Schnittstellen, die vom Objekt des Hauses hinterlassen werden, damit die Außenwelt zugreifen kann.
Im Allgemeinen sollte der private Modifikator vor dem Attribut in der Klasse hinzugefügt werden. Definieren Sie dann die Getter- und Setter -Methoden. Anschließend können die Objekte in unserer Hauptfunktion keine Eigenschaften mehr direkt aufrufen und nur durch Getter- und Setter -Methoden aufgerufen werden.
Drei Vorteile der Verpackung
1. Ein gutes Paket kann die Kopplung verringern.
2. Die Struktur innerhalb der Klasse kann frei modifiziert werden.
3. Eine genauere Kontrolle der Mitglieder kann gegeben werden.
16. Informationen ausblenden und Details implementieren.
Modifikator
Zunächst müssen Sie verstehen, was ein Modifikator ist. Zugriffsmodifikatoren können verwendet werden, um den Zugriffsbereich von Attributen und Methoden zu ändern.
Im objektorientierten Prozess verwenden wir die Berechtigungsregelung, um der eingekapselten Klasse Berechtigungen hinzuzufügen, um die Manipulation der Klasse durch die Außenstehende einzuschränken, um die Sicherheit von Daten und Methoden in der Klasse sicherzustellen. Es kann gesagt werden, dass eine Klasse eine logische Entität ist, die verwandte Attribute und Methoden zusammenfasst. Für bestimmte Eigenschaften oder Methoden in einem Objekt können sie privat sein und von der Außenwelt nicht zugänglich sein. Es kann auch geteilt und von jedem Außenseiter zugegriffen werden. Auf diese Weise bieten Objekte unterschiedliche Schutzstufen für interne Daten, um zu verhindern, dass nicht verwandte Teile des Programms versehentlich geändert oder private Teile des Objekts falsch verwendet werden, was dazu führt, dass im Programm unnötige Fehler auftreten.
Die Modifikatoren in Java sind öffentlich, geschützt, standardmäßig und privat. Dies zeigt die objektorientierte Kapselung, und wir müssen unser Bestes geben, um die Berechtigungen zu minimieren, um die Sicherheit zu verbessern.
Wie in der Abbildung gezeigt, stellt es den Zugriffsbereich verschiedener Zugriffsmodifikatoren dar, wie z. Wenn kein Modifikator hinzugefügt wird, ist Standardeinstellung Standard und kann in der aktuellen Klasse und demselben Paket standardmäßig zugegriffen und standardmäßig verwendet werden.
Zugriff auf Berechtigungen Klassenbrötchen Unterklasse Andere Pakete
public ∨ ∨ ∨ ∨ ∨ ∨
Schützen Sie ∨ ∨ ∨ ×
Standard ∨ ∨ × ×
Privat ∨ × × × ×
Wenn vor dem Attribut kein Modifikator hinzugefügt wird, ist die Standardgenehmigung standardmäßig. Wir können den Attributwert direkt ändern, indem wir ein Objekt erstellen, und die Einkapselungseigenschaften werden nicht reflektiert. Dies ist bei der Programmierung nicht sicher, daher müssen wir die Kapselung verwenden, um unseren Code zu verbessern.
Beispiel für Modifikatoren
Zunächst definieren wir vier Klassen Person, Eltern, Lehrer, Schüler und vergleichen die Unterschiede zwischen anderen Paketen, Unterklassen, Paketen und dieser Klasse. Das Standortdiagramm jeder Klasse wird angezeigt.
Paket com.java.test; public class Person {public String name = "Zhang san"; public void intucemyself () {System.out.println (Name); }}Der Name ist öffentlich. Wenn die Zusammenstellung kein Fehler gibt, bedeutet dies, dass die öffentliche Variable Zugriff auf diese Klasse hat.
paket com.java.test; public class student {Person p = new Person (); public void test () {System.out.println (p.uname); }}Schüler und Person sind im selben Paket. Wenn es keinen Fehler in der Kompilierung gibt, bedeutet dies, dass die Variable Zugriffsrechte im selben Paket enthält.
Paket com.java.test1; import com.java.test.person; öffentlicher Klasse Lehrer erweitert die Person {public int age; Person p = neue Person (); public void test1 () {System.out.println (p.uname); }}Schüler und Person sind nicht im selben Paket, sondern der Lehrer erbt die Personklasse. Wenn die Kompilierung kein Fehler gibt, bedeutet dies, dass die Variable Zugriffsrechte im Unterpackung enthält.
Paket com.java.test1; import com.java.test.person; public class Eltern {public String uname = "haha"; Person p = neue Person (); public void test2 () {System.out.println (p.uname); }}Elternteil und Person sind nicht im selben Paket. Wenn die Kompilierung keinen Fehler gibt, bedeutet dies, dass die Variable keine Zugriffsberechtigungen hat.
Nach dem obigen Test bedeutet dies, dass die mit der Öffentlichkeit geänderten Klassen in dieser Klasse, demselben Paket, der Unterklasse und anderen Paketen aufeinander zugreifen können.
Wir begannen auch, das geschützte Erlaubnisproblem zu testen. Wenn Person, Lehrer und Schüler kompilieren und passieren können, bedeutet dies, dass mit geschützten Klassen in dieser Klasse, demselben Paket und der Unterklassen auf einander zugreifen können. Wenn Eltern nicht kompiliert und nicht passieren, bedeutet dies, dass geschützter Schutz in Klassen ohne Erbschaftsbeziehungen außerhalb des Pakets nicht auf gegenseitig zugreifen kann.
Testen Sie auch das Problem mit der Standardberechtigung. Wenn Person und Schüler kompilieren und übergeben können, bedeutet dies, dass die mit Standardmodifizierung geänderten Klassen in dieser Klasse, demselben Paket und den Unterklassen aufeinander zugreifen können. Eltern und Lehrerkompilieren, ohne die Eltern- und Lehrerklasse zu verabschieden, können nicht auf einander zugreifen, unabhängig davon, ob es eine Erbschaftsbeziehung gibt.
Wir haben auch angefangen, das private Erlaubnisproblem zu testen. Wenn Person zusammengestellt und bestanden werden kann, bedeutet dies, dass in dieser Klasse, gleichen Paket und Unterklassen mit privaten Klassen geändert werden können. Elternteil, Lehrer und Schüler können nicht kompilieren, ohne das Privat zu verabschieden, um anzuzeigen, dass mit privaten Klassen nur in dieser Klasse zugegriffen werden können.
Im Allgemeinen sollten private Modifikatoren vor den Attributen in der Klasse hinzugefügt werden. Definieren Sie dann die Getter- und Setter -Methoden. Anschließend können die Objekte in unserer Hauptfunktion keine Eigenschaften mehr direkt aufrufen und nur durch Getter- und Setter -Methoden aufgerufen werden.
Tasche
Lassen Sie mich Ihnen die Funktion der Tasche sagen
Manchmal können wir das Konzept des Pakets verwenden, um unser Problem zu lösen, wenn Sie auf den Klassennamen des Programms stoßen. Der Zweck des Pakets besteht darin, Java -Dateien zu verwalten und Konflikte von Dateien mit demselben Namen zu lösen. Dies ähnelt einer Garderobe. Haben wir unterschiedliche Partitionen und Schubladen in der Garderobe? Wir platzieren die Kleidung getrennt in verschiedenen Kategorien, was für unser Management förderlicher ist.
Um ein Paket zu definieren, verwenden wir das Paket -Keyword sowie unseren Paketnamen.
Paket com.java.test; // Hinweis: Es muss in der ersten Zeile des Quellprogramms platziert werden, und der Paketname kann durch das "" getrennt werden. Zeichen. Die Benennungsspezifikation des Pakets ist mit allen Kleinbuchstaben geschrieben.
Häufig verwendete Pakete im Java -System
Java. (Funktion). (Klasse) Java.lang. (Klasse) enthält die Grundlagen der Java -Sprache Java.util. (Klasse) enthält verschiedene Werkzeugklassen in der Sprache Java.io. (Klasse) Enthält Eingabe- und Ausgabe -zubezogene Klassen enthält Klassen mit den zugehörigen Klassen.
Um die Klasse in einer anderen Datei in verschiedenen Paketen zu verwenden, müssen Sie das Schlüsselwort importieren. Importieren Sie beispielsweise com.java.test1.test.java. Wenn Sie gleichzeitig com.java.test1*importieren, importieren Sie alle Dateien unter das Paket.
Dieses Schlüsselwort
1. Es gibt drei Hauptanwendungen dieses Schlüsselworts:
(1) Dies nennt die Attribute in dieser Klasse, dh die Mitgliedsvariablen in der Klasse;
(2) Dies nennt andere Methoden in dieser Klasse;
(3) Dies ruft andere Konstruktoren in dieser Klasse auf und sollte beim Aufrufen in die erste Zeile des Konstruktors platziert werden.
Public class student {public student (string name) {// einen Konstruktor mit formalen Parametern definieren} public student () {// eine Methode definieren, der Name ist der gleiche wie die Klasse, also ist es der Konstruktor, der ("Hallo!"); } String -Name; // Definieren Sie einen Mitgliedsvariablenname privater void setName (String -Name) {// einen Parameter (lokalen Variablen) Name this.name = name; // Übergeben Sie den Wert der lokalen Variablen an die Mitgliedsvariable}}}Wie im obigen Code gibt es einen member -variablen Namen, und es gibt einen formalen Parameter in der Methode, und der Name ist ebenfalls Name. Dann wird der Wert des formalen Parameternamens in der Methode an den Namen der Mitgliedsvariablen übergeben.
Das Schlüsselwort, das dies darstellt, sind Mitgliedsvariablen oder Methoden im Objekt. Das heißt, wenn mit diesem Schlüsselwort eine Variable hinzugefügt wird, bezieht sie sich eher auf die Mitgliedsvariable oder -methode des Objekts als auf die formalen Parameter oder lokalen Variablen der Mitgliedsmethode. Aus diesem Grund repräsentiert dieser NAME im obigen Code die Mitgliedsvariable im Objekt, auch als Eigenschaften des Objekts bezeichnet, und der folgende Name ist der formale Parameter der Methode. Der Code this.Name = Name soll den Wert des formalen Parameters an die Mitgliedsvariable übergeben.
Wenn es in einer Klasse mehrere Konstruktoren gibt, weil ihre Namen gleich und dem Klassennamen gleich sind, welcher Konstruktor wird dann genannt? Tatsächlich ist dies die gleiche wie andere Methoden, um sich auf Konstruktoren zu beziehen, und sie werden durch formale Parameter aufgerufen. Wie im obigen Beispiel, wenn ein Parameter nach diesem Schlüsselwort hinzugefügt wird, bedeutet dies, dass er sich auf einen Konstruktor mit Parametern bezieht. Wenn es jetzt drei Konstruktionsmethoden gibt, nämlich keine Parameter, ein Parameter und zwei Parameter. Anschließend bestimmt der Java -Compiler, welchen Konstruktor anhand der Anzahl der übergebenen Parameter aufgerufen werden soll. Wie aus dem obigen Beispiel ersichtlich ist, kann dieses Schlüsselwort nicht nur für Referenzvariablen, sondern auch für Referenzkonstruktoren verwendet werden.
Interne Klasse
Die innere Klasse ist von außen sehr leicht zu verstehen. Die interne Klasse soll die Definition einer Klasse in die Definition einer anderen Klasse legen. Natürlich wird eine Klasse, die eine innere Klasse enthält, als äußere Klasse bezeichnet.
Viele Anfänger werden auf jeden Fall fragen, warum eine Klasse in einer anderen Klasse definiert werden sollte.
Manchmal gibt es einige Probleme in unserer Programmierung, die mit Schnittstellen schwer zu lösen sind. Zu diesem Zeitpunkt können wir die Fähigkeit, die interne Klassen bereitzustellen, dazu nutzen, mehrere konkrete oder abstrakte Klassen zu erben, um diese Programmierprobleme zu lösen. Es kann gesagt werden, dass Schnittstellen nur einige Probleme lösen, während interne Klassen die Lösung mehrerer Vererbung vollständiger machen.
In "Think in Java" gibt es einen Satz: Der attraktivste Grund für die Verwendung innerer Klassen ist, dass jede innere Klasse unabhängig eine Implementierung (Schnittstelle) erben kann. Ob die periphere Klasse eine bestimmte Implementierung (Schnittstelle) hat, hat keinen Einfluss auf die innere Klasse.
öffentliche Schnittstelle Vater {} öffentliche Schnittstelle Mutter {} öffentliche Klasse Sohn implementiert Vater, Mutter {} Tochter der öffentlichen Klasse implementiert Vater {Klasse mutter_ implementiert Mutter {}}Interne Klassenfunktionen
1. Die interne Klasse kann mehrere Instanzen verwenden, jede Instanz hat ihre eigenen Zustandsinformationen und ist unabhängig von anderen peripheren Objektinformationen.
2. In einer einzelnen peripheren Klasse können mehrere innere Klassen dieselbe Schnittstelle auf unterschiedliche Weise implementieren oder dieselbe Klasse erben.
3.. Der Moment beim Erstellen eines internen Klassenobjekts hängt nicht von der Erstellung peripherer Klassenobjekte ab.
4.. Es gibt keine verwirrende "is-a" -Beziehung in der internen Klasse, es ist eine unabhängige Einheit.
5. Die innere Klasse bietet eine bessere Kapselung, und auf andere Klassen können mit Ausnahme der peripheren Klasse nicht zugegriffen werden.
Paket com.java.test; öffentliche Klasse äußereClass {private String name; privates int Alter; public String getName () {return name; } public void setName (String -Name) {this.name = name; } public int getage () {return ay; } public void setage (int age) {this.age = älter; } public void display () {System.out.println ("Die Anzeige der äußeren Klasse heißt"); } öffentliche Klasse Innerclass {public InnerClass () {name = "Chenssy"; Alter = 23; } public oterClass getouterClass () {return outclass.this; } public void display () {System.out.println ("Name:" + getName () + "; Alter:" + getage ()); }} public static void main (String [] args) {äußereklasse oberClass = new outerClass (); OuterClass.InnerClass Innerclass = OuterClass.New InnerClass (); Innerclass.display (); InnerClass.getouterClass (). display (); }} Name: Chenssy; Alter: 23Die Anzeige der äußeren Klasse wird genannt
Wir müssen klar sein, dass interne Klassen ein Kompilierungszeitkonzept sind. Sobald sie erfolgreich zusammengestellt wurden, gehören sie zu zwei völlig unterschiedlichen Klassen aus peripheren Klassen (natürlich sind sie immer noch verwandt).
Wir sehen auch, wie man die innere Klasse verweist: Wenn wir uns auf die innere Klasse beziehen, müssen wir den Typ dieses Objekts angeben: äußere. Gleichzeitig müssen wir das externe Klassenobjekt verwenden, um ein inneres Klassenobjekt zu erstellen, um eine innere Klasse durch .New: outerClass.InnerClass Innerclass = OuterClass.New InnerClass () zu erstellen.
Wenn wir gleichzeitig einen Verweis auf das externe Klassenobjekt generieren müssen, können wir den äußeren Klassennamen verwenden, damit wir einen Verweis auf die externe Klasse korrekt generieren können.
In Java sind interne Klassen hauptsächlich in interne Klassen, lokale interne Klassen, anonyme interne Klassen und statische interne Klassen unterteilt.
Interne Klasse
Die interne Klasse ist auch die häufigste interne Klasse. Es ist ein Mitglied der peripheren Klasse, sodass es ohne Einschränkung auf alle Mitgliedattribute und Methoden der peripheren Klasse zugreifen kann. Obwohl es privat ist, wenn die periphere Klasse auf die Mitgliedattribute und -methoden der internen Klasse zugreifen möchte, muss sie über die interne Klasseninstanz zugreifen.
In der internen Mitgliederklasse sollten zwei Punkte beachtet werden.
Es gibt keine statischen Variablen und Methoden in der internen Klasse des Mitglieds.
Die internen Klassen der Mitglieder sind an Peripherieklassen verbunden, sodass interne Klassen nur dann erstellt werden können, wenn zuerst die Peripherieklassen erstellt werden.
öffentliche Klasse OuterClass {private String str; public void oterdisplay () {System.out.println ("äußereClass ..."); } öffentliche Klasse Innerclass {public void innerDisplay () {// Verwenden Sie das Attribut STR in der peripheren Str = "Chenssy ..."; System.out.println (str); // Verwenden Sie die Methode oterdisplay (); }} /*Empfohlen, Getxxx () zu verwenden, um interne Klassen zu erhalten, insbesondere wenn der Konstruktor der inneren Klasse keine Parameter hat } public static void main (String [] args) {äußere klasse äußere = new outerClass (); OuterClass.InnerClass inner = äußere.getInnerClass (); Inner.InnerDisplay (); }}Ich persönlich empfehle, Getxxx () zu verwenden, um die interne Mitgliedsklasse zu erhalten, insbesondere wenn der Konstruktor dieser internen Klasse keine Parameter hat.
Urteil lokale interne Klasse
Lokale interne Klassen sind innerhalb von Methoden und Scopes verschachtelt. Die Verwendung dieser Klasse besteht hauptsächlich darin, relativ komplexe Probleme anzuwenden und zu lösen. Ich möchte eine Klasse erstellen, um unsere Lösung zu unterstützen. Zu diesem Zeitpunkt möchte ich nicht, dass diese Klasse öffentlich ist, damit wir lokale interne Klassen erstellen können.
Lokale innere Klassen werden wie Mitglieder -Innenklassen zusammengestellt. Sie können nur in dieser Methode und diesem Attribut verwendet werden. Wenn sie sich nicht in dieser Methode und Attribut befinden, sind sie ungültig.
In der Methode definiert:
public class parcel5 {public destionation asziel (string str) {class pdestionation implementiert destion {private String -Label; private pdestion (string whireto) {label = whireto; } public String readLabel () {return label; }} return New Pdestion (str); } public static void main (String [] args) {Parcel5 Parcel5 = new Parcel5 (); Destion D = Parcel5.Destionation ("Chenssy"); }}Im Bereich des Umfangs definiert:
public class parcel6 {private void internTracking (boolean b) {if (b) {class TrackingsLip {private String -ID; TrackingsLip (String s) {id = s; } String getLip () {return id; }} TrackingSlip ts = new TrackingsLip ("Chenssy"); String string = ts.getSlip (); }} public void track () {internTracking (true); } public static void main (String [] args) {parcel6 parcel6 = new Parcel6 (); Parcel6.Track (); }}Anonyme interne Klasse
public class oberClass {public InnerClass GetInnerClass (endgültige int num, string str2) {return New InnerClass () {int number = num + 3; public int getNumber () {Rückgabenummer; }}; / * Hinweis: Semikolons können nicht retten */} public static void main (String [] args) {outclass out = new outerClass (); Innerclass inner = out.getInnerClass (2, "Chenssy"); System.out.println (inner.getNumber ()); }} Schnittstelle Innerclass {int getNumber ();}1. Anonyme interne Klassen haben keine Zugriffsmodifikatoren.
2. Eine neue anonyme interne Klasse, diese Klasse muss zuerst existieren. Wenn wir diese Schnittstelle für Innenklassen kommentieren, tritt ein Kompilierungsfehler auf.
3. achten Sie auf die formalen Parameter der GetInnerClass () -Methode. Der erste formale Parameter wird mit endgültig geändert, der zweite nicht. Gleichzeitig stellten wir auch fest, dass der zweite formale Parameter in der anonymen inneren Klasse nicht verwendet wurde. Wenn der formale Parameter der Methode von der anonymen inneren Klasse verwendet werden muss, muss dieser formale Parameter endgültig sein.
4.. Es gibt keinen Konstruktor für anonyme interne Klassen. Weil es nicht einmal einen Namen gibt, um ihn zu konstruieren.
Statische innere Klasse
Static kann Elementvariablen, Methoden, Codeblöcke und andere interne Klassen ändern. Wir nennen innere Klassen, die mit statischen statisch modifiziert wurden, aber wir bevorzugen es, sie verschachtelte interne Klassen zu nennen. Der größte Unterschied zwischen statischen inneren Klassen und nicht statischen inneren Klassen besteht darin, dass nach Abschluss der Zusammenstellung eine Referenz versteckt wird und die Verwendung auf ihre Peripherie hinweist. Die statische innere Klasse nicht, was bedeutet, dass die Erstellung der statischen inneren Klasse nicht auf periphere Klassen stützen muss und keine statischen Mitgliedsvariablen und -methoden einer peripheren Klasse verwenden kann.
öffentliche Klasse OuterClass {private String Sex; public static String name = "Chenssy"; / ***statische innere Klasse*/ statische Klasse InnerClass1 {/*statische Mitglieder können in der statischen inneren Klasse existieren*/ public static String _name1 = "Chenssy_static"; public void display () { /** statische innere Klasse kann nur auf statische Mitgliedsvariablen und Methoden der peripheren Klasse zugreifen* kann nicht auf nicht statische Mitgliedsvariablen und -methoden der peripheren Klasse zugreifen }} / *** Nichtstatische innere Klasse* / Klasse InnerClass2 { /* statische Mitglieder können in nicht-statischen inneren Klassen nicht existieren / * Jedes Mitglied der peripheren Klasse kann in nicht statischen inneren Klassen aufgerufen werden, ob statisch oder nicht statisch */ public void display () {System.out.println ("äußere Klassenname:" + Name); }} /** * @desc Peripheral Class-Methode * @Author Chenssy * @Data 2013-10-25 * @return void * /public void display () { / * periphere Klasse Zugriffe auf die statische innere Klasse: innere Klasse. */ System.out.println (InnerCass1._Name1); /* Eine statische innere Klasse kann direkt erstellt werden, ohne sich auf periphere Klassen zu verlassen*/ New InnerClass1 (). Display (); /* Eine nicht statische innere Kreation muss sich auf periphere Klassen verlassen*/ äußereklasse. /* Mitglieder der nicht statischen inneren Klasse müssen Instanzen der nicht statischen inneren Klasse verwenden*/ system.out.println (inner2._name2); Inner2.display (); } public static void main (String [] args) {äußere klasse äußere = new outerClass (); Outer.Display (); }}Zusammenfassen
Die oben genannte Zusammenfassung der drei Hauptfunktionen der Java - eingekapseltes Wissen, das der Editor Ihnen vorgestellt hat. Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!