学习大数据的第12天——继承的小练习
-
以下关于继承条件下构造方法执行过程的代码的执行结果是（ 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. 没有结果输出 -
以下关于this和super关键字的说法错误的是（ C D ）。（选择二项）
A. this关键字指向当前对象自身，super关键字指向当前对象的直接父类
B. 在main方法中(不)可以存在this或super关键字，但不能同时存在。
C. this和super关键字都可以访问成员属性，成员方法和构造方法
D. 在一个类的构造方法中可以同时使用this和super来调用其他构造方法 -
给出下面的代码段，在代码说明//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) -
以下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( );
}
}
static A
static B
I’m A class
HelloA
I’m B class
HelloB
-
下列选项中关于Java中super关键字的说法正确的是（ AB ）。（选择二项）
A super关键字是在子类对象内部指代其父类对象的引用
B. super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
C. 子类通过super关键字只能调用父类的方法，而不能调用父类的属性
D. 子类通过super关键字可以调用父类的构造方法
二、判断题
1.如果定义一个类时没有使用extends，则它的父类是java.lang.Object。（ T ）
2.对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类实例变量的初始化，则子类可以继承超类的构造函数。（ F ）
3.在Java中任何一个子类的构造方法都必须调用其父类的构造方法（包括隐式调用），并且调用父类的构造方法的语句必须是子类构造方法的第一条语句。（ T ）
4.Java中的类不允许多重继承，一个类只能有有一个直接父类。（T)
5.Object类有一个public方法是toString( )，一个对象通过调用该方法可以获得该对象的字符串表示。（ T ）
6.父类Person中定义了一个private void show()的方法，那么子类要重写这个方法时，方法的访问修饰符可以是默认的，protected或public。（ F ）
7.运算符“==”用于比较引用时，如果两个引用指向内存同一个对象，则返回true。（ T ）???题目什么意思
三、简答题
1.方法重载和方法重写（覆盖）的区别。
重载：在同一个类中，方法名相同，参数列表不同，返回值无关
重写：前提得有继承，子类对付类的方法重写，方法相同（方法名相同、参数列表相同、返回值一样）、方法体中的内容不同。重载的英文单词：overload
重写的英文单词：override
2.继承条件下子类构造方法的执行过程
1、栈开辟空间
2、堆开辟空间给对象
3、成员变量的值是系统默认值
4、成员变量显示赋值
5、父类的构造方法赋值
6、子类的构造方法赋值
3.super关键字的作用和使用
1、调用父类的成员（成员变量、成员方法、构造方法）
2、Super.成员变量、super.方法名(参数列表)
4.和equals()的联系和区别
比较对象不同
首先了解基础数据类型和引用类型：
八大基础数据类型：Byte、short、int、long、double、float、boolean、char
引用类型主要是一些类、接口、数组
引用类型变量中存储的是地址，对应的地址存储数据
”“：== 在基本数据类型：值内容, 引用类型时：地址
equals 重写：值内容 ， 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（） //将圆柱体的体积输出到屏幕
*/
class Circle {
private double radius;
Circle() {
}
public Circle(double radius) {
this.radius = radius;
}
public double getArea() {
return 3.14 * radius * radius;
}
public double getPerimeter() {
return 2 * 3.14 * radius;
}
public void show(double area, double perimeter) {
System.out.println("该圆的半径为：" + radius + "，面积为：" + area + "，周长为：" + perimeter);
}
}
class Cylinder extends Circle {
private double hight;
public Cylinder(double radius, double hight) {
super(radius);
this.hight = hight;
}
public double getVolume() {
return super.getArea() * hight;
}
public void showVolume() {
System.out.println("该圆柱体的体积为：" +getVolume());
}
}
public class zy1 {
public static void main(String[] args) {
Cylinder c = new Cylinder(2,6);
c.showVolume();
c.show(c.getArea(),c.getPerimeter());
}
}
/*
2.请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。
设定
1)出租车类:
属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2)家用轿车类：
属性包括：车型，车牌，车主姓名；方法包括：启动，停止
要求
1)分析出租车和家用轿车的公共成员，提取出父类—汽车类
2)利用继承机制，实现出租车类和家用轿车类
3)编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法
4)定义名为car的包存放汽车类，出租车类，家用轿车类和测试类
运行效果
*/
class Car {
private String model;
private String plate;
Car() {
}
Car(String model, String plate) {
this.model = model;
this.plate = plate;
}
public void start() {
}
public void stop() {
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public String getPlate() {
return plate;
}
public void setPlate(String plate) {
this.plate = plate;
}
}
class Taxi extends Car {
private String company;
public Taxi(String model, String plate, String company) {
super(model, plate);
this.company = company;
}
@Override
public void start(){
System.out.println("类型位："+getModel()+"，车牌号位："+getPlate()+"，所属的出租车公司："+company+"的车子启动了");
}
@Override
public void stop(){
System.out.println("类型位："+getModel()+"，车牌号位："+getPlate()+"，所属的出租车公司："+company+"的车子停止了");
}
}
class Familycar extends Car {
private String name;
public Familycar(String model, String plate, String name) {
super(model, plate);
this.name = name;
}
@Override
public void start(){
System.out.println("类型位："+getModel()+"，车牌号位："+getPlate()+"，车主姓名为："+name+"的车子启动了");
}
@Override
public void stop(){
System.out.println("类型位："+getModel()+"，车牌号位："+getPlate()+"，车主姓名为："+name+"的车子停止了");
}
}
public class zy2 {
public static void main(String[] args) {
Taxi t1 = new Taxi("奔驰","皖A1253","海马");
t1.start();
t1.stop();
Familycar f1 = new Familycar("宝马","皖A1254","尚志恒");
f1.start();
f1.stop();
}
}
/*
3.某公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精
设定
1)蛇怪类:
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）
2)蜈蚣精类：
属性包括：怪物名字，生命值，攻击力
方法包括：攻击，移动（飞行移动）
要求
1)分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类
2)利用继承机制，实现蛇怪类和蜈蚣精类
3)攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力
4)编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法
5)定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类
运行效果
*/
class Monster {
//怪物名字
private String name;
//生命值
private int lifevalue;
//攻击力
private int aggressivity;
public Monster(String name, int lifevalue, int aggressivity) {
this.name = name;
this.lifevalue = lifevalue;
this.aggressivity = aggressivity;
}
public void Attack() {
System.out.println("怪物名字为：" + name + "，血量为：" + lifevalue + "，攻击力为：" + aggressivity + " 正在攻击");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getLifevalue() {
return lifevalue;
}
public void setLifevalue(int lifevalue) {
this.lifevalue = lifevalue;
}
public int getAggressivity() {
return aggressivity;
}
public void setAggressivity(int aggressivity) {
this.aggressivity = aggressivity;
}
}
class Snake extends Monster {
public Snake(String name, int lifevalue, int aggressivity) {
super(name, lifevalue, aggressivity);
}
public void move() {
System.out.println("怪物名字为：" + getName() + "，血量为：" + getLifevalue() + "，攻击力为：" + getAggressivity() + " 正在曲线移动");
}
public void Replenishblood() {
if (getLifevalue() < 10) {
int life = getLifevalue();
life = life + 20;
setLifevalue(life);
System.out.println("小东西，俺老"+getName()+"已经加血完成了，你要没了！！");
}else{
System.out.println("小东西你的伤害很低，怪物很健康！！");
}
}
}
class Centipede extends Monster {
public Centipede(String name, int lifevalue, int aggressivity) {
super(name, lifevalue, aggressivity);
}
public void move() {
System.out.println("怪物名字为：" + getName() + "，血量为：" + getLifevalue() + "，攻击力为：" + getAggressivity() + " 正在飞行移动");
}
}
public class zy3 {
public static void main(String[] args) {
Snake s1 = new Snake("红🐍",100,5);
s1.move();
s1.Attack();
Centipede c1 = new Centipede("巨型蜈蚣怪",150,10);
c1.move();
c1.Attack();
Snake s2 = new Snake("蓝🐍",8,5);
s2.Replenishblood();
s2.Attack();
}
}
/*
1.请用面向对象的思想，设计自定义类描述演员和运动员的信息
设定
1)演员类:
属性包括：姓名，年龄，性别，毕业院校，代表作
方法包括：自我介绍
2)运动员类：
属性包括：姓名，年龄，性别，运动项目，历史最好成绩
方法包括：自我介始
要求
3)分析演员和运动员的公共成员，提取出父类—人类
4)利用继承机制，实现演员类和运动员类
5)编写测试类，分别测试人类，演员类和运动员类对象及相关方法
6)定义名为act的包存人类，演员类，运动员类和测试类
*/
class Mankind {
private String name;
private int age;
private String sex;
public Mankind(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = 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 void Introduction() {
}
}
class Actor extends Mankind {
private String colleges;
private String work;
public Actor(String name, int age, String sex, String colleges, String work) {
super(name, age, sex);
this.colleges = colleges;
this.work = work;
}
@Override
public void Introduction() {
System.out.println("姓名：" + getName() + "，年龄：" + getAge() + "，性别：" + getSex() + "，毕业院校：" + colleges + "，代表作：" + work);
}
}
class Player extends Mankind {
private String project;
private int bestresults;
public Player(String name, int age, String sex, String project, int bestresults) {
super(name, age, sex);
this.project = project;
this.bestresults = bestresults;
}
@Override
public void Introduction() {
System.out.println("姓名：" + getName() + "，年龄：" + getAge() + "，性别：" + getSex() + "，运动项目：" + project + "，历史最好成绩：" + bestresults);
}
}
public class zy4 {
public static void main(String[] args) {
Actor actor1 = new Actor("尚志恒", 18, "女", "合肥学院", "没有代表作");
actor1.Introduction();
Player player1 = new Player("叶哲良", 20, "男", "标枪", 100);
player1.Introduction();
}
}
扫一扫
33万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
