继承作业
继承作业
一、 选择题
1. |
以下关于继承条件下构造方法执行过程的代码的执行结果是（ a ）。（选择一项） |
|
|
class Person { public Person() { System.out.println("execute Person()"); } } class Student extends Person { public Student() { System.out.println("execute Student() "); } } class PostGraduate extends Student { public PostGraduate() { System.out.println("execute PostGraduate()"); } } public class TestInherit { public static void main(String[] args) { new PostGraduate(); } } |
|
|
|
|
|
A. |
execute Person() execute Student() execute PostGraduate() |
|
B. |
execute PostGraduate() |
|
C. |
execute PostGraduate() execute Student() execute Person() |
|
D. |
没有结果输出 |
2. |
以下关于this和super关键字的说法错误的是（ b,d ）。（选择二项） |
|
|
|
|
|
A. |
this关键字指向当前对象自身，super关键字指向当前对象的直接父类 |
|
B. |
在main方法中可以存在this或super关键字，但不能同时存在。 |
|
C. |
this和super关键字都可以访问成员属性，成员方法和构造方法 |
|
D. |
在一个类的构造方法中可以同时使用this和super来调用其他构造方法 |
3. |
给出下面的代码段，在代码说明//assignment x=a,y=b处写入如下（ d ）个代码是正确的。（选择一项） |
|
|
public class Base { int w, x, y, z; public Base(int a, int b) { x = a; y = b; } public Base(int a, int b, int c, int d) { // assignment x=a,y=b w = d; z = c; } } |
|
|
|
|
|
A |
Base(a,b); |
|
B. |
x=a,y=b; |
|
C. |
this(a),this(b); |
|
D. |
this(a,b); |
4. |
以下Java程序编译运行后的输出结果是（ a ）。（选择一项） |
|||
|
class HelloA { public HelloA( ) { System.out.println("HelloA"); } { System.out.println("I'm A class"); } static { System.out.println("static A"); } } public class HelloB extends HelloA { public HelloB( ) { System.out.println("HelloB"); } { System.out.println("I'm B class"); } static { System.out.println("static B"); } public static void main(String[] args) { new HelloB( ); } } |
|||
|
|
|
||
|
A |
static A static B I'm A class HelloA I'm B class HelloB |
C. |
static A I'm A class HelloA static B I'm B class HelloB |
|
B. |
static A static B I'm A class I'm B class HelloA HelloB |
D |
static A static B HelloA HelloB I'm A class I'm B class |
5. |
下列选项中关于Java中super关键字的说法正确的是（ a,d ）。（选择二项） |
|
|
|
|
|
A |
super关键字是在子类对象内部指代其父类对象的引用 |
|
B. |
super关键字不仅可以指代子类的直接父类，还可以指代父类的父类 |
|
C. |
子类通过super关键字只能调用父类的方法，而不能调用父类的属性 |
|
D. |
子类通过super关键字可以调用父类的构造方法 |
二、 判断题
1. 如果定义一个类时没有使用extends，则它的父类是java.lang.Object。（ dui ）
2. 对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类实例变量的初始化，则子类可以继承超类的构造函数。（ cuo ）
3. 在Java中任何一个子类的构造方法都必须调用其父类的构造方法（包括隐式调用），并且调用父类的构造方法的语句必须是子类构造方法的第一条语句。（ cuo ）
4. Java中的类不允许多重继承，一个类只能有有一个直接父类。dui
5. Object类有一个public方法是toString( )，一个对象通过调用该方法可以获得该对象的字符串表示。（dui ）
6. 父类Person中定义了一个private void show()的方法，那么子类要重写这个方法时，方法的访问修饰符可以是默认的，protected或public。（ cuo ）
7. 运算符“==”用于比较引用时，如果两个引用指向内存同一个对象，则返回true。（ dui ）
三、 简答题
1. 方法重载和方法重写（覆盖）的区别。：
2. 答：方法的重载是在同一个类内进行的，多个方法名一样，参数个数或参数类型不同；方法的重写是在子类继承父类时子类方法对父类方法进行重写，重写时方法名和参数相同，子类方法访问权大于父类，子类异常大于父类异常，但返回类型比父类方法小或相同。
java.lang.Object类的六个常用方法的声明并说明其作用。:clone() 创建并返回此对象的一个副本。 equals() finalize() hashCode() toString(); 用于比较两个对象是否指向同一块内存区域，相当于==运算符。(注意：在String类中，已将该方法改写比较字符串内容是否相同)； hashCode():返回该对象的哈希码值(整数)，用于标识一个对象，如果两个对象相等，则哈希码值一定相同；
toString():返回值是String类型，描述当前对象的有关信息，当对象与String型数据的连接时，自动调用其toString()方法。
finalize():当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法
getClass(): 返回此 Object 的运行时类。
3.
4. 继承条件下子类构造方法的执行过程：
5. ：先调用super来实例父类对象
6. super关键字的作用和使用
7.
8. ==和equals()的联系和区别：
1，基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean
他们之间的比较，应用双等号（==）,比较的是他们的值。
2.复合数据类型(类)
当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。
四、 编码题
1. 编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）
提示:（1）编写一个圆类Circle，该类拥有：
1) 一个成员变量，radius（私有，浮点型）;//存放圆的半径；
2) 两个构造方法
Circle（） //将半径设为0
Circle（double r ） //创建Circle对象时将半径初始化为r
3) 三个成员方法
double getArea（） //获取圆的面积
double getPerimeter（） //获取圆的周长
void show（） //将圆的关径、周长、面积输出到屏幕
（2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：
1) 一个成员变量，double hight （私有，浮点型）; //圆柱体的高；
2) 构造方法
//创建Cylinder对象时将半径初始化为r,高度初始化为h
Cylinder（double r,double h）
3) 成员方法
double getVolume（） //获取圆柱体的体积
void showVolume（） //将圆柱体的体积输出到屏幕
package cn.lineration;
public class Circle {
public float radius;//圆的半径
Circle(){
this.radius=0;
}
Circle(double r){
this.radius=(float)r;
}
public double getArea(){
return 3.14*(radius*radius);
}
public double getPerimeter(){
return 2*radius;
}
public void show(){
System.out.println("圆的面积是: "+getArea());
System.out.println("圆的周长是: "+getPerimeter());
}
}
package cn.lineration;
public class Cylinder extends Circle {
private double hight;//float
Cylinder(double r,double h){
this.radius=(float)r;
this.hight=h;
}
double getVolume(){
return 3.14*this.radius*this.radius*this.hight;
}
void showVolume(){
System.out.println("圆柱体的体积是: "+getVolume());
}
}
package cn.lineration;
public class TestCircle {
public static void main(String[] args) {
Cylinder c=new Cylinder(4,2);
c.show();
c.showVolume();
}
}
2. 请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。
设定
1) 出租车类:
属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2) 家用轿车类：
属性包括：车型，车牌，车主姓名；方法包括：启动，停止
要求
1) 分析出租车和家用轿车的公共成员，提取出父类—汽车类
2) 利用继承机制，实现出租车类和家用轿车类
3) 编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法
4) 定义名为car的包存放汽车类，出租车类，家用轿车类和测试类
运行效果
package cn.car;
public class PrivateCar extends Car{
private String owner;
void start(){
System.out.println("我是武大郎,我的车我做主");
}
void stop(){
System.out.println("目的地到了,我们去玩吧");
}
}
package cn.car;
public class Texi extends Car{
private String company;
void printSuper(){
super.start();
super.stop();
}
void start(){
System.out.println("乘客您好\n我是景顺出租车公司的,我的车牌号是京B123,您要去哪里?");
}
void stop(){
System.out.println("目的地已经到了,请您付费下车,欢迎再次乘车");
}
}
package cn.car;
public class Car {
private String type;
private long carNum;
void start(){
System.out.println("我是车,我启动");
}
void stop(){
System.out.println("我是车,我停止");
}
}
package cn.car;
public class TestCar {
public static void main(String[] args) {
PrivateCar p=new PrivateCar();
Texi t=new Texi();
t.printSuper();
System.out.println("================================");
p.start();
p.stop();
System.out.println("================================");
t.start();
t.stop();
}
}
3. 某公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精
设定
1) 蛇怪类:
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）
2) 蜈蚣精类：
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（飞行移动）
要求
1) 分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类
2) 利用继承机制，实现蛇怪类和蜈蚣精类
3) 攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力
4) 编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法
5) 定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类
运行效果
package mon;
public class Basilisk extends Monster{
Basilisk(String name,
double lifeValue,
double aggressivity){
this.name=name;
this.lifeValue=lifeValue;
this.aggressivity=aggressivity;
}
public void move(){
System.out.println("我是"+this.name+",我走S型路线");
}
}
package mon;
public class CentipedeExtract extends Monster{
CentipedeExtract(String name,double lifeValue,double aggressivity){
this.name=name;
this.lifeValue=lifeValue;
this.aggressivity=aggressivity;
}
public void move(){
System.out.println("我是"+this.name+",御风飞行");
}
}
package mon;
public class TestMonster {
public static void main(String[] args) {
Monster b=new Basilisk("蛇妖甲",24,20);
b.attack();
b.enrichBlood();
b.move();
System.out.println("=========================");
b=new CentipedeExtract("蜈蚣乙",60,15);
b.attack();
b.move();
}
}
package mon;
public class Monster {
String name;
double lifeValue;
double aggressivity;
public void attack(){
System.out.println("怪物"+this.name+"展开攻击\n当前生命值是: "+
this.lifeValue+"\n攻击力是: "+this.aggressivity);
}
public void enrichBlood(){
if(this.lifeValue<10){
this.lifeValue+=20;
}else{
this.lifeValue++;
}
System.out.println("实施大蛇补血术。。。。。，当前生命值是: "+this.lifeValue);
}
public void move(){}
}
五、 可选题
1. 请用面向对象的思想，设计自定义类描述演员和运动员的信息
设定
1) 演员类:
属性包括：姓名，年龄，性别，毕业院校，代表作
方法包括：自我介绍
2) 运动员类：
属性包括：姓名，年龄，性别，运动项目，历史最好成绩
方法包括：自我介始
要求
3) 分析演员和运动员的公共成员，提取出父类—人类
4) 利用继承机制，实现演员类和运动员类
5) 编写测试类，分别测试人类，演员类和运动员类对象及相关方法
6) 定义名为act的包存人类，演员类，运动员类和测试类
运行效果
package act;
public class Person {
private String name;
private int age;
private String gender;
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 getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public void introduce(){
System.out.println("我就是一个普通老百姓");
}
}
package act;
public class Athlete extends Person{
private String sportEvent;
private String bestScore;
Athlete(String sportEvent,String bestScore){
this.sportEvent=sportEvent;
this.bestScore=bestScore;
}
public void introduce(){
System.out.println("大家好,我是"+this.getName()+"\n今年"+this.getAge()+
"\n我擅长的运动项目是: "+this.sportEvent+"\n历史最好成绩是: "+this.bestScore);
}
}
package act;
public class Actor extends Person {
private String graUni;
private String representiveWork;
Actor(String graUni,String representiveWork){
this.graUni=graUni;
this.representiveWork=representiveWork;
}
public void introduce(){
System.out.println("大家好,我是"+this.getName()+"\n今年"+this.getAge()+
"\n我毕业于: "+this.graUni+"\n代表作有: "+this.representiveWork);
}
}
package act;
public class TestAct {
public static void main(String[] args) {
Person a=new Person();
a.introduce();
System.out.println("=========================");
Person b=new Athlete("200米短跑","22秒30");
b.setName("刘小祥");
b.setAge(23);
b.introduce();
System.out.println("=========================");
b=new Actor("北京电影学院","<寄往舔过的家书>");
b.setName("章依");
b.setAge(27);
b.introduce();
}
}
继承作业答案
一、 选择题
1. A
2. BD
3. D
4. A
5. AD
二、 判断题
1. √
2. ×
3. ×
4. √
5. √
6. ×
7. √
8. ×
三、 简答题
答案略
四、 编码题
1. 编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）
提示:（1）编写一个圆类Circle，该类拥有：
1) 一个成员变量，radius（私有，浮点型）;//存放圆的半径；
2) 两个构造方法
Circle（） //将半径设为0
Circle（double r ） //创建Circle对象时将半径初始化为r
3) 三个成员方法
double getArea（） //获取圆的面积
double getPerimeter（） //获取圆的周长
void show（） //将圆的关径、周长、面积输出到屏幕
（2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：
1) 一个成员变量，double hight （私有，浮点型）; //圆柱体的高；
2) 构造方法
//创建Cylinder对象时将半径初始化为r,高度初始化为h
Cylinder（double r,double h）
3) 成员方法
double getVolume（） //获取圆柱体的体积
void showVolume（） //将圆柱体的体积输出到屏幕
public class Circle {
private double radius;
public Circle(){ //将半径设为0
this.radius = 0;
}
public Circle(double r ){ //创建Circle对象时将半径初始化为r
this.radius = r;
}
public double getArea(){ //获取圆的面积
return Math.PI * this.radius * this.radius ;
}
public double getPerimeter(){//获取圆的周长
return Math.PI * this.radius * 2 ;
}
/** 将圆的面积 ,周长 */
public void show(){
System.out.println("圆的半径:"+this.radius);
System.out.println("圆的面积:"+this.getArea());
System.out.println("圆的周长:"+this.getPerimeter());
}
}
public class Cylinder extends Circle {
private double hight;
/** 构造时设置圆的高，并调用父类的构造设置半径 */
public Cylinder(double r,double h){
super(r);
this.hight = h;
}
/** 获得体积 */
public double getVolume(){
double area = super.getArea();
return area * hight;
}
/**打印半径，周长，面积，体积*/
public void showVolume(){
super.show();
System.out.println("圆的体积是："+this.getVolume());
}
}
public class Test {
public static void main(String[] args) {
Cylinder c = new Cylinder(10,10);
c.showVolume();
}
}
2. 请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。
设定
1) 出租车类:
属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2) 家用轿车类：
属性包括：车型，车牌，车主姓名；方法包括：启动，停止
要求
1) 分析出租车和家用轿车的公共成员，提取出父类—汽车类
2) 利用继承机制，实现出租车类和家用轿车类
3) 编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法
4) 定义名为car的包存放汽车类，出租车类，家用轿车类和测试类
运行效果
public class Car {
private String type;
private String carNo;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getCarNo() {
return carNo;
}
public void setCarNo(String carNo) {
this.carNo = carNo;
}
public void start(){
System.out.println("我是车，我启动");
}
public void stop() {
System.out.println("我是车，我停止");
}
}
public class FamilyCar extends Car {
private String owner;
public FamilyCar(String owner) {
this.owner = owner;
}
public void start() {
System.out.println("我是"+owner+"，我的汽车我做主");
}
public void stop() {
System.out.println("目的地到了，我们去玩吧");
}
}
public class TaxiCar extends Car {
private String company;
public TaxiCar(String company) {
this.company = company;
}
public void start() {
System.out.println("乘客您好\n我是"+this.company+
"的，我的车牌号是"+this.getCarNo()+"，你要去那里？");
}
public void stop() {
System.out.println("目的地已经到了，请您下车付款，欢迎再次乘坐");
}
}
public class Test {
public static void main(String[] args) {
Car c = new Car();
c.start();
c.stop();
System.out.println("===========================");
FamilyCar fc = new FamilyCar("武大郞");
fc.start();
fc.stop();
System.out.println("============================");
TaxiCar tc = new TaxiCar("景顺出租公司");
tc.setCarNo("京B123");
tc.start();
tc.stop();
}
}
3. 某公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精
设定
1) 蛇怪类:
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）
2) 蜈蚣精类：
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（飞行移动）
要求
1) 分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类
2) 利用继承机制，实现蛇怪类和蜈蚣精类
3) 攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力
4) 编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法
5) 定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类
运行效果
//妖怪类
public class Monster {
private String name;//怪物名
private int hp;//血量
private int aggressivity;//攻击力
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
public int getAggressivity() {
return aggressivity;
}
public void setAggressivity(int aggressivity) {
this.aggressivity = aggressivity;
}
/** 攻击 */
public void attack() {
System.out.println("怪物"+this.getName()+"展开攻击");
System.out.println("当前生命值："+this.getHp());
System.out.println("攻击力是："+this.getAggressivity());
}
/** 移动 */
public void move() {
}
}
/** 怪蛇类 */
public class Snake extends Monster {
/** 加血 */
public void addHp(){
this.setHp(this.getHp()+20);
System.out.println("实施大蛇补血术......，当前的生命值是"+this.getHp());
}
/** 重写父类的移动方法*/
public void move() {
System.out.println("我是蛇，我走S线路");
}
}
/** 蜈蚣类 */
public class Centipede extends Monster {
/** 重写父类的移动方法*/
public void move() {
System.out.println("我是蜈蚣精，我御风飞行");
}
}
public class Test {
public static void main(String[] args) {
Snake sn = new Snake();//生产一个蛇精
sn.setName("怪蛇甲");
sn.setHp(5);
sn.setAggressivity(20);
sn.attack();//调用攻击方法
if(sn.getHp()<10){//当生命少于10时，加20血
sn.addHp();
}
sn.move();//蛇移动
System.out.println("======================");
Centipede ct = new Centipede();//new一个蜈蚣
ct.setName("蜈蚣精乙");
ct.setHp(60);
ct.setAggressivity(15);
ct.attack();//蜈蚣攻击
ct.move();
}
}
五、 可选题
1. 请用面向对象的思想，设计自定义类描述演员和运动员的信息
设定
1) 演员类:
属性包括：姓名，年龄，性别，毕业院校，代表作
方法包括：自我介绍
2) 运动员类：
属性包括：姓名，年龄，性别，运动项目，历史最好成绩
方法包括：自我介始
要求
3) 分析演员和运动员的公共成员，提取出父类—人类
4) 利用继承机制，实现演员类和运动员类
5) 编写测试类，分别测试人类，演员类和运动员类对象及相关方法
6) 定义名为act的包存人类，演员类，运动员类和测试类
运行效果
public class Person {
//姓名，年龄，性别
String name;
int age;
String sex;
public Person(){}
public Person(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
//介绍
public void introduction(){
System.out.println("大家好，我是一个老百姓");
}
}
public class Sportsman extends Person{//运动员类
private String item;
private String bestResult;
public Sportsman(){}
public Sportsman(String name,int age,String sex,String item,String best) {
super(name,age,sex);
this.item = item;
this.bestResult = best;
}
public void introduction() {
System.out.println("大家好，我是"+this.name);
System.out.println("今年"+this.age);
System.out.println("我擅长的项目是："+this.item);
System.out.println("历史最好成绩是："+this.bestResult);
}
}
public class Performer extends Person {//演员类
private String school;//学校
private String production;//作品
public Performer(){}
public Performer(String name,int age,String sex,String school,String pro) {
super(name,age,sex);
this.school = school;
this.production = pro;
}
public void introduction() {
System.out.println("大家好，我是"+this.name);
System.out.println("今年"+this.age);
System.out.println("我毕业于："+this.school);
System.out.println("代表作有："+this.production);
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
p.introduction();
System.out.println("==============");
Sportsman sm = new Sportsman("刘小翔",23,"男",
"200米短跑","22秒30");
sm.introduction();
System.out.println("==============");
Performer pf = new Performer("章依",27,"女","北京电影学院",
"《寄往天国的家书》");
pf.introduction();
}
}