面向对象习题 继承

设计一个工资管理系统，针对两种雇员的工资进行管理：长期合同工、短期小时工；
合同工的工资按月发放，小时工的工资为每小时工资乘以工作小时数；都是月底结算；

如果当月为雇员生日所在月，则当月加发200元的贺金；

建立一个雇员父类Employee，两种雇员类继承Employee类；
利用循环结构，输出各个雇员对象的工资；
（扩展功能，不必须实现：如果是合同工，则给该员工每月加发当月所有人基本工资和的千分之五做为红利；）

构造方法：
Employee(String name, String employeeId, int year, int month, int day)
SalariedEmployee(String name, String employeeId, int year, int month, int day, double salary)
HourlyEmployee(String name, String employeeId, int year, int month, int day, double wage, double hours)

最后创建一个测试类SalaryManagement，使用前面的三个类，输出下面四个雇员的相关信息；再单独输出每个雇员的类型；
雇员如下：
合同工张三，员工号：111-11-1111，生日：1975年2月5日，工资：2000.00
合同工李四，员工号：222-22-2222，生日：1978年11月25日，工资：2222.00
小时工王五，员工号：333-33-3333，生日：1974年6月24日，每小时工资：20.00,
工作了120小时
小时工赵六，员工号：444-44-4444，生日：1975年8月9日，每小时工资：30.00,
工作了56小时
假设当月为2月份；

package com.hhj.entity;

public class Dome01 {
	public static void main(String[] args) {
		SalariedEmployee e1 = new SalariedEmployee("张三", "111-11-1111", 1975, 2, 5, 2000.00);
		SalariedEmployee e2 = new SalariedEmployee("李四", "222-22-2222", 1978, 11, 25, 2222.00);
		HourlyEmployee e3 = new HourlyEmployee("王五", "333-33-3333", 1974, 6, 24, 20.00, 120);
		HourlyEmployee e4 = new HourlyEmployee("赵六", "444-44-4444", 1975, 8, 9, 30.00, 56);
        double[] salary= {e1.getSalary(),e2.getSalary(),e3.getSalary(),e4.getSalary()};
        System.out.println("张三,李四,王五,赵六2月月薪分别是");
        for(int i=0;i<salary.length;i++) {
        	System.out.print(salary[i]+" ");	
        }
        System.out.println();
		e1.getInfo();
        e2.getInfo();
        e3.getInfo();
        e4.getInfo();
        System.out.println(e1.getInfo1()+"，2月月薪："+e1.getSalary());
        System.out.println(e2.getInfo1()+"，2月月薪："+e2.getSalary());
        System.out.println(e3.getInfo1()+"，2月月薪："+e3.getSalary());
        System.out.println(e4.getInfo1()+"，2月月薪："+e4.getSalary());
	}

}

class Employee {
	private String name;
	private String employeeId;
	private int year;
	private int month;
	private int day;

	public Employee(String name, String employeeId, int year, int month, int day) {// 父类中定义了一个带参数的构造函数，那么自己本来就有的隐式的构造函数就不存在了，那么子类中必须也有带参数的构造函数
		this.name = name;
		this.employeeId = employeeId;
		this.year = year;
		this.month = month;
		this.day = day;
	}

	public String getName() {
		return name;
	}

	public String getEmployeeId() {
		return employeeId;
	}

	public int getYear() {
		return year;
	}

	public int getMonth() {
		return month;
	}

	public int getDay() {
		return day;
	}

	@Override
	public String toString() {
		return ": " + name + "，员工号:" + employeeId + ", 生日：" + year + "年" + month + "月" + day + "日";
	}

	public double getSalary() {
		if (month == 2) {
			return 200;
		} else {
			return 0;
		}
	}
}

class SalariedEmployee extends Employee {
	private double salary;

	public SalariedEmployee(String name, String employeeId, int year, int month, int day, double salary) {
		super(name, employeeId, year, month, day);
		this.salary = salary;
	}

	@Override
	public double getSalary() {
		return salary + super.getSalary();

	}

	public void getInfo() {
		System.out.println("合同工" + super.toString()+"，工资："+salary);

	}
	public String getInfo1() {
		return super.getName()+"合同工";
	}
}

class HourlyEmployee extends Employee {
	private double wage;
	private double hours;

	public HourlyEmployee(String name, String employeeId, int year, int month, int day, double wage, double hours) {
		super(name, employeeId, year, month, day);
		this.wage = wage;
		this.hours = hours;
	}

	public double getWage() {
		return wage;
	}

	public double getHours() {
		return hours;
	}

	@Override
	public double getSalary() {
		return wage * hours + super.getSalary();

	}

	public void getInfo() {
		System.out.println("小时工" + super.toString() + "，每小时工资：" + wage + ",工作了" + hours + "小时");
	}
	public String getInfo1() {
		return super.getName()+"是小时工";
	}
}

结果：