Sprechen Sie kurz über objektorientiertes Java

Dieser Artikel vermittelt Ihnen relevantes Wissen über Java. Er stellt hauptsächlich objektorientierte Java-Probleme vor, einschließlich der grundlegenden Eigenschaften von Objektorientierung, der Beziehung zwischen Objekten usw. Ich hoffe, dass er für alle hilfreich ist.

Empfohlenes Lernen: „Java-Tutorial“

1. Java-Spezialeffekte

1. Menschen möchten ein System erstellen, das ohne fundierte Fachausbildung programmiert werden kann und konform sein muss mit der heutigen Standardpraxis. Obwohl die Leute denken, dass C++ nicht geeignet ist, ist Java so nah wie möglich an C++ konzipiert, damit das System leichter zu verstehen ist. Java eliminiert viele selten verwendete, schwer verständliche und verwirrende Funktionen in C++. Derzeit verursachen diese Funktionen weitaus mehr Ärger als Nutzen.

Tatsächlich ist die Java-Syntax eine „reine“ Version der C++-Syntax. Es gibt keine Header-Dateien, Zeigerarithmetik (oder gar Zeigersyntax), Strukturen, Unions, Operatorüberladung, virtuelle Basisklassen usw. Allerdings haben die Designer nicht versucht, alle ungeeigneten Funktionen in C++ zu beseitigen. Beispielsweise hat sich die Syntax der Switch-Anweisung in Java nicht geändert. Wenn Sie C++ beherrschen, fällt Ihnen die Konvertierung in die Java-Syntax leicht.

Als Java veröffentlicht wurde, war C++ tatsächlich nicht die am häufigsten verwendete Programmiersprache. Viele Entwickler verwenden Visual Basic und seine Drag-and-Drop-Programmierumgebung. Diese Entwickler finden Java nicht einfach. Es dauerte viele Jahre, bis die Java-Entwicklungsumgebung aufholte. Heute hat sich die Java-Entwicklungsumgebung weit über die der meisten anderen Programmiersprachen hinaus entwickelt.

Ein weiterer Aspekt der Einfachheit ist die Kleinheit. Eines der Ziele von Java besteht darin, die Entwicklung von Software zu unterstützen, die unabhängig auf kleinen Maschinen ausgeführt werden kann. Die grundlegende Interpreter- und Klassenunterstützung beträgt nur etwa 40 KB; die grundlegende Standardklassenbibliothek und Thread-Unterstützung (im Grunde ein eigenständiger Mikrokernel) fügt etwa 175 KB hinzu.

Das war damals eine erstaunliche Leistung. Natürlich ist die Klassenbibliothek aufgrund der kontinuierlichen Erweiterung bereits recht groß. Mittlerweile gibt es eine eigene Java Micro Edition (JavaMicroEdition) mit einer kleineren Klassenbibliothek, die für eingebettete Geräte geeignet ist.

2. Objektorientiert

Objektorientiert ist eine neue Programmiermethode oder eine neue Programmierspezifikation. Ihre Grundidee besteht darin, grundlegende Konzepte wie Objekte, Klassen, Vererbung, Kapselung und Polymorphismus zu verwenden. Konstruieren Sie Softwaresysteme auf der Grundlage objektiv existierender Dinge (d. h. Objekte) in der realen Welt und nutzen Sie bei der Systemkonstruktion so weit wie möglich das natürliche Denken des Menschen.

3. Verteilt

Für Benutzer steht in einem verteilten System lediglich ein Server zur Verfügung, der die Dienste bereitstellt, die die Benutzer benötigen Das verteilte System sieht aus wie ein Supercomputer.

4. Robustheit

Die Multiplattformumgebung des Web stellt besondere Anforderungen an Programme, da Programme zuverlässig in verschiedenen Systemen ausgeführt werden müssen. Daher wurde der Fähigkeit, robuste Programme zu erstellen, bei der Entwicklung von Java eine hohe Priorität eingeräumt. Um Zuverlässigkeit zu erreichen, erlegt Java in einigen Schlüsselbereichen Einschränkungen auf und zwingt Programmierer so dazu, Fehler frühzeitig in der Programmentwicklung zu erkennen. Gleichzeitig müssen sich Programmierer nicht mehr um viele der häufigsten Probleme kümmern, die zu Programmierfehlern führen. Da Java eine stark typisierte Sprache ist, überprüft es den Code zur Kompilierungszeit. Natürlich wird der Code in jedem Fall auch zur Laufzeit überprüft. Viele schwer zu verfolgende Fehler lassen sich zur Laufzeit oft nur schwer reproduzieren, was in Java nahezu unmöglich ist. Denn die vorhersehbare Ausführung des geschriebenen Programms unter verschiedenen Betriebsbedingungen ist eines der Hauptmerkmale von Java. Um besser zu verstehen, wie robust Java ist, analysieren wir die beiden Hauptursachen für Programmfehler: Speicherverwaltungsfehler und nicht behandelte Ausnahmen (d. h. Laufzeitfehler). In herkömmlichen Programmierumgebungen ist die Speicherverwaltung eine schwierige und mühsame Aufgabe. In C/C++ muss der Programmierer beispielsweise den gesamten dynamischen Speicher manuell zuweisen und freigeben. Manchmal kann dies zu Problemen führen, da der Programmierer möglicherweise vergisst, zuvor zugewiesenen Speicher freizugeben, oder, schlimmer noch, versucht, Speicher freizugeben, der noch von anderen Teilen des Programms verwendet wird. Java kann diese Probleme im Wesentlichen beseitigen, indem es die Zuweisung und Freigabe von Speicher für Sie verwaltet (tatsächlich erfolgt die Speicherfreigabe völlig automatisch, da Java eine Speicherbereinigung für Objekte bereitstellt, die nicht mehr verwendet werden). Ausnahmen in herkömmlichen Umgebungen werden oft durch Fehler wie „Dividieren durch Null“ oder „Datei nicht gefunden“ verursacht und müssen mit umständlichen und schwer verständlichen Strukturen verwaltet werden. Java hilft in diesem Bereich, indem es objektorientierte Ausnahmebehandlungsfunktionen bereitstellt. In einem gut geschriebenen Java-Programm können und sollten alle Laufzeitfehler vom Programm verwaltet werden.

5. Sicherheit

Java hat leistungsstarke, aber gefährliche Hinweise entfernt und durch Referenzen ersetzt. Da Zeiger Verschiebungsvorgänge ausführen können, können Zeiger auf jeden Speicherbereich verweisen, unabhängig davon, ob dieser Bereich verfügbar ist. Dies ist gefährlich, da sich herausstellt, dass diese Speicheradresse möglicherweise wichtige Daten speichert oder von anderen Programmen belegt ist. Dies gilt auch für die Verwendung von Zeigern Arrays können leicht außerhalb der Grenzen geraten.

Garbage-Collection-Mechanismus: Programmierer müssen das Speicherrecycling nicht direkt steuern, und der Garbage Collector stellt im Hintergrund automatisch ungenutzten Speicher wieder her. Verhindern Sie, dass das Programm die Wiederverwendung rechtzeitig vergisst, was zu Speicherverlusten führen kann. Vermeiden Sie Programmfehler beim Recycling des Speichers der Kernklassenbibliothek des Programms, die zu Systemabstürzen führen können.

Mechanismus zur Ausnahmebehandlung: Der Java-Ausnahmemechanismus basiert hauptsächlich auf den fünf Schlüsselwörtern Try, Catch, Final, Throw und Throws.

Erzwungene Typkonvertierung: Eine erzwungene Konvertierung kann nur erfolgreich sein, wenn die Regeln für die erzwungene Konvertierung erfüllt sind.

Java verwendet bei der Übertragung von Bytecode die Public-Key-Verschlüsselung (PKC).

Bietet vierstufige Sicherheitsmechanismen in der laufenden Umgebung: Bytecode-Verifizierer – Klassenlader – Laufzeitspeicherlayout – Dateizugriffsbeschränkungen.

6. Architekturneutral

Der Compiler generiert ein architekturneutrales Objektdateiformat, bei dem es sich um einen kompilierten Code handelt, der auf vielen Prozessoren ausgeführt werden kann, sofern ein Java-Laufzeitsystem vorhanden ist. Der Java-Compiler erreicht diese Funktion, indem er Bytecode-Anweisungen generiert, die unabhängig von einer bestimmten Computerarchitektur sind. Gut gestalteter Bytecode kann nicht nur einfach interpretiert und auf jeder Maschine ausgeführt werden, sondern kann auch schnell in lokalen Maschinencode übersetzt werden.
Bytecode ist strukturneutral und hat nichts mit der Computerstruktur zu tun.

7. Portabilität

Das größte Merkmal der Java-Sprache ist ihre Portabilitätsunterstützung. Die sogenannte Portabilität bedeutet, dass dasselbe Programm beliebig zwischen verschiedenen Betriebssystemen bereitgestellt werden kann, sodass die Entwicklung vereinfacht wird Um die Portabilitätskontrolle in Java zu erreichen, verlassen Sie sich hauptsächlich auf die JVM (Java Virtual Machine). Die Java Virtual Machine ist ein durch Software und Hardware simulierter Computer. Alle Programme können ausgeführt werden, sofern sie von der Java Virtual Machine unterstützt werden und verschiedene Versionen der JVM auf verschiedenen Betriebssystemen vorhanden sind Ermöglichen Sie die Portabilität.
Das Urheberrecht liegt beim Autor. Für den kommerziellen Nachdruck wenden Sie sich bitte an den Autor, um eine Genehmigung einzuholen. Für den nichtkommerziellen Nachdruck geben Sie bitte die Quelle an.

8. Interpretierbarkeit

Manche Leute sagen, dass Java kompiliert ist. Da der gesamte Java-Code kompiliert werden muss, kann .java nicht ohne Kompilierung ausgeführt werden. Manche Leute sagen auch, dass Java interpretiert wird. Da Java-Code nicht direkt nach der Kompilierung ausgeführt werden kann, wird er interpretiert und auf der JVM ausgeführt, sodass er interpretiert wird.

9. Hohe Leistung

Der Just-in-Time-Compiler kann überwachen, welche Codes häufig ausgeführt werden, und diese Codes optimieren, um die Geschwindigkeit zu erhöhen. Eine komplexere Optimierung besteht darin, Funktionsaufrufe zu eliminieren (d. h. Inlining). Der Just-in-Time-Compiler weiß, welche Klassen geladen wurden. Inlining kann verwendet werden, wenn bestimmte Funktionen basierend auf dem aktuell geladenen Klassensatz nicht überschrieben werden. Optimierungen können bei Bedarf auch rückgängig gemacht werden.

10. Multithreading

bedeutet, dass dieses Programm (ein Prozess) mehr als einen Thread generiert, wenn es ausgeführt wird.

11. Dynamik

Java ist im Wesentlichen eine statische Sprache, keine dynamische Sprache. Das bemerkenswerte Merkmal dynamischer Sprachen besteht darin, dass die Programmstruktur oder der Variablentyp geändert werden kann, während das Programm ausgeführt wird. Zu den typischen dynamischen Sprachen gehören Python, Ruby, Javascript usw. Java ist keine dynamische Sprache, aber Java hat einen gewissen Grad an Dynamik, der sich in den folgenden Aspekten widerspiegelt:

Dynamischer Bytecode-Betrieb;
1. Ausführung anderer Skriptcodes
3. II, Objekt
4. Ein Objekt ist eine Entität, die zur Beschreibung objektiver Dinge im System verwendet wird. Es ist eine Grundeinheit, die das System bildet. Ein Objekt besteht aus einer Reihe von Eigenschaften und einer Reihe von Diensten, die mit der Reihe von Eigenschaften arbeiten.

Die Instanziierung einer Klasse kann Objekte generieren. Der Lebenszyklus eines Objekts umfasst drei Phasen: Generierung, Verwendung und Eliminierung.

Wenn es keinen Bezug zu einem Objekt gibt, wird das Objekt zu einem nutzlosen Objekt. Der Garbage Collector von Java scannt automatisch den dynamischen Speicherbereich von Objekten, sammelt nicht referenzierte Objekte und gibt sie als Müll frei. Wenn dem System der Speicher ausgeht oder System.gc() aufruft, um eine Garbage Collection anzufordern, wird der Garbage Collection-Thread synchron mit dem System ausgeführt.

3. Klasse

Eine Klasse ist eine Sammlung von Objekten mit denselben Attributen und Methoden. Sie bietet eine einheitliche abstrakte Beschreibung für alle zur Klasse gehörenden Objekte und umfasst zwei Hauptteile: Attribute und Methoden. In objektorientierten Programmiersprachen ist eine Klasse eine unabhängige Programmeinheit. Sie sollte einen Klassennamen haben und zwei Hauptteile enthalten: Attribute und Methoden.

Die Klassenimplementierung in Java besteht aus zwei Teilen: Klassendeklaration und Klassenkörper.

1. Klassendeklaration

[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}

Unter diesen beschreiben die Modifikatoren public, abstract und final die Attribute der Klasse, className ist der Klassenname, superclassName ist der Name der übergeordneten Klasse der Klasse und interfaceNameList die Liste der von der Klasse implementierten Schnittstellen.

2. Klassenkörper

class className{
    [public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
        statements
    }//成员方法
}

Die Bedeutung des Mitgliedsvariablen-Qualifizierers:

• statisch: statische Variable (Klassenvariable)
• final: Konstante: temporäre Variable, verwendet für die Objektarchivierung, verwendet für die Objektserialisierung
• flüchtig: Beitragsvariablen zum Teilen zwischen gleichzeitigen Threads

Die Implementierung der Methode umfasst auch zwei Teile: Methodendeklaration und Methodenkörper.

• statisch: Klassenmethode, kann direkt über den Klassennamen aufgerufen werden
• abstrakt: abstrakte Methode, kein Methodenkörper
• final: Methode kann nicht überschrieben werden
• nativ: Code aus anderen Sprachen integrieren
• synchronisiert: Steuerung Mehrfach-Parallelitäts-Thread-Zugriff

Die Methodendeklaration umfasst den Methodennamen, den Rückgabetyp und externe Parameter. Der Typ der Parameter kann ein einfacher Datentyp oder ein zusammengesetzter Datentyp (auch als Referenzdatentyp bezeichnet) sein.
Für einfache Datentypen implementiert Java die Wertübertragung. Die Methode empfängt den Wert des Parameters, kann den Wert dieser Parameter jedoch nicht ändern. Wenn Sie den Wert eines Parameters ändern möchten, verwenden Sie einen Referenzdatentyp, da der Referenzdatentyp die Adresse der Daten im Speicher an die Methode übergibt und die Operation an den Daten in der Methode den Wert der Daten ändern kann .

3. Methodenkörper

Der Methodenkörper ist die Implementierung der Methode, die die Deklaration lokaler Variablen und aller zulässigen Java-Anweisungen umfasst. Der Bereich der im Methodenkörper deklarierten lokalen Variablen liegt innerhalb der Methode. Wenn die lokale Variable denselben Namen wie eine Mitgliedsvariable der Klasse hat, wird die Mitgliedsvariable der Klasse ausgeblendet.

Um Parameter von Klassenmitgliedsvariablen zu unterscheiden, müssen wir dies verwenden. Dies wird in einer Methode verwendet, um auf das aktuelle Objekt zu verweisen, und sein Wert ist das Objekt, das die Methode aufgerufen hat. Der Rückgabewert muss mit dem Rückgabetyp konsistent oder genau gleich oder einer Unterklasse davon sein. Wenn der Rückgabetyp eine Schnittstelle ist, muss der Rückgabewert die Schnittstelle implementieren.

4. Bauweise

• Die Bauweise ist eine besondere Methode. Jede Klasse in Java verfügt über eine Konstruktormethode, die ein Objekt dieser Klasse initialisiert.
• Der Konstruktor hat denselben Namen wie der Klassenname und gibt keinen Datentyp zurück.
• Überladung wird häufig für Konstrukteure verwendet.
• Der Konstruktor kann nur vom neuen Operator aufgerufen werden

Kommentare werden in Java zur Erläuterung Ihres Codes verwendet, sodass Sie nach Belieben Kommentare hinzufügen können.

Wann-Zeilen-Kommentare //

Mehrzeilige Kommentare/**/
• 6. Implizite Parameter und explizite Parameter

(1) Explizite Parameter sind die Parameter zwischen den Klammern des Methodennamens.

(2) Der implizite Parameter ist das Instanzfeld der in der Klassenmethode aufgerufenen Klasse. Das aufgerufene Instanzfeld ist der implizite Parameter.

(3) Codebeispiel

package com.nezha.javase;

public class Test1107 {
    private int score;

    /**
     * x为显式参数
     * score为隐式参数
     * @param x
     */
    public void addScore(int x){
        int temp = this.score + x;
        score += temp;
    }
}

x ist ein expliziter Parameter

score ist ein impliziter Parameter
• Wenn Sie dies vor dem impliziten Parameter hinzufügen, wird der implizite Parameter klarer.

Es wird empfohlen, diesen Operator vor dem impliziten Parameter hinzuzufügen. Dieser Operator repräsentiert diese Klasse.

7. Methoden mit variablen Parametern

Vor jdk5 hatte jede Java-Methode eine feste Anzahl von Parametern. Die aktuelle Version bietet jedoch eine Möglichkeit, variable Parameter zu verwenden. Nehmen Sie als Beispiel den am häufigsten verwendeten Sout.

System.out.println("获奖编号："+i);

println ruft intern

public PrintStream printf(String format, Object ... args) {
    return format(format, args);
}

Object auf ... Der Parametertyp ist genau der gleiche wie Object [], was bedeutet, dass ... diese Deklarationsmethode verwendet werden kann, um denselben Array-Typ zu empfangen, es gibt jedoch keine feste Größe des Arrays, da dies möglich ist Variable Parameter.

Die Auslassungspunkte hier... sind Teil des Java-Codes, der angibt, dass diese Methode eine beliebige Anzahl von Objekten empfangen kann.

Tatsächlich empfängt die printf-Methode zwei Parameter, einer ist die Formatzeichenfolge und der andere ist das Array Object [], in dem alle Parameter gespeichert sind (wenn es sich bei den Parametern um Grundtypen handelt, werden sie durch automatisches Boxen in Objekte konvertiert).

Der Compiler muss jeden Aufruf in printf konvertieren, um die Argumente an ein Array zu binden und sie bei Bedarf automatisch zu boxen.

4. Grundmerkmale der objektorientierten

1. Kapselung besteht darin, die internen Details des Objekts so weit wie möglich zu verbergen, eine Grenze nach außen zu bilden und nur begrenzte Schnittstellen und Methoden zur Interaktion beizubehalten mit der Außenwelt. Das Prinzip der Kapselung besteht darin, zu verhindern, dass andere Teile als das Objekt nach Belieben auf die internen Eigenschaften des Objekts zugreifen und diese manipulieren, und so zu verhindern, dass die Außenwelt die internen Eigenschaften des Objekts beschädigt.

（1）可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

• private：类中限定为private的成员，只能被这个类本身访问。
• default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
• protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
• public：类中限定为public的成员，可以被所有的类访问。

（2）封装的优点

1. 良好的封装能够减少耦合
2. 类内部的结构可以自由修改
3. 可以对成员变量进行更精确的控制
4. 隐藏信息，实现细节

（3）代码实例

1. 将 id、name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
2. 提供set方法进行赋值，提供get方法进行取值。
3. 赋值方法set中的this的作用是解决显式参数与局部变量同名的问题。

package com.nezha.javase;

public class Student {
    //将 id、name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

2、继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

• Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
• 继承实现了代码的复用。
• Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
• 子类不能继承父类中访问权限为private的成员变量和方法。
• 子类可以重写父类的方法，即命名与父类同名的成员变量。

Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

• 访问父类被隐藏的成员变量
• 调用父类中被重写的方法
• 调用父类的构造函数

3、多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

• 编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
• 运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

4、重载

• 方法重载是让类以统一的方式处理不同数据类型的手段。
• 一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
• 返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

5、重写

• 子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
• 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
• 子类函数的访问修饰权限不能低于父类的。

五、对象间的四种关系

1、依赖

依赖关系表示一个类依赖于另一个类的定义。例如，一个人(Person)可以买车(car)和房子(House)，Person类依赖于Car类和House类的定义，因为Person类引用了Car和House。与关联不同的是，Person类里并没有Car和House类型的属性，Car和House的实例是以参量的方式传入到buy()方法中去的。一般而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。 

2、关联

关联(Association）关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。

3. Aggregation

Aggregationsbeziehung ist eine Art Assoziationsbeziehung und eine starke Assoziationsbeziehung. Aggregation ist die Beziehung zwischen einem Ganzen und einem Individuum. Beispielsweise ist die Beziehung zwischen der Automobilkategorie und der Motorkategorie, der Reifenkategorie und anderen Teilekategorien die Beziehung zwischen dem Ganzen und dem Einzelnen. Wie Assoziationsbeziehungen werden auch Aggregationsbeziehungen durch Instanzvariablen implementiert. Allerdings befinden sich die beiden an der Assoziationsbeziehung beteiligten Klassen auf derselben Ebene, während sich die beiden Klassen in der Aggregationsbeziehung auf unterschiedlichen Ebenen befinden, wobei eine das Ganze und die andere einen Teil darstellt.

4. Kombinationsbeziehung (Kompositionsbeziehung) ist eine Art Assoziationsbeziehung und eine stärkere Beziehung als Aggregationsbeziehung. Es erfordert, dass das Objekt, das das Ganze in einer gewöhnlichen Aggregationsbeziehung darstellt, für die Darstellung des Lebenszyklus eines Teils des Objekts verantwortlich ist und die Kombinationsbeziehung nicht gemeinsam genutzt werden kann. Das Objekt, das das Ganze darstellt, muss dafür verantwortlich sein, das Teilobjekt am Leben zu erhalten und in einigen Fällen das Objekt, das für den Teil verantwortlich ist, zu vernichten. Ein Objekt, das ein Ganzes darstellt, kann ein Objekt, das einen Teil darstellt, an ein anderes Objekt übergeben, das für den Lebenszyklus dieses Objekts verantwortlich ist. Mit anderen Worten, das den Teil darstellende Objekt kann zu jedem Zeitpunkt nur mit einem Objekt kombiniert werden, und dieses ist ausschließlich für den Lebenszyklus verantwortlich. Teile haben den gleichen Lebenszyklus wie Ganze.

Empfohlenes Lernen: „

Java-Lern-Tutorial

“

Das obige ist der detaillierte Inhalt vonSprechen Sie kurz über objektorientiertes Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!