Java类的继承

Java是一种面向对象的编程语言，就像其他面向对象的语言一样，Java也支持类的继承。类的继承是面向对象编程的重要概念之一，它允许一个类继承另一个类的属性和方法，同时还可以定义新的属性和方法。

一、基本概念

在Java中，类的继承是通过使用关键字extends来实现的。在定义一个类时，可以使用extends关键字来指定该类继承自另一个类。被继承的类称为父类或者超类，继承该类的类称为子类或者派生类。在Java中，只能单继承，即一个子类只能继承一个父类。

下面是一个简单的例子：

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.bark();
    }
}

在上面的例子中，Animal是父类，Dog是子类。Dog继承了Animal的eat()方法并新增了bark()方法。在main()方法中，可以看到Dog对象可以调用eat()和bark()方法。

二、构造方法

当一个类被继承时，子类会继承父类的所有属性和方法，但是不会继承构造方法。子类必须调用父类的构造方法来初始化继承的属性。Java提供了两种方式来调用父类的构造方法：

• 使用super关键字调用父类的构造方法。
• 如果子类没有调用任何父类构造方法，则会默认调用父类的无参构造方法。

下面是一个例子：

class Animal {
    String name;
    
    Animal(String name) {
        this.name = name;
    }
}

class Dog extends Animal {
    int age;
    
    Dog(String name, int age) {
        super(name);
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("Tom", 2);
        System.out.println(dog.name + " is " + dog.age + " years old");
    }
}

在上面的例子中，Animal有一个有参构造方法，Dog调用了父类的构造方法并初始化了自己的属性。

三、方法重写

当子类继承父类后，如果子类需要修改继承的方法的实现，可以使用方法重写。方法重写也称为方法覆盖或者方法复写。方法重写用于改变继承方法的行为，但是不改变继承方法的方法名、参数列表、返回值类型。

下面是一个例子：

class Animal {
    void move() {
        System.out.println("Animal is moving");
    }
}

class Dog extends Animal {
    void move() {
        System.out.println("Dog is running");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        animal.move();
        dog.move();
    }
}

在上面的例子中，Animal有一个move()方法，Dog重写了该方法并改变了实现。在main()方法中，可以看到Animal和Dog调用的move()方法实现不同。

四、抽象类和接口

抽象类和接口都是面向对象编程的重要概念，它们可以被继承。抽象类可以被继承并且可以包含抽象方法，抽象方法是没有方法体的方法，子类必须重写这些方法。接口也可以被继承，但是接口中的方法只有方法头，没有方法体，子类必须实现这些方法。

下面是一个例子：

// 抽象类
abstract class Animal {
    abstract void move();
}

// 实现抽象类
class Dog extends Animal {
    void move() {
        System.out.println("Dog is running");
    }
}

// 接口
interface Speakable {
    void speak();
}

// 实现接口
class Cat implements Speakable {
    void speak() {
        System.out.println("Cat is speaking");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        dog.move();
        cat.speak();
    }
}

在上面的例子中，Animal是一个抽象类，Dog实现了它并重写了move()方法。Speakable是一个接口，Cat实现了它并实现了speak()方法。

五、多态

多态是面向对象编程的重要概念之一，它允许使用父类的引用来指向子类的对象。通过多态，可以动态的选择调用哪个子类的方法。多态必须满足的条件是：继承、方法重写、父类引用指向子类对象。

下面是一个例子：

class Animal {
    void move() {
        System.out.println("Animal is moving");
    }
}

class Dog extends Animal {
    void move() {
        System.out.println("Dog is running");
    }
}

class Cat extends Animal {
    void move() {
        System.out.println("Cat is jumping");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        animal1.move();
        animal2.move();
    }
}

在上面的例子中，Animal是父类，Dog和Cat都是Animal的子类。在main()方法中，animal1和animal2都是Animal类型的引用，但是它们分别指向了Dog和Cat类型的对象。在调用move()方法时，会动态的选择调用哪个子类的方法。