Java抽象类 #

一、抽象类概述 #

抽象类是用abstract修饰的类，不能被实例化，用于定义子类的通用模板。

1.1 抽象类特点 #

不能实例化
可以有抽象方法和具体方法
可以有构造方法
可以有成员变量

1.2 基本语法 #

java

public abstract class Animal {
    protected String name;
    
    // 构造方法
    public Animal(String name) {
        this.name = name;
    }
    
    // 抽象方法：没有方法体
    public abstract void eat();
    
    // 具体方法
    public void sleep() {
        System.out.println(name + "在睡觉");
    }
}

二、抽象方法 #

2.1 定义 #

抽象方法只有声明，没有实现，由子类实现。

java

public abstract class Shape {
    // 抽象方法
    public abstract double getArea();
    public abstract double getPerimeter();
}

2.2 实现抽象方法 #

java

public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

2.3 抽象方法规则 #

只有抽象类可以包含抽象方法
抽象方法不能是private、static、final
子类必须实现所有抽象方法，否则也是抽象类

java

public abstract class Parent {
    public abstract void method1();
    public abstract void method2();
}

// 必须实现所有抽象方法
public class Child extends Parent {
    @Override
    public void method1() { }
    
    @Override
    public void method2() { }
}

// 或者子类也是抽象类
public abstract class Child2 extends Parent {
    @Override
    public void method1() { }
    // method2仍未实现
}

三、抽象类特点 #

3.1 不能实例化 #

java

public abstract class Animal {
}

// 错误：抽象类不能实例化
// Animal a = new Animal();

// 正确：创建子类对象
Animal a = new Dog();

3.2 可以有构造方法 #

java

public abstract class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // 调用父类构造
    }
}

3.3 可以有成员变量 #

java

public abstract class Person {
    protected String name;
    protected int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public abstract void work();
}

3.4 可以有具体方法 #

java

public abstract class Animal {
    // 抽象方法
    public abstract void eat();
    
    // 具体方法
    public void sleep() {
        System.out.println("在睡觉");
    }
}

四、抽象类vs普通类 #

特性	抽象类	普通类
实例化	不能	可以
抽象方法	可以有	不能有
继承	必须实现抽象方法	可选重写
构造方法	可以有	可以有

五、抽象类vs接口 #

特性	抽象类	接口
继承	单继承	多实现
成员变量	可以有任意类型	public static final
构造方法	可以有	不能有
方法	抽象和具体都可以	默认public abstract
设计目的	代码复用	定义规范

六、抽象类应用 #

6.1 模板方法模式 #

java

public abstract class DataProcessor {
    // 模板方法
    public final void process() {
        readData();
        processData();
        writeData();
    }
    
    protected abstract void readData();
    protected abstract void processData();
    protected abstract void writeData();
}

public class FileProcessor extends DataProcessor {
    @Override
    protected void readData() {
        System.out.println("从文件读取数据");
    }
    
    @Override
    protected void processData() {
        System.out.println("处理数据");
    }
    
    @Override
    protected void writeData() {
        System.out.println("写入文件");
    }
}

6.2 图形类层次 #

java

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

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;
    }
    
    @Override
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }
}

6.3 员工管理系统 #

java

public abstract class Employee {
    private String name;
    private double baseSalary;
    
    public Employee(String name, double baseSalary) {
        this.name = name;
        this.baseSalary = baseSalary;
    }
    
    public abstract double calculateSalary();
    
    public String getName() {
        return name;
    }
    
    public double getBaseSalary() {
        return baseSalary;
    }
}

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

public class Developer extends Employee {
    private int overtimeHours;
    
    public Developer(String name, double baseSalary, int overtimeHours) {
        super(name, baseSalary);
        this.overtimeHours = overtimeHours;
    }
    
    @Override
    public double calculateSalary() {
        return getBaseSalary() + overtimeHours * 100;
    }
}

七、总结 #

概念	说明
abstract class	抽象类
abstract method	抽象方法
不能实例化	抽象类不能创建对象
必须实现	子类必须实现抽象方法

抽象类要点：

用abstract修饰
不能实例化
可以有抽象方法和具体方法
子类必须实现所有抽象方法
用于定义通用模板