案例一：员工薪资管理系统（核心：抽象类 + 继承 + 多态 + static）

需求:

1. 定义抽象类Employee，包含final 属性工号、姓名、私有静态属性公司名称、静态方法统一修改公司名称；

2. 抽象方法calculateSalary()计算薪资，子类必须实现；

3. 实现两个子类：FullTimeEmployee（全职员工：固定月薪）、PartTimeEmployee（兼职员工：时薪 × 工作时长）；

4. 利用多态遍历员工数组，统一打印员工信息和薪资；

5. 静态属性全局生效，所有员工共享公司名称。

打印结果:

公司：互联网科技公司 | 工号：1001 | 姓名：张三 | 薪资：8000.0
公司：互联网科技公司 | 工号：1002 | 姓名：李四 | 薪资：5000.0

思路分析：

1.找出共性，写到父类里面：

• 抽象类声明：用 abstract class 定义，不能直接实例化
• final 属性：工号、姓名用 final 修饰，保证一旦赋值不可修改（符合业务逻辑：员工工号 / 姓名不可随意变更）
• 私有静态公司名称：private static String companyName，所有员工共享，用 private 封装，仅通过静态方法修改
• 静态修改方法：public static void setCompanyName(String name)，全局修改公司名
• 抽象薪资方法：public abstract double calculateSalary()，子类必须实现，体现多态
• 构造方法：初始化工号、姓名（final 属性必须在构造器中赋值）
• getter 方法：提供属性的访问入口（因为属性是 private/final）

public abstract class Employee {

    final String id;//属性工号
    String name;//姓名
    private static String companyName;//私有静态属性公司名称

    public static void setCompanyName(String name) {
        Employee.companyName = name;
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public static String getCompanyName() {
        return companyName;
    }

    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }

    //抽象方法
    public abstract double caluateSalary();
}

2.实现子类1：

FullTimeEmployee（全职员工）

全职员工的薪资逻辑：固定月薪，直接返回月薪值即可。

1. 继承父类：extends Employee，复用父类的属性和方法
2. 新增属性：monSalary（固定月薪）
3. 构造方法：调用父类构造器 super(id, name) 初始化工号、姓名
4. 重写抽象方法：@Override calculateSalary()，返回固定月薪
5. 遵循多态：子类对象可以向上转型为父类 Employee 类型

public class FullTimeEmployee extends Employee {
    //固定月薪
    private double monSalary;

    //子类构造方法
    public FullTimeEmployee(String id, String name, double monSalary) {
        super(id, name);
        this.monSalary = monSalary;
    }

    @Override
    public double caluateSalary() {
        return monSalary;
    }
}

3.实现子类 2：PartTimeEmployee（兼职员工）

兼职员工的薪资逻辑：时薪 × 工作时长，需要两个属性计算薪资。

1. 继承父类：extends Employee
2. 新增属性：hourlyWage（时薪）、workHours（工作时长）
3. 构造方法：调用父类构造器，初始化时薪和工作时长
4. 重写抽象方法：@Override calculateSalary()，计算 时薪 × 工作时长
5. 遵循多态：同样可以向上转型为 Employee 类型

public class PartTimeEmployee extends Employee {
    private double hourLyWage;
    private int workHours;

    public PartTimeEmployee(String id, String name, double hourLyWage, int workHours) {
        super(id, name);
        this.hourLyWage = hourLyWage;
        this.workHours = workHours;
    }

    @Override
    public double caluateSalary() {
        return hourLyWage * workHours;
    }
}

4.编写测试类，实现多态遍历与打印

这一步是验证需求的核心，完成数组创建、多态遍历、全局静态属性验证。

1. 创建员工数组：Employee[] employees，用父类类型存储子类对象（向上转型，多态的核心）
2. 初始化数组元素：创建全职、兼职员工对象，存入数组
3. 遍历数组打印
4. 验证静态属性全局生效：修改公司名后，所有员工的打印信息同步更新

import java.util.ArrayList;

public class EmployeeTest {
    public static void main(String[] args) {
        //统一设置公司名称
        Employee.setCompanyName("互联网科技公司");

        //多态：存放对象
        ArrayList<Employee> arrayList = new ArrayList<>();
        arrayList.add(new FullTimeEmployee("1001","张三",8000));
        arrayList.add(new PartTimeEmployee("1002","李四",100,50));

        //遍历集合
        for (int i = 0; i < arrayList.size(); i++) {
            Employee emp = arrayList.get(i);
            System.out.println("公司：" + Employee.getCompanyName() + "|" + "工号：" + emp.id + "|" + "姓名：" + emp.name
                    + "|" + "薪资：" + emp.caluateSalary());
        }
    }
}

原文地址：https://blog.csdn.net/Han_han919/article/details/159955631

免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！