Qu'est-ce que l'héritage en Java ? Comment utiliser l'héritage en Java ?

Le contenu de cet article est de vous présenter ce qu'est l'héritage Java ? Comment utiliser l’héritage en Java ? , apprenez aux novices comment utiliser l'héritage et comprenez le concept d'héritage. Maîtrisez les modificateurs d’accès et maîtrisez l’utilisation du mot-clé final. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Héritage

Pourquoi utiliser l'héritage

Nous examinons d'abord ces deux classes :

public class Teacher {
    private int teachingAge;
    private String name;
    private int age;
    
    public void teach() {
        
    }
    public void seyHi() {
        System.out.println("我是："+this.name);
    }
}

public class Student {
    private int studentNo;
    private String name;
    private int age;
    
    public void learn() {
        
    }
    public void seyHi() {
        System.out.println("我是："+this.name);
    }
}

Classe d'étudiant et Classe d'enseignant Là Il existe des propriétés et des méthodes identiques dans le programme, qui sont des codes en double. Lorsqu'il y a un grand nombre de classes dans un programme, une grande quantité de codes en double sera générée. Ces codes en double peuvent-ils être extraits et utilisés par d'autres classes pour les simplifier ? C'est-à-dire utiliser l' héritage .

Après avoir utilisé l'optimisation de l'héritage :

Créez le package d'héritage

Classe parent : (classe de code public)

package inherit;

public class People {
    private String name;
    private int age;
    
    public void sayHi() {
        System.out.println("我是："+this.name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

Sous-classe : Student.java

package inherit;

public class Student extends People{
    private int studentNo;
    public void learn() {
        System.out.println("学习课程");
    }
    public int getStudentNo() {
        return studentNo;
    }
    public void setStudentNo(int studentNo) {
        this.studentNo = studentNo;
    }
}

Sous-classe : Teacher.java

package inherit;

public class Teacher extends People{
    private int teachingAge;
    
    public void teach() {
        System.out.println("教授课程");
    }
    
    public int getTeachingAge() {
        return teachingAge;
    }

    public void setTeachingAge(int teachingAge) {
        this.teachingAge = teachingAge;
    }
    
}

Classe de test :

package inherit;

public class TestInherit {
    public static void main(String[] args) {
        //创建Student对象
        Student stu=new Student();
        stu.setName("张三");//父类中继承过来的方法
        stu.learn();//子类中特有的方法
        stu.sayHi();
        //创建Teacher对象
        Teacher teacher=new Teacher();
        teacher.setName("汤尼");
        teacher.setTeachingAge(2);//子类中特有的方法
        teacher.sayHi();
    }
}

En observant l'exemple de code ci-dessus, nous trouvons :

1. Le code public de la sous-classe peut être placé dans la classe parent

2. La sous-classe peut avoir ses propres méthodes et attributs uniques

3. Une fois que la sous-classe héritera de la classe parent, elle en sera propriétaire. la classe parent Propriétés et méthodes

4. Mettez le code public dans la classe parent pour faciliter la modification uniforme du code

Syntaxe héritée

Mots clés : extends

1. Écrire une classe parent

public class 父类{
    //公共的属性和方法
}

2. Écrire une sous-classe et hériter de la classe parent

public class 子类 extends 父类{
    //子类特有的属性和方法
}

Une sous-classe ne peut en hériter qu'une seule. classe parent

La sous-classe accède aux membres de la classe parent

Si une sous-classe souhaite accéder aux membres de la classe parent, elle doit utiliser le mot-clé super, super représente la classe parent l'objet

accède à la structure de la classe parent Méthodes :

super();//访问无参构造
super(参数);//访问有参构造

Accès aux attributs de la classe parent :

super.name;

Accès aux méthodes de la classe parent :

super.print();

Accès aux constructions de classe parent, doit être dans l'enfant Lorsqu'il est appelé dans un constructeur de classe, il doit s'agir de la première phrase

super ne peut apparaître que dans les méthodes et les constructeurs de sous-classes

🎜>

super ne peut pas visiter les membres privés de la classe parent

Un coup : rendre visite aux membres de la classe parent

Créez le package visitparent et créez la classe suivante sous le rapport
Classe parent

package visitparent;

public class Animal {
    private String name;
    private int legs;
    
    public Animal() {
        this.name="无名";
        this.legs=4;
    }
    public Animal(String name,int legs) {
        this.name=name;
        this.legs=legs;
    }
    
    public void eat(String food) {
        System.out.println(name+" 吃食物："+food);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getLegs() {
        return legs;
    }

    public void setLegs(int legs) {
        this.legs = legs;
    }
    
}

Sous-classes

package visitparent;

public class Cat extends Animal{
    private String hairColor;//毛发颜色
    private int age;
    
    public Cat () {
        super();//调用父类无参
    }
    public Cat(String name,int legs,String hairColor,int age) {
        super(name, legs);//这里调用相当于重用父类构造方法了
        this.hairColor=hairColor;
        this.age=age;
        //super(name, legs);//去掉注释试试
        //this.name="无名";//去掉注释试试
    }
    public void catchMouse() {
        System.out.println(super.getName()+":抓老鼠");
    }
    
    public void paly() {
        System.out.println(super.getName()+" 玩累了。");
        super.eat("小鱼干");
    }

    public String getHairColor() {
        return hairColor;
    }

    public void setHairColor(String hairColor) {
        this.hairColor = hairColor;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

Les sous-classes ne peuvent pas hériter des membres privés de la classe parent

Les sous-classes ne peuvent pas hériter des membres de différents packages qui utilisent les autorisations d'accès par défaut (l'autorisation d'accès par défaut consiste à ne pas écrire de modificateurs d'accès)

Les sous-classes ne peuvent pas hériter de la méthode de construction de la classe parent

Processus d'exécution de l'héritage multiple

Que fait la classe parent lors de la création d'une sous-classe ?

Créez trois classes ci-dessous pour observer le processus d'exécution. La classe C hérite de la classe B et la classe B hérite de la classe A.

A.java

public class A {
    public A() {
        System.out.println("A类的无参构造函数执行");
    }
}

B.java

public class B extends A{
    public B() {
        System.out.println("B类的无参构造函数执行");
    }
}

C.java

public class C extends B{
    public C() {
        System.out.println("C类的无参构造函数执行");
    }
}

Classe de test TestRunFlow.java, affichant la Résultat de l'opération

public class TestRunFlow {
    public static void main(String[] args) {
        C c=new C();
    }
}

Le résultat d'exécution est :

Le constructeur sans paramètre de la classe A est exécuté
Le constructeur sans paramètre de la classe B est exécuté
Le constructeur sans paramètre de la classe C est exécuté

Si le constructeur de la sous-classe appelle explicitement le constructeur correspondant de la classe parent via super, le constructeur sans paramètre de la classe parent ne sera pas exécuté

La sous-classe constructeur Par défaut, le constructeur sans paramètre de la classe parent sera appelé

jusqu'à ce que le constructeur sans paramètre de la classe parent de niveau supérieur de la classe Object soit exécuté

Selon les règles ci-dessus, jugez si le code suivant peut être compilé et transmis

Classe parent

public class Pet {
    private String name;
    public Pet(String name) {
        this.name=name;
    }
}

Sous-classe

public class Dog extends Pet{
}

La réponse est non, dans la classe parent Il n'y a que des constructeurs paramétrés et aucun constructeur sans paramètre. Aucun code dans la sous-classe n'a de constructeur sans paramètre implicite par défaut. Le constructeur sans paramètre de la sous-classe appelle le constructeur sans paramètre de la classe parent par défaut. la classe parent. Tout en erreur signalé dans la sous-classe.

Solution : 1. Ajoutez explicitement un constructeur sans paramètre dans la classe parent, 2. Appelez explicitement le constructeur paramétré de la classe parent dans le constructeur de sous-classe.

Modificateurs d'accès en java

Le modificateur d'accès protégé peut modifier les propriétés et les méthodes Après modification, cette classe, les sous-classes et le même package peuvent y accéder.

< td >protégé

Modificateur d'accès

Cette classe

Même package

sous-classe

Autre

privé

√

访问修饰符	本类	同包	子类	其他
private	√
默认(friendly)	√	√
protected	√	√	√
public	√	√	√	√

<🎜>

<🎜>

Par défaut (convivial)

√

√

<🎜>

<🎜>

√

√

√

<🎜>

public

√

√

√

√

方法重写

在"继承优化后"的代码中，Teacher 继承了 People 类，(忘记代码可以翻回去再看一遍) People 类中有个一个打招呼的方法 sayHi() 用于输出人的名字，但是 Teacher 调用这个方法并不能打印出 Teacher 的属性 teachingAge 的值，但是我们还想用这个方法实现这个功能，应该怎么办呢？

我们可以使用 方法重写 解决这个问题，修改子类 Teacher 中的代码，下面看一下使用方法重写后的效果。

Teacher.java

package inherit;

public class Teacher extends People{
    //省略其他属性
    
    @Override
    public void sayHi() {
        System.out.println("我是："+super.getName()+" ,从事教育行业 "+this.teachingAge+" 年了。");
    }

    //省略其他方法、getter、setter
}

在 Eclipse 中重写某方法的快捷键是 Alt+Shift+S+V ，按完后选择要重写的方法

在 Idea 中重写某方法的快捷键是 Ctrl+O ，按完后选择要重写的方法

@Override 注解的作用， 用来检测是否符合重写规则，不符合重写规则将报错，这个注解可以不写

构造方法不能重写，因为构造方法不能被继承

方法重写的规则：

1.方法名相同

2.参数列表相同

3.返回值类型相同或者是其子类

4.访问权限不能严于父类

final 关键字的使用

1.final 修饰变量后变为常量

private static final long serialVersionUID = -6849794470754667710L;

2.final 修饰类后，该类不能被继承

package java.lang;
public final class Math {
    //省略属性和方法……
}

3.final 修饰方法后，该方法不能被重写

public final void teach() {
        System.out.println("教授课程");
    }

4.final 修饰创建的对象后，该对像不能再次实例化(可以修改属性)

final Teacher teacher=new Teacher();
teacher.setName("汤尼");
//teacher=new Teacher();//去掉注释试试

String 类就是一个典型的被 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!