Héritage

Introduction

L'héritage consiste à dériver une nouvelle classe à partir d'une classe existante. La nouvelle classe peut absorber les attributs de données et les comportements de la classe existante et peut étendre la nouvelle classe. . capacité. L'héritage est souvent appelé la relation est-une. La sous-classe hérite des caractéristiques et des comportements de la classe parent, de sorte que la sous-classe possède divers attributs et méthodes de la classe parent. Ou bien la sous-classe hérite des méthodes de la classe parent afin que la sous-classe ait le même comportement que la classe parent.

Exemple :
Par exemple, vous pouvez d'abord définir une classe appelée voiture. La voiture a les attributs suivants : la taille de la carrosserie, la couleur, le volant, les pneus, et deux classes, les voitures et les camions. dérivé de la classe automobile Ajoutez un petit coffre pour une berline et un grand coffre pour un camion.

L'héritage exprime une relation d'intersection entre les classes d'objets, qui permet à un objet d'un type d'hériter des données membres et des méthodes membres d'un autre type d'objet. Si la classe B hérite de la classe A, alors les objets appartenant à B auront tout ou partie des propriétés (attributs de données) et fonctions (opérations) de la classe A. On appelle la classe A héritée une classe de base, une classe parent ou une super classe, et nous l'appelons classe de base, classe parent ou super classe. La classe héritée B est une classe dérivée ou une sous-classe de A.

Termes indiquant la classe parent et la sous-classe : classe parent et sous-classe, superclasse et sous-classe, classe de base et classe dérivée, ils signifient la même chose.

Pourquoi avez-vous besoin d'hériter

Développer des classes d'animaux, où les animaux sont des pingouins et des souris. Les exigences sont les suivantes :
Pingouin : attributs (nom, identifiant), méthodes (. manger, dormir, s'auto-présenter )
Souris : attributs (nom, identifiant), méthodes (manger, dormir, s'auto-présenter)
Les pingouins et les souris sont tous deux des animaux Pouvons-nous écrire une classe d'animaux ? le code beaucoup plus simple. Certaines personnes disent que je veux juste créer deux classes distinctes pour écrire cet attribut. Je peux seulement vous dire que c'est possible, mais c'est comme si votre père vous donnait des millions, mais vous n'en voulez pas. Vous jetez l'argent. et insiste pour le gagner vous-même, je n'y peux rien si vous voulez faire ça. Puisque Java nous fournit l'héritage, nous devons en faire bon usage. Cela améliorera considérablement notre efficacité de développement. Par exemple : la maintenabilité est améliorée, le code est plus concis et la réutilisabilité du code est également améliorée (la réutilisabilité signifie que). il peut être utilisé plusieurs fois, pas besoin d'écrire le même code plusieurs fois).

Fonction :

1. L'héritage peut réduire le code en double. Par exemple, les méthodes déjà fournies par la classe parent peuvent être utilisées directement par la sous-classe sans avoir à les implémenter.

2. L'héritage est la condition préalable au polymorphisme. Bien entendu, l’utilisation de l’héritage améliore également le couplage des classes.

　Lorsque vous n'avez pas besoin des attributs de la classe parent, vous pouvez remplacer les attributs d'origine.

Classification de l'héritage Java

L'héritage est divisé en héritage unique et héritage multiple. L'héritage unique signifie qu'une sous-classe peut avoir au plus une classe parent. L'héritage multiple signifie qu'une sous-classe peut avoir plus de deux classes parentes. Étant donné que l’héritage multiple peut entraîner une ambiguïté, l’héritage unique doit être utilisé autant que possible dans les applications pratiques. Les classes en langage Javaava ne prennent en charge que l'héritage unique, tandis que les interfaces prennent en charge l'héritage multiple. La fonction d'héritage multiple en Java est indirectement implémentée via les interfaces.

Implémentation de l'héritage

L'héritage peut être obtenu en utilisant les deux mots-clés extends et Implements, et toutes les classes héritent de java.lang.Object Lorsqu'une classe n'hérite pas des deux mots-clés, elle héritera. la classe ancêtre de l'objet (cette classe est dans le package java.lang, il n'est donc pas nécessaire d'importer) par défaut.

Séquence d'initialisation héritée :

Classe parent—>Attributs dans l'objet d'initialisation de la classe parent—>Méthode constructeur de la classe parent—>Sous-classe—>Initialisation de la sous-classe Attributs dans l'objet -> Méthode constructeur de la sous-classe

S'il existe une méthode constructeur : exécutez d'abord l'attribut, puis exécutez la méthode constructeur

Si l'attribut name n'a pas de valeur dans la méthode constructeur , alors La valeur de name est la valeur attribuée à l'attribut de classe

mot-clé extends

En Java, l'héritage de classe est un héritage unique, c'est-à-dire qu'une sous-classe ne peut avoir qu'une seule classe parent . Les extensions ne peuvent donc hériter que d’une seule classe.

/*动物类*/
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{ 
//企鹅继承了动物类，所以拥有了动物类的属性和方法
}

Copier après la connexion

mot-cléimplements

L'utilisation du mot-clé Implements peut donner à Java la fonctionnalité d'héritage multiple déguisé. Le champ d'utilisation est lorsqu'une classe hérite d'une interface multiple (interfaces). peuvent être hérités en même temps).

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

Copier après la connexion

super et this mots-clés

super mot-clé : Nous pouvons utiliser le super mot-clé pour accéder aux membres de la classe parent et l'utiliser pour référencer le parent de l'objet actuel classe.

Remarque :
1. Le mot-clé super ne peut être utilisé que dans les constructeurs ou les méthodes d'instance, mais le mot-clé super ne peut pas être utilisé dans les méthodes statiques et les blocs de code statiques

2. If If les variables et méthodes membres de la classe parent sont définies comme des types privés, alors la sous-classe ne pourra jamais y accéder. Si vous essayez d'accéder à la variable var de type privé de la classe parent sous la forme de super.var, cela provoquera une compilation. error

ce mot-clé : Une référence pointant vers elle-même, indiquant la référence d'objet qui appelle actuellement cette méthode.

Remarque :
1. Lorsqu'il y a plusieurs constructeurs surchargés et qu'un constructeur doit en appeler un autre pour le construire, utilisez ce formulaire (param) dans sa première ligne pour appeler, et seulement peut être sur le première ligne ;

2. Lorsqu'une méthode dans l'objet doit appeler d'autres méthodes dans l'objet, utilisez-la comme mélodie principale, ou vous n'avez pas besoin de l'écrire. En fait, la valeur par défaut est celle-ci. comme mélodie principale

　　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();
    }
}

Copier après la connexion

运行结果：
　　父类的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。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!