继承

超类位于子类之上，但并不意味着比子类拥有更多的功能，相反，子类比超类
拥有的功能更丰富。

override重写

• "==" 方法名形参列表相同
• "<=" 子类返回值类型或者异常声明小于等于父类
• ">=" 子类访问权限大于大于等于父类

super

class Manager extends Empoyee
{
public void steBouns(double b)
 { 
 bouns=b;
 }
  public double getsalary()
  {  
   double baseSalary=super.getSalary();//调用Manager中的getSalary方法  
   return baseSalary+bouns;
  }
private double bouns;
}

super不是一个对象的引用，不能将super赋给另一个对象变量，它只是一个提示编译器调用超类方法的特有关键字

子类可以添加域，添加方法，覆盖超类的方法，不能删除继承的超类的任何方法和域。

super在构造器中的应用

public Manager(Sting n, double s, int year, int month, int day)
{
 super(n, s, year, month, day);//调用超类Employee中含有n，s，year, month, da的y构造器
 bouns=0;
}

Reason：

   由于Manager类的构造器不能访问Employee类的私有域，所以必须利用Employee的构造器对这部分私有域进行初始化，通过super实现对超类构造器的调用。使用super调用构造器的语句必须是子类构造器的第一条语句。
      如果没有调用，子类将自动调用超类的无参构造器，如果超类没有，那么编译器将会报错

总结

this关键字：1.引用隐式参数
            2.调用该类的其他构造器
super关键字：1.调用超类方法
             2.调用超类的构造器

调用构造器语句必须作为第一句出现，构造器参数既能传递给本类的其他构造器（this），也能传递给子类的构造器（super）

import java.util.Date;
import java.util.GregorianCalendar;

/**
 * 
 * @author asus
 *
 */
public class ManagerTest{
	public static void main(String[] args) 
	{   Manager boss=new Manager("Cheng",80000,1987,1,1);
		boss.setBonus(5000);
		Employee[] staff =new Employee[3];
		
		
		staff[0]=boss;
		staff[1]=new Employee("cindy",2000,2018,10,1);
		staff[2]=new Employee("paul",3000,2018,10,1);
	for(Employee e:staff) {
		e.raiseSalary(5);//将e的salary域值增加5%，即double raise=e.salary*5/100;e.salary+=raise;
	}
	for (Employee e:staff) {
		System.out.println("name="+e.getName()+"slary="+e.getSalary()+"\n"+"hireday="+e.getHireDay());
	}
	
	}
}
	
	class Employee{
		public Employee(String n,double s,int year,int month,int day) 
		{   
			name =n;
			salary=s;
			GregorianCalendar calendar=new GregorianCalendar(year,month-1,day);
			hireDay=calendar.getTime();
		}
	public String getName() { 
		return name;
	}
	public double getSalary() { 
		return salary;
	}
	
	public Date getHireDay() { 
		return (Date)hireDay.clone();
	}
	/*方法用于操作对象以及存取它们的实例域。将调用这个方法的对象的salary实例域设置为新值。*/
	public void raiseSalary(double byPercent) { 
		  double raise=this.salary*byPercent/100;//this表示隐式参数  
		  this.salary+=raise;
	}
	
	private String name;
	private double salary;
	private Date hireDay;
	
	
	}	
	class Manager extends Employee{
		public Manager(String n,double s,int year,int month,int day) {
			super(n,s,year,month,day);
			bonus=0;
		}
		public double getSalary() {
			double baseSalary=super.getSalary();
			return baseSalary+bonus;
		}
		public void setBonus(double b) {
			bonus=b;
		}
	    private double bonus;
	}

    e虽然声明为Employee类型，但实际上e既可以引用Employee类型的对象，调用Employee类中的getSalary方法； 也可以引用Manager类型的对象，调用Manager类中的getSalary方法。
    一个对象变量（e）可以引用多种实际类型的现象被称为多态。在运行时能够自动选择调用哪个方法的现象称为动态绑定。

继承层次

     继承并不仅限于一个层次，例如，Manager类可以派生出Executive类，由一个公共超级类派生出的所有类的集合称为继承层次，从某个特定的类到其祖先的路径被称为该类的继承链。