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

最新推荐文章于 2024-05-01 19:17:00 发布
最新推荐文章于 2024-05-01 19:17:00 发布
阅读量1.6k 收藏 15
点赞数 6
分类专栏： java实验 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62215764/article/details/123805020
版权

一、 实验目的

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();
	}
}

 

capucino_bubble
关注
  • 6
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java编译实验包
12-08
这是一个关于java在命令行中编译运行的实验资源。
Java语言程序设计 选实验3 包及继承应用
arveis的博客
11-24 236
Java语言程序设计 选实验3 包及继承应用
java上机实验答案_java上机实验答案与解析
weixin_33499681的博客
02-16 1259
java上机实验答案与解析 JAVA上机实验题答案与解析 实验一 Java程序编程 1. 编写一个Java应用程序，输出内容为Hello!。 注：文件位置位于e:\2:\Hello.java 编译：(1)e:(2)cd 2 (3)javac Hello.java(4)java Hello 2.编写一个Java小应用程序，输出内容为我一边听音乐，一边学Java。 第一步编写 import java....
Java之package语句和import语句
Sunshine博客
03-26 3194
这里写目录标题package语句什么是包Java的包机制需要两个方面保证 package语句 什么是包 包是一组类的集合,可以包含若干个类文件,还可以包含若干个包; 防止重名(公司里边一般是公司的域名反着写,域名一般是唯一的); 形成层次化文件结构. Java的包机制需要两个方面保证 源文件里使用package语句制定包名; class文件必须放在对应的路径下. 项目文件夹srcbinle...
Java 2实用教程（第三版）实验指导与习题解答and实验模版代码及答案(一)
热门推荐
zxq1138634642的专栏
11-26 1万+
Java 2实用教程（第三版）实验指导与习题解答 清华大学出版社 （编著 耿祥义 张跃平） 实验模版代码及答案 建议使用文档结构图 （选择Word菜单→视图→文档结构图） 上机实践1  初识Java 3 实验1  一个简单的应用程序 3 实验2  一个简单的Java Applet程序 3 实验3  联合编译 4 上机实践2  基本数据类型与控制语句 5 实验1  输出希腊
Java实验报告——类的继承、多态的应用
02-21
1、实验名称：类的继承、多态的应用 2、代码内容：学生管理类 3、【实验目的】 （1）进一步熟悉抽象类和抽象方法的定义 （2） 进一步掌握集成和多态的实现方式。
西南科技大学Java程序设计与实践 实验三 类的继承与多态的应用
06-14
西南科技大学Java程序设计与实践 实验三 类的继承与多态的应用 一、实验目的： 1、练习类的继承与多态设计过程； 2、练习面向对象的图形用户界面设计、事件设计方法。 二、实验内容： 1、利用多态性编程，创建一个 ...
java实验报告.docx
06-11
java实验报告，一共16个实验，包含代码截图。目录 实验一 使用 Java 开发环境 Myeclipse 和 1 实验二 Java 结构化程序设计应用 3 实验三 Java 数组和方法应用 10 实验四 类和对象；类的继承和派生；多态性；接口；...
实验：JAVA类的使用
11-04
这个资源适用于正在学习Java基础的人，也适用于需要写Java实验报告的人，这个资源中共有6个关于类的编程习题和运行截图，可以更好的帮助正在学习Java基础的人了解Java中的类该如何使用。 需要学习Java的类的知识的...
java《面向对象程序设计》实验报告三
07-31
1.编写一个Java应用程序，该程序中有3个类：Trangle、Leder和Circle，分别用来刻画“三角形”、“梯形”和“圆形”。具体要求如下： a) Trangle类具有类型为double的三个边，以及周长、面积属性，Trangle类具有返回...
关于使用包下的类
weixin_47256096的博客
11-08 386
关于使用包下面的类 1.类的前面创建的时候会自动加入package ###；申明类所在的包 2.使用同一个包下的其他类，直接使用即可 这里有一个类Auto和Car在package week4下面,我们测试在Car中继承Auto 这个是Auto的内容 下面的是Car中的内容，直接引用继承了Auto类，无需import 3.但是要使用其他包下的类，必须import，格式为import packagename.classname 例如下图有两个包，包里面分别有Hero.java和TestHero.java，
Java核心编程二：使用类和包
zzulp的专栏
09-19 1302
1 创建对象 对象声明后，只处理未初始化状态，可以用NULL或对象来初始化。 Java实现中将日期类Date和日历类Calendar分离开了。 2 自定义类 class Test {         field1;     methods;  } java的构造函数和类名同名，可以进行重载多个。Java的方法均定义在类的内部，但并不代表为内联。 对于
软件构造笔记：Java包的应用
weixin_42697247的博客
07-15 189
在编写功能较为复杂，代码量较大的软件时，对不同类的规划十分重要，为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。 文章目录Java 包(package)包的作用创建包import 关键字package 的目录结构 Java 包(package) 包的作用 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因
java 实验四类与对象习题答案_JavaSE习题 第四章 类与对象
weixin_26802933的博客
02-13 1967
问答题：1.在声明类时，类名应该遵守哪些习惯？1.与文件名相同2.首字母大写2.类体内容中有那两类比较重要的成员？1.成员变量2.方法3.实例方法可以操作类变量吗？类方法可以操作实例变量吗？类中的实例方法可以操作类变量因为类总是先于实例存在的 实例只是类在特定状态下的一个特定对象 所以必须类存在 才能从类创建实例 所以实例方法可以操作类变量 因为类变量肯定存在类方法不可以操作实例变量因为类方法的作...
链表刷题集
yajunjiao的专栏
04-30 799
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1789
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1341
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
Java解决最长公共前缀
无人罪的博客
04-28 653
编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串""。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1158
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
实验目的：练习swing布局和事件处理 。实验要求：通过java制作计算器的界面和简单功能
05-30
好的，这个实验要求你使用Java Swing布局和事件处理来制作一个简单的计算器。下面是一个简单的示例代码，演示了如何创建计算器的界面和实现加法操作： ```java import javax.swing.*; import java.awt.*; import ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值