继承语法

概述

继承是面向对象的核心特性之一，通过 extends 关键字实现。

基本语法

类继承

public class Animal {
    protected String name;

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

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

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

接口实现

public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }
}

继承的特性

单继承

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

// ❌ 错误
class A extends B, C { }

// ✅ 正确：类只能单继承
class A extends B { }

// ✅ 正确：接口可以多实现
class A extends B implements C, D { }

多层继承

class GrandParent {
    void grandParentMethod() {
        System.out.println("GrandParent");
    }
}

class Parent extends GrandParent {
    void parentMethod() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void childMethod() {
        System.out.println("Child");
    }
}

// Child 对象可以调用所有父类的方法
Child child = new Child();
child.grandParentMethod();  // ✅
child.parentMethod();       // ✅
child.childMethod();       // ✅

继承的内存结构

┌──────────────────────────────────────────────────────────────┐
│                     继承的内存结构                            │
├──────────────────────────────────────────────────────────────┤
│                                                               │
│  Dog dog = new Dog("旺财");                                │
│                                                               │
│  ┌─────────────────────┐                                   │
│  │     Dog 对象         │                                   │
│  │  ┌───────────────┐ │                                   │
│  │  │ Animal 部分   │ │  ← 从 Animal 继承的成员            │
│  │  │  name="旺财" │ │                                   │
│  │  │  eat()       │ │                                   │
│  │  └───────────────┘ │                                   │
│  │  ┌───────────────┐ │                                   │
│  │  │ Dog 部分      │ │  ← Dog 自己的成员                 │
│  │  │  bark()      │ │                                   │
│  │  └───────────────┘ │                                   │
│  └─────────────────────┘                                   │
│                                                               │
└──────────────────────────────────────────────────────────────┘

访问权限与继承

父类成员	private	default	protected	public
继承可见	❌	✅	✅	✅
访问可见	❌	❌	✅	✅

class Parent {
    private int privateField = 1;    // ❌ 子类不可见
    int defaultField = 2;            // ✅ 同包子类可见
    protected int protectedField = 3; // ✅ 子类可见
    public int publicField = 4;       // ✅ 任何地方可见
}

注意事项

1. 子类不继承父类的构造方法

class Parent {
    Parent(String name) { }  // 构造方法不继承
}

class Child extends Parent {
    Child() {
        super();  // 隐式调用父类无参构造
    }
}

2. 私有成员仍然被继承，只是不可以直接访问

class Parent {
    private String secret = "秘密";
}

class Child extends Parent {
    void show() {
        // ❌ 编译错误：私有成员不可直接访问
        // System.out.println(secret);
    }
}

3. final 类不能被继承

final class Constants {
    static final int MAX = 100;
}

// ❌ 编译错误
// class Extended extends Constants { }

总结

继承 = extends + is-a 关系
接口 = implements + can-do 关系
类   = 单继承
接口 = 多实现