Java继承 #

一、继承概述 #

继承是面向对象三大特性之一，它允许子类继承父类的属性和方法，实现代码复用。

1.1 继承的好处 #

代码复用
扩展功能
实现多态

1.2 继承语法 #

java

// 父类
public class Animal {
    protected String name;
    
    public void eat() {
        System.out.println(name + "在吃东西");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println(name + "在叫");
    }
}

二、继承特点 #

2.1 单继承 #

Java只支持单继承，一个类只能有一个直接父类。

java

// 正确：单继承
public class Dog extends Animal { }

// 错误：多继承不支持
// public class Dog extends Animal, Creature { }

2.2 多层继承 #

java

public class Animal { }
public class Dog extends Animal { }
public class Husky extends Dog { }  // 多层继承

2.3 所有类的父类 #

所有类都直接或间接继承自Object类。

java

public class Person { }
// 等价于
public class Person extends Object { }

三、成员访问 #

3.1 继承的内容 #

子类继承父类的：

public和protected成员
默认访问权限成员（同包）

子类不继承父类的：

private成员
构造方法

java

public class Parent {
    public int publicField;
    protected int protectedField;
    int defaultField;
    private int privateField;
    
    public void publicMethod() { }
    protected void protectedMethod() { }
    void defaultMethod() { }
    private void privateMethod() { }
}

public class Child extends Parent {
    public void test() {
        publicField = 1;       // 可访问
        protectedField = 2;    // 可访问
        defaultField = 3;      // 同包可访问
        // privateField = 4;   // 不可访问
        
        publicMethod();        // 可访问
        protectedMethod();     // 可访问
        defaultMethod();       // 同包可访问
        // privateMethod();    // 不可访问
    }
}

3.2 成员变量隐藏 #

java

public class Parent {
    public int count = 10;
}

public class Child extends Parent {
    public int count = 20;  // 隐藏父类变量
    
    public void show() {
        System.out.println(count);      // 20（子类变量）
        System.out.println(super.count); // 10（父类变量）
    }
}

四、方法重写 #

4.1 重写规则 #

方法名、参数列表必须相同
返回类型可以相同或是子类
访问权限不能更严格
不能重写private和final方法

java

public class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
    
    public Object getInfo() {
        return "动物信息";
    }
}

public class Dog extends Animal {
    @Override  // 重写注解
    public void eat() {
        System.out.println("狗在吃骨头");
    }
    
    @Override
    public String getInfo() {  // 返回类型可以是父类返回类型的子类
        return "狗的信息";
    }
}

4.2 @Override注解 #

java

public class Dog extends Animal {
    @Override  // 编译器检查是否正确重写
    public void eat() {
        System.out.println("狗在吃东西");
    }
    
    // @Override  // 错误：父类没有此方法
    // public void sleep() { }
}

4.3 super调用父类方法 #

java

public class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        super.eat();  // 调用父类方法
        System.out.println("狗在吃骨头");
    }
}

// 调用
Dog dog = new Dog();
dog.eat();
// 输出：
// 动物在吃东西
// 狗在吃骨头

五、构造方法与继承 #

5.1 子类构造方法 #

子类构造方法默认调用父类无参构造。

java

public class Parent {
    public Parent() {
        System.out.println("父类构造方法");
    }
}

public class Child extends Parent {
    public Child() {
        super();  // 默认调用，可省略
        System.out.println("子类构造方法");
    }
}

new Child();
// 输出：
// 父类构造方法
// 子类构造方法

5.2 super调用父类构造 #

java

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

public class Child extends Parent {
    private int age;
    
    public Child(String name, int age) {
        super(name);  // 必须在第一行调用父类构造
        this.age = age;
    }
}

5.3 构造方法调用链 #

java

public class Grandparent {
    public Grandparent() {
        System.out.println("爷爷构造方法");
    }
}

public class Parent extends Grandparent {
    public Parent() {
        System.out.println("父亲构造方法");
    }
}

public class Child extends Parent {
    public Child() {
        System.out.println("儿子构造方法");
    }
}

new Child();
// 输出：
// 爷爷构造方法
// 父亲构造方法
// 儿子构造方法

六、final与继承 #

6.1 final类 #

final类不能被继承。

java

public final class FinalClass {
}

// 错误：不能继承final类
// public class Child extends FinalClass { }

6.2 final方法 #

final方法不能被重写。

java

public class Parent {
    public final void finalMethod() {
    }
}

public class Child extends Parent {
    // 错误：不能重写final方法
    // public void finalMethod() { }
}

七、继承示例 #

7.1 图形类 #

java

public abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    public abstract double getArea();
    
    public void display() {
        System.out.println("颜色: " + color + ", 面积: " + getArea());
    }
}

public class Circle extends Shape {
    private double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;
    
    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double getArea() {
        return width * height;
    }
}

7.2 员工类 #

java

public class Employee {
    private String name;
    private double salary;
    
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    
    public double calculateBonus() {
        return salary * 0.1;
    }
    
    public void display() {
        System.out.println("姓名: " + name + ", 工资: " + salary);
    }
}

public class Manager extends Employee {
    private double bonus;
    
    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }
    
    @Override
    public double calculateBonus() {
        return super.calculateBonus() + bonus;
    }
}

八、总结 #

概念	说明
extends	继承关键字
单继承	一个类只能有一个直接父类
super	引用父类成员
@Override	重写注解
final	不能继承或重写

继承要点：

Java只支持单继承
子类继承父类非private成员
重写方法使用@Override注解
super调用父类构造必须在第一行
final类不能被继承