面向对象的继承性_类的继承作业1 1.简答题 1.定义项目经理类 属性: 姓名工号工资奖金 行为: 工

继承的定义

类继承的定义 : 严格来说继承性是指 扩充一个类已有的功能。
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
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

/*分析以下需求,并用代码实现
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("");
			
		}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

标题 子类对象实例化流程

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

标题 super（）的作用 ：

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

标题 继承的限制 ：

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

标题 方法覆写的定义

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