一、选择

1. 在Java中，以下程序的输出结果是A

   A. Super-->print
   B. Test-->print
   C. Super-->print
      Test-->print
   D. 编译错误
   

2. 在Java中，以下关于方法重载和方法重写描述正确的是  D

   A. 方法重载和方法重写实现的功能相同
   B. 方法重载出现在父子关系中，方法重写是在同一类中
   C. 方法重载的返回类型必须一致，参数项必须不同
   D. 方法重写需要出现在满足继承关系的子类中
   

3. 哪个选项中的方法插入到（1）处可以正确实现方法重写   C

   A. public static void bark(){}
   B. public final void display(){}
   C. public void eat(String food){}
   D. public boolean eat(String food){}
   

4. 在下面程序的注释1处补充上下列（）方法，会导致在编译过程中发生错误

   A. public float getNum() { return 4.0f; }
   B. private float getNum() {return 4.0f;}
   C. public void getNum（double d）{}
   D. public double getNum（float d）{ return 4.0f; }
   

5. 如下Java源文件，编译并运行Child.java后，以下结果描述正确的是B

   A. 编译错误：没有找到构造器Child()
   B. 编译错误：没有找到构造器Parent1()
   C. 正确运行，没有输出值
   D. 正确运行，输出结果为：parent2
   

6. 分析如下所示的Java代码，则选项中的说法正确的是C

   A. 第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
   B. 第3行错误，应使用super关键字调用父类的name属性，改为super.name="hello"
   C. 第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
   D. 程序编译通过，无错误 
   

7. 关于super的说法正确的是  C

   A. 是指当前子类的对象
   B. 是指当前类的对象
   C. 是指当前父类的对象
   D. 可以用在main()方法中
   

8. 阅读下面JAVA代码片段，正确的选项是  B 虽然编译错误但是整个代码过程中都没有调用无参构造器所以选择B多余出来的无参构造器时错误的代码编译

   A. 第1行编译错误，但能输出正确结果
   B.   第2行编译错误，但能输出正确结果
   C. 第3行编译错误，不能输出正确结果
   D. 第4行编译错误，不能输出正确结果
   

9. 下列关于super和this的说法正确的是（多选）ABD

   A. this关键字通常指当前对象
   B. super关键字则指父类对象
   C. 在一个类中this只可以调用当前类中公有属性和方法
   D. 在一个类中super可以调用父类中允许被访问的属性和方法
   

10. 下列关于Object类的叙述错误的是 D

    A. Object类是所有类的父类
    B. 所有类都可以继承Object中允许被继承的方法
    C. 一个类没有使用extends关键字明确标识继承关系，则默认继承Object类
    D. 要想继承Object类，必须使用extends关键字标识继承关系，否则不会实现继承
    

11. 该段代码的运行结果为  D

    A. true
    B. 相等
    C. 不相等
    D. false
    

12. 在Java中，关于继承的说法错误的是  C

    A. 使用extends关键字实现一个类继承另一个类
    B. 所有的Java类都直接或间接地继承了java.lang.Object类
    C. 在子类的构造方法中，必须显式调用父类的构造方法
    D. 在子类的构造方法中，可以通过super关键字调用父类的构造方法
    

13. 下列关于final的说法错误的是 C

    A. final修饰的变量值不允许被修改
    B. final修饰的方法不可被重写
    C. final可以修饰所有方法
    D. final不可以修饰构造方法
    

二、编程

1. 编程练习：某公司要开发“XX车行管理系统”，请使用面向对象的思想，设计自定义类描述自行车、电动车和三轮车。
   程序参考运行效果图如下：
   
   任务
   任务分析；
   第一步：分析自行车、电动车和三轮车的共性：

   1. 都是非机动车，具有非机动车的基本特征
   2. 都有运行的方法

   第二步：根据共性，定义非机动车
   属性：品牌、颜色、轮子(默认2个)、座椅（默认   1个）
   方法：
   1. 编写无参构造方法、双参构造方法和四参构造方法，其中，在双参构造方法中，完成对品牌和颜色的赋值；在四参构造方法中，完成对所有属性的赋值
   2. 编写运行的方法，描述内容为：这是一辆**颜色的，**牌的非机动车，有**个轮子，有**个座椅的非机动车。其中**的数据由属性提供

   第三步：定义自行车、电动车和三轮车分别继承自行车类，要求：

   • 自行车类：
   1. 在构造方法中调用父类多参构造，完成属性赋值
   2. 重写运行方法，描述内容为：这是一辆**颜色的，**牌的自行车。其中**的数据由属性提供
   • 电动车：
   1. 增加“电池品牌”属性
   2. 重写运行方法，描述内容为：这是一辆使用**牌电池的电动车。其中**的数据由属性提供
   • 三轮车：
   1. 在无参构造中实现对轮子属性值进行修改
   2. 重写运行方法，描述内容为：三轮车是一款有**个轮子的非机动车。其中**的数据由属性提供

   3. package car;
      
      /**
       * 定义非机动车共有属性
       * 
       * @author user
       *
       */
      public class Car {
      	private String carName;// 品牌
      
      	private String carcol;// 颜色
      
      	private int cargulu = 2;// 轮子数量默认2个
      
      	private int cardown = 1;// 座椅数量默认1个
      
      	public String getCarName() {
      		return carName;
      	}
      
      	public void setCarName(String carName) {
      		this.carName = carName;
      	}
      
      	public String getCarcol() {
      		return carcol;
      	}
      
      	public void setCarcol(String carcol) {
      		this.carcol = carcol;
      	}
      
      	public int getCargulu() {
      		return cargulu;
      	}
      
      	public void setCargulu(int cargulu) {
      		this.cargulu = cargulu;
      	}
      
      	public int getCardown() {
      		return cardown;
      	}
      
      	public void setCardown(int cardown) {
      		this.cardown = cardown;
      	}
      
      	public Car() {
      		super();
      	}
      	
      
      	public Car(String carName, String carcol) {
      		super();
      		this.setCarName(carName);
      		this.setCarcol(carcol);
      	}
      
      	public Car(String carName, String carcol, int cargulu, int cardown) {
      		super();
      		this.setCarName(carName);
      		this.setCarcol(carcol);
      		this.setCargulu(cargulu);
      		this.setCardown(cardown);
      	}
      
      	public String info() {
      		String str = "父类信息测试:这是一辆" + this.getCarcol() + "颜色的，" + this.getCarName() + "牌的非机动车，有" + this.getCargulu() + "个轮子，有"
      				+ this.getCardown() + "个座椅的非机动车。";
      		return str;
      	}
      }
      

      package car;
      /**
       * 自行车
       * @author user
       *
       */
      public class Zixinche extends Car{
      	public Zixinche(){
      		super();
      	}
      	
      	public Zixinche(String carcol, String carName){
      		super(carcol,carName);
      		System.out.println( "自行车类信息测试:这是一辆" + carcol + "颜色的，" + carName + "牌的自行车。");
      	}
      }

      package car;
      /**
       * 电动车
       * @author user
       *
       */
      public class Diandongche extends Car {
      	private String dianchi;
      
      	public String getDianchi() {
      		return dianchi;
      	}
      
      	public void setDianchi(String dianchi) {
      		this.dianchi = dianchi;
      	}
      	
      	public Diandongche(){
      		super();
      	}
      
      	public Diandongche(String dianchi) {
      		super();
      		this.dianchi = dianchi;
      		System.out.println("电动车类信息测试:这是一辆使用" + this.getDianchi() + "牌电车的电动车。");
      	}
      	
      	
      }
      

      package car;
      /**
       * 三轮车
       * @author user
       *
       */
      public class Sanlunche extends Car {
      	public Sanlunche(){
      		super();
      		this.setCargulu(3);
      	}
      	
      	public String inpp(){
      		String str = "三轮车类信息测试:三轮车是一款有" + this.getCargulu() + "个轮子的非机动车。";
      		return str;
      	}
      }
      

      package test;
      
      import car.Car;
      import car.Diandongche;
      import car.Sanlunche;
      import car.Zixinche;
      
      public class Test {
      	public static void main(String[] args){
      		Car car = new Car("天宇", "紅色",4,2);
      		System.out.println(car.info());
      		Zixinche zxc = new Zixinche("红色","捷安特");
      		Diandongche ddc = new Diandongche("飞鸽");
      		Sanlunche slc = new Sanlunche();
      		System.out.println(slc.inpp());
      	}
      }
      

       

       

2. 请使用面向对象的思想，设计自定义类Person继承Object类，重写toString方法实现对象信息输出。
   运行效果如下图所示：
   
   思路分析

   • 创建一个 Person 类继承自 Object，其中类的结构要求为：
     属性：name（姓名）、age(年龄)、sex（性别）
     方法：
     • 创建带参（name、age、sex为参数）构造方法
     • 重写 toString 方法，输出信息格式为：姓名：** 年龄：** 性别：**（其中，**为对象对应属性值）
   • 创建测试类，在测试方法中，实例化 Person对 象，并传入三个属性值。然后，分别通过直接打印Person对象以及利用重写的 toString 方法，打印输出2行对象信息。

   • package person;
     
     public class Person {
     	private String name;
     	
     	private int age;
     	
     	private String sex;
     
     	public String getName() {
     		return name;
     	}
     
     	public void setName(String name) {
     		this.name = name;
     	}
     
     	public int getAge() {
     		return age;
     	}
     
     	public void setAge(int age) {
     		this.age = age;
     	}
     
     	public String getSex() {
     		return sex;
     	}
     
     	public void setSex(String sex) {
     		this.sex = sex;
     	}
     	
     	public Person(){
     		super();
     	}
     
     	public Person(String name, int age, String sex) {
     		super();
     		this.setName(name);
     		this.setAge(age);
     		this.setSex(sex);
     	}
     	
     	@Override
     	public String toString() {
     		String str = "姓名：" + this.getName() + "  " + "年龄：" + this.getAge() + "   " + "性别：" + this.getSex();
     		return str;
     	}
     
     }
     

     package test;
     
     import person.Person;
     
     public class Test1 {
     	public static void main(String[] args) {
     		Person person = new Person("李明",18,"男");
     		System.out.println(person);
     		System.out.println(person.toString());
     	}
     }
     

      

3. 请使用面向对象的思想，实现杨梅和仙人蕉的信息描述。
   程序参考运行效果图如下：
   
   思路分析：
   1、根据杨梅和香蕉的共性，抽取父类水果（Fruits）
   私有属性：水果的形状（shape）和口感（taste）
   方法：

   • 带参构造函数（参数为shape和taste）
   • 创建无参无返回值得方法eat（描述内容为：水果可供人们食用！）
   • 重写equals方法，比较两个对象是否相等（比较shape，taste）

   2、子类Waxberry
   私有属性：颜色（color）
   方法：

   • 调用父类的构造方法，完成属性赋值
   • 创建不允许重写的face方法，描述为：杨梅：**、**，果味酸甜适中。
   • 重写父类eat方法，描述为：杨梅酸甜适中，非常好吃！
   • 重写toString方法，输出的表现形式不同（输出shape,color,taste）
   • 要求Waxberry类不允许有子类

   3、子类：Banana
   私有属性：品种（variety）
   方法：

   • 带参构造方法为所有属性赋值
   • 创建无参无返回值的advantage方法，描述为：**果形**,果肉香甜，可供生食。
   • 重载要求(2)中的advantage方法（带参数color），描述为：**颜色为**

   4、测试，运行效果参照效果图：

   • 实例化2个父类对象，并传入两组相同的参数值
   • 调用父类eat方法
   • 测试重写equals方法，判断两个对象是否相等
   • 实例化子类Wacberry对象，并传入相关参数值
   • 调用子类face方法和重写父类eat方法后的eat方法
   • 测试重写toString方法，输出子类对象的信息
   • 实例化Banana类对象，并传入相关参数值
   • 调用子类的advantage和它的重载方法

4. package fruits;
   /**
    * 水果类
    * 成员属性：shape形状 taste口感
    * @author user
    *
    */
   public class Fruits {
   	private String shape;
   	
   	private String taste;
   
   	public String getShape() {
   		return shape;
   	}
   	
   	public void setShape(String shape) {
   		this.shape = shape;
   	}
   
   	public String getTaste() {
   		return taste;
   	}
   
   	public void setTaste(String taste) {
   		this.taste = taste;
   	}
   
   	public Fruits() {
   		super();
   	}
   
   	public Fruits(String shape, String taste) {
   		super();
   		this.setShape(shape);
   		this.setTaste(taste);
   	}
   
   	public void eat() {
   		System.out.println("水果可供人们食用！");
   	}
   
   
   	@Override
   	public boolean equals(Object obj) {
   		if (obj == null) {
   			return false;
   		} else {
   			Fruits fruits = (Fruits) obj;
   			if (this.getShape().equals(fruits.getShape()) && this.getTaste().equals(fruits.getTaste())) {
   				return true;
   			} else {
   				return false;
   			}
   		}
   	}
   
   }
   

   package fruits;
   /**
    * 子类Waxberry类
    * 添加final属性阻止产生子类创建
    * @author user
    *
    */
   public final class Waxberry extends Fruits {
   	// 成员属性
   	private String color;
   
   	public String getColor() {
   		return color;
   	}
   
   	public void setColor(String color) {
   		this.color = color;
   	}
   
   	//无参构造器
   	public Waxberry() {
   		super();
   	}
   	
   	//多参构造器
   	public Waxberry(String shape, String taste, String color) {
   		super(shape, taste);
   		this.setColor(color);
   	}
   
   	//添加final阻止重写
   	public final void face() {
   		System.out.println("杨梅:" + this.getColor() + "、" + this.getShape() + "," + "果味" + this.getTaste() + "。");
   	}
   	
   	@Override
   	public void eat() {
   		System.out.println("杨梅酸甜适中，非常好吃!");
   	}
   	
   	//toString方法
   	@Override
   	public String toString() {
   		String str = "杨梅的信息:果实为" + this.getShape() + "、" + this.getColor() + "," + this.getTaste() + ",非常好吃!";
   		return str;
   	}
   
   }
   

   package fruits;
   /**
    * 子类：Banana
    * @author user
    *
    */
   public class Banana extends Fruits{
   	//添加私有属性品种为variety
   	private String variety;
   
   	public String getVariety() {
   		return variety;
   	}
   
   	public void setVariety(String variety) {
   		this.variety = variety;
   	}
   
   	//无参构造器
   	public Banana() {
   		super();
   	}
   
   	//多参构造器
   	public Banana(String shape, String taste, String variety) {
   		super(shape, taste);
   		this.setVariety(variety);
   	}
   
   	//无参描述
   	public void advantage() {
   		System.out.println(this.getVariety() + "过形" + this.getShape() + "，过肉" + this.getTaste() + "，可供审食。");
   	}
   	
   	//带参描述
   	public void advantage(String color) {
   		System.out.println(this.getVariety() + "颜色为" + color);
   	}
   
   }
   

   package test;
   
   import fruits.Banana;
   import fruits.Fruits;
   import fruits.Waxberry;
   
   public class Tested {
   	public static void main(String[] args) {
   		Fruits fru1 = new Fruits("圆形", "酸甜适中");
   		Fruits fru2 = new Fruits("圆形", "酸甜适中");
   		fru1.eat();
   		System.out.println("fru1和fru2的引用比较：" + fru1.equals(fru2));
   		System.out.println("————————————————————————————————————");
   		Waxberry wb = new Waxberry("圆形", "酸甜适中", "紫红色");
   		wb.face();
   		wb.eat();
   		System.out.println(wb);
   		System.out.println("————————————————————————————————————");
   		Banana banana = new Banana("短而稍圆", "香甜", "仙人蕉");
   		banana.advantage();
   		banana.advantage("黄色");
   	}
   
   }
   

    

一、选择题

1.A
A. Super–>print
B. Test–>print
C. Super–>print
Test–>print
D. 编译错误

2.在Java中，以下关于方法重载和方法重写描述正确的是 A
A. 方法重载和方法重写实现的功能相同
B. 方法重载出现在父子关系中，方法重写是在同一类中
C. 方法重载的返回类型必须一致，参数项必须不同
D. 方法重写需要出现在满足继承关系的子类中

3.C
A. public static void bark(){}
B. public final void display(){}
C. public void eat(String food){}
D. public boolean eat(String food){}

4.在下面程序的注释1处补充上下列（）方法，会导致在编译过程中发生错误 D
A. public float getNum() { return 4.0f; }
B. private float getNum() {return 4.0f;}
C. public void getNum（double d）{}
D. public double getNum（float d）{ return 4.0f; }

5.如下Java源文件，编译并运行Child.java后，以下结果描述正确的是 B

A. 编译错误：没有找到构造器Child()
B. 编译错误：没有找到构造器Parent1()
C. 正确运行，没有输出值
D. 正确运行，输出结果为：parent2

6.分析如下所示的Java代码，则选项中的说法正确的是 A

A. 第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
B. 第3行错误，应使用super关键字调用父类的name属性，改为super.name=“hello”
C. 第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
D. 程序编译通过，无错误

7.关于super的说法正确的是 C
A. 是指当前子类的对象
B. 是指当前类的对象
C. 是指当前父类的对象
D. 可以用在main()方法中

8. 阅读下面JAVA代码片段，正确的选项是 B
   
   A. 第1行编译错误，但能输出正确结果
   B. 第2行编译错误，但能输出正确结果
   C. 第3行编译错误，不能输出正确结果
   D. 第4行编译错误，不能输出正确结果

9. 下列关于super和this的说法正确的是（多选）ABD
   A. this关键字通常指当前对象
   B. super关键字则指父类对象
   C. 在一个类中this只可以调用当前类中公有属性和方法
   D. 在一个类中super可以调用父类中允许被访问的属性和方法

10. 下列关于Object类的叙述错误的是 D
    A. Object类是所有类的父类
    B. 所有类都可以继承Object中允许被继承的方法
    C. 一个类没有使用extends关键字明确标识继承关系，则默认继承Object类
    D. 要想继承Object类，必须使用extends关键字标识继承关系，否则不会实现继承

11. A
    

A. true
B. 相等
C. 不相等
D. false

12. 在Java中，关于继承的说法错误的是 C
    A. 使用extends关键字实现一个类继承另一个类
    B. 所有的Java类都直接或间接地继承了java.lang.Object类
    C. 在子类的构造方法中，必须显式调用父类的构造方法
    D. 在子类的构造方法中，可以通过super关键字调用父类的构造方法

13. 下列关于final的说法错误的是 C
    A. final修饰的变量值不允许被修改
    B. final修饰的方法不可被重写
    C. final可以修饰所有方法
    D. final不可以修饰构造方法

二、编程题
1.某公司要开发“XX车行管理系统”，请使用面向对象的思想，设计自定义类描述自行
车、电动车和三轮车。
程序参考运行效果图如下：

任务分析；
第一步：分析自行车、电动车和三轮车的共性：
都是非机动车，具有非机动车的基本特征
都有运行的方法
第二步：根据共性，定义非机动车
属性：品牌、颜色、轮子(默认2个)、座椅（默认 1个）
方法：
编写无参构造方法、双参构造方法和四参构造方法，其中，在双参构造方法中，完成对品牌和
颜色的赋值；在四参构造方法中，完成对所有属性的赋值
编写运行的方法，描述内容为：这是一辆颜色的，牌的非机动车，有个轮子，有个座椅
的非机动车。其中的数据由属性提供
第三步：定义自行车、电动车和三轮车分别继承自行车类，要求：
自行车类：
在构造方法中调用父类多参构造，完成属性赋值
重写运行方法，描述内容为：这是一辆颜色的，牌的自行车。其中的数据由属性提供
电动车：
增加“电池品牌”属性
重写运行方法，描述内容为：这是一辆使用牌电池的电动车。其中的数据由属性提供
三轮车：
在无参构造中实现对轮子属性值进行修改
重写运行方法，描述内容为：三轮车是一款有个轮子的非机动车。其中的数据由属性提供

父类


自行车类

电动车类

三轮车类

测试类

2.请使用面向对象的思想，设计自定义类Person继承Object类，重写toString方法实现对象信息输
出。
运行效果如下图所示：

思路分析
创建一个 Person 类继承自 Object，其中类的结构要求为：
属性：name（姓名）、age(年龄)、sex（性别）
方法：
创建带参（name、age、sex为参数）构造方法
重写 toString 方法，输出信息格式为：姓名：** 年龄：** 性别：（其中，为对象对应
属性值）
创建测试类，在测试方法中，实例化 Person对 象，并传入三个属性值。然后，分别通过直接
打印Person对象以及利用重写的 toString 方法，打印输出2行对象信息。


3.请使用面向对象的思想，实现杨梅和仙人蕉的信息描述。
程序参考运行效果图如下：

思路分析：
1、根据杨梅和香蕉的共性，抽取父类水果（Fruits）
私有属性：水果的形状（shape）和口感（taste）
方法：
带参构造函数（参数为shape和taste）
创建无参无返回值得方法eat（描述内容为：水果可供人们食用！）
重写equals方法，比较两个对象是否相等（比较shape，taste）
2、子类Waxberry
私有属性：颜色（color）
方法：
调用父类的构造方法，完成属性赋值
创建不允许重写的face方法，描述为：杨梅：、，果味酸甜适中。
重写父类eat方法，描述为：杨梅酸甜适中，非常好吃！
重写toString方法，输出的表现形式不同（输出shape,color,taste）
要求Waxberry类不允许有子类
3、子类：Banana
私有属性：品种（variety）
方法：
带参构造方法为所有属性赋值
创建无参无返回值的advantage方法，描述为：果形,果肉香甜，可供生食。
重载要求(2)中的advantage方法（带参数color），描述为：颜色为
4、测试，运行效果参照效果图：
实例化2个父类对象，并传入两组相同的参数值
调用父类eat方法
测试重写equals方法，判断两个对象是否相等
实例化子类Wacberry对象，并传入相关参数值
调用子类face方法和重写父类eat方法后的eat方法
测试重写toString方法，输出子类对象的信息
实例化Banana类对象，并传入相关参数值
调用子类的advantage和它的重载方法

父类

Waxberry类

Banner类

test类