Classes orientées objet JavaSE, héritage et polymorphisme

Comprenez-vous les cours ?

• 1 En Java, un fichier de classe est un fichier de code avec le suffixe .java. Une seule classe publique est autorisée à apparaître dans chaque fichier de classe. Lorsqu'il existe une classe publique, La. le nom du fichier de classe doit être le même que le nom de la classe publique. Si public n'existe pas, le nom du fichier de classe peut être n'importe quel nom.

• 2 Au sein de la classe, pour les variables membres, s'il n'y a pas d'initialisation d'affectation explicite lors de la définition, Java veillera à ce que chaque variable membre de la classe soit correctement initialisée
  1) Pour les variables de types de données de base telles que char, short, byte, int, long, float, double, etc., elles seront initialisées à 0 par défaut (les variables booléennes seront initialisées à false par défaut
  2) ; types de référence Les variables seront initialisées à null par défaut.

• 3 Si le constructeur n'est pas explicitement défini, le compilateur créera automatiquement un constructeur sans argument ; si le constructeur est explicitement défini, le compilateur n'ajoutera pas automatiquement le constructeur. Notez que tous les constructeurs sont statiques par défaut.

• 4 L'ordre dans lequel les classes instancient les objets
  1) Lorsque le programme est exécuté, un objet d'une certaine classe doit être généré. Le moteur d'exécution Java vérifiera d'abord si. cette classe est chargée. Si elle n'est pas chargée, la classe sera chargée en premier puis l'objet sera généré. S'il a été chargé, l'objet sera généré directement.
  2) Pendant le processus de chargement de la classe, les variables membres statiques de la classe seront initialisées. De plus, s'il y a un bloc d'instructions statiques dans la classe, le bloc d'instructions statiques sera exécuté. L'ordre d'exécution des variables membres statiques et des blocs d'instructions statiques est cohérent avec l'ordre dans le code.
  3) En Java, les classes sont chargées à la demande. Cette classe ne sera chargée que lorsqu'elle sera nécessaire, et une seule fois.
  Regardez l'exemple suivant pour comprendre :

  public class Bread {
    static {
        System.out.println("Bread is loaded");
    }
    public Bread() {
        System.out.println("bread");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        Bread bread1 = new Bread();
        Bread bread2 = new Bread();
    }
  }

  Exécutez ce code et vous constaterez que "Le pain est chargé" ne sera imprimé qu'une seule fois.
  4) Dans le processus de génération d'un objet, les variables membres de l'objet seront d'abord initialisées, puis le constructeur sera exécuté. Cela signifie que les variables de la classe seront initialisées avant qu'une méthode (y compris le constructeur) ne soit appelée, même si les variables sont intercalées entre les définitions de méthode.

  public class Test {
    public static void main(String[] args)  {
        new Meal();
    }
  } 
  class Meal {     
    public Meal() {
        System.out.println("meal");
    }
    Bread bread = new Bread();
  }
  class Bread {     
    public Bread() {
        System.out.println("bread");
    }
  }

  Le résultat de sortie est :

  bread
  meal

Comprenez-vous l'héritage ?

• 1 Héritage
  1) L'héritage est un élément indispensable de tous les langages POO. Le mot-clé extends est utilisé en Java pour exprimer la relation d'héritage. Lorsqu'une classe est créée, elle est toujours héritée. Si la classe à hériter n'est pas explicitement indiquée, elle est toujours implicitement héritée de la classe racine Object. Par exemple, le code suivant :

  class Person {
    public Person() {
  
    }
  }
  class Man extends Person {
    public Man() {
  
    }
  }

  2) La classe Man hérite de la classe Person. Dans ce cas, la classe Person est appelée classe parent (classe de base), et la classe Man est appelée. la sous-classe (classe dérivée) . S'il existe une relation d'héritage entre deux classes, la sous-classe héritera automatiquement des méthodes et variables de la classe parent, et les méthodes et variables de la classe parent pourront être appelées dans la sous-classe.
  3) En Java, seul l'héritage unique est autorisé, c'est-à-dire qu'une classe ne peut hériter explicitement que d'une classe parent au maximum. Mais une classe peut être héritée par plusieurs classes, ce qui signifie qu’une classe peut avoir plusieurs sous-classes.

• 2 La sous-classe hérite des attributs de la classe parent
  Lorsque la sous-classe hérite d'une certaine classe, elle peut utiliser les variables membres de la classe parent, mais elle n'hérite pas complètement de la classe parent. toutes les variables membres. Les principes spécifiques sont les suivants :
  1) Les variables membres publiques et protégées de la classe parent peuvent être héritées ; les variables membres privées de la classe parent ne peuvent pas être héritées
  2) Pour les variables membres d'autorisation d'accès au package ; de la classe parent, si la sous-classe et Si la classe parent est dans le même package, la sous-classe peut hériter ; sinon, la sous-classe ne peut pas hériter
  3) Pour les variables membres de la classe parent dont la sous-classe peut hériter, si un ; Une variable membre du même nom apparaît dans la sous-classe, alors le phénomène hide se produira, c'est-à-dire que les variables membres de la sous-classe bloqueront les variables membres de la classe parent avec le même nom. Si vous souhaitez accéder à une variable membre portant le même nom dans la classe parent d'une sous-classe, vous devez utiliser le mot-clé super comme référence.

• 3 La sous-classe hérite des méthodes de la classe parent
  De même, la sous-classe n'hérite pas complètement de toutes les méthodes de la classe parent.
  1) Peut hériter des méthodes membres publiques et protégées de la classe parent ; ne peut pas hériter des méthodes membres privées de la classe parent
  2) Pour les méthodes membres d'autorisation d'accès au package de la classe parent, si la sous-classe et la classe parent est dans le même package, la sous-classe peut hériter ; sinon, la sous-classe ne peut pas hériter
  3) Pour les méthodes membres de la classe parent dont la sous-classe peut hériter, si une méthode membre du même nom apparaît dans ; la sous-classe, on l'appelle overrides , c'est-à-dire que les méthodes membres de la sous-classe remplaceront les méthodes membres de la classe parent du même nom. Si vous souhaitez accéder à une méthode membre portant le même nom dans la classe parent d'une sous-classe, vous devez utiliser le mot-clé super comme référence.

• 4 Remarque
  Le cache et la couverture sont différents.
  Le masquage concerne les variables membres et les méthodes statiques,
  tandis que l'écrasement concerne les méthodes ordinaires.

• 5 构造器
  1）子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。
  2）如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

• 6 super主要有两种用法
  1）super.成员变量/super.成员方法;
  2）super(parameter1,parameter2....)
  第一种用法主要用来在子类中调用父类的同名成员变量或者方法；
  第二种主要用在子类的构造器中显示地调用父类的构造器
  要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

你了解多态吗？

• 1 子类必是父类，所以父类型的引用可以指向子类型的对象。

• 2 动态绑定方法的多种不同版本（即非编译时绑定，而是晚绑定或者动态绑定）

  Parent p = new Child(); 
  p.eat();

  此时Parent和Child中必须都有eat()方法；
  即多态进行动态绑定的前提条件是继承，子类必须继承父类的方法，才能使用父类的引用进行方法调用。

• 3 父类引用能向下转换成子类引用的前提是父类引用指向子类的对象。

• 4 向下转换后的引用，就可以调用子类特有的方法了。

• 5 多态的好处，定义方法时，出入参可以申明为父类的类型，传参时，可以传递子类的对象。这样在方法不改变的前提下，就可以扩展子类的种类，添加新的逻辑。

• 6 覆盖方法才会进行动态绑定，而隐藏是不会发生动态绑定的。
  1）举例如下

  public class Test {
    public static void main(String[] args)  {
        Shape shape = new Circle();
        System.out.println(shape.name); // 成员变量（隐藏）
        shape.printName(); // 静态方法（隐藏）
        shape.printType(); // 非静态方法（覆盖）
    }
  }
  class Shape {
    public String name = "shape";
  
    public Shape(){
        System.out.println("shape constructor");
    }
  
    public void printType() {
        System.out.println("this is shape");
    }
  
    public static void printName() {
        System.out.println("shape");
    }
  }
  class Circle extends Shape {
    public String name = "circle";
  
    public Circle() {
        System.out.println("circle constructor");
    }
  
    public void printType() {
        System.out.println("this is circle");
    }
  
    public static void printName() {
        System.out.println("circle");
    }
  }

  2）输出结果：

  shape constructor
  circle constructor
  shape
  shape
  this is circle

  3）原因分析
  覆盖受RTTI（Runtime type  identification）约束的，而隐藏却不受该约束。也就是说只有覆盖方法才会进行动态绑定，而隐藏是不会发生动态绑定的。在Java中，除了static方法和final方法，其他所有的方法都是动态绑定。因此，就会出现上面的输出结果。

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!