Une introduction aux concepts et aux méthodes d'implémentation de l'héritage et du polymorphisme Java

1. L'héritage

1. 🎜 🎜#Mécanisme d'héritage : la programmation orientée objet est le moyen le plus important pour la réutilisation du code. Elle permet aux programmeurs d'étendre et d'ajouter de nouvelles fonctions tout en conservant les caractéristiques de la classe d'origine. Les nouvelles classes générées deviennent des classes/sous-classes dérivées. 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.

2. Syntaxe d'héritage

indique la relation d'héritage entre les classes. Vous devez utiliser le mot-clé extends. comme suit :

Modifier la sous-classe de classe/la classe dérivée étend la classe parent/classe de base/superclasse{

//…………#🎜 🎜#

}

La sous-classe héritera des variables membres ou des méthodes membres de la classe parent dans la sous-classe

#🎜 🎜#

• Une fois qu'une sous-classe hérite d'une classe parent, elle doit ajouter ses propres membres uniques pour refléter la différence par rapport à la classe de base

• 3 . Accès membre de la classe parent

(1) Accès aux variables membres de la classe parent dans une sous-classe

Lorsqu'il n'y a pas de variable membre avec le même nom, un accès normal suffit#🎜 🎜#

• Il existe une variable membre du même nom, utilisez (nom de la super.variable) pour accéder à la variable membre de la classe parent#🎜🎜 #

  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; // 访问父类继承的a，还是子类自己新增的a？
          b = 101; // 访问父类继承的b，还是子类自己新增的b?
          c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
      }
  }

• Lorsque vous accédez aux variables membres, accédez d'abord à vos propres variables membres. Autrement dit, lors de l'accès aux variables membres portant le même nom, l'accès aux sous-classes est prioritaire. C'est à dire : la sous-classe cache les membres de la classe parent

Member l'accès aux variables suit le principe de proximité Si vous en avez une, vous avez la priorité. Si vous ne l'avez pas, vous le chercherez dans la classe parent.
(2) Méthodes membres dans les sous-classes qui accèdent aux classes parentes
Les noms des méthodes membres sont différents , ce qui est normal Accédez-y simplement

Les méthodes membres ont le même nom et vous pouvez accéder à la méthode de la classe parent avec le même nom via [super.method name]

• # 🎜🎜#Si les listes de paramètres des méthodes portant le même nom dans la classe parent et la sous-classe sont différentes (surchargées), sélectionnez la méthode appropriée à laquelle accéder en fonction des paramètres transmis lorsque appeler la méthode.
• Si les prototypes de la méthode de même nom de la classe parent et de la sous-classe sont cohérents, accédez au
  4, super mot-clé
#🎜🎜 de la sous-classe #super mot-clé La fonction principale est d'accéder aux membres de la classe parent portant le même nom dans la méthode de sous-classe. (Ne peut être utilisé que dans les méthodes non statiques)

public class Base {
    int a;
    int b;
    public void methodA(){
        System.out.println("Base中的methodA()");
    }
    public void methodB(){
        System.out.println("Base中的methodB()");
}
public class Derived extends Base{
    int a; 
    char b; 
    // 与父类中methodA()构成重载
    public void methodA(int a) {
        System.out.println("Derived中的method()方法");
    }
    // 与父类中methodB()构成重写
    public void methodB(){
        System.out.println("Derived中的methodB()方法");
    }
    public void methodC(){
        a = 100; // 等价于： this.a = 100;
        b = 101; // 等价于： this.b = 101;
        // 访问父类的成员变量时，需要借助super关键字
        // super是获取到子类对象中从基类继承下来的部分
        super.a = 200;
        super.b = 201;
        methodA(); // 没有传参，访问父类中的methodA()
        methodA(20); // 传递int参数，访问子类中的methodA(int)
        methodB(); // 直接访问，则永远访问到的都是子类中的methodA()，基类的无法访问到
        super.methodB(); // 访问基类的methodB()
    }
}

5 Méthode de construction de sous-classe

Lors de la construction d'un objet de sous-classe, vous devez appeler la méthode de construction de la classe parent. d'abord, puis exécutez la méthode Constructor de la sous-classe.

public class Base {
    public Base(){
        System.out.println("Base()");
    }
}
public class Derived extends Base{
    public Derived(){
   // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
   // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
   // 并且只能出现一次
        System.out.println("Derived()");
    }
}

Si la classe parent définit explicitement un constructeur sans paramètre ou par défaut, il y aura un appel super() implicite par défaut dans la première ligne du constructeur de la sous-classe.

Lorsque la classe parent définit un constructeur avec des paramètres, le compilateur ne générera plus de constructeur par défaut pour la sous-classe. La sous-classe doit être explicitement définie et ajoutée dans le fichier. Dans la méthode de construction de classe, appelez la méthode de construction de classe parent appropriée

• Dans la méthode de construction de sous-classe, super(……) appelle la méthode de construction de classe parent. , qui doit être une sous-classe La première instruction du constructeur

• super(……) ne peut apparaître qu'une seule fois dans le constructeur de la sous-classe, et ne peut pas apparaître en même temps temps comme this#🎜🎜 #

• 6, super et this
  super et cela peut être utilisé dans les méthodes membres pour accéder aux variables membres et appeler d'autres fonctions membres , les deux peuvent être utilisés comme première instruction de la méthode constructeur, alors quelle est la différence entre eux ?
• (1) Les similitudes

sont tous des mots-clés Java

#🎜🎜 #Peut uniquement être utilisé dans les méthodes non statiques d'une classe pour accéder aux méthodes et propriétés membres non statiques

doit être utilisé comme première instruction dans le constructeur et ne peut pas exister à la en même temps
(2) Différences
this est une référence à l'objet actuel, et super est une sous-classe Références aux membres hérités de la classe parent dans l'objet
ceci est un paramètre caché de la méthode membre non statique, super n'est pas un paramètre caché#🎜 🎜#

#🎜 🎜#

Dans la méthode constructeur : this() est utilisé pour appeler la méthode constructeur de cette classe, super() est utilisé pour 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 de la sous-classe, mais this() n'existera pas si l'utilisateur ne l'écrit pas

• 7. Ordre d'exécution du bloc de code
  [Classe commune]

• Le bloc de code statique est exécuté une première et une seule fois, lors de la phase de chargement de la classe

• Lorsqu'un objet est créé, le bloc de code d'instance sera exécuté. , et enfin la méthode du constructeur le bloc de code est exécuté avant le bloc de code statique de la classe enfant et est exécuté au plus tôt

#🎜🎜 #

Le bloc de code d'instance de classe parent et la méthode de constructeur de classe parent sont exécutés immédiatement#🎜 🎜#

Le bloc de code d'instance et la méthode constructeur de la sous-classe sont enfin exécutés

# 🎜🎜#

• Lorsque l'objet de la sous-classe est instancié pour la deuxième fois, les blocs de code statiques de la classe parent et de la sous-classe ne seront plus exécutés

8、继承方式

【注】Java中不支持多继承

• super只能指代直接父类

• 继承关系一般不超过三层

9、final关键字

• 修饰变量时，表示常量（不能修改）

• 修饰类：此类不能被继承

• 修饰方法：表示方法不能被重写

10、继承和组合

组合和继承都能实现代码的复用。组合没有涉及到特殊的语法（如extend关键字），仅仅是将一个类的实例作为另一个类的属性。

• 继承表示对象与对象之间是is-a的关系

• 组合表示对象与对象之间是has-a的关系

一般建议：能用组合尽量用组合

二、多态

1、向上转型

通过父类类型的引用调用子类对象，向上转型是安全的

【发生向上转型的时机】

• 直接赋值

• 方法传参

• 函数的返回值

public class TestAnimal {
    // 2. 函数传参：形参为父类引用，可以接收任意子类的对象
    public static void eatFood(Animal a) {
        a.eat();
    }
 
    // 3. 作返回值：返回任意子类对象
    public static Animal buyAnimal(String var) {
        if ("狗" == var) {
            return new Dog("狗狗", 1);
        } else if ("猫" == var) {
            return new Cat("猫猫", 1);
        } else {
            return null;
        }
    }
 
    public static void main(String[] args) {
        Animal cat = new Cat("元宝", 2); // 1. 直接赋值：子类对象赋值给父类对象
        Dog dog = new Dog("小七", 1);
    }
}

优缺点：

• 优点：让代码更加灵活

• 缺点：不能访问到子类特有的方法

2、重写

函数名相同、参数列表相同、返回值相同或是【协变类型】（父子类关系）

【方法重写的规则】

• 重写的方法访问权限不能比父类中原方法的的权限低；

• 父类中被static、private、final修饰的方法、构造方法不能被重写；

• 重写的方法，可以使用 @override 注解来显示指定（帮助我们进行一些合法性的检验）。比如方法名拼写错误，编译会报错；

• 重写的返回值类型可以不同，但是必须具有父子关系。

• 被final修饰的方法，叫做密封方法，该方法不能被重写。

• 外部类只能是public或者默认权限

【动态绑定和静态绑定】

• 动态绑定：发生的条件（1、父类引用引用子类对象；2、通过父类引用，可以访问到子类中的方法）。后期绑定，即在编译时不能确定方法的行为，需要等到程序运行时，才能够确定调用哪个类的方法；

• 静态绑定：前期绑定，编译时，根据用户传递的参数类型确定具体的调用方法（函数重载）

3、多态

一个引用调用同一个方法，可以表现出不同的形式，这种思想称为多态。在父类的构造方法中不要调用重写的方法。

【多态实现的条件】

• 必须在继承条件下

• 子类对父类方法进行重写

• 通过父类引用调用重写的方法

• 发生了向上转型

public class Animal(){
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
        }
}
public class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
public class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    @Override
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class TestAnimal {
    // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
   // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
   // 注意：此处的形参类型必须时父类类型才可以
    public static void eat(Animal a){
        a.eat();
    }
    public static void main(String[] args) {
        Animal animal1 = new Cat("元宝",2);
        Animal animal2 = new Dog("小七", 1);
        eat(animal1);
        eat(animal2);
    }
}

【注】Java中所有的类默认继承Object类

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!