Java 抽象类详解：概念、特性与代码示例

• 虽然抽象类不能直接实例化，但它可以有构造方法。
• 构造方法用于子类创建对象时，初始化从父类继承来的成员。

五、完整示例

// 1. 定义抽象类
public abstract class Animal {
    private String name;
    private int age;
    
    // 抽象类可以有构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 抽象方法：定义了一个必须完成的行为规范
    public abstract void eat();
    
    // 普通方法：子类可以直接继承使用
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    
    // Getter/Setter
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

// 2. 具体子类：必须重写所有抽象方法
public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age); // 调用父类构造方法
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + "（" + getAge() + "岁）正在吃鱼");
    }
}

// 3. 另一个具体子类
public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + "（" + getAge() + "岁）正在啃骨头");
    }
    
    // 子类可以有自己的特有方法
    public void watchHouse() {
        System.out.println(getName() + "在看家");
    }
}

// 4. 测试类
public class Test {
    public static void main(String[] args) {
        // Animal a = new Animal(); // 错误！抽象类不能实例化
        Animal cat = new Cat("小花", 2);
        cat.eat(); // 输出：小花（2 岁）正在吃鱼
        cat.sleep(); // 输出：小花正在睡觉
        
        Dog dog = new Dog("大黄", 3);
        dog.eat(); // 输出：大黄（3 岁）正在啃骨头
        dog.watchHouse(); // 输出：大黄在看家
    }
}

// 5. 抽象子类示例（不重写抽象方法）
public abstract class Bird extends Animal {
    // 没有重写 eat() 方法，所以 Bird 也必须是抽象类
    public Bird(String name, int age) {
        super(name, age);
    }
    
    // 可以定义新的抽象方法
    public abstract void fly();
}

// 6. 最终的具体类，需要实现所有抽象方法（包括 Animal 的和 Bird 的）
public class Sparrow extends Bird {
    public Sparrow(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void eat() {
        // 实现 Animal 的 eat()
        System.out.println(getName() + "正在吃虫子");
    }
    
    @Override
    public void fly() {
        // 实现 Bird 的 fly()
        System.out.println(getName() + "正在飞翔");
    }
}

六、抽象类 vs 普通类 vs 接口

七、总结

1. 抽象类是一个'半成品'类，它定义了部分实现，也声明了部分必须由子类完成的规范（抽象方法）。
2. 核心作用：代码复用 + 强制规范。既提取了共性代码，又强制子类必须实现特定行为。
3. 使用场景：当多个相关类有共同的属性和行为，但某些行为的具体实现各不相同时。
4. 设计理念：'面向抽象编程'，依赖于抽象（父类或接口）而非具体实现，提高了代码的灵活性和可扩展性。

八、完整项目代码示例

以下展示了结合接口 Swim 的完整项目结构：

package abstract02;

public class Test {
    public static void main(String[] args) {
        Frog f = new Frog(1, "wawa");
        System.out.println(f.getName() + ", " + f.getAge());
        f.drink();
        f.eat();
        f.swim();
        
        Dog d = new Dog(5, "wangwang");
        System.out.println(d.getName() + ", " + d.getAge());
        d.drink();
        d.eat();
        d.swim();
        
        Sheep s = new Sheep(6, "miemie");
        System.out.println(s.getName() + ", " + s.getAge());
        s.drink();
        s.eat();
    }
}

package abstract02;

public abstract class Animal {
    private String name;
    private int age;
    
    public Animal() {
    }
    
    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public void drink() {
        System.out.println("动物在喝水");
    }
    
    public abstract void eat();
}

package abstract02;

public class Dog extends Animal implements Swim {
    public Dog() {
    }
    
    public Dog(int age, String name) {
        super(age, name);
    }
    
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
    
    @Override
    public void swim() {
        System.out.println("狗在游泳");
    }
}

package abstract02;

public class Frog extends Animal implements Swim {
    public Frog() {
    }
    
    public Frog(int age, String name) {
        super(age, name);
    }
    
    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
    
    @Override
    public void swim() {
        System.out.println("青蛙在游泳");
    }
}

package abstract02;

public class Sheep extends Animal {
    public Sheep() {
    }
    
    public Sheep(int age, String name) {
        super(age, name);
    }
    
    @Override
    public void eat() {
        System.out.println("🐏在吃草");
    }
}

package abstract02;

public interface Swim {
    public abstract void swim();
}