Java类继承完整解析

Java类的继承是面向对象编程中最重要和最基本的概念之一。继承的概念是指一个类从另外一个类获取属性和方法，而被获取的类称为父类或超类，使用该属性和方法的类称为子类或派生类。在本篇文章中，我们将全面介绍Java类的继承，从基本概念开始到高级应用，提供丰富的代码示例和详细解析，让读者轻松掌握Java类继承的所有知识。

一、基本概念

1.1 父类与子类

在Java中，一个类可以通过extends关键字继承另一个类的属性和方法。被继承的类称为父类或超类，继承的类称为子类或派生类。例如：

public class Animal {
    protected String name;
    protected int age;

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

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

在这个例子中，Animal是Dog的父类，Dog是Animal的子类。Dog继承了Animal的name和age属性，同时也继承了eat()方法。

1.2 继承层次结构

Java中支持多级继承，即一个子类可以通过继承多个父类来获取更多的属性和方法。这样就形成了继承层次结构。例如：

public class Animal {
    protected String name;
    protected int age;

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

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

public class GoldenRetriever extends Dog {
    public void fetch() {
        System.out.println("Golden Retriever is fetching.");
    }
}

在这个例子中，GoldenRetriever是Dog的子类，同时也是Animal的子类。GoldenRetriever继承了Dog的bark()方法和Animal的name和age属性以及eat()方法。

1.3 protected关键字

protected关键字用于控制属性和方法的访问范围，被protected修饰的属性和方法可以被子类继承和访问，但不能被其他包中的类访问。例如：

public class Animal {
    protected String name;
    protected int age;

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

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

public class Labrador extends Dog {
    public void swim() {
        System.out.println("Labrador is swimming.");
    }
}

public class Main {
    public static void main(String[] args) {
        Labrador labrador = new Labrador();
        labrador.name = "Max";     // 可以访问父类的protected属性
        labrador.age = 3;
        System.out.println(labrador.name + " is " + labrador.age + " years old.");
    }
}

在这个例子中，Labrador继承了Animal和Dog的protected属性name和age，可以使用labrador.name和labrador.age来访问。但是在Main类中，无法访问Labrador的name和age属性。

二、继承的常见问题

2.1 父类构造函数

在Java中，子类的构造函数默认会调用父类的无参构造函数。如果父类没有无参构造函数，子类需要显式地调用父类的构造函数。例如：

public class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

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

public class Dog extends Animal {
    public Dog(String n, int a) {
        super(n, a);     // 显式调用父类的构造函数
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

在这个例子中，Animal类的构造函数需要定义两个参数，所以Dog类的构造函数中需要显式调用父类的构造函数。

2.2 方法重写

方法重写是指子类重新定义了父类已有的方法，使得子类的方法版本覆盖了父类的方法版本。在Java中，使用@Override注解可以标记一个方法是重写父类方法的。例如：

public class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

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

public class Dog extends Animal {
    public Dog(String n, int a) {
        super(n, a);
    }

    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

在这个例子中，Dog重写了Animal的eat()方法，并且使用@Override注解加以标记。在调用Dog的eat()方法时，将会输出“Dog is eating.”而不是“Animal is eating.”。

2.3 super关键字

super关键字用于在子类中访问父类的成员变量和成员方法。例如：

public class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

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

    public String getName() {
        return name;
    }
}

 public class Dog extends Animal {
    private String barkSound;

    public Dog(String n, int a, String b) {
        super(n, a);
        barkSound = b;
    }

    public void bark() {
        System.out.println("Dog is barking " + barkSound + ".");
    }

    public void getName() {
        System.out.println("The dog's name is " + super.getName() + ".");
    }
}

在这个例子中，Dog类中的getName()方法重写了Animal类中的getName()方法，并且在方法中使用super关键字来访问父类的getName()方法，输出“The dog's name is Max.”。

三、继承的高级应用

3.1 接口与抽象类

接口和抽象类都是Java中用于实现类似多继承的方法。接口可以理解为一种规范，它定义了一些方法的签名，不包含方法的实现。类实现接口时必须实现接口中定义的所有方法。抽象类则是一种中介形态，它可以定义一些成员变量和方法，但方法不需要全部实现。子类继承抽象类后，必须实现抽象类中未实现的方法。例如：

public interface Swim {
    public void swim();
}

public abstract class Animal {
    protected String name;
    protected int age;

    public Animal(String n, int a) {
        name = n;
        age = a;
    }

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

    public abstract void makeSound();     // 抽象方法

    public abstract void move();          // 抽象方法
}

public class Dog extends Animal implements Swim {
    private String barkSound;

    public Dog(String n, int a, String b) {
        super(n, a);
        barkSound = b;
    }

    public void bark() {
        System.out.println("Dog is barking " + barkSound + ".");
    }

    public void makeSound() {
        System.out.println("Dog is making sound.");
    }

    public void move() {
        System.out.println("Dog is moving.");
    }

    public void swim() {
        System.out.println("Dog is swimming.");
    }
}

在这个例子中，Swim是一个接口，定义了一个swim()方法。Animal是一个抽象类，其中定义了两个抽象方法makeSound()和move()。Dog继承了Animal并且实现了Animal中的两个抽象方法以及Swim接口中的swim()方法。

3.2 其他高级应用

除了接口和抽象类之外，Java中还有一些其他的高级继承应用，例如final类和final方法。final类表示该类不能被继承，final方法表示该方法不能被重写。

public final class Animal {}     // final类

public class Dog {
    public final void bark() {}   // final方法
}

四、总结

Java类的继承是面向对象编程中最重要和最基本的概念之一。一个类可以通过extends关键字继承另一个类的属性和方法。被继承的类称为父类或超类，继承的类称为子类或派生类。Java中支持多级继承，即一个子类可以通过继承多个父类来获取更多的属性和方法。使用protected关键字可以控制属性和方法的访问范围。子类需要显式地调用父类的构造函数。方法重写是指子类重新定义了父类已有的方法，使用@Override注解可以标记一个方法是重写父类方法的。使用super关键字可以在子类中访问父类的成员变量和成员方法。除了接口和抽象类之外，Java中还有一些其他的高级继承应用，例如final类和final方法。