[JavaSE] Héritage orienté objet

notion d'héritage

Mécanisme d'héritage : C'est le moyen le plus important de la programmation orientée objet pour rendre le code réutilisable. Il permet aux programmeurs d'étendre et d'ajouter de nouvelles fonctions tout en conservant les caractéristiques de la classe d'origine. Cela génère une nouvelle classe, appelée dérivation. L'héritage présente la structure hiérarchique de la programmation orientée objet et reflète le processus cognitif du simple au complexe. Le principal problème résolu par l’héritage est : l’extraction des fonctionnalités communes et la réalisation de la réutilisation du code.

Par exemple : les chiens et les chats sont tous deux des animaux, on peut alors extraire le contenu commun puis utiliser l'idée d'héritage pour réaliser le partage.

Dans l'illustration ci-dessus, Chien et Chat héritent tous deux de la classe Animal. La classe Animal est appelée classe parent/classe de base ou super classe. Chien et Chat peuvent être appelés la sous-classe/classe dérivée d'Animal. Après l'héritage, la sous-classe peut être En utilisant les membres de la classe parent, la sous-classe n'a besoin de se soucier que de ses propres membres nouvellement ajoutés lors de son implémentation.

Syntaxe héritée

En Java, si vous souhaitez exprimer la relation d'héritage entre les classes, vous devez utiliser le mot-clé extends, comme suit :

修饰符 class 子类 extends 父类 {
    
    
	// ...
}

Reconcevez donc la scène dans l'image ci-dessus en utilisant l'héritage :
créez d'abord le fichier Animal.java

public class Animal{
    
    
	String name;
	int age;
	float weight;
	public void eat(){
    
    
		System.out.println(name + "正在吃饭");
	}
	public void sleep(){
    
    
		System.out.println(name + "正在睡觉");
	}
}

Créez ensuite le fichier Dog.java

public class Dog extends Animal{
    
    
	void bark(){
    
    
		System.out.println(name + "在汪汪叫~~~");
	}
}

Continuez à créer le fichier Cat.Java

public class Cat extends Animal{
    
    
	void mew(){
    
    
		System.out.println(name + "在喵喵叫~~~");
	}
}

Créez enfin le fichier TestExtend.java pour les tests

public class TestExtend {
    
    
	public static void main(String[] args) {
    
    
		Dog dog = new Dog();
		System.out.println(dog.name);
		System.out.println(dog.age);
		dog.eat();
		dog.sleep();
		dog. Bark();
	}
}

Aucune variable membre n'est définie dans la classe Dog. Les attributs name et age doivent être hérités de la classe parent Animal. Les méthodes eat() et sleep() accessibles par Dog sont également héritées de Animal.
Avis:

1. La sous-classe héritera des variables membres ou des méthodes membres de la classe parent de la sous-classe.
2. Une fois que la sous-classe a hérité de la classe parent, elle doit ajouter ses propres membres uniques pour refléter la différence par rapport à la classe de base, sinon il n'est pas nécessaire d'hériter.

Accès aux membres de la classe parent

La sous-classe et la classe parent n'ont pas de variables membres portant le même nom

public class Base {
    
    
	int a;
	int b;
}
public class Derived extends Base{
    
    
	int c;
	public void method(){
    
    
		a = 10; // 访问从父类中继承下来的a
		b = 20; // 访问从父类中继承下来的b
		c = 30; // 访问子类自己的c
	}
}

Les sous-classes et les classes parentes ont des variables membres portant le même nom

public class Base {
    
    
	int a;
	int b;
	int c;
}

public class Derived extends Base{
    
    
	int a; // 与父类中成员a同名，且类型相同
	char b; // 与父类中成员b同名，但类型不同
	public void method(){
    
    
		a = 100;
		b = 101; 
		c = 102; 
		d = 103;// 编译失败，因为父类和子类都没有定义成员变量b
	}
}
// 访问父类继承的a，还是子类自己的a？答案是自己的
// 访问父类继承的b，还是子类自己的b? 答案是自己的
// 子类没有c，访问的肯定是从父类继承下来的c

Lors de l'accès aux membres dans une méthode de sous-classe ou via un objet de sous-classe :

Si la variable membre à laquelle accéder existe dans une sous-classe, accédez d’abord à votre propre variable membre. Si la variable membre consultée n'existe pas dans la sous-classe,elle sera accessible en héritant de la classe parent. Si la classe parent n'est pas définie,une erreur de compilation sera signalée. Si la variable membre à laquelle vous accédez porte le même nom qu’une variable membre de la classe parent, la vôtre sera accessible en premier. L'accès aux variables membres suit le principe de proximité. Si vous en avez une, vous êtes prioritaire. Dans le cas contraire, vous la retrouverez dans la classe parent.

Les noms des méthodes membres sont différents

// Base.java
public class Base {
    
    
	public void methodA(){
    
    
		System.out.println("Base中的methodA()");
	}
}
// Derived.java
public class Derived extends Base{
    
    
	public void methodB(){
    
    
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
    
    
		methodB(); // 访问子类自己的methodB()
		methodA(); // 访问父类继承的methodA()
		method(); // 编译失败，在整个继承体系中没有发现方法methodD()
	}
}

Résumé : Lorsqu'une méthode membre n'a pas le même nom, lorsque vous accédez à la méthode dans une méthode de sous-classe ou via un objet de sous-classe, vous accéderez d'abord à votre propre méthode. Si vous ne la trouvez pas vous-même, vous la chercherez dans le classe parent. S’il n’existe pas dans la classe parent, une erreur sera signalée.

Les méthodes membres ont le même nom

// Base.java
public class Base {
    
    
	public void methodA(){
    
    
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
    
    
		System.out.println("Base中的methodB()");
	}
}
// Derived.java
public class Derived extends Base{
    
    
	public void methodA(int a) {
    
    
		System.out.println("Derived中的method(int)方法");
	}
	public void methodB(){
    
    
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
    
    
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		methodB(); // 直接访问，则永远访问到的都是子类中的methodB()，父类的无法访问到
	}
}

Avis:

Lors de l'accès à des méthodes portant des noms différents dans la classe parent et dans la sous-classe via l'objet de sous-classe, la méthode est d'abord recherchée dans la sous-classe et accessible si elle est trouvée. Sinon, la méthode est recherchée dans la classe parent et accessible si elle est trouvée. Sinon, une compilation une erreur est signalée. Lors de l'accès à la méthode portant le même nom de la classe parent et de la sous-classe via l'objet sous-classe, si la liste des paramètres de la méthode portant le même nom de la classe parent et de la sous-classe est différente (surchargée), sélectionnez la méthode appropriée pour accéder selon les paramètres passés par la méthode appelante, sinon, une erreur sera signalée.

super mot-clé

La fonction principale de ce mot-clé est d'accéder aux membres de la classe parent dans les méthodes de sous-classe.

// Base.java
public class Base {
    
    
	int a;
	int b;
	public void methodA(){
    
    
		System.out.println("Base中的methodA()");
	}
	public void methodB(){
    
    
		System.out.println("Base中的methodB()");
	}
}
// Derived.java
public class Derived extends Base{
    
    
	int a; 
	char b; 
	public void methodA(int a) {
    
    
		System.out.println("Derived中的method()方法");
	}
	public void methodB(){
    
    
		System.out.println("Derived中的methodB()方法");
	}
	public void methodC(){
    
    
		// 对于同名的成员变量，直接访问时，访问的都是子类的
		a = 100; // 等价于： this.a = 100;
		b = 101; // 等价于： this.b = 101;
		super.a = 200;
		super.b = 201;
		// 父类和子类中构成重载的方法，直接可以通过参数列表区分清访问父类还是子类方法
		methodA(); // 没有传参，访问父类中的methodA()
		methodA(20); // 传递int参数，访问子类中的methodA(int)
		// 如果在子类中要访问重写的父类方法，则需要借助super关键字
		methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，父类的无法访问到
		super.methodB(); // 访问父类的methodB()
	}
}

Avis:

1. Super ne peut être utilisé que dans des méthodes non statiques.
2. Dans la méthode de sous-classe, accédez aux variables et méthodes membres de la classe parent.

Constructeur de sous-classe

Père et fils, père et fils, il y a d'abord le père puis le fils, c'est-à-dire : lors de la construction d'un objet de sous-classe, vous devez d'abord appeler le constructeur de la classe parent, puis exécuter le constructeur de la sous-classe.

// Base.java
public class Base {
    
    
	public Base(){
    
    
		System.out.println("Base()");
	}
}
// Derived.java
public class Derived extends Base{
    
    
	public Derived(){
    
    
		// super(); // 注意子类构造方法中默认会调用父类的无参构造方	法：super(),
		// 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，并且只能出现一次
		System.out.println("Derived()");
	}
}
// Test.java
public class Test {
    
    
	public static void main(String[] args) {
    
    
		Derived d = new Derived();
	}
}
/*
* 运行的结果为：
* Base()
* Derived()
*/

Dans la méthode de construction de sous-classe, aucun code sur la construction de la classe parent n'est écrit, mais lors de la construction de l'objet de sous-classe, la méthode de construction de la classe parent est exécutée en premier, puis la méthode de construction de la sous-classe est exécutée, car : Les membres de l'objet de sous-classe sont Il se compose de deux parties, la partie héritée de la classe parent et la partie nouvellement ajoutée de la sous-classe. Lors de la construction d'un objet de sous-classe, appelez d'abord la méthode de construction de la classe parent pour terminer la construction des membres hérités de la classe parent, puis appelez la propre méthode de construction de la sous-classe pour terminer l'initialisation des membres nouvellement ajoutés de la sous-classe .

Avis:

1. Si la classe parent définit explicitement un constructeur sans paramètre ou par défaut, il y a un appel implicite super() par défaut dans la première ligne du constructeur de sous-classe, c'est-à-dire que le constructeur de la classe parent est appelé.
2. Si le constructeur de la classe parent a des paramètres, l'utilisateur doit définir explicitement le constructeur de la sous-classe et sélectionner le constructeur de la classe parent approprié à appeler dans le constructeur de la sous-classe, sinon la compilation échouera.
3. Dans la méthode de construction de sous-classe, lorsque super(...) appelle la construction de la classe parent, il doit s'agir de la première instruction de la construction de la sous-classe.
4.super(...) ne peut apparaître qu'une seule fois dans le constructeur de sous-classe et ne peut pas apparaître en même temps que celui-ci.

super et ça

Super et this peuvent être utilisés pour accéder aux méthodes membres : les variables membres et l'appel d'autres fonctions membres peuvent tous deux être utilisés comme première instruction du constructeur. Alors, quelle est la différence entre elles ?

Même point :

• Ce sont tous des mots-clés en Java.
• Il ne peut être utilisé que dans les méthodes non statiques d’une classe pour accéder aux méthodes et champs membres non statiques.
• Lorsqu'elle est appelée dans un constructeur, elle doit être la première instruction du constructeur et ne peut pas exister en même temps.

différence:

• Il s'agit d'une référence à l'objet actuel, qui est l'objet qui appelle la méthode d'instance. Super équivaut à une référence à certains membres de l'objet de sous-classe hérité de la classe parent.
• Dans les méthodes membres non statiques, this est utilisé pour accéder aux méthodes et propriétés de cette classe, et super est utilisé pour accéder aux méthodes et propriétés héritées de la classe parent.
• Dans la méthode constructeur : this(...) permet d'appeler la méthode constructeur de cette classe, et super(...) permet d'appeler la méthode constructeur de la classe parent. Les deux appels ne peuvent pas apparaître dans la méthode constructeur en même temps.
• Il doit y avoir un appel à super(...) dans le constructeur, et le compilateur l'augmentera si l'utilisateur ne l'écrit pas, mais ceci(...) n'augmentera pas si l'utilisateur ne l'écrit pas.

Méthode d'héritage

Seules les méthodes d'héritage suivantes sont prises en charge en Java :