离职是件愉快的事情吗？
我想对于很多人来讲，都不是吧！
即使你跳了一个更好的地方，离职结算没有任何问题！
你就没有那么一点点对新公司某方面的不确定性的担忧？
异或是恋旧，对现在公司的环境、同事、氛围有那么一点不舍？
如果是裸辞，还得担心能不能在短时间内找到工作，社保断了怎么办的问题！
如果你工作的只是分部，总公司又很远，离职证明什么时候拿到还是个问题！
而拿不到离职证明，很多公司是无法办理入职的，这涉及到法律风险问题！
还有就是你到下家公司入职要先去体检吧！
又要被无情的放血，有些公司还不给报销费用。
离职当月工资怎么算？
某个算法
离职当月工资=月工资收入÷月平均天数30天×最后出勤日20（比如你上班到20号，最后交接日为20号）（+补助-社保-公积金）

如果有事假的话扣工资是这么算的：月工资收入÷月计薪天数21.75天×实际事假天数
正确的算法
离职当月工资=月工资收入÷月计薪天数21.75天×实际出勤天数（+补助-社保-公积金）

法定节假日用人单位应当依法支付工资，即折算日工资、小时工资时不剔除国家规定的11天法定节假日。

两种对比
其实最后的结果可能相差很少，但“某个算法”中的日薪算法工资和事假的存在很大差异，让人很不舒服！
劳动法律依据

关于职工全年月平均工作时间和工资折算问题的通知
劳社部发〔2008〕3号
各省、自治区、直辖市劳动和社会保障厅（局）：
　　根据《全国年节及纪念日放假办法》（国务院令第513号）的规定，全体公民的节日假期由原来的10天增设为11天。据此，职工全年月平均制度工作天数和工资折算办法分别调整如下：
　　一、制度工作时间的计算
　　年工作日：365天-104天（休息日）-11天（法定节假日）＝250天
　　季工作日：250天÷4季＝62.5天/季
　　月工作日：250天÷12月＝20.83天/月
　　工作小时数的计算：以月、季、年的工作日乘以每日的8小时。
　　二、日工资、小时工资的折算
　　按照《劳动法》第五十一条的规定，法定节假日用人单位应当依法支付工资，即折算日工资、小时工资时不剔除国家规定的11天法定节假日。据此，日工资、小时工资的折算为：
　　日工资：月工资收入÷月计薪天数
　　小时工资：月工资收入÷（月计薪天数×8小时）。
　　月计薪天数＝（365天-104天）÷12月＝21.75天
　　三、2000年3月17日劳动保障部发布的《关于职工全年月平均工作时间和工资折算问题的通知》（劳社部发〔2000〕8号）同时废止。
　　　　　　　　　　　　　　　　　　　　　　　　　　　劳动和社会保障部
　　　　　　　　　　　　　　　　　　　　　　　　　　 二○○八年一月三日
劳动法和劳动合同法有什么区别?
《中华人民共和国劳动合同法》是为了完善劳动合同制度，明确劳动合同双方当事人的权利和义务，保护劳动者的合法权益，构建和发展和谐稳定的劳动关系，制定的。

劳动法，是调整劳动关系以及与劳动关系密切联系的社会关系的法律规范总称，既包含《中华人民共和国劳动法》也包括《中华人民共和国劳动合同法》。

  //当月同比
    @RequestMapping(value = "/salary/api/getMonthBj", method = RequestMethod.POST)
    @ResponseBody
    public String getMonthBj(HttpServletRequest request, HttpSession session) {
        return RESULT_MAP_SUCCESS(salaryService.getMonthBj(REQUEST_BODY(request)));
    }
	
	  //当月同比
    public List getMonthBj(Map param){
        return tbGzCalculatedMapper.getMonthBj(param);
    }
	
	
	
	    List<Map> getMonthBj(Map param);
	

<select id="getMonthBj" parameterType="java.util.Map" resultType="java.util.Map">
    select A.tax,(A.tax-B.tax)/B.tax as tax1,A.sfhj,(A.sfhj-B.sfhj)/B.sfhj as sfhj1, A.skhj,(A.skhj-B.skhj)/B.skhj as skhj1,A.gz,(A.gz-B.gz)/B.gz as gz1
    from (select sum(tax) as tax,sum(sfhj) as sfhj,sum(skhj) as skhj,(sum(sfhj) - sum(skhj) - sum(tax)) as gz from tb_gz_calculated  where yf = #{yf}) A,
    (select sum(tax) as tax,sum(sfhj) as sfhj,sum(skhj) as skhj,(sum(sfhj) - sum(skhj) - sum(tax)) as gz from tb_gz_calculated where yf = #{yf}-1) B;

    <!--  select A.tax,(A.tax-B.tax)/B.tax as tax1,A.sfhj,(A.sfhj-B.sfhj)/B.sfhj as sfhj1, A.skhj,(A.skhj-B.skhj)/B.skhj as skhj1,A.gz,(A.gz-B.gz)/B.gz as gz1
      from
      (select sum(tax) as tax,sum(sfhj) as sfhj,sum(skhj) as skhj,(sum(sfhj) - sum(skhj) - sum(tax)) as gz from tb_gz_calculated
      <trim prefix="WHERE" prefixOverrides="AND">
          <if test="yf != null">
              AND yf=#{yf,jdbcType=INTEGER}
          </if>
          <if test="cnid != null">
              AND cnid=#{cnid,jdbcType=VARCHAR}
          </if>
      </trim>) A,
      (select sum(tax) as tax,sum(sfhj) as sfhj,sum(skhj) as skhj,(sum(sfhj) - sum(skhj) - sum(tax)) as gz from tb_gz_calculated
      <trim prefix="WHERE" prefixOverrides="AND">
          <if test="yf != null">
              AND yf=#{yf,jdbcType=INTEGER}-1
          </if>
          <if test="cnid != null">
              AND cnid=#{cnid,jdbcType=VARCHAR}
          </if>
      </trim>) B;-->
  </select>
 
 

 
工资系统
 
题目要求
设计思路
代码
运行结果

 
题目要求
 
附：题目来源于尚硅谷
 编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个
 Employee对象的生日，则将该雇员的工资增加100元。
 实验说明：
 （1）定义一个Employee类，该类包含：
 private成员变量name,number,birthday，其中birthday 为MyDate类的对象；abstract方法earnings()；toString()方法输出对象的name,number和birthday。
 （2）MyDate类包含:private成员变量year,month,day ；toDateString()方法返回日期对应的字符串：xxxx年xx月xx日
 （3）定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。该类包括：private成员变量monthlySalary；
 实现父类的抽象方法earnings(),该方法返回monthlySalary值；toString()方法输出员工类型信息及员工的name，number,birthday。
 （4）参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的员工处理。该类包括：private成员变量wage和hour；实现父类的抽象方法earnings(),该方法返回wage*hour值；
 toString()方法输出员工类型信息及员工的name，number,birthday。
 （5）定义SalarySystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用。利用循环结构遍历数组元素，输出各个对象的类型,name,number,birthday,以及该对象生日。当键盘输入本月月份值时，如果本月是某个Employee对象的生日，还要输出增加工资信息。
 
设计思路
 
1、Employee类中有抽象方法earnings,则Employee类应声明为抽象类
 2、设计Employee类的两个子类，分别实现父类的抽象方法。注意父类已有toString(),只是输出的内容只有name、bumber、birthday。然而对子类的该方法要求增加了需要输出类的信息，需重写该方法。
 3、编写SalarySystem类，创建Employee变量数组（此处只是声明一个类型为Employee的数组，并没有创建抽象类Employee对象），采用多态初始化数组。初始化后，需要检查是否有员工当月生日，有，则需为其增加100元工资，当时据题意，不同员工的表示方式是不同的（SalariedEmployee的薪资属性monthlySalary,HourlyEmployee的薪资属性为hourlySalary），那么遇到员工当月生日，为其增加100元工资的具体实现也是不同的，因此为当月生日的员工工资增加100元的方法在父类中已抽象方法声明，在不同的子类中做具体实现。
 
代码
 
import java.util.Scanner;
public class SalarySystem {
    public static void main(String[] args) {
        Employee employee[]=new Employee[4];
        Scanner scan=new Scanner(System.in);
        for(int i=0;i<2;i++){
            System.out.print("输入小时职员姓名：");
            String name=scan.next();
            System.out.print("编号：");
            int number=scan.nextInt();
            System.out.print("出生年、月、日：");
            int year=scan.nextInt();
            int month=scan.nextInt();
            int day=scan.nextInt();
            System.out.print("时薪：");
            int wage=scan.nextInt();
            System.out.print("工作时长：");
            int hour=scan.nextInt();
            employee[i]=new HourlyEmployee(name,number,new MyDate(year,month,day),wage,hour);
            System.out.println();
        }
        for(int i=2;i<4;i++){
            System.out.print("输入普通职员姓名：");
            String name=scan.next();
            System.out.print("编号：");
            int number=scan.nextInt();
            System.out.print("出生年、月、日：");
            int year=scan.nextInt();
            int month=scan.nextInt();
            int day=scan.nextInt();
            System.out.print("月薪：");
            int monthlySalary=scan.nextInt();
            employee[i]=new SalariedEmployee(name,number,new MyDate(year,month,day),monthlySalary);
            System.out.println();

        }

        //遍历并同时为该月生日的员工增加工资
        String name[]=new String[5];//用来存放当月生日员工的名单
        int count=0;//遇当月生日员工个数
        boolean isbirthday=false;//当月有无员工过生日

        System.out.print("输入当月月份：");
        int m=scan.nextInt();

        System.out.println("员工类型\t\t\t\t姓名\t编号\t出生日期\t\t工资");
        for(int i=0;i< employee.length ;i++){
            if(m==employee[i].getBirthday() .getMonth()){
               employee[i].birthdaySalaryAdd();
               name[count]=employee[i].getName();
               count++;
               isbirthday=true;
            }
            System.out.println(employee[i]+"\t"+employee[i].earnings());//对象引用直接调用重写父类的toString()
        }
        if(isbirthday){
            System.out.print("当月");
            for(int i=0;i<count;i++){
                System.out.print(name[i]+" ");
            }
            System.out.println("过生日，已为其增加工资100元");
        }

    }
}
abstract class Employee{
    private String name;
    private int number;
    private MyDate  birthday;

    public Employee(String name,int number,MyDate birthday){
        this.name=name;
        this.number=number;
        this.birthday=birthday;
    }
    public abstract int earnings();
    public abstract void birthdaySalaryAdd();//由于不同员工的工资表示形式有所差异，员工遇生日需增加100元由子类做具体实现
    public String  toString(){
        return name+"\t"+number+"\t"+birthday.toDateString();
    }
    public String getName(){
        return name;
    }
    public int  getNumber(){
        return number;
    }
    public MyDate  getBirthday(){
        return birthday;
    }

}

class SalariedEmployee extends Employee{
    private int monthlySalary;

    public SalariedEmployee(String name, int number, MyDate birthday,int monthlySalary) {
        super(name, number, birthday);
        this.monthlySalary=monthlySalary;
    }
    public void birthdaySalaryAdd(){
        int newSalary=monthlySalary+100;
        this.setMonthlySalary(newSalary) ;
    }
    public void setMonthlySalary(int monthlySalary){
        this.monthlySalary=monthlySalary;
    }


    public int earnings(){
        return monthlySalary;
    }

    public String toString(){
        return "SalariedEmployee\t"+super.toString();

    }
}

class HourlyEmployee extends Employee{
    private int wage;
    private int hour;
    private int hourlySalary;

    public HourlyEmployee(String name, int number, MyDate birthday,int wage,int hour) {
        super(name, number, birthday);
        this.wage=wage;//每小时的工资
        this.hour=hour;//月工作的总小时数
        this.setHourlySalary(wage*hour);
    }
    public void setHourlySalary(int hourlySalary){
        this.hourlySalary=hourlySalary;
    }
    public void birthdaySalaryAdd(){
        int newSalary=hourlySalary+100;
        this.setHourlySalary(newSalary) ;
    }
    public int earnings(){
        return hourlySalary;
    }

    public String toString(){
        return "HourlyEmployee\t\t"+super.toString();

    }
}
class MyDate{
    private int year;
    private int month;
    private int day;
    public MyDate(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
    }
    public String toDateString(){
        return year+"年"+month+"月"+day+"日";
    }
    public int getMonth(){
        return month;
    }
}
 
运行结果
 
 

编写工资系统，实现不同类型员工(多态)的按月发放工资。如果当月出现某个
 Employee对象的生日，则将该雇员的工资增加666元。
 实验说明：
 （1）定义一个Employee类，该类包含：
 private成员变量name,number,birthday，其中birthday 为MyDate类的对象；
 abstract方法earnings()；
 toString()方法输出对象的name,number和birthday。
 （2）MyDate类包含:
 private成员变量year,month,day ；
 toDateString()方法返回日期对应的字符串：xxxx年xx月xx日
 （3）定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处
 理。该类包括：private成员变量monthlySalary；
 实现父类的抽象方法earnings(),该方法返回monthlySalary值；toString()方法输
 出员工类型信息及员工的name，number,birthday。
 （4）参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的
 员工处理。该类包括：
 private成员变量wage和hour；
 实现父类的抽象方法earnings(),该方法返回wage*hour值；
 toString()方法输出员工类型信息及员工的name，number,birthday。
 （5）定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各
 类雇员对象的引用。利用循环结构遍历数组元素，输出各个对象的类
 型,name,number,birthday,以及该对象生日。当键盘输入本月月份值时，如果本
 月是某个Employee对象的生日，还要输出增加工资信息。
 提示：
 //定义People类型的数组People c1[]=new People[10];
 //数组元素赋值
 c1[0]=new People(“John”,“0001”,20); c1[1]=new People(“Bob”,“0002”,19);
 //若People有两个子类Student和Officer，则数组元素赋值时，可以使父类类型的数组元素指向子类。 c1[0]=new Student(“John”,“0001”,20,85.0); c1[1]=new Officer(“Bob”,“0002”,19,90.5);
 
/*
 * （1）	定义一个Employee类，该类包含：
 *private成员变量name,number,birthday，其中birthday 为MyDate类的对象；
 *abstract方法earnings()；
 *toString()方法输出对象的name,number和birthday。
 *
 * 
 * 
 * 
 */
public abstract class Employee {
	private String name;
	private int number;
	private MyDate birthday;
	
	public Employee() {
		super();
	}
	
	public Employee(String name, int number, MyDate birthday) {
		super();
		this.name = name;
		this.number = number;
		this.birthday = birthday;
	}

	public abstract double earnings();

	@Override
	public String toString() {
		默认是birthday.toString,则输出为地址值,所以更改为在MyDate中的toDateString()方法
		return "[名字 = " + name + ", 工号 = " + number + ", 生日 = " + birthday.toDateString() + "]";
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}

	public MyDate getBirthday() {
		return birthday;
	}

	public void setBirthday(MyDate birthday) {
		this.birthday = birthday;
	}
	
	
}
 
/*
 * （2）	MyDate类包含:
 * 	private成员变量year,month,day ；
 * 	toDateString()方法返回日期对应的字符串：xxxx年xx月xx日

 * 
 */
public class MyDate {
	private int year;
	private	int month;
	private int day;
	
	public MyDate() {
		super();
	}

	public MyDate(int year, int month, int day) {
		super();
		this.year = year;
		this.month = month;
		this.day = day;
	}

	public String toDateString() {
		return  year + "年" + month + "月" + day + "日";
	}

	public int getYear() {
		return year;
	}

	public void setYear(int year) {
		this.year = year;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public int getDay() {
		return day;
	}

	public void setDay(int day) {
		this.day = day;
	}
	
	
}
 
/*
 * 定义SalariedEmployee类继承Employee类，实现按月计算工资的员工处理。
 * 该类包括：private成员变量monthlySalary；
 * 实现父类的抽象方法earnings(),该方法返回monthlySalary值；
 * toString()方法输出员工类型信息及员工的name，number,birthday。
 * 
 * 
 */
import org.junit.Test;

public class SalariedEmployee extends Employee{
//	@Test
//	public void test(){
//		System.out.println(toString());
//	}
	private double monthlySalary;//月工资
	public SalariedEmployee(){
		
	}
	public SalariedEmployee(String name,int number,MyDate birthday,double monthlySalary){
		super(name,number,birthday);
		this.monthlySalary = monthlySalary;
	}
	public  double earnings(){
		return monthlySalary;
		
	}
	@Override
	public String toString() {
		return "正式工" + super.toString();
	}
	public double getMonthlySalary() {
		return monthlySalary;
	}
	public void setMonthlySalary(double monthlySalary) {
		this.monthlySalary = monthlySalary;
	}
	
}

 
/*
 * （4）	参照SalariedEmployee类定义HourlyEmployee类，实现按小时计算工资的员工处理。该类包括：
 * 	private成员变量wage和hour；
 *  实现父类的抽象方法earnings(),该方法返回wage*hour值；
 *  toString()方法输出员工类型信息及员工的name，number,birthday。

 */
public class HourlyEmployee extends Employee{
	private double wage;//时薪
	private double hour;

	public HourlyEmployee(String name,int number,MyDate birthday) {
		super(name,number,birthday);
	}	
	
	public HourlyEmployee(String name,int number,MyDate birthday,double wage, double hour) {
		super(name,number,birthday);
		this.wage = wage;
		this.hour = hour;
	}
	public double earnings(){
		return wage*hour;
	}
	@Override
	public String toString() {
		return "钟点工" + super.toString();
	}
	public double getWage() {
		return wage;
	}
	public void setWage(double wage) {
		this.wage = wage;
	}
	public double getHour() {
		return hour;
	}
	public void setHour(double hour) {
		this.hour = hour;
	}
	
}

 
/*
 * 定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用。
 * 利用循环结构遍历数组元素，输出各个对象的类
 * 型,name,number,birthday,以及该对象生日。
 * 当键盘输入本月月份值时，如果本月是某个Employee对象的生日，还要输出增加工资信息。
 * 
 */
import java.util.Scanner;

public class PayrollSystem {
	public static void main(String[] args) {
		//方式一
//	Scanner scanner = new Scanner(System.in);
//	System.out.println("请输入月份");
//	int month = scanner.nextInt();
		//方式二
		Calendar calender = Calendar.getInstance();
		int month = calender.get(Calendar.MONTH);//获取当前的月份
		
	//此时是声明了Employee类型的数组,不是newEmployee的对象,所以作为抽象类的Employee可以这样来创建Employee变量数组并初始化
	Employee[] employee = new Employee[2];
	employee[0] = new SalariedEmployee("John", 001,new MyDate(2016,10,21),8888);
	employee[1] = new HourlyEmployee("Tom", 002, new MyDate(2019, 5, 21), 300, 8);
	
	for (int i = 0; i < employee.length; i++) {
		System.out.println(employee[i].toString());
		double salary = employee[i].earnings();
		System.out.println("月工资为" + salary);
		//month是从零开始，要加1
		if ((month + 1) == employee[i].getBirthday().getMonth()) {
			salary += 100;
			System.out.println("本月是" + employee[i].getName() + "的生日，获得100元红包，月工资为：" + salary);
		}
	}
	
	}
	
}