Java300集-第五章面向对象进阶练习题及答案

最新推荐文章于 2023-06-16 19:52:41 发布

NQGL.

最新推荐文章于 2023-06-16 19:52:41 发布

阅读量337

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_45595929/article/details/129689258

版权

Java 专栏收录该内容

23 篇文章 1 订阅

订阅专栏

一、选择题

1.使用权限修饰符( )修饰的类的成员变量和成员方法，可以被当前包中所有类访问，也可以被它的子类(同一个包以及不同包中的子类)访问。(选择一项)

Apublic

B.protected

C.默认

D.private

B

2.以下关于继承条件下构造方法执行过程的代码的执行结果是( )。(选择一项)

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.没有结果输出

A. 子类的构造方法默认有一个super（）继承父类，若是构造方法的第一行代码没有显式的调用super(…)或者this(…);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略

3.编译运行如下Java代码，输出结果是( )。(选择一项)

class Base {
    public void method(){
        System.out.print ("Base method");
    }
}
class Child extends Base{   
    public void methodB(){
        System.out.print ("Child methodB");
    }
}
class Sample {
    public static void main(String[] args) {
        Base base= new Child();
        base.methodB();
    }
}

A.Base method

B.Child methodB

C.hild methodB

D.编译错误

D. 向上转型对象无法使用对象的新增方法,只能使用继承或重写的方法,看清题目是methodB() 如果是method（）则是继承中的父类引用指向子类对象

4.在Java中关于abstract关键字，以下说法正确的是( )。

A.abstract类中可以没有抽象方法

B.abstract类的子类也可以是抽象类

C.abstract方法可以有方法体

D.abstract类可以创建对象

C.

有抽象方法的类只能定义成抽象类 A错误
抽象类不能实例化，即不能用new来实例化抽象类。
抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。D错误
抽象类只能用来被继承。
抽象方法必须被子类实现。B错误

5.在Java接口中，下列选项中属于有效的方法声明是( )。(选择二项)

A.public void aMethod( );

B.final void aMethod( );

C.void aMethod();

D.private void aMethod( );

AC.
常量：接口中的属性只能是常量，总是：public static final 修饰。不写也是。
方法：接口中的方法只能是：public abstract。省略的话，也是public abstract。

二、简答题

1. private、默认、protected、public四个权限修饰符的作用。

private表示私有，只有自己的类能访问
默认（defualt）表示没有修饰符修饰，只有同一个包中的类能访问
protected表示可以被同一个包的类或者其他包的子类访问
public表示被该项目中的所有包中的所有类访问

2. 继承条件下子类构造方法的执行过程。

首先调用当前子类中的super()方法来调用对应的父类构造方法，一直追溯到Object类中的构造方法，然后再依次向下执行类中的初始化和构造方法。
父类非抽象类:调用父类的构造方法,然后调用子类自己的构造方法(如果有)；
父类为抽象类:(无参)调用父类的无参构造方法,然后调用自己的构造方法(如果有)；
(有参)子类显示申明调用父类的有参构造函数,然后在调用子类的构造方法(如果有)

3. 什么是向上转型和向下转型。

向上转型：父类引用指向子类对象
向下转型：指的是在向上转型中父类引用的变量只能调用它编译类型的方法，不能调用子类的属性和方法，此时转型叫向下转型
eg：向上转型： Person p = new Man() ; //向上转型不需要强制类型转化
向下转型： Man man = (Man)new Person() ; //必须强制类型转化

4. final和abstract关键字的作用。

final：用final修饰的变量不能被赋值，成为常量；用final修饰的方法不能被重写；被final修饰的类不能被继承
abstract：抽象类作用就是规范，模板，子类必须实现抽象类中的方法；抽象类中没有方法体，子类必须实现其方法体；拥有抽象方法的类必须是抽象类；抽象类不能实例化对象；抽象类中有属性、方法、构造方法，其中构造方法不能用new来实例，只能被子类调用。

5. ==和equals()的联系和区别。

“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。
“equals”默认就是比较两个对象的hashcode，是同一个对象的引用时返回true否则返回false，但是，我们可以根据自己的要求重写equals方法。

三、编码题

1. 编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。
实现思路及关键代码：

  1) 编写一个圆类Circle，该类拥有：

  a) 一个成员变量，radius(私有，浮点型);//存放圆的半径

  b) 两个构造方法(无参、有参);

  c) 三个成员方法

    double getArea() //获取圆的面积

    double getPerimeter() //获取圆的周长

    void show() //将圆的关径、周长、面积输出到屏幕

public class Circle {
    private double r ;   //圆的半径
    public void setR(double r) {
        this.r = r;
    }
    //
    public Circle(double r) {
        this.r = r;
    }
    public  Circle() {

    }

    //获取圆的面积
    public double getArea() {
        return Math.PI*Math.pow(r,2);
    }
    //获取圆的周长
    public double getPerimeter() {
        return 2*Math.PI*r;
    }
    //将圆的关径、周长、面积输出到屏幕
    public void show() {
        System.out.println("圆的半径："+r);
        System.out.println("圆的周长："+getPerimeter());
        System.out.println("圆的面积："+getArea());
    }
}

  2) 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：

  a) 一个成员变量，double hight (私有，浮点型); //圆柱体的高;

  b) 构造方法

  c) 成员方法

    double getVolume() //获取圆柱体的体积

    void showVolume() //将圆柱体的体积输出到屏幕

class Cylinder extends Circle {
    private double height;   //圆柱体的高
    public Cylinder(double r, double height) {
        super(r);
        this.height = height;
    }
    public Cylinder(){}
    public double getVolume() {
        return getArea()*height;
    }
    public void showVolume() {
        System.out.println("圆柱体的体积："+getVolume());
    }
}

测试：

public class Test01 {
    public static void main(String[] args) {
        Circle r = new Circle(2);
        Cylinder h = new Cylinder(2,4);

        r.show();
        h.showVolume();
    }
}

2. 编写程序实现乐手弹奏乐器。乐手可以弹奏不同的乐器从而发出不同的声音。可以弹奏的乐器包括二胡、钢琴和琵琶。

  实现思路及关键代码：

  1) 定义乐器类Instrument，包括方法makeSound();

  2) 定义乐器类的子类：二胡Erhu、钢琴Piano和小提琴Violin;

  3) 定义乐手类Musician，可以弹奏各种乐器play(Instrument i);

  4) 定义测试类，给乐手不同的乐器让他弹奏。

abstract class Instrument {
    abstract public void makeSound();
}
class Erhu extends Instrument {
    public void makeSound() {
        System.out.println("二月泉");
    }
}
class Piano extends Instrument {
    public void makeSound() {
        System.out.println("肖邦的夜曲");
    }
}
class Violin extends Instrument {
    public void makeSound() {
        System.out.println("爱的礼赞");
    }
}
class Musician {
    public void play(Instrument i) {
        i.makeSound();
    }
}

测试类：

public class Test2 {
    public static void main(String[] args) {
        Musician m = new Musician();
        m.play(new Erhu());
        m.play(new Piano());
        m.play(new Violin());
    }
}

3. 编写程序描述影视歌三栖艺人。需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。

  实现思路：

  1) 分析影视歌三栖艺人的特性：可以演电影，可以演电视剧，可以唱歌

  2) 定义多个接口描述特性

  a) 演电影的接口-----方法：演电影

  b) 演电视剧的接口-----方法：演电视剧

  c) 唱歌的接口-----方法：唱歌

  3) 定义艺人类实现多个接口

接口：

interface Movie {
    public abstract void playMovie();
}
interface Tvshow {
    public abstract void playTvshow();
}
interface Singer {
    public abstract void sing();
}

Actor：

public class Actor implements Movie,Tvshow,Singer{
    private String name;

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public  void introduction(){
        System.out.println("大家好，我是"+name);
    }
    public void playMovie() {
        System.out.println("我能拍电影");
    }
    public void playTvshow() {
        System.out.println("我能演电视剧");
    }
    public void sing() {
        System.out.println("我能唱歌");
    }
}

测试：

public class Test03 {
    public static void main(String[] args) {
        Actor actor = new Actor("XX");
        actor.introduction();
        actor.playMovie();
        actor.playTvshow();
        actor.sing();
    }
}