Java实验六

关注

原创最新推荐文章于 2026-09-08 20:07:47 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

【Java】实验六最终选择了单独定义一个类，自定义构造函数的参数为tank类很好的解决了爆炸位置的问题，这样就完全可取代在tank类中定义尘缘变量的方法，且若在tank类中实现爆炸需要将绘制爆炸有关的代码写在tank类的draw()函数中，而当tank对象的draw()每隔50ms就会调用，即实现对坦克对象和爆炸效果的绘制，这显然不合适，因此排除此方式；函数通过循环遍历每颗敌方子弹和己方子弹，判断每颗敌方子弹的位置与己方坦克的位置，和己方子弹与敌方坦克的位置，到达一定范围内，认为发生碰撞，返回不同的值。阅读详情

实验六接口和继承

第一题：

实验内容

1. 编写程序为公交车的老人卡、学生卡和普通市民卡提供收费功能，将充值、收费功能提取，以接口的形式定义，然后被这三种卡类实现。最后编写一个测试类，用于测试公交车三类卡的刷卡操作。

package text;
public class text1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
old o=new old();
o.input(100);
o.output();
student s=new student();
s.input(50.5);
s.output();
people p=new people();
p.input(90);
p.output();
	}
}
interface card{
	void input(double sum);
	void output();
}
 class old implements card{
	public void input(double sum) {
		System.out.println("老人卡已充值"+sum+"元");
	}
	public void output() {
		System.out.println("使用老年卡，扣一元");
	}
}
 class student implements card{
		public void input(double sum) {
			System.out.println("学生卡已充值"+sum+"元");
		}
		public void output() {
			System.out.println("使用学生卡，扣1.5元");
		}
	}
 class people implements card{
		public void input(double sum) {
			System.out.println("普通市民卡已充值"+sum+"元");
		}
		public void output() {
			System.out.println("使用普通市民卡，扣2元");
		}
	}

2.设计四个类、一个接口，类之间的关系如下：

在类App中使用Compute、Circle、Rectangle类，在Compute类中使用Shape接口（Shape对象作为computeArea方法的形式参数），Circle、Rectangle类实现接口Shape，重写area()方法。图中“+”的表示public，“-”的表示private，框图中上面一栏是类或接口的名称，中间一栏是属性，下面一栏是方法。

在App类的main()中：

创建一个Compute类对象、一个Circle类对象和一个Rectangle类对象。
调用Compute对象的computeArea方法(实际参数为Circle对象)计算圆的面积。

调用Compute对象的computeArea方法(实际参数为Rectangle对象)计算矩形面积。

package text;

public class App {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
Compute c=new Compute();
Circle i=new Circle(5);
Rectangle r=new Rectangle(7,9);
c.computeArea(i);
c.computeArea(r);
System.out.println("圆的面积为"+c.computeArea(i));
System.out.println("矩形的面积为"+c.computeArea(r));
	}

}
interface Shape{
	public double PI=3.14;
	public double area();
}
class Compute{
	double computeArea(Shape s){
		return s.area() ;
	}
}
class Circle implements Shape{
	private int radius;
	 Circle(int radius){
		this.radius=radius;
	}
	public double area(){
		return PI*radius*radius;
	}
}
class Rectangle implements Shape{
	private int width;
	private int heigth;
	 Rectangle(int width,int heigth){
		this.width=width;
		this.heigth=heigth;
	}
	public double area(){
		return width*heigth;
	}
}

3. 普通门和报警门。

（1）定义一个接口Alarm（报警），含有一个报警方法void alarm( )；

（2）定义一个类Door（普通门），Door类有一个私有属性name（品牌）；有4个公有方法getName、setName、open（开门）、close（关门）；open、close方法的功能由自己确定。

（3）定义一个类AlarmDoor（报警门），继承Door类，实现接口Alarm，重写接口中的抽象方法alarm（方法的功能由自己确定）。

（4）编写一个测试类DoorTest，在main方法中，给出多种型号的报警门和普通门，调用开门、关门、报警等动作。

package text;
public class text1 {
	public static void main(String[] args){
        Door d=new Door();
        d.open();
        d.close();
        AlarmDoor a=new AlarmDoor();
        a.getName("李四");
        if(a.setName()=="张三"){
            a.open();
            a.close();
        }
        else
            a.alarm();
        a.open1();
        a.close1();
    }
}
interface Alarm{
    void alarm();
}
 class Door {
     private String name;

     public void getName(String name) {
         this.name = name;
     }
     public String setName() {
         return name;
     }
     public void open() {
         System.out.println("普通门已开门");
     }
     public void close() {
         System.out.println("普通门已关门");
     }
     public void open1() {
         System.out.println("报警门已开门");
     }
     public void close1() {
         System.out.println("报警门已关门");
     }
 }
 class AlarmDoor extends Door implements Alarm {
        public void alarm(){
            System.out.println("有问题，已触发警报！");
        }
     }

4. 设计五个类（测试类、计算机类、手机类、充电器类、U盘类）、一个接口（Usb接口），各类之间的关系如下：

（1）在UsbTest类的main方法中，创建一个Xiaomi手机对象、一个小米CDQ012M充电器对象、一台联想电脑、一个Kingston U盘对象。然后将充电器插入手机充电，将U盘插入计算机。

（2）在Mobile类的InsertUsb方法中，连接Usb。

（3）在Computer类的InsertUsb方法中，连接Usb。

（4）在Charger类的connect方法中，输出“已连接充电器，正在充电...”。

（5）在Usb类的connect方法中，输出“已连接U盘器，正在读取数据...”。

package text;
public class UsbTest {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
Mobile m=new Mobile("xiaomi");
Computer c=new Computer("联想电脑");
Charger c1=new Charger("小米CDQ012M");
UDisk u=new UDisk("Kingston");
m.insertUsb(c1);
c.insertUsb(u);
	}
}
interface Usb{
	void connect();
}
class Charger implements Usb{
	String brand;
	 Charger(String brand){
		this.brand=brand;
	}
	public void connect(){
		System.out.println("已连接充电器,"+brand+"正在充电...");
	}	
}
class UDisk implements Usb{
	String brand;
	 UDisk(String brand){
		this.brand=brand;
	}
	public void connect(){
		System.out.println("已连接U盘器,"+this.brand+"正在读取数据...");
	}	
}
class Mobile{
	String brand;
	Mobile(String brand){
		this.brand=brand;
	}
	public void insertUsb(Usb device){
		System.out.print(this.brand);
		device.connect();
	}
}
class Computer{
	String brand;
	Computer(String brand){
		this.brand=brand;
	}
	void insertUsb(Usb device){
		System.out.print(this.brand);
		device.connect();
	}
}

5. 设计一个武器系统，要求如下：

（1）定义一个弹药类Bullet，有一个弹药名称属性name。设计一个构造方法及set、get方法。

（2）定义一个可装载弹药的接口Loadable，该接口有一个装载的抽象方法load()。

（3）定义一个可发射弹药的接口Launchable，该接口有一个发射的抽象方法launch()。

（4）定义一个武器类Weapon，实现接口Loadable、Launchable（既可以装弹，也可以发射）。

武器类有属性：String name（武器名称）、Bullet bullet（可使用的弹药）

以及对应的get、set方法。

重写load方法，在方法中输出装载的弹药。

重写launch方法，在方法中输出发射的弹药。

（5）定义3个普通武器类：Tank、Flighter、WarShip都继承武器类Weapon。每个普通武器类都有一个带一个参数name的构造方法，在构造方法中创建弹药对象。

坦克Tank使用的弹药是炮弹，战斗机Flighter使用的弹药是导弹，舰艇WarShip使用的弹药是鱼雷。

（6）定义一个类Army，代表一支军队，包括：。

1) 属性：ArrayList<Weapon> weapon（用来存放军队装备的各种武器）；

2) 获取军队的拥有的武器数量方法getNum;

3）添置武器的方法addWeapon

4) 让所有武器都装载弹药的方法loadAll；

5）让所有武器都发起攻击的方法luanchAll。

（7）编写一个测试类，在main方法中：

1）建立一支强大的军队；

2）添置各种型号武器，包括坦克、战机、舰艇。

3）输出军队拥有的武器数量；

4）让所有的武器都装上弹药；

5）让所有的武器都发射。

package text;
import java.util.ArrayList;
public class text1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
Army a=new Army("一支军队");
a.getNum(6);
Weapon w1=new Weapon();
Tank t1=new Tank("99坦克");
Flighter f1=new Flighter("歼20");
WarShip w2=new WarShip("武汉舰");
WarShip w3=new WarShip("芜湖舰");
Flighter f2=new Flighter("歼31");
Flighter f3=new Flighter("F35"); 

Bullet b1=new Bullet("炮弹");
Bullet b2=new Bullet("鱼雷");
Bullet b3=new  Bullet("导弹");

a.loadAll();
System.out.print("1:99坦克   ");
w1.Load(b1);
System.out.print("2:歼20   ");
w1.Load(b3);
System.out.print("5:武汉舰    ");
w1.Load(b2);
System.out.print("6:芜湖舰    ");
w1.Load(b2);
System.out.print("3:歼31   ");
w1.Load(b3);
System.out.print("4:F35");
w1.Load(b3);

a.launchAll();
System.out.print("1:99坦克   ");
w1.Launch(b1);
System.out.print("2:歼20   ");
w1.Launch(b3);
System.out.print("5:武汉舰    ");
w1.Launch(b2);
System.out.print("6:芜湖舰    ");
w1.Launch(b2);
System.out.print("3:歼31   ");
w1.Launch(b3);
System.out.print("4:F35   ");
w1.Launch(b3);

	}

}
class Bullet{
	private String name;
	Bullet(String name){
		this.name=name;
	}
	String getName() {
	return name;	
	}
	void setName(String name) {
		this.name=name;
	}
}
interface Loadable{
	void Load(Bullet bullet);
}
interface Launchable{
	void Launch(Bullet bullet);
}
class Weapon{
	private String name;
	private Bullet bullet;
	String getName(String name) {
		return name;	
		}
	void setName(String name) {		
		}
	void Load(Bullet bullet) {
    System.out.println("装载"+bullet.getName());
	}
	void Launch(Bullet bullet) {
    System.out.println("发射"+bullet.getName());	
	}
}
class Tank extends Weapon{
	Tank (String name){
		Bullet b1=new Bullet("炮弹");
	}
}
class Flighter extends Weapon{
	Flighter (String name){
		Bullet b2=new Bullet("导弹");
	}
}
class WarShip extends Weapon{
	WarShip (String name){
		Bullet b3=new Bullet("鱼雷");
	}
}
class Army{
	int num;
	String name;
	Army(String name){
		this.name=name;
	}
	public int getNum(int num) {
	System.out.println("武器拥有的数量为："+num);
	return num;
	}
    public void addWeapon(Weapon weapon) {
	    System.out.println("添置"+weapon.getName(name)+"武器");                                                                         	
	}
	void loadAll(){
	System.out.println("所有武器准备装载弹药…");
	}
    void launchAll(){
	System.out.println("所有武器准备发起攻击…");	
	}

6. 设计五个类，类之间的关系如下：

在类App中使用Paint、Rectangle、Circle、Rabit类，在paint类中使用AsciiArt抽象类（AsciiArt对象作为setArt方法的参数），Rectangle、Circle、Rabit类继承抽象类AsciiArt，并重写draw()方法。

具体设计步骤：

App类的main( )

1）创建一个Paint对象paint

2）显示作品列表

========作品列表=======

矩形
圆
小兔子

======================

请选择：

3）根据选择，显示不同的作品

① 画矩形

a.创建一个Rectangle对象rect。

b.调用paint的setArt方法，将rect设置为paint对象要显示的作品。

c.调用对象paint的draw方法显示作品。

②画圆

a.创建一个Circle对象c。

b.调用paint的setArt方法，将c设置为paint对象要显示的作品。

c.调用对象paint的draw方法显示作品。

③画小兔子

a.创建一个Rabit对象rabit。

b.调用paint的setArt方法，将rabit设置为paint对象要显示的作品。

c.调用对象paint的draw方法显示作品。

2、Paint类中的draw( )

①显示作品名、作者。

②调用成员变量art的draw方法显示作品。

3、Rectangle类中的draw( )

输出width行height列个“*”。

4、Circle类中的draw( )

输出用“*”组成的圆。

5、Rabit类中的draw( )

输出可爱的小兔。

package text;
import java.util.Scanner;
public class App {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("========作品列表=======");
		System.out.println("1.矩形");
		System.out.println("2.圆");
		System.out.println("3.小兔子");
		System.out.println("======================");
		System.out.println("请选择:");
		int select = in.nextInt();
		Paint paint = new Paint();
		switch (select) {
		case 1:
			Rectangle rect = new Rectangle("矩形", "张三", 3, 8);
			paint.setArt(rect);
			paint.draw();
			break;
		case 2:
			Circle c = new Circle("圆形", "小丫", 4);
			paint.setArt(c);
			paint.draw();
			break;
		case 3:
			Rabit rabit = new Rabit("兔子", "李四");
			paint.setArt(rabit);
			paint.draw();
			break;
		}
	}
}
abstract class AssciiArt {
	private String title;
	private String author;
	public AssciiArt(String title, String author) {
		this.title = title;
		this.author = author;
	}
	abstract void draw();
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
}
class Circle extends AssciiArt {
	private int radius;
	public Circle(String title, String author, int radius) {
		super(title, author);
		this.radius = radius;
	}
	public void draw() {
		int d = 2 * radius;
		for (int y = 0; y <= d; y++) {
			for (int x = 0; x <= d; x++) {
				if ((x - radius) * (x - radius) + (y - radius) * (y - radius) <= radius* radius)
					System.out.print("**");
			    else
					System.out.print("  ");
			}
			System.out.println();
		}
	}
}
class Paint {
	private AssciiArt art;
	public void setArt(AssciiArt art) {
		this.art = art;
	}
	public void draw() {
		System.out.println("作品:" + this.art.getTitle());
		System.out.println("作者:" + this.art.getAuthor());
		this.art.draw();
	}
}
class Rabit extends AssciiArt {
	public Rabit(String title, String author) {
		super(title, author);
	}
	public void draw() {
	System.out.println("/)/)");
		System.out.println("(- -) )o");
		System.out.println("  || ||");
	}
}
class Rectangle extends AssciiArt {
	private int width;
	private int height;
	public Rectangle(String title, String author, int width, int height) {
		super(title, author);
		this.width = width;
		this.height = height;
	}
	public void draw() {
		for (int a = 0; a < width; a++) {
			for (int b = 0; b < height; b++) {
			System.out.print("*");
			}
		System.out.println();
		}
	}
}