Java继承题目练习

最新推荐文章于 2024-04-09 19:20:58 发布

别总想着静静

最新推荐文章于 2024-04-09 19:20:58 发布

阅读量3k

点赞数 6

文章标签： java object

本文链接：https://blog.csdn.net/xdh1996/article/details/107511799

版权

一、选择

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

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

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

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

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

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

在下面程序的注释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; }

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

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

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

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

关于super的说法正确的是 C

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

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

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

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

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

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

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

该段代码的运行结果为

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

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

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

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

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

二、编程

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

任务
任务分析；
第一步：分析自行车、电动车和三轮车的共性：

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

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

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

自行车类：

在构造方法中调用父类多参构造，完成属性赋值
重写运行方法，描述内容为：这是一辆**颜色的，**牌的自行车。其中**的数据由属性提供

电动车：

增加“电池品牌”属性
重写运行方法，描述内容为：这是一辆使用**牌电池的电动车。其中**的数据由属性提供

三轮车：

在无参构造中实现对轮子属性值进行修改
重写运行方法，描述内容为：三轮车是一款有**个轮子的非机动车。其中**的数据由属性提供

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());
	}
}

请使用面向对象的思想，设计自定义类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());
	}
}

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

思路分析：
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和它的重载方法

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("黄色");
	}

}

别总想着静静

关注

6
点赞
踩
30

收藏

觉得还不错? 一键收藏
0
评论
Java继承题目练习

一、选择在Java中，以下程序的输出结果是A A. Super-->printB. Test-->printC. Super-->print Test-->printD. 编译错误在Java中，以下关于方法重载和方法重写描述正确的是B A. 方法重载和方法重写实现的功能相同B. 方法重载出现在父子关系中，方法重写是在同一类中C. 方法重载的返回类型必须一致，参数项必须不同D. 方法重写需要出现在满足继承关系的子类中哪个选项中的方..
复制链接

扫一扫