Quelles sont les caractéristiques de l’héritage Java et du remplacement de méthode ?

Concept : l'héritage est l'une des trois caractéristiques majeures de la grammaire orientée objet. L'héritage peut réduire la redondance du code et améliorer l'efficacité de la programmation. En héritant d'une sous-classe, vous pouvez librement appeler certains attributs et méthodes de la classe parent. Une sous-classe ne peut hériter que d'une seule classe parent, et une classe parent peut être héritée par plusieurs sous-classes. C'est comme nous montrer que les enfants héritent de leur vivant des biens de leur père. L'avantage de la substitution est que les sous-classes peuvent définir leur propre comportement selon leurs besoins. C'est-à-dire que les sous-classes peuvent implémenter les méthodes de la classe parent selon les besoins, tout comme les golden retrievers et les huskies, leurs caractéristiques proviennent de chiens, de hamsters et d'écureuils, leurs caractéristiques proviennent de souris et leurs différences sont des mutations génétiques, ce qui est équivalent. à la réécriture

Caractéristiques de l'héritage :

1) : Java ne prend en charge que l'héritage racine unique, c'est-à-dire qu'une classe ne peut avoir qu'une seule classe parent directe et une classe parent peut avoir plusieurs sous-classes

2) : Extraire les attributs communs des sous-classes Sortez pour générer des attributs de classe parent pour l'héritage

3) : Les sous-classes ne peuvent pas hériter ou remplacer les propriétés et les ressources modifiées par la classe parent en privé

Caractéristiques de la substitution :

1). identiques à ceux de la classe parent La méthode remplacée a le même nom de méthode et la même liste de paramètres

2). Le type de valeur de retour de la méthode remplacée par la sous-classe ne peut pas être supérieur au type de valeur de retour remplacé de la classe parent

3. ). La méthode surchargée par la sous-classe Les droits d'accès utilisés ne peuvent pas être inférieurs aux droits d'accès de la méthode surchargée de la classe parent. Les sous-classes ne peuvent pas remplacer les méthodes déclarées comme privées (c'est-à-dire les attributs privés) dans la classe parent

4). L'exception levée par la méthode de sous-classe ne peut pas être supérieure aux droits d'accès de la classe parent.Exception lorsque la classe est remplacée par la méthode

Méthodes ou mots-clés à utiliser :

extends : Nous pouvons hériter via ce mot-clé. écrire la classe ou la méthode qui doit être héritée après le mot-clé

super() : nous pouvons utiliser cette méthode pour appeler les attributs ou les méthodes de la classe parent dont nous avons hérité en utilisant

Classe de test :

package com.ytzl.total;
/*继承*/
public class inherit {
    public static void main(String[] args) {
        son son = new son();//调用子类
        System.out.println(son.a);//调用子类中的属性
        son.a=2;//可以通过子类改变父类中的属性
        System.out.println("更改后的父类属性"+son.a);
        son.myfather();//带调用父类的方法
        son.money();//调用重写的方法w
        son.jng();//调用静态修饰方法
        son.jing();
        System.out.println("子类通过继承方法调用父类中的属性=>"+son.b);//调用父类中的静态属性
        son.two();
    }
}

Classe parent :

package com.ytzl.total;
public class father {
    int a=0;
    static int b=2;
    private int one=4;//被私有属性修饰后将不能别子类调用或继承,
    protected int two=0;
    protected void two(){//该方法只能被子类继承重写不能被调用
        System.out.println("我是protected方法");
    }
    public void setOne(int one) {
        this.one = one;
    }
    public void money(){
        System.out.println("我是被子类重写的方法");
        System.out.println("父类的属性=>"+a);
    }
    public void myfather(){
        System.out.println("我是被子类继承的方法");
    }
    public static void jing(){
        System.out.println("你好");
    }
    public static void jng(){
        System.out.println("你好");
    }
    private void dong(){
        System.out.println("私有方法");
    }
}

Sous-classe :

package com.ytzl.total;
public class son extends father{
    //方法的重写
    public void money(){
        super.money();//通过继承过去父类的money方法里的内容
        System.out.println("重写后的方法");
        System.out.println("被继承后"+super.a);//通过super来继承父类的属性
        System.out.println("继承后的protected属性=>"+super.two);//通过super来继承protected方法
        super.two();
    }
    public static void jing(){//不能重写静态方法static
        System.out.println("不好");
    }
    private void dong(){//不能重写或者继承父类的私有方法
        System.out.println("私有方法");
    }
    protected void two(){//重写后的protected方法
        System.out.println("我是重写后的protected方法");
    }
}

Résultat après exécution :

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!