Java在面对对象如何编写

某公司员工有临时工和正式员工，两个类的属性和方法要求如下：

- 临时工TempEmployee：

  - 属性：ID，姓名，性别，年龄，日薪，

  - 方法：

    - 自我介绍introduce()，显示“我是临时工xxx（姓名）”

    - 打印工资printSalary()（显示日薪）

- 正式员工ContractEmployee：

  - 属性：ID，姓名，性别，年龄，月薪，奖金

  - 方法：

    - 自我介绍introduce()，显示“我是正式员工xxx（姓名）”

    - 打印薪水printSalary()（显示月薪+奖金的值）

从以上属性中可以看出，两个类有共同的属性和方法，因此，需要创建父类。编写程序实现以下要求：

1. 创建父类Employees，将共同的属性（ID，姓名，性别，年龄）作为父类的属性。两个抽象方法：introduce()和printSalary()。

2. 创建两个子类：TempEmployee和ContractEmployee，继承自父类Employees。并且实现父类的两个抽象方法。

3. 分别创建两个子类的对象，为对象属性赋值，调用introduce()方法和printSalary()方法，显示个人介绍和自己的工资。

// 定义Employees类，作为父类
abstract class Employees {
    protected int ID;
    protected String name;
    protected String gender;
    protected int age;

    // 构造函数
    public Employees(int ID, String name, String gender, int age) {
        this.ID = ID;
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    // 定义抽象方法
    abstract public void introduce();
    abstract public void printSalary();
}

// 定义TempEmployee类，继承Employees类
class TempEmployee extends Employees {
    private double dailyWage;

    // 构造函数
    public TempEmployee(int ID, String name, String gender, int age, double dailyWage) {
        super(ID, name, gender, age);
        this.dailyWage = dailyWage;
    }

    // 实现抽象方法introduce()
    public void introduce() {
        System.out.println("我是临时工" + this.name);
    }

    // 实现抽象方法printSalary()
    public void printSalary() {
        System.out.println("我的日薪为：" + this.dailyWage);
    }
}

// 定义ContractEmployee类，继承Employees类
class ContractEmployee extends Employees {
    private double monthlySalary;
    private double bonus;

    // 构造函数
    public ContractEmployee(int ID, String name, String gender, int age, double monthlySalary, double bonus) {
        super(ID, name, gender, age);
        this.monthlySalary = monthlySalary;
        this.bonus = bonus;
    }

    // 实现抽象方法introduce()
    public void introduce() {
        System.out.println("我是正式员工" + this.name);
    }

    // 实现抽象方法printSalary()
    public void printSalary() {
        System.out.println("我的薪水为：" + (this.monthlySalary + this.bonus));
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        // 创建TempEmployee对象
        TempEmployee tempEmployee = new TempEmployee(1001, "张三", "男", 25, 200);
        // 调用introduce()方法
        tempEmployee.introduce();
        // 调用printSalary()方法
        tempEmployee.printSalary();

        // 创建ContractEmployee对象
        ContractEmployee contractEmployee = new ContractEmployee(2001, "李四", "女", 32, 5000, 1000);
        // 调用introduce()方法
        contractEmployee.introduce();
        // 调用printSalary()方法
        contractEmployee.printSalary();
    }
}

在上述代码中，我们首先定义了一个 Employees 类作为父类，包含了共同的属性 ID、name、gender 和 age，以及两个抽象方法 introduce() 和 printSalary()。接着，我们定义了 TempEmployee 和 ContractEmployee 两个子类，分别继承了 Employees 类，并实现了父类的两个抽象方法。

在测试类中，我们分别创建了一个 TempEmployee 对象和一个 ContractEmployee 对象，然后调用了它们的 introduce() 和 printSalary() 方法，完成了个人介绍和工资的打印。