Java 继承之应用技巧

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 Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // 继承自Animal
        dog.bark(); // Dog自身的方法
    }
}

方法重写（Override）

子类可以重写父类的方法以实现不同的行为。使用 @Override 注解确保方法正确重写。

class Animal {
    void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound(); // 输出: Cat meows
    }
}

使用 super 关键字

super 用于调用父类的构造方法、方法或属性，避免直接复制父类代码。

class Vehicle {
    int speed;
    Vehicle(int speed) {
        this.speed = speed;
    }
}

class Car extends Vehicle {
    Car(int speed) {
        super(speed); // 调用父类构造方法
    }
    void display() {
        System.out.println("Speed: " + super.speed); // 访问父类属性
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car(120);
        car.display(); // 输出: Speed: 120
    }
}

继承中的多态

多态允许父类引用指向子类对象，实现动态绑定。

class Shape {
    void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle(); // 父类引用指向子类对象
        shape.draw(); // 输出: Drawing a circle
    }
}

抽象类与继承

抽象类定义通用行为，子类必须实现抽象方法。

abstract class Bird {
    abstract void fly();
}

class Eagle extends Bird {
    @Override
    void fly() {
        System.out.println("Eagle flies high");
    }
}

public class Main {
    public static void main(String[] args) {
        Eagle eagle = new Eagle();
        eagle.fly(); // 输出: Eagle flies high
    }
}

继承与接口结合

类可以继承一个父类并实现多个接口，实现多重行为。

interface Swimmable {
    void swim();
}

class Fish extends Animal implements Swimmable {
    @Override
    public void swim() {
        System.out.println("Fish swims");
    }
}

public class Main {
    public static void main(String[] args) {
        Fish fish = new Fish();
        fish.swim(); // 输出: Fish swims
    }
}

避免继承滥用

继承适用于“is-a”关系，组合（Composition）更适合“has-a”关系。

class Engine {
    void start() {
        System.out.println("Engine starts");
    }
}

class Car {
    private Engine engine; // 使用组合而非继承
    Car() {
        engine = new Engine();
    }
    void start() {
        engine.start();
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.start(); // 输出: Engine starts
    }
}

通过合理使用继承、多态和抽象，可以构建灵活且可维护的代码结构。