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

一、选择题

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.

1. 有抽象方法的类只能定义成抽象类 A错误
2. 抽象类不能实例化，即不能用new来实例化抽象类。
3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。D错误
4. 抽象类只能用来被继承。
5. 抽象方法必须被子类实现。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();
    }
}

程序运行结果如图所示：