面向对象的继承性

继承的定义

类继承的定义 : 严格来说继承性是指 扩充一个类已有的功能。
Java中实现继承关系我们使用的语法定义是 ： class 子类 extends 父类 / public class 子类 extends 父类 这里我们用到了 extends 关键字 。 在继承中子类继承父类全部属性和方法。

**继承的目的 ：**主要是子类可以重用父类中的结构，同时根据子类功能的需要进行结构的扩充，所以子类往往比 父类描述的范围小。

/*分析以下需求，并用代码实现
要求:完成代码(按照标准格式写)，然后在测试类中测试。
	1.项目经理类 
		属性：姓名 工号 工资 奖金
		行为：工作work
	2.程序员类
		属性：姓名 工号 工资
		行为：工作work		
	3.测试类
		分别创建经理类对象和程序员对象,利用对象调用各自的方法
*/


//创建一个员工类
class Staff{
	private String name ;
	private int    number ;
	private double salary ;
	private double bonus ;
	
	/**
	 * 创建无参构造方法
	 */
	public Staff() {
	}
	/**
	 * 创建有参构造方法
	 * @param name
	 * @param number
	 * @param salary
	 * @param bonus
	 */
	public Staff(String name, int number ,double salary , double bonus) {
		this.name = name ;
		this.number = number ;
		this.salary = salary ;
		this.bonus = bonus ;
		
	}
		
	
	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 double getSalary() {
		return salary;
	}


	public void setSalary(double salary) {
		this.salary = salary;
	}


	public double getBonus() {
		return bonus;
	}


	public void setBonus(double bonus) {
		this.bonus = bonus;
	}

/**
 * 创建工作的方法
 */
	public void work() {
		System.out.println("工号为"+number+"的" + name + "在努力的工作 ." +" 他的工资是 " +  salary +"奖金为 " +bonus);
		
	}
	
}
//Jinli 类继承Staff类(员工类)
class Jinli extends Staff {
	   public Jinli(String name ,int number ,double salary ,double bonus) {
		   super(name,number,salary,bonus);
	   }
	  }

//程序员类 继承 Staff类(员工类)
class ChengXuYuan extends Staff{
	 public ChengXuYuan(String name , int number ,double salary,double bonus) {
		  super(name,number,salary, bonus);
	
	 }
}
public class Test {
		public static void main(String[] args) {
	       Jinli person = new Jinli("王华",5213,20000,30000);  // 实例化对象 并传参数
	       person.work();                                     // 对象调用work方法
	       
	       ChengXuYuan person1 = new ChengXuYuan("小李",5214,6000,0); //实例化对象 并传参数
	       person1.work();
	       
 }
}

/*分析以下需求,并用代码实现
1.定义员工类:
	属性:
		工号,姓名
	行为:
		工作方法(用简单的输出语句模拟)
2.定义经理类:
	属性:
		工号,姓名,奖金
	行为:
		工作方法(管理员工,简单输出语句模拟)
3.定义服务员类:
	属性:
		工号,姓名
	行为:
		工作方法(为客户服务,简单输出语句模拟)
4.定义测试类:
	分别创建经理类对象和服务员类对象
	调用各自的工作方法

	要求:
		分析各个事物之间的继承关系,抽取出相关的类
*/

//定义一个Worker 类
class Worker{
	private String name ;
	private int   number;
	private double salary ;
	private double bonus ;
	
	public Worker(){
		
	}
	public Worker(String name , int number ){
		this.name = name ;
		this.number = number ;
	}
	public Worker(String name , int number , double salary){
		this.name = name ;
		this.number = number ;
		this.salary = salary ;
	}
	public Worker(String name , int number , double salary,double bonus){
		this.name = name ;
		this.number = number ;
		this.salary = salary ;
		this.bonus = bonus ;
	}
	
	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 double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	/**
	 * 定义一个经理工作行为的方法
	 */
	public void  work1() {
		System.out.println("工号为" + number + "的" + name + "在办公室检查项目" + "他的年中奖为" + bonus);
	}
	/**
	 * 定义一个程序员工作行为的方法
	 */
	public void work2() {
		System.out.println("工号为" + number + "的" + name + "在努力完成项目");
	}
	/**
	 * 定义一个服务员工作行为的方法
	 */
	public void work3() {
		System.out.println("工号为" + number + "的" + name + "在给客人倒水");
	}
}

class manager extends Worker{
	public manager (String name , int number , double salary,double bonus) {
		super(name,number,salary,bonus);    // 用super关键字调用父类的有参构造构造并指明要调用的参数
	}
}

class YuanGong extends Worker{
	public YuanGong(String name , int number ) {
		super(name,number);					 // 用super关键字调用父类的有参构造构造并指明要调用的参数
	}
}
 
class Server extends Worker{
	public Server(String name , int number){
		super(name,number);					 // 用super关键字调用父类的有参构造构造并指明要调用的参数
	}
	
}


public class Test8 {
		public static void main(String[] args) {
			manager  Jili = new manager ("熊经理",123,10000,5200);  //实例化对象 并传参数
			Jili.work1();                                        //对象调用父类中的work1() 方法
			System.out.println("");
			 
			YuanGong p = new YuanGong("小张",125);			//实例化对象 并传参数
			p.work2();                          //对象调用父类中的work2() 方法
			System.out.println("");
			
			Server p2 = new Server("小英",156);   			//实例化对象 并传参数
			p2.work3();                          //对象调用父类中的work3() 方法
			System.out.println("");
			
		}
}

标题 子类对象实例化流程

子类对象实例化流程 ：在继承结构中，子类需要重用父类的结构（成员属性 ，父类方法），所以在子类实例化之前，往往都会默认调用父类的无参构造 ，为父类对象实例化（属性的初始化），然后在进行子类构造调用 。
即 ：子类对象实例化之前一定会实例化父类对象，实际上这个时候就是相当于子类的构造方法中隐含了一个 调用父类的无参构造 super（）的形式 。

标题 super（）的作用 ：

super（）的作用 ：
1.
子类中 super（）的作用是表示 明确调用父类的无参构造，如果不写 也会默认调用父类的无参构造
2.
如果要调用父类的 有参构造 必须指明调用方法的参数如 super（参数，…）
3.
super（）构造调用的语句只能够在子类中的构造方法中定义。并且只能放在子类构造方法的首行

标题 继承的限制 ：

继承的限制 ：
一个子类只能继承一个父类，（通俗的说 一个儿子只能有一个爸爸）
一个父类可以被多个子类继承（通俗的说一个爸爸可以有多个儿子）
这就是继承的 单继承局限 java中只允许多层继承。
在子类继承父类的时候，实际上是继承父类的所有操作（ 即属性、方法），但是对于私有的（private）操作，我们需要 通过间接访问的形式完成。

标题 方法覆写的定义

**方法覆写的定义 ：**在子类中定义一个与父类中 方法名称 ，放回值类型 ，参数类型及参数个数相同的方法 ，我们叫方法覆写。 当通过子类实例化对象调用方法时所调用的方法是被子类覆写过 的方法 。如果要调用父类中没用被覆写的方法我们就用 super.方法（）的形式调用 。