Das zweite der drei Hauptmerkmale von Java – Vererbung (wesentliche Fähigkeiten für Arbeit, Vorstellungsgespräche und Lernen)

Inhaltsverzeichnis

Überblick über die Vererbung

 Merkmale der Vererbung

 Mitgliedsvariablen in der Vererbung

 Mitgliedsmethoden in der Vererbung

 Überschreibende Methode

Konstruktormethode in der Vererbung

 Super-Schlüsselwort 

Der Unterschied zwischen Super und diesem

Überblick über die Vererbung

• Wenn in mehreren Klassen dieselben Attribute (Mitgliedsvariablen) und Verhaltensweisen (Methoden) vorhanden sind, extrahieren Sie diese Inhalte in eine einzelne Klasse. Dann müssen die mehreren Klassen diese Attribute und Verhaltensweisen nicht definieren, sondern nur diese Klasse erben.
• Unterklassen können direkt auf nicht private Eigenschaften und Verhaltensweisen in der übergeordneten Klasse zugreifen.
• Verwenden Sie das Schlüsselwort „extends“, um eine Vererbungsbeziehung zwischen Klassen zu erstellen.

        –Klasse SubDemo erweitert Demo{} SubDemo ist eine Unterklasse und Demo ist eine übergeordnete Klasse

package com.demo01;
/*
 * 继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。
 * extends
 * 
 */
public class ExtendsDemo {
	public static void main(String[] args) {
		DotA d = new DotA();
		d.start();
		
		LOL l = new LOL();
		l.start();
	}
}
// 父类
class Game {
	String name;
	double version;//版本号
	String agent;//代理商
	
	//法
	public void start() {
		System.out.println("游戏启动了");
	}
	
	public void stop() {
		System.out.println("游戏关闭了");
	}
}

//子类 继承了游戏所有的属性和方法
class DotA extends Game {

}

//子类 继承了游戏所有的属性和方法
class LOL extends Game {

}

Code-Analyse:Wir erstellen eine übergeordnete Spielklasse – die Klasse game. Wir erstellen DotA- und LOL-Unterklassen, um die übergeordnete Klasse des Spiels und alle von uns erstellten Attribute und Methoden des Spiels zu erben zwei Unterklassenobjekte und führt Dinge in der übergeordneten Klasse aus.

Die Ergebnisse zeigen Folgendes:

 GeerbteMerkmale

• Java unterstützt nur die Einzelvererbung und keine Mehrfachvererbung.

        –Eine Klasse kann nur eine übergeordnete Klasse und nicht mehrere übergeordnete Klassen haben.

        –class SubDemo erweitert Demo{} //ok

        –Klasse SubDemo erweitert Demo1,Demo2...//Das ist falsch

• Java unterstützt mehrstufige Vererbung (Vererbungssystem)

        –Klasse A{}

        –Klasse B erweitert A{}

        –Klasse C erweitert B{}

        Deklarieren einer übergeordneten Klasse: A, Unterklasse B kann C erben, Unterklasse C kann auch Unterklasse B erben, dh eine Klasse kann sowohl eine Unterklasse als auch eine übergeordnete Klasse sein.

package com.demo02;
/*
 * Java中继承的特点：
 * 			Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹）
 * 			Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）
 * 
 */
public class ExtendsDemo2 {
	public static void main(String[] args) {
		LOL l = new LOL();
		MobileGame s = new MobileGame();
		l.update();
		l.start();
		s.update();
		s.start();
	}
}

class Game {
	public void start() {
		System.out.println("游戏启动了");
	}
}

class PCGame extends Game {
	public void update() {
		System.out.println("PCGame更新了");
	}
}

class MobileGame extends Game {
	public void update() {
		System.out.println("MobileGame更新了");
	}
}

class LOL extends PCGame {
	
}

Code-Analyse:Wir haben eine übergeordnete Klasse für Game erstellt, in der die Unterklassen PCGame und MobileGame beide die übergeordnete Klasse Game geerbt haben – als Opa-Ebene, und LOL PCGame geerbt hat—— Als Vaterklasse erstellen wir ein neues LOL-Objekt.

Die Ergebnisse zeigen Folgendes:

 Mitgliedsvariablen in der Vererbung

• Wenn eine nicht private Mitgliedsvariable mit demselben Namen in der untergeordneten Elternklasse erscheint,Wenn die Unterklasse auf die Variablen in dieser Klasse zugreifen möchte, verwenden Sie diese ; Verwenden Sie super, um auf die gleichnamige Variable in der übergeordneten Klasse zuzugreifen.
• Die Verwendung von super ist fast die gleiche wie die Verwendung von this.
• dies stellt einen Verweis auf ein Objekt dieser Klasse dar; super ist ein Verweis auf die übergeordnete Klasse des aktuellen Unterklassenobjekts.

Merkmale von Mitgliedsvariablen bei der Vererbung:

Unterklassen können nur nicht private Mitglieder der übergeordneten Klasse erhalten

Wenn die Namen der Mitgliedsvariablen in der untergeordneten Klasse und der übergeordneten Klasse unterschiedlich sind, erhalten Sie direkt die Mitgliedsvariablen der übergeordneten Klasse.

Die Namen der Mitgliedsvariablen in der untergeordneten und übergeordneten Klasse sind gleich, und es wird die Mitgliedsvariable der Unterklasse erhalten.

package com.demo02;
/*
 * 继承中成员变量的特点
 * 		子类只能获取父类非私有成员
 * 		子父类中成员变量的名字不一样,直接获取父类的成员变量
 * 		子父类中成员变量名字是一样的,获取的是子类的成员变量
 * 
 * 就近原则：谁离我近我就用谁
 * 		如果有局部变量就使用局部变量
 * 		如果没有局部变量，有子类的成员变量就使用子类的成员变量
 * 		如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量
 * 		啥都没有，出错了！！！
 * 
 * super:可以获取父类的成员变量和成员方法,用法和this是相似的
 */
public class ExtendsDemo3 {
	public static void main(String[] args) {
		Kid3 k = new Kid3();
		k.show();
	}
}

class Dad3 {
	String name = "建霖";
	String superName = "父类中的成员变量";
}

class Kid3 extends Dad3 {
	String name = "四葱";
	
	public void show() {
		System.out.println(super.superName);
		
		String name = "五葱";
		
		//System.out.println(super.name);
		System.out.println(this.name);
		System.out.println(name);
	}
}

Code-Analyse:Erstellen Sie eine übergeordnete Klasse – Dad3. Die Mitgliedsvariablen sind name und superName. Kid3 hat auch name in der Unterklasse. Wenn Sie auf den Namen der Mitgliedsvariablen zugreifen möchten In der Unterklasse müssen Sie dies verwenden. Wenn Sie in der Unterklasse auf den SuperNamen in der übergeordneten Klasse zugreifen möchten, müssen Sie Super verwenden. Beim Zugriff auf lokale Variablen ist dies jedoch nicht erforderlich, und das Proximity-Prinzip wird übernommen .

 ErbenMember-Methoden in

• Wenn die Unterklasse eine Methode hat, die genau mit der der übergeordneten Klasse übereinstimmt, wenn das Unterklassenobjekt die Methode aufruft -Methode, führt den Inhalt der Unterklassenmethode aus. Genauso wie die Methode der übergeordneten Klasse durch überschrieben wird.
• Dieser Fall ist MethodeEin weiteres Merkmal:
• überschreiben)
• ÜberlastungÜberlastung

 Merkmale von Mitgliedsmethoden bei der Vererbung:

Wenn es in der Unterklasse keine solche Methode gibt, rufen Sie die der übergeordneten Klasse auf

Diese Methode wird in der Unterklasse überschrieben und ruft die der Unterklasse auf

Methodenüberschreibung (Überschreibung):In der untergeordneten übergeordneten Klasse ist die Methode der untergeordneten Klasse genau dieselbe wie die Methode der übergeordneten Klasse, und die untergeordnete Klasse überschreibt die Methode der übergeordneten Klasse ( overrides ), wenn die Unterklasse die Methode der übergeordneten Klasse überschreibt, wird die Methode der Unterklasse mithilfe des Unterklassenobjekts aufgerufen

Methodenüberladung (Überladung):In einer Klasse gibt es mehrere Methoden mit demselben Namen, aber ihre Parameter sind unterschiedlich (Anzahl der Parameter, Art der Parameter, Reihenfolge der Methoden). Parameter), unabhängig vom Rückgabewert

package com.demo02;
/*
 * 继承中成员方法的特点
 * 		子类中没有这个方法，调用父类的
 * 		子类中重写了这个方法，调用子类的
 * 
 
 	方法的重写(override)：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法
 	方法的重载(overload)：在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关
 
 */
public class ExtendsDemo4 {
	public static void main(String[] args) {
		Kid4 k = new Kid4();
		k.eat();
		k.eat(null);
	}
}

class Dad4 {
	public void eat() {
		System.out.println("小酌两口");
		System.out.println("去睡觉了");
	}
}

class Kid4 extends Dad4 {
	public void eat() {
		super.eat();
		System.out.println("好好吃饭");
	}
	
	public void eat(String name) {
		super.eat();
		System.out.println("好好吃饭1");
	}
}

Code-Analyse: definiert eine übergeordnete Klasse – Dad4, die eine eat()-Methode definiert, eine Unterklasse Kid4 definiert, die übergeordnete Klasse Dad4 erbt und außerdem eine eat( Die Methode stimmt mit der Methode der übergeordneten Klasse überein. Verwenden Sie super, um die Methode der übergeordneten Klasse aufzurufen, ein Klassenobjekt zu erstellen und das Programm auszuführen. Zuerst wird die übergeordnete Klasse und dann die Unterklasse ausgeführt.

 Überschreibende Methode

• Wenn in einer Unterklasse eine Methode erscheint, die genau mit der übergeordneten Klasse übereinstimmt, kommt es zu einem Überschreibvorgang, der auch Überschreiben oder Überschreiben genannt wird.
• Können private Methoden in der übergeordneten Klasse überschrieben werden? Unterklassen können die Methoden der übergeordneten Klasse überhaupt nicht sehen
• In einer überschreibenden Methode einer Unterklasse kann die weitere Verwendung der überschriebenen Methode über den Namen der super. Methode erfolgen.
• Hinweise zur Deckung:

        – Beim Überschreiben von müssen die Methodenberechtigungen der Unterklasse größer oder gleich den Methodenberechtigungen der übergeordneten Klasse sein

• Abgedeckte Anwendungen:

        Die Funktion definiert auch den für die Unterklasse eindeutigen Inhalt.

package com.demo03;
/*
 * 	方法重写的应用场景：当父类的方法不能完全满足子类使用，这个时候子类重写父类的方法，
 * 				    并可以在方法中使用关键字super调用父类的方法，这样做即可以保有父类的功能，也可以拥有子类特有的功能
 *  方法重写的注意事项：
 *  			  不能重写父类私有的方法
 *  			 权限必须大于等于父类方法的权限
 *  
 *  注解：@
 *  
 */
public class ExtendsDemo5 {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call();
	}
}

//父类
class Phone {
	void call() {
		System.out.println("打电话");
	}
}

//子类
class NewPhone extends Phone {
	
	@Override // 说明方法是重写父类中的方法
	public void call() {
		System.out.println("录音");
		//System.out.println("打电话");
		
		//super.call();
	}
}

Code-Analyse:Erstellen Sie zunächst eine übergeordnete Klasse – Phone. Die Methode der übergeordneten Klasse ist call. Anschließend erstellen wir eine Unterklasse und verwenden @Override, um die call-Methode neu zu schreiben. Was ist die Funktionstyp in der übergeordneten Klasse, welcher Funktionstyp in der Unterklasse sein muss; Beispiel: Wenn es in der übergeordneten Klasse „Public“ ist, muss die Unterklasse auch „Public“ sein.

Konstruktormethode in der Vererbung

• Beim Initialisieren eines Unterklassenobjekts wird auch die Konstruktionsmethode der übergeordneten Klasse ausgeführt. Das liegt daran, dass die Konstruktion der Unterklasse / a>r () supe eine implizite Anweisung in der ersten ZeileDie Methode hat standardmäßig
• super(): greift auf die leere Parameterstruktur in der übergeordneten Klasse zu < a i=4> Herstellungsverfahren. Und alle Konstruktoren in Unterklassen verwenden standardmäßig die erste Zeile von super( < a i=8>)

package com.demo03;
/*
 * 继承中构造方法的执行顺序
 * 			在子父类中，创建子类对象，调用子类的构造方法，
 * 			在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造，则默认调用父类无参构造
 * 为什么要调用父类构造？
 * 			因为需要给父类的成员变量初始化
 * 肯定会先把父类的构造执行完毕，再去执行子类构造中的其他代码
 * 
 * 我是父类无参构造 --- 我是子类有参构造 --- 我是子类无参构造
 */
public class ExtendsDemo6 {
	public static void main(String[] args) {
		//Parent d = new Parent();
		Son6 son = new Son6(1);
	}
}

class Parent6 {
	public Parent6() {
		System.out.println("我是父类无参构造");
	}
	
	public Parent6(int num) {
		System.out.println("我是父类有参构造");
	}
}

//子类
class Son6 extends Parent6 {
	public Son6() {
		super(1);//写不写一定会执行父类无参数
		System.out.println("我是子类无参构造");
	}
	
	public Son6(int num) {
		this(1l);
		//会默认调用父类无参构造
		System.out.println("我是子类有参构造");
	}
	
public Son6(long num) {
		//会默认调用父类无参构造
		System.out.println("我是子类有参构造");
	}
}

Code-Analyse:Unabhängig davon, ob super() in die Unterklasse geschrieben wird oder nicht, wird die Konstruktion ohne Parameter der übergeordneten Klasse ausgeführt. Wenn super(1) geschrieben wird, wird die übergeordnete Klasse ausgeführt Die Parameterlose Konstruktion der Klasse wird ausgeführt. Wenn wir für die Parameterkonstruktion den Parameterlosen Konstruktor in der übergeordneten Klasse nicht aufrufen möchten, sollten wir dies (1) schreiben, sodass der Parameterlose Konstruktor in der übergeordneten Klasse nicht aufgerufen wird am Ende wird noch die Unterklasse Son6 aufgerufen. Auf diese Weise muss es eine Unterklassenmethode zum Aufrufen der übergeordneten Klasse geben. Sie können nicht zyklisch aufgerufen werden. Schließlich ruft eine der Unterklassen die übergeordnete Klasse auf.

Ergebnis:

 superunverschämt 

• Die Verwendung von super ist ähnlich
• Dies stellt einen Verweis auf das Objekt dar (wer auch immer es aufruft, repräsentiert denjenigen, der es aufruft)
• super stellt einen Verweis auf die übergeordnete Klasse des aktuellen Unterklassenobjekts dar
• Wenn ein Mitglied mit demselben Namen in einer untergeordneten oder übergeordneten Klasse erscheint, kann super zur Unterscheidung verwendet werden
• Wenn eine Unterklasse den Konstruktor der übergeordneten Klasse aufrufen möchte, kann sie die super-Anweisung verwenden.

super和diesgeteilt

• dies : Verweis auf das Objekt (wer auch immer es aufruft, stellt es dar)
• Verwenden Sie dieses Schlüsselwort, um auf Mitgliedsvariablen zu verweisen.
• Verwenden Sie dieses Schlüsselwort, um auf andere Konstruktoren innerhalb Ihres eigenen Konstruktors zu verweisen.
• Verwenden Sie dieses Schlüsselwort , um auf Mitgliedsmethoden zu verweisen
• super : Verweis auf die übergeordnete Klasse im aktuellen Objekt.
• Referenzieren Sie den Konstruktor der übergeordneten Klasse innerhalb des Konstruktors der Unterklasse.
• Rufen Sie Mitgliedsmethoden in der übergeordneten Klasse in der Unterklasse auf.
• Rufen Sie Mitgliedsvariablen in der übergeordneten Klasse in der Unterklasse auf.

package com.demo03;
/*
 * this和super的区别
		this:当前对象的引用
			调用子类的成员变量
			调用子类的成员方法
			在子类的构造方法第一行调用子类其他构造方法
		super:子类对象的父类引用
			调用父类的成员变量
			调用父类的成员方法
			在子类的构造方法第一行调用父类的构造方法
 */
public class ExtendsDemo7 {
	public static void main(String[] args) {
		Son z = new Son();
		z.function();
	}
}

//父类
class Parent {
	int num = 10;
	
	//无参构造方法
	public Parent() {
		System.out.println("我是父类无参构造");
	}
	// 有参构造方法
	public Parent(int num) {
		System.out.println("我是父类有参构造");
	}
	// 普通方法
	public void method() {
		System.out.println("我是父类的方法");
	}
}


// 子类
class Son extends Parent {
	int num = 30;
	
	public Son() {
		this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造
		//super();
		System.out.println("我是子类无参构造");
	}
	
	public Son(int num) {
		System.out.println("我是子类有参构造");
	}
	
	public void method() {
		System.out.println("我是子类的方法");
	}
	
	public void function() {
		//this.num = 50;
		//System.out.println(num);
		//this.method();
		
		//super.num = 40;
		super.method();
		
		//System.out.println(super.num);
		//System.out.println(this.num);
	}
}

Code-Analyse:Wir erstellen ein neues Unterklassenobjekt. Wenn wir dies(1) sehen, hat die Unterklasse einen Parameterkonstruktor, aber kein super() darin. Die Standardeinstellung ist der übergeordnete Parameterlose Aufbau der Klasse. Führen Sie dann den parametrisierten Konstruktor „Ich bin eine Unterklasse“ aus, kehren Sie nach der Ausführung zurück, führen Sie den parametrisierten Konstruktor „Ich bin eine Unterklasse“ aus, ist die Konstruktionsmethode abgeschlossen und führen Sie dann die z.function aus.

Die Ergebnisse zeigen Folgendes:

VererbteVor- und Nachteile

• Mangel:

        –Die Kopplung der Klasse wurde verbessert

        –Entwicklungsprinzipien: hohe Kohäsion und geringe Kopplung

        –Zusammenhalt: die Fähigkeit, etwas selbst zu Ende zu bringen

        –Kopplung: die Beziehung zwischen Klassen