练习4/5（继承）Java

练习
一、选择

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

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后，以下结果描述正确的是 B

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

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

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

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

阅读下面JAVA代码片段，正确的选项是 B

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

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

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

该段代码的运行结果为 D

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个）
方法：

编写无参构造方法、双参构造方法和四参构造方法，其中，在双参构造方法中，完成对品牌和颜色的赋值；在四参构造方法中，完成对所有属性的赋值
编写运行的方法，描述内容为：这是一辆颜色的，牌的非机动车，有个轮子，有个座椅的非机动车。其中**的数据由属性提供

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

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

public class Car {// 非机动车的基本特征public String brand;public String color;public int wheel = 2;public int seat = 1;// 无参构造方法public Car() {}// 双参构造方法public Car(String brand, String color) {this.brand = brand;this.color = color;}// 四参构造方法public Car(String brand, String color, int wheel, int seat) {this.brand = brand;this.color = color;this.wheel = wheel;this.seat = seat;}// 描述车辆信息的方法public String info() {String information = "这是一辆" + this.color + "," + this.brand + "牌的非机动车，有" + this.wheel + "个轮子，有" + this.seat+ "个座椅的非机动车";return information;}
}

//自行车
public class Bike extends Car{public Bike(String brand, String color){super(brand,color);}public String info(){String information ="这是一辆"+this.color+","+this.brand+"牌的自行车";return information;}
}

//电动车
public class Electrocar extends Car {// 添加电池品牌属性public String battery;public Electrocar(String battery) {this.battery = battery;}public String info() {String information = "这是一辆使用" + this.battery + "电池的电动车";return information;}
}

//三轮车
public class Tricycle extends Car {// 无参构造中实现对轮子属性值进行修改public Tricycle() {super.wheel = 3;}public String info() {String information = "三轮车是一款有" + super.wheel + "个轮子的非机动车";return information;}
}

//测试类
public class Test {public static void main(String[] args) {System.out.print("父类信息测试：");Car car = new Car("天宇", "红", 4, 2);System.out.println(car.info());System.out.print("自行车类信息测试：");Bike bike = new Bike("捷安特", "黄");System.out.println(bike.info());System.out.print("电动车类信息测试：");Electrocar dd = new Electrocar("飞鸽");System.out.println(dd.info());System.out.print("三轮车类信息测试：");Tricycle ss = new Tricycle();System.out.println(ss.info());}
}

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

思路分析

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

public class Person {// 私有属性：name（姓名）、age(年龄)、sex（性别）private String name;private int age;private String sex;// 无参构造方法public Person() {}// 带参构造方法（name、age、sex为参数）public Person(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}// 通过封装实现对属性的get/set方法设定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;}// 重写toString方法，表示形式为：姓名：+**+ 年龄：+**+ 性别：+**public String toString() {return "姓名：" + getName() + "年龄:" + getAge() + "性别:" + getSex();}
}

public class Test {public static void main(String[] args) {// 实例化 Person对象Person lm = new Person("李明", 18, "男");// 打印输出对象信息System.out.println(lm);System.out.println(lm.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和它的重载方法

public class Fruits {// 私有属性：水果的形状（shape）和口感（taste）private String shape;private String taste;// 无参构造public Fruits() {}// 带参构造函数（参数为shape和taste）public Fruits(String shape, String taste) {this.shape = shape;this.taste = 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;}// 创建无参无返回值得方法eat（描述内容为：水果可供人们食用！）public void eat() {System.out.println("水果可供人们食用！");}// 重写equals方法，比较两个对象是否相等（比较shape，taste）public boolean equals(Object obj) {// 1. 首先判断传入的对象是否为nullif (obj == null) {// 如果是null则直接返回falsereturn false;} else {// 2. 接着判断两个对象中的属性值是否一致// 此时是引用数据类型的强制类型转换，形式也是类似于之前学习过的基本数据类型强制类型转换Fruits ff = (Fruits) obj;if (this.getShape().equals(ff.getShape()) && ff.getTaste().equals(ff.getTaste())) {return true;} else {return false;}}}
}

public class Waxberry extends Fruits {private String color;// get/set方法public String getColor() {return color;}public void setColor(String color) {this.color = color;}// 调用父类的构造方法，完成属性赋值public Waxberry(String shape, String taste, String color) {super(shape, taste);this.setColor(color);}// 创建不允许重写的face方法，描述为：杨梅：**、**，果味酸甜适中。public final String face() {return "杨梅：" + getColor() + "、" + getShape() + ",果味酸甜适中。";}// 重写父类eat方法，描述为：杨梅酸甜适中，非常好吃！public void eat() {System.out.println("杨梅酸甜适中，非常好吃！");}// 重写toString方法，输出的表现形式不同（输出shape,color,taste）public String toString() {return "杨梅的信息：果实为" + this.getShape() + "、" + this.getColor() + "," + this.getTaste() + ",非常好吃！";}
}

public class Banana extends Fruits {private String variety;public String getVariety() {return variety;}public void setVariety(String variety) {this.variety = variety;}// 无参构造方法public Banana() {}// 带参构造方法为所有属性赋值public Banana(String shape, String taste, String variety) {super(shape, taste);this.setVariety(variety);}// 创建无参无返回值的advantage方法，描述为：**果形**,果肉香甜，可供生食。public void advantage() {System.out.println(getVariety() + "果形" + getShape() + "，果肉香甜，可供生食。");}// 重载要求(2)中的advantage方法（带参数color），描述为：**颜色为**public void advantage(String color) {System.out.println(getVariety() + "颜色为" + color);}
}

public class Test {public static void main(String[] args) {// 实例化2个父类对象，并传入两组相同的参数值Fruits f1 = new Fruits("圆形", "果肉香甜");Fruits f2 = new Fruits("圆形", "果肉香甜");// 调用父类eat方法f1.eat();f2.eat();// 测试重写equals方法，判断两个对象是否相等boolean flag = f1.equals(f2);System.out.println("fru1和fru2的引用比较:" + flag);System.out.println("——————————————————————————————————————");// 实例化子类Wacberry对象，并传入相关参数值Waxberry wb = new Waxberry("圆形", "果味酸涩", "紫红色");// 调用子类face方法和重写父类eat方法后的eat方法wb.face();wb.eat();// 测试重写toString方法，输出子类对象的信息System.out.println(wb.toString());System.out.println("——————————————————————————————————————");// 实例化Banana类对象，并传入相关参数值Banana banana = new Banana("短而稍圆", "果肉香甜", "仙人蕉");// 调用子类的advantage和它的重载方法banana.advantage();banana.advantage("黄色");}
}

练习4/5（继承）Java相关推荐

继承 java 1614784316
继承 java 1614784316 生活中的继承程序中的继承父类的选择父类的抽象四个类有什么共性? 抽取后的结果共性的内容放在父类继承的语法继承的特点不可继承方法的覆盖
java线程如何继承,java多线程(一)之继承Thread类
一.概述进程:正在执行的应用程序线程:进程的执行单元,执行路径单线程:一个应用程序只有一条执行路径多线程:一个应用程序有多条执行路径二.两种实现方式, 下面为第一种方式: 继承Thread类 ...
java人学生大学生类的继承,java实验报告7.doc
java实验报告7.doc 实验报告( 2014 / 2015学年第2学期)课程名称JAVA程序设计实验名称类的继承实验时间2015年4月30日指导单位计算机学院/软件学院软件工程系指导教师 ...
js继承java方法吗_你知道JavaScript的继承吗？
导读: 在ES6 之前js中是并没有extends继承,就像是java的单继承继承,我们通过多实现的方法模拟java的多继承,所以我们也可以同通过,利用构造函数和原型对象实现来实现JavaScript ...
类之间的继承java,Java类与类之间的继承关系
Java父类与子类继承关系,调用的各种关系示例一(子类调用父类函数): // 定义一类 A public class A { // 此方法打印一句话 public void a() { System ...
JAVA 基础 / 第二十九课：接口与继承 / JAVA中的对象转型
2018-03-19 一.明确引用类型与对象类型的概念引用类型与对象类型的概念在这个例子里,有一个对象 new ADHero(), 同时也有一个引用ad 对象是有类型的, 是ADHero 引用也是 ...
每个java小应用程序都得继承,JAVA复习题3
23.容器JFrame及JPanel默认的布局管理器分别是() A.FlowLayout和GridLayout B.BorderLayout和FlowLayout C.FlowLayout和FlowL ...
java 实现类转接口_JAVA 基础 / 第二十九课：接口与继承 / JAVA中的对象转型
2018-03-19 一.明确引用类型与对象类型的概念引用类型与对象类型的概念在这个例子里,有一个对象 new ADHero(), 同时也有一个引用ad 对象是有类型的, 是ADHero 引用也是 ...
JAVA 基础 / 第二十九课：接口与继承 / JAVA 重写方法和多态
2018-03-19 子类可以继承父类的对象方法.在继承后,重复提供该方法,就叫做方法的重写:又叫覆盖 override 1.父类Item 父类Item有一个方法,叫做effect package p ...
java 单例继承,Java单例模式的讲解
1,单例模式的要素 1)私有构造方法. 2)public static synchronized的getInstance()方法. 上述2个要素虽然可以保证单例模式的实现,但并不是最好的方式.因为当我 ...

练习4/5（继承）Java

练习4/5（继承）Java相关推荐

最新文章

热门文章