Java抽象类Abstract Class示例代码详解_Java

java中的抽象类（abstract class）是面向对象编程中的重要概念，它通过abstract关键字声明，用于定义一组相关类的公共行为和属性。抽象类不能被实例化，只能作为其他类的基类存在，其核心作用是提取共性、强制子类实现特定方法，并提供代码复用的能力。以下是关于java抽象类的详细介绍：

一、抽象类的定义

1. 语法格式

abstract class 类名 {
    // 可以包含成员变量、构造方法、具体方法和抽象方法
    abstract void 抽象方法名(); // 抽象方法没有方法体
}

2. 核心特征

不能被实例化：抽象类不能使用new关键字直接创建对象。
可以包含抽象方法：抽象方法只有方法声明，没有具体实现（用abstract修饰）。
可以包含具体方法：抽象类中可以定义普通方法（有具体实现的方法）。
可以包含构造方法：抽象类的构造方法用于初始化子类对象的公共属性。
可以有成员变量：抽象类可以定义成员变量（包括static、final等类型）。
继承关系：子类继承抽象类后，必须实现所有抽象方法（除非子类也是抽象类）。

二、抽象类的核心用途

1. 定义公共接口

抽象类通过抽象方法定义一组子类的共同行为契约，要求子类必须实现这些方法。
示例：

abstract class animal {
    // 抽象方法：所有动物必须实现的接口
    public abstract void makesound();
    // 具体方法：所有动物共享的行为
    public void sleep() {
        system.out.println("this animal is sleeping.");
    }
}

2. 提供默认实现

抽象类可以包含具体方法，为子类提供通用的默认实现，减少代码重复。
示例：

abstract class shape {
    // 公共方法：计算面积的默认实现（可被子类覆盖）
    public abstract double area();
    // 具体方法：打印形状信息
    public void displayinfo() {
        system.out.println("shape with area: " + area());
    }
}

3. 实现代码复用

抽象类可以定义成员变量和构造方法，子类继承后可以直接使用这些共享的属性和初始化逻辑。
示例：

abstract class employee {
    protected string name;
    protected int id;
    public employee(string name, int id) {
        this.name = name;
        this.id = id;
    }
    public abstract double computepay();
}

三、抽象类的使用规则

1. 抽象方法的定义

抽象方法必须使用abstract关键字修饰，且没有方法体（即没有{}）。
抽象方法的访问权限不能是private，因为子类无法继承私有方法。
抽象方法不能是static，因为静态方法属于类而非对象。

2. 抽象类的继承

子类继承抽象类后，必须实现所有抽象方法，否则子类也必须声明为抽象类。
抽象类可以继承其他抽象类或具体类。

3. 抽象类的实例化

抽象类本身不能被实例化，但可以通过多态的形式，用抽象类引用指向子类对象。
示例：

animal mydog = new dog(); // dog是animal的子类
mydog.makesound(); // 调用dog类的实现

4. 常见限制

abstract不能与final共存：final类不能被继承，而abstract类必须被继承。
abstract不能与private共存：私有方法无法被继承，因此无法实现抽象方法。
abstract不能与static共存：静态方法属于类级别，而抽象方法需要子类实现。

四、抽象类与接口的区别

特性	抽象类（abstract class）	接口（interface）
是否能实例化	否	否
是否能包含具体方法	是（默认方法、静态方法）	是（java 8+ 默认方法、静态方法）
是否能包含成员变量	是（可以是任何访问权限）	否（只能是`public static final`常量）
是否能有构造方法	是	否
是否支持多继承	否（一个类只能继承一个抽象类）	是（一个类可以实现多个接口）
访问权限	可定义不同访问权限（`protected`、`public`等）	方法默认是`public`，变量默认是`public static final`
适用场景	需要共享代码、构造器初始化、定义部分默认实现	定义行为契约、多继承、解耦实现与接口

五、实际应用场景

1. 统一行为规范

当多个类需要实现相同的行为（如draw()、compute()），但具体实现不同时，可以定义抽象类。
示例：

abstract class shape {
    abstract double area();
}
class circle extends shape {
    private double radius;
    public circle(double radius) { this.radius = radius; }
    @override
    double area() { return math.pi * radius * radius; }
}
class rectangle extends shape {
    private double width, height;
    public rectangle(double width, double height) { 
        this.width = width; this.height = height; 
    }
    @override
    double area() { return width * height; }
}

2. 模板方法模式

抽象类通过具体方法定义算法框架，子类实现具体步骤。
示例：

abstract class reporttemplate {
    public void generatereport() {
        collectdata();
        formatdata();
        printreport();
    }
    abstract void collectdata();
    abstract void formatdata();
    void printreport() {
        system.out.println("printing report...");
    }
}

3. 限制类的继承

通过将类定义为抽象类，防止其他类直接实例化，只能通过继承来扩展功能。
示例：

abstract class databaseconnection {
    public abstract void connect();
    public abstract void disconnect();
}

六、示例代码

1. 定义抽象类

// 抽象类：定义动物的公共行为
abstract class animal {
    protected string name;
    public animal(string name) {
        this.name = name;
    }
    // 抽象方法：子类必须实现
    public abstract void makesound();
    // 具体方法：所有动物共享
    public void sleep() {
        system.out.println(name + " is sleeping.");
    }
}

2. 实现子类

// 具体类：dog实现animal的抽象方法
class dog extends animal {
    public dog(string name) {
        super(name);
    }
    @override
    public void makesound() {
        system.out.println(name + " says: woof!");
    }
}
// 具体类：cat实现animal的抽象方法
class cat extends animal {
    public cat(string name) {
        super(name);
    }
    @override
    public void makesound() {
        system.out.println(name + " says: meow!");
    }
}

3. 使用抽象类

public class main {
    public static void main(string[] args) {
        // 通过多态调用抽象类方法
        animal mydog = new dog("buddy");
        animal mycat = new cat("whiskers");
        mydog.makesound(); // 输出: buddy says: woof!
        mydog.sleep();     // 输出: buddy is sleeping.
        mycat.makesound(); // 输出: whiskers says: meow!
        mycat.sleep();     // 输出: whiskers is sleeping.
    }
}