Méthode de construction de la classe parent enfant dans l'héritage JAVA

Tout d'abord, le constructeur lui-même aura un constructeur implicite sans argument (par défaut) :

①N'écrivez pas le constructeur, la première ligne de code dans le la classe est le fait Il existe une construction par défaut sans argument (le système l'écrira implicitement pour vous)

public class Student {
        private String name;
//        public Student() {}      隐式地“写”在这里，你看不见
//  Strudent类中虽然没有写构造方法，但相当于有上面的无参构造
//   只不过是隐式的，你看不见
}

(vidéo recommandée : tutoriel vidéo Java )

②Écrivez uniquement le constructeur avec paramètres, ce qui équivaut uniquement au constructeur avec paramètres (la construction implicite sans paramètre sera protégée et ignorée et considérée comme invalide)

public class Student {
        private String name;
        public Student(String name) {
            this.name=name;
        }
//  此时原来Strudent类中的隐式的无参构造方法被屏蔽了，无效了
//  类中只有带参构造
}

③ Si vous souhaitez avoir à la fois des constructeurs sans paramètre et paramétrés, vous devez explicitement écrire les constructeurs sans paramètre et paramétrés

public class Student {
        private String name;
        public Student() {}
// 显式地将无参构造写出来        
        public Student(String name) {
            this.name=name;
        }
//  若想Strudent类中拥有无参构造方法，必须显式地写出来
}

Pour combiner davantage l'héritage, vous devez considérer les classes enfant et parent :

④Dans le constructeur de la sous-classe (qu'elle soit sans paramètre ou paramétrée), la première ligne de code de la méthode inclut en fait implicitement le constructeur sans paramètre de la classe parent

C'est-à-dire : super()

public class Stu extends Student {
    private String name;
    public Stu() {
    // super();
    // 在子类的无参构造中，super()是隐式的“写”在这里的
    }
    
    public Stu(String name) {
    // super();
    this.name=name;
    // 在子类的带参构造，上面的super()同样也是隐式的“写”在这里的
    }
}

C'est pourquoi, lors de l'appel du constructeur d'une sous-classe, le constructeur sans paramètre de la classe parent sera appelé en premier, car le super() par défaut existe.

⑤ De même, comme ② ci-dessus, si vous écrivez une construction paramétrée, super(xx) bloquera le super() implicite

public class Stu extends Student {
    private String name;
    
    public Stu(String name) {
    // super();  原来隐式写在这里的super()被屏蔽了，无效了
    super(name);
    
    // 在子类的带参构造， 由于的super(name)的存在，super()无效了
    //此时子类的带参构造中，只有super(name)
    }
}

C'est pourquoi quand Quand la classe parent n'a pas un constructeur sans paramètre (c'est-à-dire qu'il n'a qu'un constructeur paramétré – correspondant au cas 2), la méthode constructeur de la sous-classe ne peut pas réussir la compilation. En effet, le constructeur de la classe enfant (avec ou sans paramètres) appellera le constructeur sans paramètre de la classe parent. Étant donné que le compilateur essaie d'insérer super() dans 2 constructeurs de la classe enfant, mais que le constructeur par défaut de la classe parent n'est pas défini, le compilateur signale un message d'erreur.

Pour résoudre ce problème,

1) Ajoutez un constructeur sans argument à la classe parent - ajoutez explicitement le constructeur sans argument à la classe parent

2 ) Supprimez le constructeur paramétré personnalisé dans la classe parent - équivalent à restaurer le constructeur sans paramètre par défaut

3) Ajoutez Super(XXX) au constructeur de sous-classe - via l'original de ⑤ Bloquez le super() par défaut

Cet article provient du site Web php chinois, rubrique tutoriel Java, bienvenue pour apprendre !

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!