Ausführliche Erläuterung von Beispielen für die objektorientierte Vererbung in Java

Vererbung

Einführung

Bei der Vererbung wird eine neue Klasse von einer vorhandenen Klasse abgeleitet. Die neue Klasse kann die Datenattribute und Verhaltensweisen der vorhandenen Klasse übernehmen und die neue Klasse erweitern . Fähigkeit. Vererbung wird oft als Ist-eine-Beziehung bezeichnet. Die Unterklasse erbt die Eigenschaften und Verhaltensweisen der übergeordneten Klasse, sodass die Unterklasse über verschiedene Attribute und Methoden der übergeordneten Klasse verfügt. Oder die Unterklasse erbt Methoden von der übergeordneten Klasse, sodass die Unterklasse das gleiche Verhalten wie die übergeordnete Klasse aufweist.

Beispiel:
Sie können beispielsweise zunächst eine Klasse namens Auto definieren. Das Auto hat die folgenden Attribute: Karosseriegröße, Farbe, Lenkrad, Reifen, und es gibt zwei Klassen, Autos und Lastwagen Abgeleitet von der Pkw-Klasse. Fügen Sie einen kleinen Kofferraum für eine Limousine und eine große Ladebox für einen LKW hinzu.

Vererbung drückt eine Schnittbeziehung zwischen Objektklassen aus, die es einem Objekt eines Typs ermöglicht, die Datenmitglieder und Mitgliedsmethoden eines anderen Objekttyps zu erben. Wenn die Klasse B die Klasse A erbt, verfügen die zu B gehörenden Objekte über alle oder einen Teil der Eigenschaften (Datenattribute) und Funktionen (Operationen) der Klasse A. Wir nennen die geerbte Klasse A eine Basisklasse, eine übergeordnete Klasse oder eine Superklasse. und nennen Sie es. Die geerbte Klasse B ist eine abgeleitete Klasse oder Unterklasse von A.

Begriffe, die Elternklasse und Unterklasse bezeichnen: Elternklasse und Unterklasse, Oberklasse und Unterklasse, Basisklasse und abgeleitete Klasse, sie bedeuten dasselbe.

Warum müssen Sie

Tierklassen entwickeln, bei denen die Tiere Pinguine und Mäuse sind? Die Anforderungen sind wie folgt:
Pinguin: Attribute (Name, ID), Methoden (. Essen, Schlafen, Selbstvorstellung)
Maus: Attribute (Name, ID), Methoden (Essen, Schlafen, Selbstvorstellung)
Pinguine und Mäuse sind beide Tiere. Können wir eine Tierklasse schreiben? der Code viel einfacher. Einige Leute sagen, dass ich nur zwei separate Klassen erstellen möchte, um dieses Attribut zu schreiben. Ich kann Ihnen nur sagen, dass Sie es können, aber es ist, als hätte Ihr Vater Ihnen Millionen gegeben, aber Sie wollten es nicht Ich musste es mir selbst verdienen, ich kann nicht anders, wenn du das tun willst. Da Java uns Vererbung bietet, müssen wir diese gut nutzen. Dies wird unsere Entwicklungseffizienz erheblich verbessern. Beispielsweise wird die Wartbarkeit verbessert, der Code wird prägnanter und die Wiederverwendbarkeit des Codes wird ebenfalls verbessert Es kann mehrfach verwendet werden. Es ist nicht erforderlich, denselben Code mehrmals zu schreiben.

Funktion:

1. Durch Vererbung kann doppelter Code reduziert werden. Beispielsweise können Methoden, die bereits von der übergeordneten Klasse bereitgestellt werden, direkt von der Unterklasse verwendet werden, ohne dass diese implementiert werden müssen.

2. Vererbung ist die Voraussetzung für Polymorphismus. Natürlich verbessert die Verwendung der Vererbung auch die Kopplung von Klassen.

　Wenn Sie die Attribute der übergeordneten Klasse nicht benötigen, können Sie die ursprünglichen Attribute überschreiben.

Java-Vererbungsklassifizierung

Die Vererbung ist in Einzelvererbung und Mehrfachvererbung unterteilt. Einfache Vererbung bedeutet, dass eine Unterklasse höchstens eine übergeordnete Klasse haben kann. Mehrfachvererbung bedeutet, dass eine Unterklasse mehr als zwei übergeordnete Klassen haben kann. Da die Mehrfachvererbung zu Mehrdeutigkeiten führen kann, sollte in praktischen Anwendungen so weit wie möglich die Einzelvererbung verwendet werden. Klassen in der Java-Sprache unterstützen nur die Einzelvererbung, während Schnittstellen die Mehrfachvererbung unterstützen. Die Funktion der Mehrfachvererbung in Java wird indirekt über Schnittstellen implementiert.

Vererbungsimplementierung

Die Vererbung kann mithilfe der beiden Schlüsselwörter „extends“ und „implements“ erreicht werden. Alle Klassen erben von java.lang.Object. Wenn eine Klasse die beiden Schlüsselwörter nicht erbt, erbt sie standardmäßig die Vorfahrenklasse des Objekts (diese Klasse befindet sich im java.lang-Paket, sodass kein Import erforderlich ist).

Geerbte Initialisierungssequenz:

Übergeordnete Klasse –>Attribute im Initialisierungsobjekt der übergeordneten Klasse –>Konstruktormethode der übergeordneten Klasse –>Unterklasse –>Initialisierung der Unterklasse-Attribute in das Objekt -> Konstruktormethode der Unterklasse

Wenn es eine Konstruktormethode gibt: Führen Sie zuerst das Attribut aus, dann führen Sie die Konstruktormethode aus

Wenn dem Namensattribut in der Konstruktormethode kein Wert zugewiesen ist , dann Der Wert von name ist der dem Klassenattribut zugewiesene Wert

extends keyword

In Java ist die Klassenvererbung eine Einzelvererbung, das heißt, eine Unterklasse kann nur eine übergeordnete Klasse haben . Extends können also nur von einer Klasse erben.

/*动物类*/
public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
/*企鹅是动物，所以可以继承动物类*/
public class Penguin  extends  Animal{ 
//企鹅继承了动物类，所以拥有了动物类的属性和方法
}

implements Schlüsselwort

Die Verwendung des Schlüsselworts „implements“ kann dazu führen, dass Java über die Funktion der Mehrfachvererbung verfügt. Der Anwendungsbereich liegt darin, dass eine Klasse mehrere Schnittstellen (Schnittstellen) erbt. können gleichzeitig durch Kommas getrennt vererbt werden.

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

Super- und This-Schlüsselwörter

Super-Schlüsselwort: Wir können das Super-Schlüsselwort verwenden, um auf übergeordnete Klassenmitglieder zuzugreifen und damit auf das übergeordnete Objekt des aktuellen Objekts zu verweisen Klasse.

Hinweis:
1. Das Schlüsselwort super kann nur innerhalb von Konstruktoren oder Instanzmethoden verwendet werden, das Schlüsselwort super kann jedoch nicht innerhalb statischer Methoden und statischer Codeblöcke verwendet werden

2. Wenn Wenn Die Mitgliedsvariablen und -methoden in der übergeordneten Klasse sind als private Typen definiert, und die Unterklasse kann niemals auf sie zugreifen. Wenn Sie versuchen, auf die Variable vom privaten Typ var in der Form von super.var zuzugreifen, führt dies zu einer Kompilierung Fehler

dieses Schlüsselwort: eine Referenz, die auf sich selbst zeigt und die Objektreferenz angibt, die diese Methode gerade aufruft.

Hinweis:
1. Wenn mehrere überladene Konstruktoren vorhanden sind und ein Konstruktor einen anderen aufrufen muss, um ihn zu erstellen, verwenden Sie diese (param) Form, um ihn in der ersten Zeile aufzurufen, und nur Kann aktiviert sein die erste Zeile;

2. Wenn eine Methode im Objekt andere Methoden im Objekt aufrufen muss, verwenden Sie diese als Hauptmelodie, oder Sie müssen sie nicht schreiben. Tatsächlich ist die Standardeinstellung dies als Hauptmelodie;

　　3.当对象属性和方法中的局部变量名称相同时，在该方法中需要显式的使用this作为主调，以表示对象的属性，若不存在此问题，可以不显式的写this。

　　其实，其牵涉到的一个问题就是变量的查找规则：先局部变量 => 当前类中定义的变量 => 其父类中定义的可以被子类继承的变量 => 父类...

这块要完全理解需要看上面我写的“继承的初始化顺序”从这里可以看到程序是如何初始化的。

/**
 * 父类
 * @author gacl
 *
 */
class FatherClass {
    public int value;
    public void f() {
        value=100;
        System.out.println("父类的value属性值="+value);
    }
}

/**
 * 子类ChildClass从父类FatherClass继承
 */
class ChildClass extends FatherClass {
    /**
     * 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性，
     * 也就是说，此时的子类拥有两个value属性。
     */
    public int value;
    /**
     * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。
     */
    public void f() {
        super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
        value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value
        System.out.println("子类的value属性值="+value);
        System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200
        /**
         * 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时，
         * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法，
         * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。
         * 所以这里打印出来的value值是100。
         */
        System.out.println(super.value);
    }
}

/**
 * 测试类
 */
public class TestInherit {
    public static void main(String[] args) {
        ChildClass cc = new ChildClass();
        cc.f();
    }
}

运行结果：
　　父类的value属性值＝100
　　子类的value属性值=200
　　200
　　100

分析：
　　执行　　　ChlidClass cc = new ChlidClass();

　首先在栈空间里面会产生一个变量cc，cc里面的值是什么这不好说，总而言之，通过这个值我们可以找到new出来的ChlidClass对象。由于子类ChlidClass是从父类FatherClass继承下来的，所以当我们new一个子类对象的时候，这个子类对象里面会包含有一个父类对象，而这个父类对象拥有他自身的属性value。这个value成员变量在FatherClass类里面声明的时候并没有对他进行初始化，所以系统默认给它初始化为0，成员变量（在类里面声明）在声明时可以不给它初始化，编译器会自动给这个成员变量初始化，但局部变量（在方法里面声明）在声明时一定要给它初始化，因为编译器不会自动给局部变量初始化，任何变量在使用之前必须对它进行初始化。

　　子类在继承父类value属性的同时，自己也单独定义了一个value属性，所以当我们new出一个子类对象的时候，这个对象会有两个value属性，一个是从父类继承下来的value，另一个是自己的value。在子类里定义的成员变量value在声明时也没有给它初始化，所以编译器默认给它初始化为0。即（父类的value为0,子类的value为0；）

　　执行第二句话：　　　cc.f();

　当new一个对象出来的时候，这个对象会产生一个this的引用，这个this引用指向对象自身。如果new出来的对象是一个子类对象的话，那么这个子类对象里面还会有一个super引用，这个super指向当前对象里面的父对象。所以相当于程序里面有一个this，this指向对象自己，还有一个super，super指向当前对象里面的父对象。

　　这里调用重写之后的f()方法，方法体内的第一句话：“super.f();”是让这个子类对象里面的父对象自己调用自己的f()方法去改变自己value属性的值，父对象通过指向他的引用super来调用自己的f()方法，所以执行完这一句以后，父对象里面的value的值变成了100。接着执行“value=200；”这里的vaule是子类对象自己声明的value，不是从父类继承下来的那个value。所以这句话执行完毕后，子类对象自己本身的value值变成了200。

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung von Beispielen für die objektorientierte Vererbung in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!