Java选实验三：包及继承的应用

一、实验目的 1. 熟悉面向对象编程中package,import等语句的使用。
二、实验内容与要求 1. 编写一个CSSE类和一个Teacher类。CSSE类中包含有多个Teacher类的实例（所有特聘教授的名字请查阅http://csse.szu.edu.cn/cn/people）。调用CSSE类的实例中的getTeacherNames方法时，能够输出学院中所有特聘教授的名字。在报告中附上程序截图、运行结果截图和详细的文字说明。（10分）
2.把CSSE类和Teacher类放进cn.edu.szu包中。编写一个测试类，在源代码中用import语句引入cn.edu.szu包中的所有类，并对它们所包含的方法进行测试。在报告中附上程序截图、运行结果截图和详细的文字说明。（10分）
3.定义一个包，在该包中定义一个类并输出“I love SZU”字符串。在报告中附上程序截图、运行结果截图和详细的文字说明。（10分）
4.在一个包中定义一个默认访问权限控制的类DefaultClass，然后在该包以及另一个包中分别定义类来测试DefaultClass类中的protected和public数据成员的访问控制能力。在报告中附上程序截图、运行结果截图和详细的文字说明。（10分）
5.在一个包中定义一个public访问权限控制的类PublicClass，然后在该包以及另一个包中分别定义类来测试PublicClass类中的protected和public数据成员的访问控制能力。在报告中附上程序截图、运行结果截图和详细的文字说明。（10分）
【Java选实验三：包及继承的应用】6.编写一个抽象类Animal，它具有两个抽象方法run和eat 。分别实现这个抽象类的三个子类Tiger、Cat和Dog 。实现一个测试类，在测试类的main方法中分别使用这三个子类创建对象实体，然后通过它们的上转型对象变量调用run方法和eat方法。在报告中附上程序截图、运行结果截图和详细的文字说明。（15分）
7.一个三维向量由三个分量组成。三维向量的相加和相减等价于对应三个分量的相加和相减。比如两个三维向量（5,2,1）和（3,-1,0），它们的和为（8,1,1），它们的差为（2,3,1）。编写一个接口Computable，它具有两个抽象方法add和minus 。编写一个Vector类，通过Computable接口实现三维向量的相加和相减。在报告中附上程序截图、运行结果截图和详细的文字说明。（15分）
三、实验过程及结果 1.编写一个CSSE类和一个Teacher类。CSSE类中包含有多个Teacher类的实例（所有特聘教授的名字请查阅http://csse.szu.edu.cn/cn/people）。调用CSSE类的实例中的getTeacherNames方法时，能够输出学院中所有特聘教授的名字。
package example;import java.util.Scanner;class CSSE{//CSSE类 private Teacher t[];//多个Teacher的实例 private int n; CSSE(Teacher tea[], int nn){//带参构造函数t = new Teacher[nn];n = nn;for(int i = 0; i < n; i++)t[i] = tea[i]; } public void getTeacherName() {//getTeacherName()方法for(int i = 0; i < n; i++)t[i].display(); }}class Teacher{//Teacher类 private String name; Teacher(String n){name = n; } public void display() {System.out.println(name); }}public class Example {//主类 static public void main(String args[]) {System.out.print("请输入特聘教授的数量：");Scanner sc = new Scanner(System.in);int n = sc.nextInt();System.out.print("请输入特聘教授的名字：");Teacher []tea = new Teacher[n]; //用new关键字为tea数组开辟长度为n的空间String name = " ";for(int i = 0; i < n; i++) {name = sc.next();tea[i] = new Teacher(name);//每输入一个teacher的名字声明一个对象}CSSE cs= new CSSE(tea, n);//声明cs对象System.out.println();cs.getTeacherName(); //调用CSSE类的实例中的getTeacherNames方法sc.close(); }}
2. 把CSSE类和Teacher类放进cn.edu.szu包中。编写一个测试类，在源代码中用import语句引入cn.edu.szu包中的所有类，并对它们所包含的方法进行测试。在报告中附上程序截图、运行结果截图和详细的文字说明。
//1、编写CSSE公共类来测试cn.edu.szu包中的类能否被另外一个包中的类访问，答案是能package cn.edu.szu;public class CSSE{ private String professor; private String subject; public CSSE(String p, String s) {professor = p;subject = s; } public void display() {System.out.printf("CSSE-display(): ");System.out.printf("%s教的科目为：%s \n", professor, subject); }//编写默认访问权限的getProfessor（）方法在来测试该方法能否被另一个包的使用，答案是不能 String getProfessor() {System.out.printf("CSSE-getProfessor(): ");return professor; }}//2、编写Teacher类来测试public实例能否被另一个包中的类使用，答案是能package cn.edu.szu;public class Teacher { private String name; private int age; public int subjects;//public实例，能直接通过对象调用 public Teacher(String n, int a) {name = n;age = a;subjects = 3; } public void display() {System.out.printf("Teacher-display(): ");System.out.printf("%s %d\n", name, age); }}//3、编写Major类来测试默认访问权限的类能否被另一个包中的类使用，答案是不能package cn.edu.szu;class Major{ protected String major; Major(String m){major = m; } public void display() {System.out.printf("Major-display(): ");System.out.println(major); }}//4、另一个包test1，用import导入cn.edu.szu内所有的类，测试哪些类，哪些方法，哪些实例可以被使用package test1;import cn.edu.szu.*;public class Test2 { static public void main(String []args) {CSSE css = new CSSE("xiaoming","math");css.display();//System.out.println(css.getProfessor());//错误，不能调用CSSE类中的默认访问权限的方法Teacher tea = new Teacher("xiaohong",30);tea.display();System.out.println(tea.subjects);//错误，不能使用默认访问权限的Major类//Major maj = new Major("计算机科学与技术");//maj.display(); }}
3. 定义一个包，在该包中定义一个类并输出“I love SZU”字符串。
package printString;//定义printString包class Print{//定义默认访问权限的Print类 private String str; Print(String s){str = s; } public void display() {System.out.println(str); }}public class PrintString { static public void main(String []agrs) {Print p = new Print("I Love SZU.");//声明p对象p.display();//用p对象调用Print类中的display（）方法System.out.println("I Love SZU."); }}
4. 在一个包中定义一个默认访问权限控制的类DefaultClass，然后在该包以及另一个包中分别定义类来测试DefaultClass类中的protected和public数据成员的访问控制能力。
//默认访问权限的DefaultClass类package test;public class DefaultClass{ protected char ch;private int num; public String str; //分别定义protected，private，public实例 public DefaultClass(char c, int n, String s){ch = c;num = n;str = s; } public char getCh() {return ch; } public int getNum() {return num; } public String getStr() {return str; } public void display() {System.out.printf("%c %d %s\n",ch, num, str); }} //同一个包中的类，无需import即可访问DefaultClass类package test;public class Test_test { static public void main(String []args) {//声明def对象DefaultClass def = new DefaultClass('a', 3, "xiaoming");System.out.printf("def.ch: %c\n", def.ch);//测试protected实例，可访问//System.out.println(def.num);//测试private实例，不可访问System.out.printf("def.str: %s\n", def.str);//测试public实例，可访问//测试public方法，可访问System.out.printf("def.getCh(): %c\n", def.getCh());System.out.printf("def.getNum(): %d\n", def.getNum());System.out.printf("def.getStr(): %s\n", def.getStr());def.display(); }} 另外，经测试得，不可以访问另一个包中的默认访问权限的类
5. 在一个包中定义一个public访问权限控制的类PublicClass，然后在该包以及另一个包中分别定义类来测试PublicClass类中的protected和public数据成员的访问控制能力。
//public访问权限控制的类PublicClasspackage test;public class PublicClass { protected char ch; private int num; public String str;//分别定义protected，private，public实例 public PublicClass(char c, int n, String s){ch = c;num = n;str = s; } public void display() {System.out.printf("%c %d %s\n",ch, num, str); }} //同一个包中的类，无需import即可访问PublicClass类package test;public class Test_PublicClass { static public void main(String []args) {//声明pub对象PublicClass pub = new PublicClass('a', 3, "xiaoming");System.out.printf("pub.ch: %c\n", pub.ch);//测试protected实例，可访问//System.out.println(def.num);//测试private实例，不可访问System.out.printf("pub.str: %s\n", pub.str);//测试public实例，可访问pub.display();//测试public方法，可访问 }} //不同包中的类，需要importPublicClass所在的包才能访问package test1;import test.PublicClass;public class Test_PublicClass { static public void main(String []args) {//声明pub对象PublicClass pub = new PublicClass('a', 3, "xiaoming");//System.out.printf("pub.ch: %c\n", pub.ch);//测试protected实例，不可访问//System.out.println(def.num);//测试private实例，不可访问System.out.printf("pub.str: %s\n", pub.str);//测试public实例，可访问pub.display();//测试public方法，可访问 }}
6. 编写一个抽象类Animal，它具有两个抽象方法run和eat 。分别实现这个抽象类的三个子类Tiger、Cat和Dog 。实现一个测试类，在测试类的main方法中分别使用这三个子类创建对象实体，然后通过它们的上转型对象变量调用run方法和eat方法。
package animal;import java.util.Scanner;abstract class Animal{//定义抽象父类Animal protected String name;//定义受保护的实例name，只有子类能访问 public Animal(String n) {name = n; } abstract public void run(); abstract public void eat(); //声明抽象方法}class Tiger extends Animal{//定义Tiger子类继承Animal public Tiger(String n){super(n); } public void run() {//编写与父类相对应的run抽象方法System.out.print("Hello, I am a "+ name + ", my running speed is about 60 kilometers per hour.\n"); } public void eat() {//编写与父类相对应的eat抽象方法System.out.print("I like eating meat.\n"); }}class Cat extends Animal{//定义Cat子类继承Animal public Cat(String n){super(n); } public void run() {//编写与父类相对应的run抽象方法System.out.print("Hello, I am a "+ name + ", my running speed is about 55 kilometers per hour.\n"); } public void eat() {//编写与父类相对应的eat抽象方法System.out.print("I like eating fish.\n"); }}class Dog extends Animal{//定义Dog子类继承Animal public Dog(String n){super(n); } public void run() {//编写与父类相对应的run抽象方法System.out.print("Hello, I am a "+ name + ", my running speed is about 20 kilometers per hour.\n"); } public void eat() {//编写与父类相对应的eat抽象方法System.out.print("I like eating all kinds of food.\n"); }}public class Animals {//主类 static public void main(String []agrs) {Scanner sc = new Scanner(System.in);System.out.println("请输入测试次数：");int t = sc.nextInt();for(int i = 0; i < t; i++) {System.out.println("请输入动物名称：");String name = sc.next();//根据输入的动物名称分别声明对应的对象，调用run与eat方法if(name.equals("tiger")) {//此处用equals（）方法判断字符串是否相等Tiger tiger = new Tiger(name);tiger.run();tiger.eat();}else if(name.equals("cat")) {Cat cat = new Cat(name);cat.run();cat.eat();}else if(name.equals("dog")) {Dog dog = new Dog(name);dog.run();dog.eat();}elseSystem.out.println("Sorry! There is no such animal.");}sc.close(); }}
7.一个三维向量由三个分量组成。三维向量的相加和相减等价于对应三个分量的相加和相减。比如两个三维向量（5,2,1）和（3,-1,0），它们的和为（8,1,1），它们的差为（2,3,1）。编写一个接口Computable，它具有两个抽象方法add和minus 。编写一个Vector类，通过Computable接口实现三维向量的相加和相减。
package example;import java.util.Scanner;interface Computable{//定义接口 abstract void add(Vector vec) ;abstract void minus(Vector vec) ;//声明抽象方法}class Vector implements Computable{//以Computable接口来实现Vector类 private int x; private int y; private int z; public Vector(int xx, int yy, int zz) {x = xx;y = yy;z = zz; } public void add(Vector vec) {//实现接口中的add（）方法x += vec.x;y += vec.y;z += vec.z;System.out.printf("两向量和");display(); } public void minus(Vector vec) {//实现接口中的minus（）方法x -= vec.x;y -= vec.y;z -= vec.z;System.out.printf("两向量差");display(); } public void display() {System.out.printf("为：(" + x + ',' + y + ',' + z + ")\n"); }}public class ComputeVector{//主类 static public void main(String []args) {System.out.print("请输入测试次数：");Scanner sc = new Scanner(System.in);int t = sc.nextInt();for(int i = 0; i < t; i++) {System.out.print("请输入向量1：");int x1 = sc.nextInt();int y1 = sc.nextInt();int z1 = sc.nextInt();Computable vec1 = new Vector(x1, y1, z1);//声明父接口变量vec1，指向子类对象Vector temp1 = new Vector(x1, y1, z1);//声明Vector类的变量temp1，保存x1，y1，z1的值，防止调用add()方法后三个值改变System.out.print("请输入向量2：");int x2 = sc.nextInt();int y2 = sc.nextInt();int z2 = sc.nextInt();Vector vec2 = new Vector(x2, y2, z2);vec1.add(vec2);temp1.minus(vec2);}sc.close(); }}