一. 编程题

请使用面向对象的思想，设计自定义类 Person 继承 Object 类，重写 toString 方法实现对
象信息输出。
运行效果如下图所示：
image.png
任务
思路分析
1、创建一个 Person 类继承自 Object，其中类的结构要求为：
属性：name（姓名）、age(年龄)、sex（性别）
方法：
▪ 创建带参（name、age、sex 为参数）构造方法
▪ 重写 toString 方法，输出信息格式为：姓名： 年龄： 性别：（其中，为对象对
应属性值）
2、创建测试类，在测试方法中，实例化 Person 对 象，并传入三个属性值。然后，分别
通过直接打印 Person 对象以及利用重写的 toString 方法，打印输出 2 行对象信息。

  1. public class Person {
  2.     private String name;
  3.     private  int age;
  4.     private String sex;
  6.     public Person(String name, int age, String sex) {
  7.         this.name = name;
  8.         this.age = age;
  9.         this.sex = sex;
  10.     }
  12.     @Override
  13.     public String toString() {
  14.         return  "姓名："+name+" "+
  15.                 "年龄："+age+" "+
  16.                 "性别："+sex;
  17.     }
  18. }
  1. public class Main {
  2.     public static void test1(){
  3.         Person person = new Person("李明",18,"男");
  4.         System.out.println(person.toString());
  5.         System.out.println(person.toString());
  7.     }
  9.     public  static void main(String[] args){
  10.         test1();
  12.     }
  13. }

二.编程题

请使用面向对象的思想，实现出租车和家用轿车的信息描述。
程序运行参考效果图如下：
image.png
任务
要求：
1 、 根据出租车和家用轿车的共性，抽取父类 根据出租车和家用轿车的共性，抽取父类 Car
属性：车的颜色 color、车主姓名 userName
方法：
1带参构造函数（参数为 color 和 useName）
2创建无参无返回值得方法 use（描述内容为：我是机动车！）
3) 重写 equals 方法，比较两个对象是否相等（比较 color，userName）

2、子类 、子类 taxi
属性：所属公司( company)
方法：
1调用父类的构造方法，完成属性赋值
2创建不允许重写的 ride 方法，描述为：出租车是所属于在*公司的。
3写父类 use 描述为：出租车是提高市民生活质量的重要条件之一
4) 重写 toString 方法，输出的表现形式不同（输出 color,userName）

3、子类：私家车 、子类：私家车 HomeCar
属性：载客数（num）
方法：
1带参构造方法为所有属性赋值
2创建无参无返回值的 display 方法，表现为：拥有的颜色的私家车有座位
3重载要求（2）中的 display 方法（带参数 num），描述为：家用汽车大多有个座位
4) 要求私家车类不允许有子类

4、测试类，运行效果参照效果图： 、测试类，运行效果参照效果图：
1实例化 2 个父类对象，并传入两组相同的参数值
2类 use 方法
3调用父类重写的 equals 方法，测试两个对象是否相等
4实例化子类对象，并传入相关参数值
5类 ride 方法和 use 方法
6调用子类重写的 toString 方法，输出子类对象的信息
7实例化 HomeCar 类对象，并传入相关参数值
8) 调用子类的 display 和他的重载方法

  1. public class Car {
  2.     protected String color;//由于需要继承，所以用protected或者public
  3.     protected String userName;
  5.     public Car(String color, String userName) {
  6.         this.color = color;
  7.         this.userName = userName;
  8.     }
  10.     public void use(){
  11.         System.out.println("我是机动车！");
  12.     }
  14.     @Override//equals方法重写自Object，因为Car继承自Object这个类
  15.     public boolean equals(Object obj) {
  16.         if(obj instanceof  Car){
  17.             Car car = (Car)obj;
  18.             if(car.color.equals(color)&&car.userName.equals(userName)){
  19.                 return true;
  20.             }
  21.         }
  22.         return false;
  23.     }
  24. }
  1. public class Taxi extends Car{
  2.     String company;
  4.     public Taxi(String color, String userName, String company) {
  5.         super(color, userName);
  6.         this.company = company;
  7.     }
  9.     @Override
  10.     public void use() {
  11.         System.out.println("出租车是提高市民生活质量的重要条件之一");
  12.     }
  14.     public final void ride(){
  15.         System.out.println(super.userName+"的出租车是所属于"+company+"公司的");
  16.     }
  18.     @Override
  19.     public String toString() {
  20.         return "taxi的信息是："+super.userName+"拥有一辆"+super.color+"出租车";
  21.     }
  24. }
  1. public final class HomeCar extends Car {
  2.     private  int num;
  4.     public HomeCar(String color, String userName, int num) {
  5.         super(color, userName);
  6.         this.num = num;
  7.     }
  9.     public void display(){
  10.         System.out.println(userName +"拥有的"+color+"颜色的私家车，有"+num+"座位");
  11.     }
  12.     public void display(int num){
  13.         System.out.println("家用汽车大多数有"+num+"个座位");
  14.     }
  15. }
  1. public class Main {
  2.     private static void test2(){
  3.         Car car1 = new Car("黄色","麦克");
  4.         Car car2 = new Car("黄色","麦克");
  5.         car1.use();
  6.         boolean bRet = car1.equals(car2);
  7.         System.out.println("car1和car2的引用比较："+bRet);
  8.         System.out.println("==================================");
  9.         Taxi taxi = new Taxi("黑色","尼古拉斯赵四","长生");
  10.         taxi.ride();
  11.         taxi.use();
  12.         System.out.println(taxi.toString());
  13.         System.out.println("====================================");
  14.         HomeCar homeCar = new HomeCar("紫色","孙二娘",7);
  15.         homeCar.display();
  16.         homeCar.display(5);
  18.     }
  20.     public  static void main(String[] args){
  21.         test2();
  23.     }
  24. }

三.编程题

应用继承和多态的思想，编写动物类，成员方法是动物叫声。写三个具体的类（猫、狗、
羊），它们都是动物类的子类，并重写父类的成员方法。编写测试类，随机产生三种具体
动物，调用叫声这个方法。
程序参考运行效果如图所示：
image.png
提示：
1. 定义一个父类 Animal 类 类
属性：kind(种类)
方法：创建带参（kind 为参数）构造方法
创建 cry():void 方法
2. 编写三个具体的子类 Cat 类、Dog 类、Sheep 类 类
分别重写父类中的 cry() 方法，输出信息分别为
Cat 类：小猫的叫声：喵喵喵~
Dog 类：小狗的叫声：汪汪汪~
Sheep 类：小羊的叫声：咩咩咩~~~
3. 编写测试类，首先生成长度为 5 的父类对象数组，然后通过循环依次向数组中存入
数据，现设定存储规则为： 数据，现设定存储规则为：
a) 每次随机产生一个 0~2 的正整数
b) 若数值为 0，则生成一个 Cat 类的对象，存入数组
c) 若数值为 1，则生成一个 Dog 类的对象，存入数组
d) 若数值为 2，则生成一个 Sheep 类的对象，存入数组
最后循环输出数组成员，并分别调用 cry() 方法。
随机数类的使用：
Random r = new Random(1);
int ran1 = r.nextInt(100);

  1. public class Animal {
  2.     protected String kind;
  4.     public Animal(String kind) {//kind是为了实现多态，不同种类的动物
  5.         this.kind = kind;
  6.     }
  8.     public void cry(){
  10.     }
  11. }
  1. public class Cat extends Animal {
  2.     public Cat(String kind) {
  3.         super(kind);
  4.     }
  6.     @Override
  7.     public void cry() { 
  8.         System.out.println("小"+kind+"的叫声：喵喵喵~~~");
  9.     }
  10. }
  1. public class Dog extends Animal {
  2.     public Dog(String kind) {
  3.         super(kind);
  4.     }
  6.     @Override
  7.     public void cry() {
  8.         System.out.println("小"+kind+"的叫声：汪汪汪~~~ ");
  9.     }
  10. }
  1. public class Sheep extends Animal {
  2.     public Sheep(String kind) {
  3.         super(kind);
  4.     }
  6.     @Override
  7.     public void cry() {
  8.         System.out.println("小"+kind+"的叫声：咩咩咩~~~ ");
  9.     }
  11. }
  1. public class Main {
  2.     private static void test3() {
  3.         // 长度5的父类对象数组
  4.         Animal animal[] = new Animal[5];
  5.         Random r = new Random(5);
  6.         for (int i = 0; i <animal.length ; i++) {
  7.             int ran1 = r.nextInt(3);//指定上限(不包括)
  8.             switch(ran1){
  9.                 case 0:
  10.                     animal[i] = new Cat("猫");
  11.                     break;
  12.                 case 1:
  13.                     animal[i] = new Dog("狗");
  14.                     break;
  15.                 case 2:
  16.                     animal[i] = new Sheep("羊");
  17.                     break;
  18.             }
  19.         }
  21.         for (int i = 0; i < animal.length ; i++) {
  22.             animal[i].cry();
  23.         }
  24.     }
  25.     public  static void main(String[] args){
  26.         test3();
  28.     }
  29. }

四. 编程题

使用接口的知识， 定义接口 IFly,创建三个类 Plane 类、Bird 类、Balloon 类，分别重写接
口中的 fly( )方法，然后再测试类中进行调用。
程序运行参考效果如图所示：
image.png
提示：
1、创建接口 IFly( )
方法：创建抽象方法 fly() 方法
2、创建子类：Plane
方法：实现接口中的方法 fly( )，输出信息“飞机在天上飞”
创建子类：Bird
方法：实现接口中的方法 fly( )，输出信息“小鸟在天空翱翔””
创建子类：Balloon(气球)
方法：实现接口中的方法 fly( )，输出信息“气球飞上天空”
3、创建测试类，分别创建 Plane、Bird、Balloon 类的对象，调用 fly( ) 方法，输出效果
参考效果图

  1. public interface IFly {
  2.     void fly();
  3. }
  1. public class Plane implements IFly {
  2.     @Override
  3.     public void fly() {
  4.         System.out.println("飞机在天上飞");
  5.     }
  6. }
  1. public class Balloon implements IFly {
  2.     @Override
  3.     public void fly() {
  4.         System.out.println("气球飞上天空");
  5.     }
  6. }
  1. public class Bird implements IFly {
  2.     @Override
  3.     public void fly() {
  4.         System.out.println("小鸟在天空翱翔");
  5.     }
  6. }
  1. public class Main {
  2.     private static void test4(){
  3.         Plane plane = new Plane();
  4.         plane.fly();
  5.         Bird bird = new Bird();
  6.         bird.fly();
  7.         Balloon balloon = new Balloon();
  8.         balloon.fly();
  9.     }
  10.     public  static void main(String[] args){
  11.         test4();
  13.     }
  14. }

五．编程题

分别通过成员内部类、匿名内部类完成接口 Ball，在测试类 BallTest 中的调用。
程序参考运行效果图如下：
image.png
提示：
1. 创建接口 IBall
包含抽象方法 play( )
2. 创建外部类 BallTest
定义方法 void playBall(Ball ball)，调用接口中的 play( ) 方法
3. 分别通过成员内部类、匿名内部类完成接口实现
在 BallTest 中，创建成员内部类 Inner_m 实现接口 IBall，在类中重写 play( ) 方法，输出两
条信息，分别为”成员内部类:”和”打篮球”
在测试类 Test 中通过匿名内部类实现接口 IBall，并重写 play( )方法，输出两条信息，分别为
“**“，”匿名内部类:” 和 “打排球”
4. 创建测试类 Test，通过创建 BallTest 类及相关内部类实例，调用相关方法，依次完成
相关内部类测试。运行效果参见效果图

  1. public interface IBall {
  2.     void play();
  3. }
  1. public class BallTest {
  3.     public class Inner_m implements IBall{
  4.         @Override
  5.         public void play() {
  6.             System.out.println("打篮球");
  7.         }
  8.     }
  10.     void playBall(IBall ball){
  11.         ball.play();
  12.     }
  13. }
  1. public class Main {
  2.     private static void test5(){
  3.         BallTest ballTest = new BallTest();
  5.         System.out.println("成员内部类：");
  6.         ballTest.playBall(new BallTest().new Inner_m());
  8.         System.out.println("*******************");
  9.         System.out.println("匿名内部类：");
  10.         ballTest.playBall(new IBall() {
  11.             @Override
  12.             public void play() {
  13.                 System.out.println("打排球");
  14.             }
  15.         });
  16.     }
  17.     public  static void main(String[] args){
  18.         test4();
  20.     }
  21. }