Was ist Vererbung in Java? Wie verwende ich Vererbung in Java?

Der Inhalt dieses Artikels soll Ihnen vorstellen, was Java-Vererbung ist. Wie verwende ich Vererbung in Java? Bringen Sie Anfängern bei, wie man Vererbung nutzt und das Konzept der Vererbung versteht. Beherrschen Sie Zugriffsmodifikatoren und beherrschen Sie die Verwendung des endgültigen Schlüsselworts. Es hat einen gewissen Referenzwert. Freunde in Not können sich darauf beziehen. Ich hoffe, es wird Ihnen hilfreich sein.

Vererbung

Warum Vererbung verwenden

Werfen wir zunächst einen Blick auf diese beiden Klassen:

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

rrree

Es gibt einige Ähnlichkeiten zwischen der Student-Klasse und die Eigenschaften und Methoden der Lehrerklasse. Hierbei handelt es sich um doppelte Codes. Wenn ein Programm eine große Anzahl von Klassen enthält, wird eine große Menge doppelter Codes generiert. Können diese doppelten Codes extrahiert und von anderen Klassen verwendet werden, um sie zu vereinfachen? Das heißt, Vererbung zu verwenden.

Nach der Verwendung der Vererbungsoptimierung:

Erstellen Sie das Vererbungspaket

Übergeordnete Klasse: (öffentliche Codeklasse)

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

Unterklasse: Student.java

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;
    }
    
}

Unterklasse: Teacher.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;
    }
}

Testklasse:

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;
    }
    
}

Bei Betrachtung des obigen Beispielcodes haben wir Folgendes gefunden:

1. Der gesamte öffentliche Code der Unterklasse kann in der übergeordneten Klasse platziert werden

2. Unterklassen können ihre eigenen eindeutigen Methoden und Attribute haben

3 Sobald eine Unterklasse die übergeordnete Klasse erbt, verfügt sie über die Attribute und Methoden der übergeordneten Klasse

4. Fügen Sie den öffentlichen Code in die übergeordnete Klasse ein, um die einheitliche Änderung des Codes zu erleichtern.

Geerbte Syntax

Schlüsselwörter: extends

1. Schreiben Sie die übergeordnete Klasse

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();
    }
}

2. Schreiben Sie eine Unterklasse und erben Sie von der übergeordneten Klasse

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

Eine Unterklasse kann nur eine übergeordnete Klasse erben

Die Unterklasse kann auf die Mitglieder der übergeordneten Klasse zugreifen

Wenn eine Unterklasse auf Mitglieder der übergeordneten Klasse zugreifen möchte, muss sie das Schlüsselwort super verwenden, das das übergeordnete Klassenobjekt super darstellt

Zugriff auf den Konstruktor der übergeordneten Klasse:

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

Zugriff auf die Attribute der übergeordneten Klasse:

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

Zugriff auf die Methode der übergeordneten Klasse:

super.name;

Zugriff auf den Konstruktor der übergeordneten Klasse, muss im Unterklassenkonstruktor aufgerufen werden, muss der erste Satz sein

super kann nur in Methoden und Konstruktoren von Unterklassen erscheinen

super kann nicht auf private Mitglieder zugreifen der Elternklassen

Ein Klopfen: Besuchen Sie die Mitglieder der Elternklasse

Erstellen Sie das Paket „visitparent“ und erstellen Sie die folgende Klasse unter dem Bericht

Elternklasse

super.print();

Unterklasse

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;
    }
    
}

Die Unterklasse kann die übergeordneten privaten Mitglieder einer Klasse nicht erben

Unterklassen können keine Mitglieder verschiedener Pakete erben, die Standardzugriffsberechtigungen (den Standardzugriff) verwenden Berechtigungen schreiben keine Zugriffsmodifikatoren)

Unterklassen können die Konstruktormethode der übergeordneten Klasse nicht erben

Ausführungsprozess der Mehrfachvererbung

Was Tut die Elternklasse etwas, wenn sie eine Unterklasse erstellt?

Erstellen Sie unten drei Klassen, um den Ausführungsprozess zu beobachten. Klasse C erbt Klasse B und Klasse B erbt Klasse A.

A.java

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;
    }
    
}

B.java

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

C.java

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

TestRunFlow.java-Testklasse, die die laufenden Ergebnisse anzeigt

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

Das laufende Ergebnis ist:

Der Parameterlose Konstruktor der Klasse A wird ausgeführt

Der Parameterlose Konstruktor der Klasse B wird ausgeführt
Der Parameterlose Konstruktor der Klasse C wird ausgeführt

Wenn der Unterklassenkonstruktor den entsprechenden Konstruktor der übergeordneten Klasse explizit über super aufruft, wird der parameterlose Konstruktor der übergeordneten Klasse nicht ausgeführt

Der Unterklassenkonstruktor ruft den parameterlosen Konstruktor der übergeordneten Klasse auf Standardmäßig ruft die Methode

den Parameterlosen Konstruktor der übergeordneten Klasse auf, bis der Parameterlose Konstruktor des Objekts der übergeordneten Klasse der obersten Ebene ausgeführt wird

Gemäß Obige Regeln, beurteilen Kann der folgende Code durch

Elternklasse

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

Unterklasse

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

kompiliert werden? Die Antwort lautet: Nein. Es gibt nur parametrisierte Konstruktoren in der Elternklasse Kein Parameterloser Konstruktor in der Klasse. Der Parameterlose Konstruktor der Unterklasse ruft standardmäßig den Parameterlosen Konstruktor der Elternklasse auf, daher liegt ein Fehler vor in der Kinderklasse gemeldet.

Lösung: 1. Fügen Sie der übergeordneten Klasse explizit einen Konstruktor ohne Parameter hinzu. 2. Rufen Sie im Konstruktor der Unterklasse explizit den parametrisierten Konstruktor der übergeordneten Klasse auf.

Zugriffsmodifikatoren in Java

Der geschützte Zugriffsmodifikator kann Eigenschaften und Methoden ändern. Nach der Änderung können diese Klasse, Unterklassen und dasselbe Paket darauf zugreifen.

< td >geschützt

Zugriffsmodifikator

Diese Klasse

Gleiches Paket

Unterklasse

Andere

privat

√

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

<🎜>

Standard (freundlich)

√

√

<🎜>

<🎜>

√

√

√

<🎜>

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 修饰的类

Das obige ist der detaillierte Inhalt vonWas ist Vererbung in Java? Wie verwende ich Vererbung in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!