Resumen de aprendizaje de Java: 9

Herencia

La herencia es la segunda característica principal de la orientación a objetos, y la herencia es resolver el problema de la reutilización del código, el uso de la herencia puede continuar derivando nuevas subclases de las clases existentes, o puede usar subclases para extender más Funciones operativas

Implementación heredada

Formato heredado

class 子类 extends 父类 {}

La subclase es en realidad un medio para definir la clase padre más concretamente.

Explicación:
1. Para las extensiones, debe traducirse como una extensión, pero por conveniencia, se denomina herencia de manera uniforme;
2. La subclase también se denomina clase derivada;
3. La clase padre también se denomina superclase (Superclase) .

Implementación heredada:

class Person{
    private String name;
    private int age;
    public void setName(String name){
        this.name=name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public String getName(){
        return this.name;
    }
    public int getAge(){
        return this.age;
    }
}
class Student extends Person{   //Student类继承了Person类
    private String school;  //子类扩充的属性
    public void setSchool(String school){   //扩充的方法
        this.school=school;
    }
    public String getSchool(){     //扩充的方法
        return this.school;
    }
}
public class Test1_1_3_3 {
    public static void main(String args[]){
        Student stu=new Student();  //实例化的是子类
        stu.setName("小关");  //Person类定义
        stu.setAge(19);
        stu.setSchool("西安邮电大学");    //Student类扩充方法
        System.out.println("姓名："+stu.getName()+",年龄："+stu.getAge()+",学校："+stu.getSchool());
    }
}
//结果：
//姓名：小关,年龄：19,学校：西安邮电大学

Restricciones de herencia

1. Java no permite la herencia múltiple, pero permite la herencia múltiple, Java tiene una única limitación de herencia.

Herencia incorrecta: (herencia múltiple)

class A{}
class B{}
class C extends A,B{}	//一个子类继承两个父类

Herencia multinivel:

class A{}
class B extends A{}	//B类继承A类
class C extends B{}	//C类继承B类

2. Cuando la subclase hereda la clase padre, estrictamente hablando, heredará todas las operaciones en la clase padre, pero todas las operaciones privadas son herencia implícita, y todas las operaciones no privadas son herencia explícita.

class A{
    private String msg;
    public void setMsg(String msg){
        this.msg=msg;
    }
    public String getMsg(){
        return this.msg;
    }
}
class B extends A{//继承自A类
}
public class Test1_1_3_4 {
    public static void main(String args[]){
        B b=new B();
        b.setMsg("HelloWorld");
        System.out.println(b.getMsg());
    }
}
//结果：
//HelloWorld

Se puede ver de lo anterior que el atributo msg debe existir en la clase B, y este atributo se hereda de la clase padre.
Sin embargo , no puede acceder directamente al atributo msg en la clase B, porque es una declaración privada en la clase A, y solo puede usar los métodos setter o getter para acceder indirectamente a los atributos privados.

3. Antes de que se construya el objeto de la subclase, la construcción de la clase principal se llamará de forma predeterminada (la estructura sin parámetros se usa de forma predeterminada) para garantizar que el objeto de la clase principal se instancia primero y luego el objeto de la subclase.

1. La clase padre proporciona un método de construcción sin parámetros:

class A{
    public A(){		//父类提供的无参构造方法
        System.out.println("A类的构造方法");
    }
}
class B extends A{//继承自A类
    public B(){
        System.out.println("B类的构造方法");
    }
}
public class Test1_1_3_4 {
    public static void main(String args[]){
        new B();
    }
}
//结果：
//A类的构造方法
//B类的构造方法

2. La clase padre no proporciona un método de construcción sin parámetros:

class A{
    public A(String title){     //父类提供的有参构造方法
        System.out.println("A类的构造方法"+title);
    }
}
class B extends A{//继承自A类
    public B(String title){
        super(title);   //明确调用父类构造，否则将出现编译错误
        System.out.println("B类的构造方法");
    }
}
public class Test1_1_3_4 {
    public static void main(String args[]){
        new B("!!!");   //实例化子类对象
    }
}
//结果：
//A类的构造方法!!!
//B类的构造方法