Java练习 -------------抽象

最新推荐文章于 2024-04-17 19:06:37 发布

?abc!

最新推荐文章于 2024-04-17 19:06:37 发布

阅读量1.4k

点赞数

分类专栏： # 小测试

本文链接：https://blog.csdn.net/yyuggjggg/article/details/119684836

版权

小测试专栏收录该内容

26 篇文章 0 订阅

订阅专栏

第一题

按需求实现图形类程序计算功能。
要求：
A. 定义一个图形类作为父类具体两个抽象方法：为计算面积和周长的方法（10分）
B. 定义一个圆类和矩形类继承图形类，要求重写父类的抽象方法，分别实现计算面积和周长的方法。（20分）
C. 定义测试类分别测试。（20分）

// 抽象类，父类
//抽象类存在的意义：被继承
public abstract class Graphics {
    //抽象方法存在的意义是：被子类重写
	public abstract void area();//面积
	public abstract void perimeter();//周长
}

//子类
public class Circle extends Graphics{
	@Override
	public void area() {
		System.out.println("圆计算面积:");
	}

	@Override
	public void perimeter() {
		System.out.println("圆计算周长:");
	}
}

//子类
public class Rectangle extends Graphics{

	@Override
	public void area() {
		System.out.println("矩形计算面积:");
	}
	@Override
	public void perimeter() {
		System.out.println("矩形计算周长:");
	}
}

//测试类
public class Test {
	public static void main(String[] args) {
		Circle c = new Circle();
		c.area();
		c.perimeter();
		
		Rectangle r = new Rectangle();
		r.area();
		r.perimeter();
	}
}
/*
	输出结果：
			圆计算面积:
			圆计算周长:
			矩形计算面积:
			矩形计算周长:
*/

第二题

按需求实现程序功能。
要求：
① 定义一个乘车卡类。其中有一个抽象方法：消费金额
② 定义一个子类公交卡，继承乘车卡类，并实现其抽象方法。
③ 定义一个学生卡类，继承乘车卡，并实现其抽象方法
④ 定义一个老年卡类，继承乘车卡，并实现其抽象方法。
⑤ 定义测试类，分别定义公交卡，学生卡，老年卡类的对象，并测试。

public abstract class Riding {
	public abstract void consume();

}

public class ACard extends Riding{
	@Override
	public void consume() {
		System.out.println("子类公交卡");
	}
}

public class StudentC extends Riding{

	@Override
	public void consume() {
		System.out.println("子类学生卡");
	}

}

public class OlderC extends Riding{

	@Override
	public void consume() {
		System.out.println("子类老年卡");
	}

}

public class Test {

	public static void main(String[] args) {
		StudentC st = new StudentC();
		st.consume();
		
		OlderC o = new OlderC();
		o.consume();
		
		ACard a = new ACard();
		a.consume();

	}

}

第三题

9、⻢继承Animal，还能实现能⻜的能⼒，简称⻜⻢，运⾏结果如下：

提示：（1）定义⼀个抽象类Animal，⾥⾯有name属性（2）定⼀个Flyable的接⼝，表示⻜的能⼒，⾥⾯有⻜fly()的⽅法，返回void （3）定义⼀个Horse类，让他继承抽象类Animal，并实现接⼝Flyable

注：注意修饰符，构造⽅法，使⽤多态，注释的各个规范，否则扣分

package Day0813pm1;

public abstract class Animal {
	public String name;

	public Animal(String name) {
		super();
		this.name = name;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
}
package Day0813pm1;

public interface Flyable {
	public abstract void fly();
}
package Day0813pm1;

public class Horse extends Animal implements Flyable {

	public Horse(String name) {
		super(name);
	}

	@Override
	public void fly() {
		System.out.println(this.name+"，是一只会飞的马");
	}

}
package Day0813pm1;

public class Tets {
	public static void main(String[] args) {
		Horse h = new Horse("小马炖炖");
		h.fly();
	}

}

第四题

设计⼀个能细分为矩形、三⻆形、圆形和椭圆形的“图形”类。使⽤继承将这些

图形分类，找出能作为基类部分的共同特征(如校准点)和⽅法(如画法、初始化)，

并看看这些图形是否能进⼀步划分为⼦类

package Day0813pm1;

public class Test1 {
	public static void main(String[] args) {
		Graph g = new Graph();
		g.rt();
		g.tc();
		
		rectangle r = new rectangle();
		r.rt();
		Triangle t = new Triangle();
		t.rt();
		
		circle c = new circle();
		c.tc();
		ellipse e = new ellipse();
		e.tc();
		
		
	}

}
package Day0813pm1;

public class Graph {
	//三角形和矩形没有弧，并且有角
	public void rt(){
		System.out.println("我三角形和矩形没有弧，但是有角");
	}
	//圆形和椭圆形没有上面的特点
	public void tc(){
		System.out.println("我圆形和椭圆形有弧，但是没有角");
	}

}
package Day0813pm1;

public class rectangle extends Graph{
	//矩形分为长方形，正方形等
	@Override
	public void rt() {
		System.out.println("我是矩形，还可以分为长方形，正方形等");
	}
	
	

}
package Day0813pm1;

public class Triangle extends Graph{
	//三角形分为等腰三角形，直角三角形等
	@Override
	public void rt() {
		System.out.println("我是三角形，还可以分为等腰三角形，直角三角形等");
	}

}
package Day0813pm1;

public class circle extends Graph{
	//圆分为椭圆等
	@Override
	public void tc() {
		System.out.println("我是圆形，还可以分为椭圆等");
	}

}
package Day0813pm1;

public class ellipse extends Graph{
	//椭圆没有其他类别
	@Override
	public void tc() {
		System.out.println("我是椭圆，没有兄弟了");
	}

}

第五题

2、创建⼀个Vehicle类并将它声明为抽象类。在Vehicle类中声明⼀个numOfWheels⽅法，使它返回⼀个字符串值。创建两个类Car和Motorbike从Vehicle类继承，并在这两个类中实现numOfWheels⽅法。在Car类中，应当显示“四轮⻋”信息；⽽在Motorbike类中，应当显示“双轮⻋”信息。创建另⼀个带main⽅法的类，在该类中创建Car和Motorbike的实例，并在控制台中显示消息。

package Day0813pm2;

public class Test {

	public static void main(String[] args) {
		Car c = new Car();
		System.out.println(c.numOfWheels());
		
		Motorbike m = new Motorbike();
		System.out.println(m.numOfWheels());

	}

}
package Day0813pm2;

public abstract class Vehicle {
	public abstract String numOfWheels();
}
package Day0813pm2;

public class Car extends Vehicle{

	@Override
	public String numOfWheels() {
		return "四轮⻋";
		
	}

}
package Day0813pm2;

public class Motorbike extends Vehicle{

	@Override
	public String numOfWheels() {
		return "双轮车";
		
	}

}

第六题

4、创建⼀个名称为Vehicle的接⼝，在接⼝中添加两个带有⼀个参数的⽅法start()
和stop()。在两个名称分别为Bike和Bus的类中实现Vehicle接⼝。创建⼀个名称为
interfaceDemo的类，在interfaceDemo的main()⽅法中创建Bike和Bus对象，并访
问start()和stop()⽅法。

package Day0813pm1;

public class interfaceDemo {

	public static void main(String[] args) {
		Bike b = new Bike();
		b.start("哈迪达斯");
		b.stop("哈迪达斯");
		
		Bus b1 = new Bus();
		b1.start("五菱宏光");
		b1.stop("五菱宏光");

	}

}
package Day0813pm1;

public interface Vehicle {
	public abstract void start(String name);
	public abstract void stop(String name);
}
package Day0813pm1;

public class Bike implements Vehicle {

	@Override
	public void start(String name) {
		System.out.println(name+"Bik start");
		
	}

	@Override
	public void stop(String name) {
		System.out.println(name+"Bike stop");
		
	}

}
package Day0813pm1;

public class Bus implements Vehicle {
	@Override
	public void start(String name) {
		System.out.println(name+"Bus start");
		
	}

	@Override
	public void stop(String name) {
		System.out.println(name+"Bus stop");
		
	}
}

第七题

6、XXX⻔的实现过程：流程：设计⼀张抽象的⻔Door，那么对于这张⻔来说，就应该拥有所有⻔的共性，开⻔openDoor()和关⻔closeDoor()；然后对⻔进⾏另外的功能设计,防盗–theftproof()、防⽔–waterproof()、防弹–bulletproof()、防⽕、防锈„„ 要求：利⽤继承、抽象类、接⼝的知识设计该⻔

接口：防盗–theftproof()、防⽔–waterproof()、防弹–bulletproof()、防⽕

实现类：Door

package Day0813pm1;

public class TestProof {
	public static void main(String[] args) {
		Door d = new Door();
		d.open();
		d.close();
		d.preventBullet();
		d.preventFire();
		d.preventTheft();
		d.preventWater();
	}

}
package Day0813pm1;

//门，通过implements关键字可以实现接口
public class Door implements FireProof, WaterProof, BulletProof, TheftProof{

	public void open() {
		System.out.println("能开门");
	}
	
	public void close() {
		System.out.println("能关门");
	}

	@Override
	public void preventFire() {
		System.out.println("能防火");
	}

	@Override
	public void preventWater() {
		System.out.println("能防水");
	}

	@Override
	public void preventBullet() {
		System.out.println("能防弹");
	}

	@Override
	public void preventTheft() {
		System.out.println("能防火");		
	}
	
}
package Day0813pm1;

public interface FireProof {
	//防火的功能，接口中的方法都是公共的抽象方法
	public abstract void preventFire();
}
package Day0813pm1;

public interface WaterProof {
	//防水的功能
	public abstract void preventWater();

}
package Day0813pm1;

public interface BulletProof {
	//防弹的功能
	public abstract void preventBullet();
}
package Day0813pm1;

public interface TheftProof {
	//防盗的功能
	public abstract void preventTheft();
}

第八题

7、定义⼀个抽象类机动⻋Motovercal，⾥⾯有⻋牌号no，类型type，价格price属性，⾥⾯有⼀个show()⽅法是抽象⽅法，定义⼀个轿⻋Car类，他有特有的属性颜⾊color，有⼀个公共汽⻋Bus，他有特有属性座位数seatCount，实现如图功能：

提示：（1）定义⼀个抽象类Motovercal，⾥⾯有属性⻋牌号no，类型type，价格price，⾥⾯有抽象⽅法show（）（2）定义⼀个轿⻋Car类，继承Motovercal，他有特有的属性颜⾊color （3）定义⼀个轿⻋Bus类，继承Motovercal，他有特有的属性座位数seatCount （4）编写测试类MotovercalTest

注：注意修饰符，构造⽅法，使⽤多态，注释的各个规范，否则扣分

抽象类 Motovercal 属性：⻋牌号no，类型type，价格price

抽象方法 show()

其他类：轿⻋Car类属性颜⾊color

公共汽⻋Bus 属性座位数seatCount

package Day0813pm3;

public class MotovercalTest {

	public static void main(String[] args) {
		Car c = new Car("A000002","宝马",300000.0,"红色");
		c.show();
		
		Bus b = new Bus("B000002","一汽大众",300000.0,60);
		b.show();
	}

}
package Day0813pm3;

public abstract class Motovercal {
	private String no;
	private String type;
	private double money;
	
	public abstract void show();
	

	public Motovercal(String no, String type, double money) {
		super();
		this.no = no;
		this.type = type;
		this.money = money;
	}


	public String getNo() {
		return no;
	}

	public void setNo(String no) {
		this.no = no;
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

	public double getMoney() {
		return money;
	}

	public void setMoney(double money) {
		this.money = money;
	}
	
	
}
package Day0813pm3;

public class Car extends Motovercal{
	private String color;
	public Car(String no, String type, double money, String color) {
		super(no, type, money);
		this.color = color;
	}
	@Override
	public void show() {
		System.out.println("本车车牌号为："+super.getNo()+"\t"+
							"类型为："+super.getType()+
							"\t"+"价格为："+super.getMoney()
							+"\t"+"颜色为："+this.color);
	}
}
package Day0813pm3;

public class Bus extends Motovercal{
	
	private int seatCount;
	public Bus(String no, String type, double money, int seatCount) {
		super(no, type, money);
		this.seatCount = seatCount;
	}
	@Override
	public void show() {
		System.out.println("本车车牌号为："+super.getNo()+"\t"+
							"类型为："+super.getType()+
							"\t"+"价格为："+super.getMoney()
							+"\t"+"拥有"+this.seatCount+"个座位");
	}

}

第九题

8.定义⼀个接⼝Usb，⾥⾯有⼯作⽅法work（），定义⼀个Usb⿏标UsbMouse和UsbKeyborder键盘,让两个Usb设备实现Usb接⼝，运⾏结果如下

package Day0813pm2;

public class Test1 {
	public static void main(String[] args) {
		UsbMouse m = new UsbMouse();
		m.work();
		
		UsbKeyborder k = new UsbKeyborder();
		k.work();
	}

}
package Day0813pm2;

public interface USB {
	//公共的抽象方法
	public abstract void work();
}
package Day0813pm2;

public class UsbMouse implements USB {
	@Override
	public void work() {
		System.out.println("鼠标开始工作了！你可以移动鼠标了！");
	}
}

package Day0813pm2;

public class UsbKeyborder implements USB {
	@Override
	public void work() {
		System.out.println("键盘开始工作了！你可以开始敲字了！");
	}

}

第10题

10、有⼀个⽗类Person，⾥⾯有姓名name和性别sex，年龄age属性，还有⼀个抽象show⽅法（），定义⼀个能说的接⼝Sayable，定义⼀个能听的接⼝Hearable，还有⼀个能吃的接⼝Eatable，哑巴Dumb是不能说的，聋⼦Deaf是不能听到的，但他们都有姓名，年龄，性别，如何完成他们的关系，且运⾏结果如下：

提示：（1）定义⼀个抽象类Person，⾥⾯有name，sax，age属性，并有show抽象⽅法（2）定义⼀个接⼝Sayable，⾥⾯有⼀个说say()的⽅法（3）定义⼀个接⼝Hearable，⾥⾯有⼀个听hare()的⽅法（4）定义⼀个接⼝Eatable，⾥⾯有⼀个吃eat()的⽅法（5）定义⼀个哑巴Dumb类，继承Person，并是实现Sayable，Eatable的接⼝（6）定义⼀个哑巴Deaf类，继承Person，并是实现Hearable，Eatable的接⼝（7）定义⼀个测试类PersonTest进⾏测试注：注意修饰符，构造⽅法，使⽤多态，注释的各个规范，否则扣分

抽象类⽗类Person 姓名name和性别sex，年龄age

抽象⽅法show

能说的接⼝Sayable

能听的接⼝Hearable

能吃的接⼝Eatable

普通类：哑巴Dumb 不能说都有姓名，年龄，性别

聋⼦Deaf 不能听到

package Day0813pm2;

public class test2 {
	public static void main(String[] args) {
		Dumb d = new Dumb("张三","男",37);
		d.show();
		Deaf df = new Deaf("李四","女",38);
		df.show();
	}

}
package Day0813pm2;

public abstract class Person {
	private String name;
	private String sex;
	private int age;
	
	public abstract void show();
	
	

	public Person(String name, String sex, int age) {
		super();
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	

}
package Day0813pm2;

public interface Hearable {
	public abstract void hear();
}
package Day0813pm2;

public interface Eatable {
	public abstract void eat();
}
package Day0813pm2;

public class Dumb extends Person implements Hearable, Eatable{

	public Dumb(String name, String sex, int age) {
		super(name, sex, age);
	}

	@Override
	public void eat() {
		System.out.println("我哑巴能够说话");
		
	}

	@Override
	public void hear() {
		System.out.println("我哑巴能够听");
		
	}

	@Override
	public void show() {
		System.out.println("大家好，我是一个哑巴，叫："+super.getName());
		System.out.println("性别："+super.getSex());
		System.out.println("今年"+super.getAge()+"岁了");
		eat();
		hear();
		
	}
	
}
package Day0813pm2;

public class Deaf extends Person implements Sayable,Eatable{

	public Deaf(String name, String sex, int age) {
		super(name, sex, age);
	}

	@Override
	public void eat() {
		System.out.println("聋子能够吃饭");
		
	}

	@Override
	public void say() {
		System.out.println("聋子能够说话");
		
	}

	@Override
	public void show() {
		System.out.println("大家好，我是一个聋子，叫："+super.getName());
		System.out.println("性别："+super.getSex());
		System.out.println("今年"+super.getAge()+"岁了");
		
		eat();
		say();
		
	}

}

第11题

11、有⼀个抽象类Pet，⾥⾯有name，health，love的属性，还有eat的抽象⽅

法，定义⼀个Dog，他特有strain的属性，Penguin他特有sex的属性，定义⼀个宠

物⼯⼚类PetFactory，他⾥⾯有⼀个⽅法getPet();当传⼊“⼩花”就返回⼀条⼩花的

狗狗，当传⼊“QQ”就返回⼀个QQ的企鹅：

（1）定义⼀个抽象类pet，⾥⾯有name，health，love的属性，还有eat的抽象⽅法，返回void （2）定义⼀个类Dog，，他特有strain的属性（3）定义⼀个类Penguin，他特有sex的属性（4）定义⼀个PetTest类，测试注：注意修饰符，构造⽅法，使⽤多态，注释的各个规范，否则扣分

抽象类Pet name，health，love的属性

eat的抽象⽅法

Dog类 strain的属性

Penguin sex的属性

宠物⼯⼚类PetFactory ⽅法getPet()

传⼊“⼩花”就返回⼀条⼩花的。狗狗，当传⼊“QQ”就返回⼀个QQ的企鹅：

package Day0813pm2;

import java.util.Scanner;

public class Test3 {
	public static void main(String[] args) {
		PetFactory p = new PetFactory();
		Scanner sc = new Scanner(System.in);
		String witch = null;
		while(true){
			System.out.println("请输入你想要选择的宠物:小花 OR QQ？");
			witch = sc.next();
			p.getPet(witch);
		}
	}

}
package Day0813pm2;

public abstract class Pet {
	private String name;
	private int health;
	private int love;
	
	public abstract void eat();
	public abstract void show();

	public Pet(String name, int health, int love) {
		super();
		this.name = name;
		this.health = health;
		this.love = love;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getHealth() {
		return health;
	}

	public void setHealth(int health) {
		this.health = health;
	}

	public int getLove() {
		return love;
	}

	public void setLove(int love) {
		this.love = love;
	}
	
	

}
package Day0813pm2;

public class Dog extends Pet{
	private String strain;
	
	public Dog(String name, int health, int love, String strain) {
		super(name, health, love);
		this.strain = strain;
	}
	@Override
	public void eat() {
		System.out.println("跑回来啃骨头！");
		
	}
	@Override
	public void show() {
		System.out.print(super.getName()+"的小狗，是一只"+this.strain+"犬健康值为"+super.getHealth()+"，亲密度为"+super.getLove()+"，");
		eat();
	}
	

}
package Day0813pm2;

public class Penguin extends Pet{

	private String sex;
	
	public Penguin(String name, int health, int love, String sex) {
		super(name, health, love);
		this.sex = sex;
	}

	@Override
	public void eat() {
		System.out.println("跑回来吃鱼！");		
	}
	@Override
	public void show() {
		System.out.print(super.getName()+"的小狗，是个美"+this.sex+"健康值为"+super.getHealth()+"，亲密度为"+super.getLove()+"，");
		eat();
	}
	
	

}
package Day0813pm2;

public class PetFactory {
	public void getPet(String witch){
		if("小花".equals(witch)){
			Dog d = new Dog("小花",100,30,"拉布拉多");
			d.show();
		}else if("QQ".equals(witch)){
			Penguin p = new Penguin("QQ",90,80,"女");
			p.show();
		}else{
			System.out.println("输入错误，请重新输入：小花 OR QQ？");
		}
	}

}

第12题

12、⾖⾖家养了两只家禽Poultry，将其定义为接⼝：⼀只鸡Chicken，将其定义为类和⼀只鸭Duck（将其定义为类），在接⼝Poultry中有getName()的⽅法，实现执⾏结果如下

（1）写⼀个接⼝Poultry，他⾥⾯有⽅法getName()，返回String （2）写⼀个类Chicken，⾥⾯有name属性，实现接⼝Poultry （3）写⼀个类Duck，⾥⾯有name属性，实现接⼝Poultry （4）再写⼀个测试类PoultryTest,⾥⾯使⽤⽗类类型，⼦类对象，然后调getName()⽅法注：注意修饰符，构造⽅法，使⽤多态，注释的各个规范，否则扣分

接⼝ Poultry getName()的⽅法，返回String

类 Chicken name属性实现接⼝Poultry

鸭Duck

package Day0813pm2;

public class PoultryTest {

	public static void main(String[] args) {
		Chicken c = new Chicken("鸡");
		System.out.println(c.getName());
		
		Duck d = new Duck("鸭");
		System.out.println(d.getName());

	}

}
package Day0813pm2;

public interface Poultry {
	public abstract String getName();

}
package Day0813pm2;

public class Chicken implements Poultry {
	private String name;

	@Override
	public String getName() {
		String n = name;
		return n;
	}

	public Chicken(String name) {
		super();
		this.name = name;
	}
	
}
package Day0813pm2;

public class Duck implements Poultry {
	private String name;
	@Override
	public String getName() {
		String n = name;
		return n;
	}
	public Duck(String name) {
		super();
		this.name = name;
	}
	

}

第13题

13、定⼀个接⼝Pet，⾥⾯有getPrice的⽅法，定义⼀个Dog类，⾥⾯有price属性，定⼀个Cat⾥⾯有price属性，让两个⼦类实现接⼝，在主⽅法中，定义5个宠物，让后统计他们的总价格，使⽤接⼝数组实现

接⼝ Pet getPrice的⽅法

Dog类 price属性两个⼦类实现接⼝

Cat price属性，

package Day0813pm3;

public class test {

	public static void main(String[] args) {
		Pet p1 = new Cat(5000);
		Pet p2 = new Cat(8900);
		Pet p3 = new Cat(8000);
		Pet p4 = new Dog(1400);
		Pet p5 = new Dog(1600);
		
		//定义一个对象数组，保存这5个宠物
		Pet[] ps = {p1, p2, p3, p4, p5};

		double sum = 0;

		//增强型for循环，ForEach
		for(Pet p : ps) {
			sum += p.getPrice();
		}
		
		System.out.println("总额："+sum);
			
	}

}
package Day0813pm3;

public interface Pet {
	//公共的抽象方法
	public abstract double getPrice();
}
package Day0813pm3;

public class Dog implements Pet {
	private double price;
	//有参构造方法，目的：初始化成员变量
	public Dog(double price) {
		this.price = price;
	}
	@Override
	public double getPrice() {
		return this.price;
	}

}
package Day0813pm3;

public class Cat implements Pet {
	private double price;
	//有参构造方法，目的：初始化成员变量
	public Cat(double price) {
		this.price = price;
	}
	@Override
	public double getPrice() {
		return this.price;
	}
}

第14题

员工包含3个属性：姓名，工号，工资。经理也是员工，除了含有员工的属性外，另外还有一个奖金属性，设计出员工类和经理类，要求类中提供必要的方法进行属性访问。员工分为普通员工和经理，那么员工和经理做从事的工作即做的工作不一样，但是他们都得为公司工作。所以产生了一个工作方法，那么普通员工和经理都需要有工作这个方法。

员工Employee 抽象类属性：姓名name，工号id，工资salary 工作方法work

员工分为普通员工 worker

经理 manager

经理也是员工还有一个奖金属性 price

package Day0813pm3;

public class Test1 {
	public static void main(String[] args) {
		worker w = new worker("张三","A12322",8000.00);
		w.show();
		
		manager m = new manager("李四","Q56898",12000.00,10000.00);
		m.show();
	}

}
package Day0813pm3;

public abstract class Employee {
	private String name;
	private String id;
	private double salary;
	public abstract void work();
	public abstract void show();
	
	public Employee(String name, String id, double salary) {
		super();
		this.name = name;
		this.id = id;
		this.salary = salary;
	}


	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	

}
package Day0813pm3;

public class worker extends Employee{

	public worker(String name, String id, double salary) {
		super(name, id, salary);
	}

	@Override
	public void work() {
		System.out.println("我是普通员工！在车间干苦力！");
		
	}
	@Override
	public void show() {
		System.out.println("我是"+super.getName()+"，工号是"+super.getId()
		+"，工资为"+super.getSalary());
		System.out.println("因为！！");
		work();
	}

}

package Day0813pm3;

public class manager extends Employee{
	private double price;

	public manager(String name, String id, double salary, double price) {
		super(name, id, salary);
		this.price = price;
	}

	@Override
	public void work() {
		System.out.println("我是经理，坐办公室我电脑");
	}
	@Override
	public void show() {
		System.out.println("我是"+super.getName()+"，工号是"+super.getId()
		+"，工资为"+super.getSalary()+"，但是！我还有奖金，我的奖金为："+this.price);
		System.out.println("因为！！");
		work();
	}
	
	

}

第15题

动物（Animal）具有行为：吃（eat）、睡觉（sleep）、移动（move）

动物包括：兔子（Rabbit），老虎（Tiger）,鹰（eagle）

这些动物吃、移动的行为各不相同（eat，move动作不同）；但睡觉的行为是一致的

写一个动物园类，动物园由笼子属性，兔子不能跟老虎关在一起，鹰不能跟兔子关在一起，实现方法，入参为动物，根据传递进来的动物判断能关在哪里。

抽象类抽象方法eat、move sleep不是抽象方法

类继承动物这个抽象类：兔子（Rabbit），老虎（Tiger）,鹰（eagle）

普通方法：动物园类zoo 属性：笼子编号数组逻辑判断

package Day0813pm3;

import java.util.Scanner;

public class test6 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		zoo z = new zoo();
		int[] a = new int[3];
		
		String ani = null;
		while(true){
			System.out.println("请输入你想要操作的动物（兔子、老虎、老鹰）：");
			ani = sc.next();
			if("老虎".equals(ani)){
				Tiger t = new Tiger(ani);
				System.out.println("请输入要待的房间：");
				while(true){
					z.cageNum[0] = sc.nextInt();
					if(z.cageNum[0] != z.cageNum[2]){
						System.out.println("老虎的房间号为："+z.cageNum[0]);
						break;
					}else{
						System.out.println("该房间有兔子，不能入住，请重新输入房间号！");
					}
				}
				t.eat();
				t.move();
				t.sleep();
			}else if("老鹰".equals(ani)){
				eagle e = new eagle(ani);
				System.out.println("请输入要待的房间：");
				while(true){
					z.cageNum[1] = sc.nextInt();
					if(z.cageNum[1] != z.cageNum[2]){
						System.out.println("老鹰的房间号为："+z.cageNum[1]);
						break;
					}else{
						System.out.println("该房间有兔子，不能入住，请重新输入房间号！");
					}
				}
				e.eat();
				e.move();
				e.sleep();
			}else if("兔子".equals(ani)){
				Rabbit r = new Rabbit(ani);
				System.out.println("请输入要待的房间：");
				while(true){
					z.cageNum[2]=sc.nextInt();
					if(z.cageNum[2] != z.cageNum[0] && z.cageNum[2] != z.cageNum[1]){
						System.out.println("我大兔子就待在"+z.cageNum[2]+"这里了!");
						r.eat();
						r.move();
						r.sleep();
						break;
					}else{
						System.out.println("请重新输入房间号！");
					}
				}			
			}else{
				System.out.println("输入错误，请重新输入！");
			}
			
		}
	}

}
package Day0813pm3;

public abstract class Animal {
	private String name;
	public abstract void eat();
	public abstract void move();
	public void sleep(){
		System.out.println("所有动物都是一动不动的睡觉！");
	}
	public Animal(String name) {
		super();
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	

}
package Day0813pm3;

public class Rabbit extends Animal{

	public Rabbit(String name) {
		super(name);
	}

	@Override
	public void eat() {
		System.out.println("我兔子爱吃胡萝卜！");
	}

	@Override
	public void move() {
		System.out.println("我兔子是蹦蹦跳跳的移动");
	}

}
package Day0813pm3;

public class Tiger extends Animal{

	public Tiger(String name) {
		super(name);
	}

	@Override
	public void eat() {
		System.out.println("我老虎爱吃肉！");
	}

	@Override
	public void move() {
		System.out.println("我老虎是迅速而威武的移动");
	}
}
package Day0813pm3;

public class eagle extends Animal{

	public eagle(String name) {
		super(name);
	}

	@Override
	public void eat() {
		System.out.println("我老鹰爱吃小鸡！");
	}

	@Override
	public void move() {
		System.out.println("我老鹰是在空中飞翔的移动");
	}
}
package Day0813pm3;

public class zoo {
	public int[] cageNum = new int[3];

}

第16题

定义一个武器类Weapon,该类有两个方法attack()，move()：

这两个方法分别表示武器的攻击方式和移动方式。定义3个类：Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon类中的方法。

写一个类Army,代表一支军队，这个类有一个属性是Weapon数组w(用来存储该军队所拥有的所有武器)；该类还提供一个构造方法，在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。

武器类Weapon Tank,Flighter,WarShip 两个方法attack()，move()

类Army 两个属性武器数和Weapon数组有一个属性是Weapon数组w(用来存储该军队所拥有的所有武器)

还提供一个构造方法最大武器数

供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。（动态添加对象（不太会动态对象数组）

没有做出来，通过数组我做不出来，如果是使用集合或者是其他的这个就好做了,不想死究。。。

package Day0813pm3;

public class Test2 {

	public static void main(String[] args) {
		Army a = new Army("塔克","轰炸机","航母",6);
		a.move();
		a.attack();
		a.setI(8);
		a.addWeapon(a);
		Weapon[] w = a.getW();
		System.out.println(w[0]);
		

	}

}
package Day0813pm3;

public class Weapon {
	private String Tank;
	private String Flighter;
	private String WarShip;
	
	public void attack(){
		
	}
	public void move(){
		
	}
	
	
	public Weapon(String tank, String flighter, String warShip) {
		super();
		Tank = tank;
		Flighter = flighter;
		WarShip = warShip;
	}
	public String getTank() {
		return Tank;
	}
	public void setTank(String tank) {
		Tank = tank;
	}
	public String getFlighter() {
		return Flighter;
	}
	public void setFlighter(String flighter) {
		Flighter = flighter;
	}
	public String getWarShip() {
		return WarShip;
	}
	public void setWarShip(String warShip) {
		WarShip = warShip;
	}
	
	

}
package Day0813pm3;

public class Army extends Weapon{
	private Weapon[] w;
	private int i;
	
	
	
	
	public Army(String tank, String flighter, String warShip, int i) {
		super(tank, flighter, warShip);
		this.i = i;
	}

	public void addWeapon(Weapon wa){
		int length = 8;
		
		if(length<this.i){
			Weapon w1[] = new Weapon[length+1];
			System.arraycopy(w, 0, w1, 0, length);
			w1[length] = wa;
			System.arraycopy(wa, length, w1, length+1, 1);
			this.w = w1;
		}else{
			System.out.println("武器库已经是最大容量的了");
		}
		
	}
	
	@Override
	public void attack() {
		System.out.println("军队发起攻击");
	}

	public void move() {
		System.out.println("军队撤退");
	}

	public Weapon[] getW() {
		return w;
	}
	public void setW(Weapon[] w) {
		this.w = w;
	}
	public int getI() {
		return i;
	}
	public void setI(int i) {
		this.i = i;
	}
	
	
}

?abc!

关注

0
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java练习 -------------抽象

第一题按需求实现图形类程序计算功能。要求：A. 定义一个图形类作为父类具体两个抽象方法：为计算面积和周长的方法（10分）B. 定义一个圆类和矩形类继承图形类，要求重写父类的抽象方法，分别实现计算面积和周长的方法。（20分）C. 定义测试类分别测试。（20分）// 抽象类，父类//抽象类存在的意义：被继承public abstract class Graphics { //抽象方法存在的意义是：被子类重写 public abstract void area();//面积 pub
复制链接

扫一扫