Java抽象类案例如何定义

wen java案例 2026-07-01 28

本文目录导读：

Java抽象类案例如何定义

案例1：动物抽象类
案例2：图形计算器
案例3：员工管理系统
抽象类的关键特点
使用抽象类的场景

我来通过几个具体的案例来说明Java抽象类的定义和使用。

案例1：动物抽象类

// 定义抽象类
public abstract class Animal {
    // 普通属性
    protected String name;
    protected int age;
    // 构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 抽象方法（没有方法体）
    public abstract void makeSound();
    // 抽象方法
    public abstract void move();
    // 普通方法（有方法体）
    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
    // 获取信息
    public void displayInfo() {
        System.out.println("动物名称: " + name + ", 年龄: " + age);
    }
}
// 子类：狗
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }
    // 实现抽象方法
    @Override
    public void makeSound() {
        System.out.println(name + "汪汪叫");
    }
    @Override
    public void move() {
        System.out.println(name + "用四条腿奔跑");
    }
}
// 子类：猫
class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    @Override
    public void makeSound() {
        System.out.println(name + "喵喵叫");
    }
    @Override
    public void move() {
        System.out.println(name + "轻盈地行走");
    }
}
// 测试类
public class AnimalTest {
    public static void main(String[] args) {
        // 错误：不能实例化抽象类
        // Animal animal = new Animal("动物", 1);
        // 正确：通过子类实例化
        Animal dog = new Dog("旺财", 2);
        Animal cat = new Cat("小花", 1);
        dog.displayInfo();
        dog.makeSound();
        dog.move();
        dog.sleep();
        System.out.println("----------------");
        cat.displayInfo();
        cat.makeSound();
        cat.move();
    }
}

案例2：图形计算器

// 抽象类：图形
public abstract class Shape {
    protected String color;
    public Shape(String color) {
        this.color = color;
    }
    // 抽象方法：计算面积
    public abstract double calculateArea();
    // 抽象方法：计算周长
    public abstract double calculatePerimeter();
    // 普通方法
    public void display() {
        System.out.println("这是一个" + color + "色的图形");
        System.out.println("面积: " + calculateArea());
        System.out.println("周长: " + calculatePerimeter());
    }
}
// 圆形
class Circle extends Shape {
    private double radius;
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}
// 矩形
class Rectangle extends Shape {
    private double length;
    private double width;
    public Rectangle(String color, double length, double width) {
        super(color);
        this.length = length;
        this.width = width;
    }
    @Override
    public double calculateArea() {
        return length * width;
    }
    @Override
    public double calculatePerimeter() {
        return 2 * (length + width);
    }
}
// 三角形
class Triangle extends Shape {
    private double sideA;
    private double sideB;
    private double sideC;
    public Triangle(String color, double sideA, double sideB, double sideC) {
        super(color);
        this.sideA = sideA;
        this.sideB = sideB;
        this.sideC = sideC;
    }
    @Override
    public double calculateArea() {
        // 海伦公式
        double s = (sideA + sideB + sideC) / 2;
        return Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC));
    }
    @Override
    public double calculatePerimeter() {
        return sideA + sideB + sideC;
    }
}
// 测试类
public class ShapeTest {
    public static void main(String[] args) {
        Shape circle = new Circle("红色", 5);
        Shape rectangle = new Rectangle("蓝色", 4, 6);
        Shape triangle = new Triangle("绿色", 3, 4, 5);
        circle.display();
        System.out.println("----------------");
        rectangle.display();
        System.out.println("----------------");
        triangle.display();
    }
}

案例3：员工管理系统

// 抽象类：员工
public abstract class Employee {
    protected String employeeId;
    protected String name;
    protected double baseSalary;
    public Employee(String employeeId, String name, double baseSalary) {
        this.employeeId = employeeId;
        this.name = name;
        this.baseSalary = baseSalary;
    }
    // 抽象方法：计算工资（不同职位计算方式不同）
    public abstract double calculateSalary();
    // 抽象方法：工作职责
    public abstract void workDuties();
    // 普通方法
    public void displayInfo() {
        System.out.println("员工ID: " + employeeId);
        System.out.println("姓名: " + name);
        System.out.println("基本工资: " + baseSalary);
        System.out.println("实际工资: " + calculateSalary());
    }
}
// 经理类
class Manager extends Employee {
    private double bonus;
    public Manager(String employeeId, String name, double baseSalary, double bonus) {
        super(employeeId, name, baseSalary);
        this.bonus = bonus;
    }
    @Override
    public double calculateSalary() {
        return baseSalary + bonus;
    }
    @Override
    public void workDuties() {
        System.out.println(name + "负责：管理团队，制定策略，分配任务");
    }
}
// 程序员类
class Programmer extends Employee {
    private int projectCount;
    private double projectBonus;
    public Programmer(String employeeId, String name, double baseSalary, 
                      int projectCount, double projectBonus) {
        super(employeeId, name, baseSalary);
        this.projectCount = projectCount;
        this.projectBonus = projectBonus;
    }
    @Override
    public double calculateSalary() {
        return baseSalary + (projectCount * projectBonus);
    }
    @Override
    public void workDuties() {
        System.out.println(name + "负责：编写代码，调试程序，参与项目开发");
    }
}
// 销售员类
class Salesman extends Employee {
    private double salesAmount;
    private double commissionRate;
    public Salesman(String employeeId, String name, double baseSalary, 
                    double salesAmount, double commissionRate) {
        super(employeeId, name, baseSalary);
        this.salesAmount = salesAmount;
        this.commissionRate = commissionRate;
    }
    @Override
    public double calculateSalary() {
        return baseSalary + (salesAmount * commissionRate);
    }
    @Override
    public void workDuties() {
        System.out.println(name + "负责：销售产品，拓展客户，达成销售目标");
    }
}
// 测试类
public class EmployeeTest {
    public static void main(String[] args) {
        Employee manager = new Manager("M001", "张三", 10000, 5000);
        Employee programmer = new Programmer("P001", "李四", 8000, 3, 1000);
        Employee salesman = new Salesman("S001", "王五", 5000, 50000, 0.1);
        System.out.println("=== 员工信息 ===");
        manager.displayInfo();
        manager.workDuties();
        System.out.println("----------------");
        programmer.displayInfo();
        programmer.workDuties();
        System.out.println("----------------");
        salesman.displayInfo();
        salesman.workDuties();
    }
}

抽象类的关键特点

不能实例化：不能直接创建抽象类的对象
可以包含抽象方法和普通方法
子类必须实现所有抽象方法（除非子类也是抽象类）
可以有构造方法：用于子类的super()调用
可以有成员变量、常量、静态方法

使用抽象类的场景

当多个类具有共同的行为特征,但具体实现不同时
当你想强制子类实现某些方法时
当你想提供部分实现,同时留一些方法供子类扩展时

这些案例展示了抽象类在实际开发中的典型应用,帮助你理解如何定义和使用Java抽象类。