Java面向对象试题

==1、== 请创建一个Animal动物类，要求有方法eat（）方法，方法输出一条语句“吃东西”。 创建一个接口A，接口里有一个抽象方法fly（）。创建一个Bird类继承Animal类并实现 接口A里的方法输出一条有语句“鸟儿飞翔”，重写eat（）方法输出一条语句“鸟儿 吃虫”。在Test类中向上转型创建b对象，调用eat方法。然后向下转型调用eat（）方 法、fly（）方法。

1评分标准：
2正确写出Animal类10分
3正确定义接口A 10分
4Bird类继承Animal类实现接口A 10分
5向上转型创建对象b调用eat（）方法正确输出 10分
6向下转型调用eat（）方法、fly（）方法正确输出 10分。

答案： Animal.java： A.java： Bird.java： Bird.java：

==2、== 编写一个Person抽象类，要求含有姓名（name）年龄（age）两个私有属性以及吃饭（eat） 和睡觉（sleep）两个抽象方法，并写出带参构造方法，创建学生（student）和工人（worker） 两个类，继承Person类，学生类多出了私有属性学号和学习方法（输出我爱学习），工 人类多出了私有属性工号和工作方法（输出我爱工作），在主函数中创建学生和工人类 的实例对象，使用构造方法赋值，并输出所有属性和方法（共50分，能够定义类5分， 正确书写子父类构造方法1分，set get写对10分，方法重写10分，正确创建对象10 分，能运行5分）

1	显示结果如下：
2		姓名：李四，年龄：18，学号：1024
3		食堂吃饭
4		我爱学习
5		姓名：张三，年龄：20，工号：1025
6		自己做饭
7		在家躺着睡觉
8		我爱工作

Person.java： Student.java： Worker.java： Mains.java：

==3、== 案例题目描述：

利用继承，来描述，人，老师，学生之间的关系 1）老师含有属性：name，age，subject，含有方法：eat，teach，toString 2）学生含有属性：name，age，class，含有方法：eat，study，toString 3）利用继承的思想，从老师和学生中抽象出人，并创建Test进行调用并输出（System.out） 2、判分标准 1）创建类Person，含有公有属性：name姓名，age年龄。含有方法void eat(String something)；方法中打印输出“我爱吃XXX”。含有构造方法，带两个参数，分别是name和age，并利用this关键字传值到成员变量中 。（10分） 2）创建类Student，含有属性：class班级，含有方法，void study(String subject)；方法打印输出：我热爱学习subject。创建包含三个参数的构造方法，分别是name，age，class，利用super实现父类构造方法传值。重写toString方法，打印输出：我的名字是XX，我的年龄是XX，我的班级是XX（10分） 3）创建类Teacher，含有属性：subject，含有方法，void teach()；方法打印输出：我教授的是subject。创建包含三个参数的构造方法，分别是name，age，subject，利用super实现父类构造方法传值。重写toString方法，打印输出：我的名字是XX，我的年龄是XX（10分） 4）创建Test测试类，创建Student对象，并调用带3个参数的构造方法，自己赋值，然后依次调用study方法，eat方法，toString方法（20分） 5）创建Teacher对象，并调用带3个参数的构造方法，自己赋值，然后依次调用teach方法，eat方法，toString方法（10分） Person.java： Student.java：

Teacher.java：

Test.java： 4、需求：首先定义一个抽象类Animal,抽象类中定义一个抽象方法play（）抽象方法，创建 一个猫Cat类，继承Animal并重写play方法输出“我是猫，我玩老鼠”，创建一个狗类， 继承Animal并重写play方法输出“我是狗，我玩球”。最后编写测试类TestDemo，通 过多态创建猫，通过多态创建狗，并调用猫对象的play方，狗对象的play方法 效果如图： 我是猫，我玩老鼠 我是狗，我玩球 评分标准 1）创建Animal抽象类，并定义抽象方法play.（10） 2）创建Dog类继承Animal类，重写play方法。（10） 3）创建Cat类继承Animal类，重写play方法。（10） 4）编写测试类，通过多态创建猫对象，狗对象（15） Animal.java： Cat.java： Dog.java： Test.java：

==5、== 请创建一个Car抽象类，要求有brand（品牌）属性，并且要求封装私有化，写出属性的 set、get方法。抽象类Car构造方法中也可以对brand属性赋值，写出一个抽象方法run （）。创建一个跑车类SportsCar继承抽象类Car。实现Car抽象方法输出一条语句“超 级跑车”，在本类中写出一个自己的方法price（），输出一条语句“售价100w”。在测 试类Test类中创建跑车对象car1，用构造器赋值品牌属性，输出属性，调用run（）、 price（）方法。创建跑车car2，用set方法赋值属性，输出属性，调用run（）、price （）方法。

1评分标准：
21）正确写出抽象类Car ，封装属性，写出抽象方法10分
32）封装属性，写出set、get、抽象方法 10分
43）正确继承Car类写出SportsCar类和并实现run（） 方法。10分
54）创建car1、car2对象并调用方法10分
65）成功正确输出 10分
7显示结果如下：
8	法拉利
9	超级跑车
10	售价100w
11	兰博基尼
12	超级跑车
13	售价100w

Car.java： SportsCar.java： Test.java：

==6、== 完成那个USB接口的例子，分别定义USB接口，两个方法start，stop。两个子类：Flash和Print，重写两个方法，方法中随便输出两句话。定义计算机类Computer，有一个plugin方法，有一个USB类型的参数，用来调用start和stop。在主方法中实例化Computer类，调用plugin方法，分别传递Flash和Print的对象，通过向上转型，完成功能。

注意：因为从键盘输入我们还没有做，所以上面若提到使用键盘输入，改为在程序中随意定义几个值（如果会键盘输入那就使用键盘输入） USB.java： Print.java： Flash.java： Computer.java： Mains.java：

==7、== 完成以下要求的代码：（共30分）

（1）请创建一个Car抽象类，要求有brand（品牌）属性，并且要求封装私有化，写出属性的 set、get方法。抽象类Car构造方法中对brand属性赋值，写出一个抽象方法run（）。（2）创建一个跑车类SportsCar继承抽象类Car。实现Car抽象方法输出一条语句“超级跑车”，在本类中写出一个自己的方法price（），输出一条语句“售价100w”。（10分） （3）定义测试类Test类，并创建跑车对象car1，用构造器赋值品牌属性，使用setter方法输出属性值，再调用run（）、 price（）方法。 （10分） （4）创建跑车car2，向上转型到Car，使用setter方法为brand赋值属性，输出属性值，调用run（）方法。（10分） Car.java：

1package kaoshi_1;
2
3public abstract class Car {
4	private String brand;
5
6	public String getBrand() {
7		return brand;
8	}
9
10	public void setBrand(String brand) {
11		this.brand = brand;
12	}
13	
14	public Car(String brand) {
15		this.brand=brand;
16	}
17	
18	public Car() {
19		
20	}
21	public abstract void run();
22}
23

SportCar.java：

1package kaoshi_1;
2
3public class SportCar extends Car {
4
5	public void run() {
6		System.out.println("超级跑车");
7	}
8	public SportCar(String brand) {
9		super(brand);
10	}
11	public void price() {
12		System.out.println("售价100w");
13	}
14	public SportCar() {
15		
16	}
17}
18

Test.java：

1package kaoshi_1;
2
3public class Test {
4	public static void main(String[] args) {
5		SportCar car1 = new SportCar("奥迪A6");
6		System.out.println(car1.getBrand());
7		car1.run();
8		car1.price();
9		
10		Car car2 = new SportCar();
11		car2.setBrand("玛莎拉蒂");
12		System.out.println(car2.getBrand());
13		car2.run();
14	}
15}
16

==8、== 完成以下要求的代码：（共40分）

（1）定义一个Flower花作为父类 属性：颜色 价格
属性要进行封装（即为每条私有属性写set，get方法） 定义无参构造方法，和传两个参数的有参构造方法一个。 方法：显示详细信息的方法showInfo （15分） （2）定义一个Rose玫瑰花类继承Flower类 玫瑰花自己的属性：产地（要求对产地属性进行封装 私有化属性） 重写父类中的显示详细信息的方法showInfo，在重写的showInfo方法中通过super调用父类的showInfo方法；并显示产地信息。 再定义一个方法warn警告显示：不要摘玫瑰花，小心扎手！ （15分） （3）定义测试类Test完成：（10分） ①实例化Flower类，调用构造方法赋值，并调用方法，输出： 花的颜色是白色，价格是10元 ②实例化玫瑰花类，调用方法，输出： 花的颜色是紫色，价格是30元 产地是大理 不要摘玫瑰花，小心扎手！ Flower.java：

1package kaoshi_1;
2
3public class Flower {
4	private String color;
5	private String price;
6	public String getColor() {
7		return color;
8	}
9	public void setColor(String color) {
10		this.color = color;
11	}
12	public String getPrice() {
13		return price;
14	}
15	public void setPrice(String price) {
16		this.price = price;
17	}
18	public Flower() {
19		
20	}
21	public Flower(String color,String price) {
22		this.color=color;
23		this.price=price;
24	}
25	public void showInfo() {
26		System.out.println("花的颜色是"+this.color+",价格是"+this.price+"元");
27	}
28}
29

Rose.java：

1package kaoshi_1;
2
3public class Rose extends Flower {
4	private String address;
5	
6	public String getAddress() {
7		return address;
8	}
9	public void setAddress(String address) {
10		this.address = address;
11	}
12	public void showInfo() {
13		super.showInfo();
14		System.out.println("产地是"+this.address);
15	}
16	public void warn() {
17		System.out.println("不要摘玫瑰花，小心扎手！");
18	}
19	public Rose() {
20		
21	}
22	public Rose(String color,String price,String address) {
23		super(color,price);
24		this.address=address;
25	}
26}
27

Test2.java：

1package kaoshi_1;
2
3public class Test2 {
4	public static void main(String[] args) {
5		Flower f=new Flower("白色","10");
6		f.showInfo();
7		
8		Rose r=new Rose("紫色","30","大理");
9		r.showInfo();
10		r.warn();
11	}
12}
13

==9、== 完成以下要求的代码：

（1）首先定义一个程序员的接口Programmer,接口中定义一个抽象方法ACode（）； （10分） （2）创建一个Student类，实现接口Programmer并实现ACode（）方法，ACode（）方法可输出输出“程序员在敲代码”， Student类有年龄，姓名，班级，性别私有属性（封装），各个属性的set，get方法，写空参构造方法，和一个有参构造方法包含这四个属性。 （10分） （3）定义测试类，在main方法中创建一个Student对象，将自己的年龄，姓名，班级，性别，赋值给这个对象，并在控制台打印出对象的各个属性。调用所有的方法。（10分） 效果如图： 程序员在敲代码 姓名：孙悟空 性别：女 年龄：19 班级：三年级二班 Programmer.java：

1package kaoshi_1;
2
3public interface Programmer {
4	public abstract void ACode();
5}
6

Student.java：

1package kaoshi_1;
2
3public class Student implements Programmer {
4	private int age;
5	private String name;
6	private String clas;
7	private String sex;
8	public void ACode() {
9		System.out.println("程序员在敲代码");
10	}
11	public int getAge() {
12		return age;
13	}
14	public void setAge(int age) {
15		this.age = age;
16	}
17	public String getName() {
18		return name;
19	}
20	public void setName(String name) {
21		this.name = name;
22	}
23	public String getClas() {
24		return clas;
25	}
26	public void setClas(String clas) {
27		this.clas = clas;
28	}
29	public String getSex() {
30		return sex;
31	}
32	public void setSex(String sex) {
33		this.sex = sex;
34	}
35	public Student() {
36		
37	}
38	public Student(int age,String name,String clas,String sex) {
39		this.age=age;
40		this.name=name;
41		this.clas=clas;
42		this.sex=sex;
43	}
44}
45

Test3.java：

1package kaoshi_1;
2
3public class Test3 {
4
5	public static void main(String[] args) {
6		Student s=new Student(19,"孙悟空","三年级二班","女");
7		s.ACode();
8		System.out.println("姓名："+s.getName()+"，性别"+s.getSex()+"，年龄："+s.getAge()+"，班级："+s.getClas());
9	}
10}