选择题

1.A

2.A（首先调用父类的构造方法再调用子类的构造方法）

3.D（Base base=new Child（）强制向上转型，则base对象不存在child类的MethodB（）方法）

4.AB

1. C：abstract类的方法不存在方法体
2. D：abstract类只可以被子类继承，也只允许子类实现，自己本身不可以实例化对象

5.AD

1. 对于B选项：在接口中，final可以用来修饰接口变量，但是不可以修饰接口方法，接口的方法必须被实现

简答题

访问权限

修饰符	同一个类	同一个包	子类	所有类
private	可以
default	可以	可以
protected	可以	可以	可以
public	可以	可以	可以	可以

访问控制符的作用是提高安全性，通过访问控制符将数据的访问权限降低至最低。

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

解答：调用子类的构造器时，super会先调用父类的无参构造器，如果没有明确的构造函数，那么就会调用Object类的无参构造器；执行的顺序是从父类到子类。

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

解答：假设存在一个cat是animal的子类，animal a=new cat(); ，那么向下转型，就是子类cat向父类animal进行转型。向上转型后，父类引用变量（a）只可以使用它编译类型的方法，也就是说不存在cat类的方法，存在animal的方法。

Object obj= new String("hello");//向上转型为Object类型
String str = (String) obj;//这就是向下转型String类型

但是向下转型存在一个问题：在向下转型的过程中，必须将引用变量转成真实的子类类型（运行时类型），否则为显示转换类型错误（ ClassCastException）。

这句话的意思就是说：并不是所有的类型都可以向下转型，如果试图将一个父类实例转换为子类类型时，则这个实例对象必须是实际上为子类的实例才可以。

public class xxx {
    public static void main(String age[]){
        Object obj = new String("tzc");
        //这里obj对象实际上为String类型的实例，但是被强制转换为Object类型
        if(obj instanceof String){
        //intanceof来判断obj是否为String的实例对象
            String str=(String)obj;
            System.out.println("1");
        }
        //这里就不执行
        else if( obj instanceof  StringBuffer){
            StringBuffer str = (StringBuffer) obj;
            System.out.println("22");
        }
    }

4.final和abstract的作用

（一）final关键字

（1）修饰变量：被修饰的变量不可以进行修改；更不可以重新赋值
（2）修饰方法：方法不可以被重写，但是允许重载
（3）修饰类：修饰的类不可以继承

（二）abstract关键字

（1）修饰方法：修饰的方法只有声明，没有方法体；这样的方法被称为“抽象方法”
（2）抽象类：包括抽象方法的类叫做“抽象类”。
（3）抽象定义的只是一种“规范”

注意

1. 存在抽象方法的类只允许定义为抽象类
2. 抽象类不可以实例化，但是允许被继承（只能被继承）
3. 抽象类可以存在属性、方法、和构造器，但是构造器不可以实例化对象，只允许被子类调用
4. 抽象类必须被子类实现

5.==和equals（）的区别

区别：一是在于==如果是数值类型则判断数值是否相等，如果是引用类型，那么则是判断地址是否相等。equals方法默认的是判断两个对象的hashcode（具体暂时不清楚…）,但是equals方法是允许重写的。
例如：

class person{
    int id;
    public boolean equals(Object obj){
        if(obj==null) return false;
        if (obj instanceof person){
            person c = (person)obj;
            if(c.id==this.id) return true;
        }
    return false;
    }
}

编码题

1.编写一个圆类Circle

1. 一个成员变量：radius（私有，浮点型，存放半径的数据）
2. 两个构造方法（有参数，无参数）
3. 三个成员方法（求圆的面积、周长、输出圆的周长和面积到屏幕）

class Circle2{
    private float radius;
    public Circle2(){
        System.out.println("无参构造Circle2类。。。。。");
    }
    public Circle2(float radius){
        this.radius=radius;
    }
    public double getArea(float radius){
        return 3.14*radius*radius;
    }
    public double getPerimeter(float radius){
        return 2*3.14*radius;
    }
    public void  show(float radius){
        System.out.println(getArea(radius)+"//"+getPerimeter(radius));
    }
}

2.编写一个圆柱体类Cylinder，继承上面Circle类

1. 存在一个成员变量，圆柱体的高，double hight（私有，浮点型）
2. 构造器
3. 成员方法：获取圆柱体的体积，将圆柱体的体积输出到屏幕

class Cylinder extends Circle2 {
    private double height;
    public Cylinder(){
        System.out.println("无参构造圆柱体类");
    }
    public Cylinder(double height){
        this.height=height;
    }
    //圆柱体积
    public double getVolume(double height,float radius){
        return height*getArea(radius);
    }
    public void ShowCylinder(double height,float radius){
        System.out.println("体积为："+getVolume(height,radius));
    }
    public static void main(String args[]){
       Cylinder c = new Cylinder();
       c.ShowCylinder(2,3);
    }
}

3.编写程序实现乐手弹奏音乐

1. 定义乐器类Instrument，包括方法makeSound()
2. 定义乐器的子类：二胡，钢琴，小提琴
3. 定义乐手类Musician，可以弹奏各种乐器play（Instrument i）
4. 定义测试类，给乐手不同的乐器让他演奏

//乐器类
class Instrument {
    public void makeSound(){
        System.out.println("演奏中......");
    }
}
//乐器类的子类，继承了父类“乐器类”的所有方法
class Erhu extends Instrument{
    @Override
    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("小提琴演奏中......");
    }
}
//乐手类
public class Musician {
    public void play(Instrument i){
        i.makeSound();
    }
    public static void main(String args[]){
        //创建子类二胡实例化对象;e是ErHu类的实例化对象，向上转型为Instrument类，对ErHu类的引用
        Instrument e = new Erhu();
        //创造乐手实例化对象
        Musician m = new Musician();
        m.play(e);
    }
}

4.影、视、歌全方位艺人

interface movie{
    void yinShi();
}
interface video{
    void dianShi();
}
interface music{
    void sing();
}

class Actor implements video,movie,music{
    public void yinShi(){
        System.out.println("我在演电影");
    }
    public void dianShi(){
        System.out.println("我在演电视剧");
    }
    public void sing() {
        System.out.println("我在唱歌");
    }
}

public class user {
    public static void main(String args[]){
        Actor u = new Actor();
        System.out.println("大家好，我是谭子成");
        u.yinShi();
        u.sing();
        u.dianShi();
    }
}