Objektorientierte JavaSE-Klassen, Vererbung und Polymorphismus-javaLernprogramm-php.cn

Verstehen Sie den Unterricht?

1 In Java ist eine Klassendatei eine Codedatei mit dem Suffix .java. In jeder Klassendatei darf höchstens eine öffentliche Klasse vorkommen , Der Name der Klassendatei muss mit dem Namen der öffentlichen Klasse identisch sein. Wenn public nicht vorhanden ist, kann der Name der Klassendatei ein beliebiger Name sein.
2 Wenn innerhalb der Klasse für Mitgliedsvariablen keine explizite Zuweisungsinitialisierung beim Definieren erfolgt, stellt Java sicher, dass jede Mitgliedsvariable der Klasse ordnungsgemäß initialisiert wird
1) Für Variablen grundlegender Datentypen wie char, short, byte, int, long, float, double usw. werden standardmäßig auf 0 initialisiert (boolesche Variablen werden standardmäßig auf false initialisiert)
2) Für Referenztypenvariablen werden standardmäßig auf Null initialisiert.
3 Wenn der Konstruktor nicht explizit definiert ist, erstellt der Compiler automatisch einen Konstruktor ohne Argumente. Beachten Sie, dass alle Konstruktoren standardmäßig statisch sind.
4 Die Reihenfolge, in der Klassen Objekte instanziieren
1) Wenn das Programm ausgeführt wird, muss zunächst ein Objekt einer bestimmten Klasse generiert werden Diese Klasse wird geladen. Wenn sie nicht geladen ist, wird zuerst die Klasse geladen und dann das Objekt generiert. Wenn sie geladen wurde, wird das Objekt direkt generiert.
2) Während des Ladevorgangs der Klasse werden die statischen Mitgliedsvariablen der Klasse initialisiert. Wenn in der Klasse ein statischer Anweisungsblock vorhanden ist, wird außerdem der statische Anweisungsblock ausgeführt. Die Ausführungsreihenfolge statischer Mitgliedsvariablen und statischer Anweisungsblöcke stimmt mit der Reihenfolge im Code überein.
3) In Java werden Klassen bei Bedarf geladen. Diese Klasse wird nur dann geladen, wenn sie benötigt wird, und zwar nur einmal.
Sehen Sie sich zum Verständnis das folgende Beispiel an:
```
public class Bread {
  static {
      System.out.println("Bread is loaded");
  }
  public Bread() {
      System.out.println("bread");
  }
  public static void main(String[] args) throws ClassNotFoundException {
      Bread bread1 = new Bread();
      Bread bread2 = new Bread();
  }
}
```
Nach dem Login kopieren
Führen Sie diesen Code aus und Sie werden feststellen, dass „Brot ist geladen“ nur einmal gedruckt wird.
4) Beim Generieren eines Objekts werden zuerst die Mitgliedsvariablen des Objekts initialisiert und dann der Konstruktor ausgeführt. Dies bedeutet, dass die Variablen in der Klasse initialisiert werden, bevor eine Methode (einschließlich des Konstruktors) aufgerufen wird, selbst wenn die Variablen zwischen Methodendefinitionen verstreut sind.
```
public class Test {
  public static void main(String[] args)  {
      new Meal();
  }
} 
class Meal {     
  public Meal() {
      System.out.println("meal");
  }
  Bread bread = new Bread();
}
class Bread {     
  public Bread() {
      System.out.println("bread");
  }
}
```
Nach dem Login kopieren
Das Ausgabeergebnis ist:
```
bread
meal
```
Nach dem Login kopieren

Verstehen Sie Vererbung?

1 Vererbung
1) Vererbung ist ein unverzichtbarer Bestandteil aller OOP-Sprachen. Das Schlüsselwort „extends“ wird in Java verwendet, um die Vererbungsbeziehung auszudrücken. Beim Erstellen einer Klasse wird diese immer geerbt. Wenn die zu erbende Klasse nicht explizit angegeben wird, wird sie immer implizit von der Stammklasse Object geerbt. Zum Beispiel der folgende Code:
```
class Person {
  public Person() {

  }
}
class Man extends Person {
  public Man() {

  }
}
```
Nach dem Login kopieren
2) Die Klasse Man erbt von der Klasse Person. In diesem Fall wird die Klasse Person als übergeordnete Klasse (Basisklasse) und die Klasse Man bezeichnet die Unterklasse (abgeleitete Klasse). Wenn zwischen zwei Klassen eine Vererbungsbeziehung besteht, erbt die Unterklasse automatisch die Methoden und Variablen der übergeordneten Klasse, und die Methoden und Variablen der übergeordneten Klasse können in der Unterklasse aufgerufen werden.
3) In Java ist nur Einzelvererbung zulässig, das heißt, eine Klasse kann höchstens explizit von einer übergeordneten Klasse erben. Eine Klasse kann jedoch von mehreren Klassen geerbt werden, was bedeutet, dass eine Klasse mehrere Unterklassen haben kann.
2 Unterklasse erbt die Attribute der übergeordneten Klasse
Wenn die Unterklasse eine bestimmte Klasse erbt, kann sie die Mitgliedsvariablen in der übergeordneten Klasse verwenden, erbt diese jedoch nicht vollständig übergeordnete Klasse. Alle Mitgliedsvariablen. Die spezifischen Prinzipien lauten wie folgt:
1) Die öffentlichen und geschützten Mitgliedsvariablen der übergeordneten Klasse können nicht vererbt werden
2) Für die Paketzugriffsberechtigungs-Mitgliedsvariablen der übergeordneten Klasse, wenn sich die übergeordnete Klasse im selben Paket befindet, kann die untergeordnete Klasse erben; andernfalls kann die untergeordnete Klasse nicht erben; Wenn in der Unterklasse eine Mitgliedsvariable mit demselben Namen erscheint, tritt das Phänomen
ausblenden auf, d. h. die Mitgliedsvariablen der Unterklasse blockieren die Mitgliedsvariablen der übergeordneten Klasse mit dem gleichen Namen. Wenn Sie in einer Unterklasse auf eine gleichnamige Mitgliedsvariable in der übergeordneten Klasse zugreifen möchten, müssen Sie das Schlüsselwort super als Referenz verwenden.
3 Die Unterklasse erbt die Methoden der übergeordneten Klasse
Ebenso erbt die Unterklasse nicht alle Methoden der übergeordneten Klasse vollständig.
1) Kann die öffentlichen und geschützten Mitgliedsmethoden der übergeordneten Klasse erben;
2) Für die Paketzugriffsmethoden der übergeordneten Klasse, wenn die Unterklasse und die Die übergeordnete Klasse befindet sich im selben Paket, die Unterklasse kann erben; andernfalls kann die Unterklasse nicht erben Unterklasse heißt

überschreibt , das heißt, die Mitgliedsmethoden der Unterklasse überschreiben die gleichnamigen Mitgliedsmethoden der übergeordneten Klasse. Wenn Sie in einer Unterklasse auf eine gleichnamige Mitgliedsmethode in der übergeordneten Klasse zugreifen möchten, müssen Sie das Schlüsselwort super als Referenz verwenden.
Verstecken und Verdecken sind unterschiedlich.
Das Ausblenden gilt für Mitgliedsvariablen und statische Methoden,
während das Überschreiben für gewöhnliche Methoden gilt.
5 构造器
1）子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。
2）如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。
6 super主要有两种用法
1）super.成员变量/super.成员方法;
2）super(parameter1,parameter2....)
第一种用法主要用来在子类中调用父类的同名成员变量或者方法；
第二种主要用在子类的构造器中显示地调用父类的构造器
要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

你了解多态吗？

1 子类必是父类，所以父类型的引用可以指向子类型的对象。
2 动态绑定方法的多种不同版本（即非编译时绑定，而是晚绑定或者动态绑定）
```
Parent p = new Child(); 
p.eat();
```
Nach dem Login kopieren
此时Parent和Child中必须都有eat()方法；
即多态进行动态绑定的前提条件是继承，子类必须继承父类的方法，才能使用父类的引用进行方法调用。
3 父类引用能向下转换成子类引用的前提是父类引用指向子类的对象。
4 向下转换后的引用，就可以调用子类特有的方法了。
5 多态的好处，定义方法时，出入参可以申明为父类的类型，传参时，可以传递子类的对象。这样在方法不改变的前提下，就可以扩展子类的种类，添加新的逻辑。

6 覆盖方法才会进行动态绑定，而隐藏是不会发生动态绑定的。
1）举例如下

public class Test {
  public static void main(String[] args)  {
      Shape shape = new Circle();
      System.out.println(shape.name); // 成员变量（隐藏）
      shape.printName(); // 静态方法（隐藏）
      shape.printType(); // 非静态方法（覆盖）
  }
}
class Shape {
  public String name = "shape";

  public Shape(){
      System.out.println("shape constructor");
  }

  public void printType() {
      System.out.println("this is shape");
  }

  public static void printName() {
      System.out.println("shape");
  }
}
class Circle extends Shape {
  public String name = "circle";

  public Circle() {
      System.out.println("circle constructor");
  }

  public void printType() {
      System.out.println("this is circle");
  }

  public static void printName() {
      System.out.println("circle");
  }
}

Nach dem Login kopieren

2）输出结果：

shape constructor
circle constructor
shape
shape
this is circle

Nach dem Login kopieren

3）原因分析
覆盖受RTTI（Runtime type identification）约束的，而隐藏却不受该约束。也就是说只有覆盖方法才会进行动态绑定，而隐藏是不会发生动态绑定的。在Java中，除了static方法和final方法，其他所有的方法都是动态绑定。因此，就会出现上面的输出结果。

Das obige ist der detaillierte Inhalt vonObjektorientierte JavaSE-Klassen, Vererbung und Polymorphismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!