实验四：面向对象编程实验（2）—封装、继承和包

实验四

实验项目：面向对象编程实验（2）—封装、继承和包

实验时间：2019.4.15

实验目的

1. 掌握继承、包、与类封装性的概念与用法
2. 学习编写具有包的面向对象的应用程序
3. 掌握Java封装性中访问控制的用法。

实验内容：

必做

1. 完成并理解书中71页的J_Teacher.java例题。
   1）理解隐式类型转换和显式类型转换的区别。
   2）尝试创建一个Student类，根据类的继承特点，试问该类是否可以继承J_Employee？如果不能，可否设置一个Student类和Teacher类所共有的父类？编程实现

1.1） 区别：隐式类型转换将类型为子类型得数据转换成为类型为其父类型的数据时，可以不需要强制类型转换运算符”( )”； 显式类型转换将类型为子类型得数据转换成为类型为其父类型的数据时，需要强制类型转换运算符”( )”。
1.2） 无法继承J_Employee；重新定义一个J_Employee。java文件

源文件：

package ex04;

public class J_Employee 
{
	public int m_workyear;
	//工作年限
	public J_Employee()
	{                                         
		m_workyear = 1;
	}                          //构造方法结束
}                            //类结束

1
2
3
4
5
6
7
8
9
10
11
12

package ex04;


public class J_Teacher extends  J_Employee  
{
	public int m_classHour;          //授课的课时                     
	
	public J_Teacher()
	{                            
		m_classHour = 96;
	}                                    //构造方法结束

	public void mb_printInfon()
	{                        
		System.out.println("该教师的工作年限为："+ m_workyear);
		System.out.println("该教师的授课课时为："+ m_classHour);
		
	}//方法体mb_printInfon结束
	public static void main(String[] args) 
	{              
		J_Teacher  tom = new J_Teacher();
		tom.mb_printInfon();                     
		
	}                                               //方法结束
	
}                                            //类结束

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

package ex04;

public class Student extends J_Employee {

		public int studyYears;   //学习年长
		//工作年限
		public Student()
		{                                         
			studyYears = 15;
		}                          //构造方法结束
		public void mb_printInfon()
		{   
			System.out.println("该学生的学习年限为："+studyYears);
			System.out.println("该学生工作年限为："+m_workyear);
	}
		public static void main(String[] args) {
			Student zhangsan = new Student();
			zhangsan.mb_printInfon();
		}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：
J_Teacher.java

Student.java

2. 练习包的建立和使用用法：
   1）生成一个类Employee,域变量为name和age;类包为asia.china;
   2）生成一个类Teacher, 继承Employee类；类包为asia.china.guangdong ，域变量为工作年限（workYears）和职称(jobTitle)；成员方法包括构造方法与getter方法；
   3）生成测试类TestTeacher, 类包为asia.china.guangdong.zhuhai;在main主方法中创建Teacher类的对象jilinTeacher_zhangsan, 初始化姓名、年龄，工作年限和职称，并测试修改职称信息并显示。

源码：
Employee.java

package ex04.asia.china;

public class Employee {
	//域变量为name和age;
	public String name;
	public int age;
}
1
2
3
4
5
6
7

Teacher.java

package ex04.asia.china.guangdong;

import ex04.asia.china.Employee;

public class Teacher extends Employee {
	/*
	 *域变量为工作年限（workYears）和职称(jobTitle)；成员方法包括构造方法与getter方法； 
	 */
	private int workyears;
	
	private String iobTitle;
	
	public Teacher(int workyears,String iobTitle) {
		this.workyears = workyears;
		this.iobTitle = iobTitle;
		
		
	}

	public int getWorkyears() {
		return workyears;
	}

	//public void setWorkyears(int workyears) {
		//this.workyears = workyears;
	//}

	public String getIobTitle() {
		return iobTitle;
	}

	//public void setIobTitle(String iobTitle) {
	//	this.iobTitle = iobTitle;
	//}
	
}
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

TestTeacher.java

package ex04.asia.china.guangdong.zhuhai;

import ex04.asia.china.guangdong.Teacher;

public class TestTeacher {

	public static void main(String[] args) {
		Teacher jilinTeacher_zhangsan = new Teacher(20,"老师");
		jilinTeacher_zhangsan.name = "jilin";
		jilinTeacher_zhangsan.age = 30;
		
		System.out.println("年龄："+jilinTeacher_zhangsan.age);
		
		System.out.println("姓名："+jilinTeacher_zhangsan.name);
		
		System.out.println("工作年限："+jilinTeacher_zhangsan.getWorkyears());
		
		System.out.println("职称："+jilinTeacher_zhangsan.getIobTitle());
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

运行结果：

实验总结：
学习巩固了继承的使用方法，复习了封装getter方法的使用。