一、 实验目的
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分)
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访问权限控制的类PublicClass
package 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();
}
else
System.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();
}
}