Java中类的继承

前言

在本文中，我们将探讨Java中类的继承的基本概念和语法。我们将了解如何定义父类和子类，如何通过关键字extends建立继承关系，以及继承所带来的好处。我们还将讨论方法重写、访问修饰符和类型转换等相关主题，以加深对类继承的理解。

---

一、java中的类的继承是什么？

在Java中，类的继承是一种面向对象编程的核心概念，允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。通过继承，子类可以重用父类的代码，并且可以在不修改父类代码的情况下添加新的功能或修改现有功能。

二、基本语法

代码如下（示例）：

class 父类 {
       //
}
class 子类(派生类) extends 父类(基类/超类) {
       // 子类的成员变量和方法
}

三、继承方式

代码如下（示例）：

//单继承：
    public class A {}
    public class B extends A {}
//多重继承：
    public class A {}
    public class B extends A {}
    public class C extends B {}
//不同类继承同一个类：
    public class A {}
    public class B extends A {}
    public class C extends A {}
//不可以多继承

四、继承的应用

子类可以访问父类的非private方法,包括继承下来的和父类中声明为"public"或"protected"的成员。如果子类需要访问父类的私有成员，可以通过提供公共的getter和setter方法，或将父类成员声明为protected来实现。

    扩展功能：子类可以在继承父类的基础上，添加自己的属性和方法，从而扩展父类的功能。

    子类可以新增自己的属性和方法。

    每个类都会默认继承Object类。

    代码重用：通过继承,子类可以直接使用父类的属性和方法，避免重复编写相同的代码。
       

//Student.java
public class Student {
    //属性
    private String name;
    //public和protected均可继承
    protected void setName(String n) {    
        name = n;
    }
    public void study() {
        System.out.println(name+"正在学习！");
    }
}
//UNStudent.java
public class UNStudent extends Student {
}
//Main.java
public class Main {
    public static void main(String[] args) {
        UNStudent un = new UNStudent();
        un.setName("a");
        un.study();
    }
}
// a正在学习

        Student类定义了一个私有属性name和两个方法setName()和study()。setName()方法被声明为protected，可以被子类继承和访问。study()方法是一个公共方法，用于输出学习信息。
        UNStudent类是Student类的子类，它继承了Student类的属性和方法。由于setName()方法是protected的，所以UNStudent类可以访问和调用该方法。同时，UNStudent类继承了study()方法，并可以在其实例上调用该方法。
        在Main类的main()方法中，我们创建了一个UNStudent对象un，然后通过调用setName()方法为其设置名字为"a"。最后，调用study()方法输出学习信息。

    方法重写(覆盖)
        1.有继承关系的两个类    
        2.(访问修饰符大于等于父类)返回值类型，方法名，参数类型(个数，顺序)完全一样

class Animal {
    public void makeSound() {
        System.out.println("The animal makes a sound");
    }
}
class Dog extends Animal {
    public void makeSound() {
        System.out.println("The dog barks");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // 输出: The animal makes a sound
        Dog dog = new Dog();
        dog.makeSound(); // 输出: The dog barks
    }
}

        Dog类是Animal类的子类，它继承了makeSound()方法，并对其进行了重写。在Dog类中，makeSound()方法输出了狗的叫声。
        在Main类的main()方法中，首先创建了一个Animal对象animal，然后调用其makeSound()方法，输出了动物发出的声音。接下来，创建了一个Dog对象dog，同样调用其makeSound()方法，输出了狗的叫声。

    子类可以通过"super"关键字调用父类的构造方法和成员方法，用"this"调用自己的方法
        //学生类

public class Student {
    //属性
    private String name;
    public void study() {
        System.out.println(name+"正在学习！");
    }
}
public class UNStudent extends Student {
    public void study() {
        System.out.println("学生正在学习！");
    }   
    public void studyText() {
        super.study();
        this.study();
    }
}

    Student类定义了一个私有属性name和一个公共方法study()，用于输出学生正在学习的信息。
    UNStudent类是Student类的子类，它继承了Student类的属性和方法，并对study()方法进行了重写。在UNStudent类中，重写的study()方法输出了"学生正在学习！"的信息。
    此外，UNStudent类还定义了一个新的方法studyText()。在studyText()方法中，首先使用super.study()调用父类Student的study()方法，然后使用this.study()调用当前类UNStudent的study()方法。
    通过super关键字，可以在子类中调用父类的方法。通过this关键字，可以在当前类中调用自身的方法。

    - 自动类型转换和强制类型转换
        //自动：子类对象可以自动类型转换为父类对象,子类对象可以自动类型转换为父类对象
        //强制：将父类对象转换为子类对象,并且可以使用子类特有的方法和属性
        //使用强制类型转换是时该对象必须先自动转型
       

class Vehicle {
    public void move() {
        System.out.println("Vehicle is moving");
    }
}
class Car extends Vehicle {
    public void accelerate() {
        System.out.println("Car is accelerating");
    }   
}
public class Main {
    public static void main(String[] args) {
    Vehicle vehicle = new Car();//自动类型转换
    vehicle.move(); // 输出: Vehicle is moving
    Car car1 = (Car) vehicle;// 强制类型转换为Car对象
    car1.move(); // 输出: Vehicle is moving
    car1.accelerate(); // 输出: Car is accelerating
    }
}

    Vehicle类定义了一个公共方法move()，用于输出"Vehicle is moving"的信息。

    Car类是Vehicle类的子类，它继承了Vehicle类的方法，并定义了自己的方法accelerate()，用于输出"Car is accelerating"的信息。
    在Main类的main()方法中，首先创建了一个Vehicle对象vehicle，并使用自动类型转换将其赋值为Car类型。由于Car是Vehicle的子类，因此可以进行自动类型转换。
    然后，通过vehicle.move()调用了Vehicle类的move()方法，输出了"Vehicle is moving"的信息。
    接下来，将vehicle对象强制类型转换为Car类型，并将结果赋值给car1变量。由于vehicle实际上引用的是一个Car对象，因此可以进行强制类型转换。
    最后，通过car1.move()调用了Vehicle类的move()方法，输出了"Vehicle is moving"的信息。通过car1.accelerate()调用了Car类的accelerate()方法，输出了"Car is accelerating"的信息。
    需要注意的是，强制类型转换是一种有风险的操作。在进行强制类型转换之前，需要确保被转换的对象实际上是目标类型的一个实例，否则可能会抛出ClassCastException异常。

---

总结

继承还可以用于实现多态性，即通过父类类型的引用来引用子类的对象，从而在运行时根据实际对象的类型来调用相应的方法。这是Java面向对象编程的另一个重要概念，可以实现更灵活和可扩展的代码结构。