第一题

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

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

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

//子类
public class Rectangle extends Graphics{@Overridepublic void area() {System.out.println("矩形计算面积:");}@Overridepublic 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{@Overridepublic void consume() {System.out.println("子类公交卡");}
}

public class StudentC extends Riding{@Overridepublic void consume() {System.out.println("子类学生卡");}}

public class OlderC extends Riding{@Overridepublic 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);}@Overridepublic 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{//矩形分为长方形，正方形等@Overridepublic void rt() {System.out.println("我是矩形，还可以分为长方形，正方形等");}}
package Day0813pm1;public class Triangle extends Graph{//三角形分为等腰三角形，直角三角形等@Overridepublic void rt() {System.out.println("我是三角形，还可以分为等腰三角形，直角三角形等");}}
package Day0813pm1;public class circle extends Graph{//圆分为椭圆等@Overridepublic void tc() {System.out.println("我是圆形，还可以分为椭圆等");}}
package Day0813pm1;public class ellipse extends Graph{//椭圆没有其他类别@Overridepublic 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{@Overridepublic String numOfWheels() {return "四轮⻋";}}
package Day0813pm2;public class Motorbike extends Vehicle{@Overridepublic 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 {@Overridepublic void start(String name) {System.out.println(name+"Bik start");}@Overridepublic void stop(String name) {System.out.println(name+"Bike stop");}}
package Day0813pm1;public class Bus implements Vehicle {@Overridepublic void start(String name) {System.out.println(name+"Bus start");}@Overridepublic 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("能关门");}@Overridepublic void preventFire() {System.out.println("能防火");}@Overridepublic void preventWater() {System.out.println("能防水");}@Overridepublic void preventBullet() {System.out.println("能防弹");}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic 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 {@Overridepublic void work() {System.out.println("鼠标开始工作了！你可以移动鼠标了！");}
}package Day0813pm2;public class UsbKeyborder implements USB {@Overridepublic 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);}@Overridepublic void eat() {System.out.println("我哑巴能够说话");}@Overridepublic void hear() {System.out.println("我哑巴能够听");}@Overridepublic 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);}@Overridepublic void eat() {System.out.println("聋子能够吃饭");}@Overridepublic void say() {System.out.println("聋子能够说话");}@Overridepublic 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;}@Overridepublic void eat() {System.out.println("跑回来啃骨头！");}@Overridepublic 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;}@Overridepublic void eat() {System.out.println("跑回来吃鱼！");        }@Overridepublic 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;@Overridepublic 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;@Overridepublic 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循环，ForEachfor(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;}@Overridepublic double getPrice() {return this.price;}}
package Day0813pm3;public class Cat implements Pet {private double price;//有参构造方法，目的：初始化成员变量public Cat(double price) {this.price = price;}@Overridepublic 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);}@Overridepublic void work() {System.out.println("我是普通员工！在车间干苦力！");}@Overridepublic 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;}@Overridepublic void work() {System.out.println("我是经理，坐办公室我电脑");}@Overridepublic 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);}@Overridepublic void eat() {System.out.println("我兔子爱吃胡萝卜！");}@Overridepublic void move() {System.out.println("我兔子是蹦蹦跳跳的移动");}}
package Day0813pm3;public class Tiger extends Animal{public Tiger(String name) {super(name);}@Overridepublic void eat() {System.out.println("我老虎爱吃肉！");}@Overridepublic void move() {System.out.println("我老虎是迅速而威武的移动");}
}
package Day0813pm3;public class eagle extends Animal{public eagle(String name) {super(name);}@Overridepublic void eat() {System.out.println("我老鹰爱吃小鸡！");}@Overridepublic 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("武器库已经是最大容量的了");}}@Overridepublic 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;}}

Java练习 -------------抽象相关推荐

通达信交易接口函数Java接口抽象法
通达信交易接口函数Java接口抽象法,在package cn.itcast.day10.demo01:在任何版本的Java中,接口都能定义抽象方法.
【JAVA进阶系列】JAVA 设计模式 -- 抽象工厂模式(Abstract Factory)
[JAVA进阶系列]JAVA 设计模式 -- 抽象工厂模式(Abstract Factory) [1.1]抽象工厂模式简介抽象工厂者模式的类结构图 AbstractProduct(抽象产品),Abs ...
java设计模式---抽象工厂模式
工厂模式在项目中是常常用到的,有人说只有大项目才会用到,小项目是体会不出来.其实使用设计模式与项目的大小没有实质性的联系.设计模式是经验的总结而不是衡量项目大小的标准. 以开发项目的DAO层为例,在项 ...
Java 面向抽象编程和面向接口编程
以下内容来自<Java 2实用教程>,主编:耿祥义.张跃平鉴于面向抽象编程和面向接口编程思维培养的重要性,写此博客巩固. 面向抽象编程: 在设计程序时,经常会使用到abstract类,其 ...
java如何抽象一辆车,java新职篇：面向对象之抽象
面向对象编程的一个实质性的要素是抽象.人们通过抽象(abstraction)处理复杂性. 例如,人们不会把一辆汽车想象成由几万个互相独立的部分所组成的一套装置,而是把汽车想成一个具有自己独特行为的对象 ...
java 反射抽象_Java实现抽象工厂模式+java的反射的机制
Java的反射机制: JAVA反射机制是就是运行的状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法 ...
Java设计模式--抽象工厂模式
抽象工厂模式(别名:配套) 提供一个创建一系列或相互依赖对象的接口,而无需指定它们具体的类. Abstract Factory Pattern(Another Name: Kit) Provide a ...
java AST 抽象语法树
AST : Abstract Syntax Tree https://www.geeksforgeeks.org/abstract-syntax-tree-ast-in-java/ 抽象语法树是一种用 ...
Java设计模式——抽象工厂模式
文章目录抽象工厂概念优缺点优点缺点适用场景代码案例抽象工厂使用工厂方法模式足以应付我们可能遇到的大部分业务需求. 但是当产品种类非常多时,就会出现大量的与之对应的工厂类,这不应该是 ...

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

第一题

第二题

第三题

第四题

第五题

第六题

第七题

第八题

第九题