09

A:简答题

1、什么是多态,多态的前提是什么?

多态是指一种事物在不同时刻所表现的不同状态，前提是继承

2、多态中成员(成员变量,成员方法,静态成员方法)的访问特点是什么?

多态形式来访问成员变量，编译看左边，运行也是看左边；

多态形式访问成员方法，如果子类有重写，编译看左边，运行看右边；

多态形式访问静态方法，静态方法不参与重写，调用的时父类的，与子类无关

3、多态的好处?

提高了代码的维护性和复用性；提高了代码的扩展性

4、多态的弊端是什么,如果我们想访问子类的特有的功能我们应该怎么办?

不能使用子类的特有功能，可以通过强制转型，通过向下转型把父类引用转化为子类型（Son son=(son)f）

5、抽象类是什么,抽象类的特点?

在JAVA中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。特点：被abstract关键字修饰，可以修饰类和方法；抽象类不一定有抽象方法，有抽象方法的类一定是抽象类；被abstract修饰的方法在子类中必须被重写；抽象类不能被实例化，抽象类的子类要么是抽象类要么就被重写

6、抽象类中有没有构造方法,如果有它是用来做什么的?

可以有构造方法，主要是用于子类访问父类数据时的初始化

7、接口中成员变量的特点,以及成员方法的特点?

接口中的成员变量是常量，并且是静态的；成员方法只能是抽象方法，具体的由子类去实现，；

8、请说出类与类,类与接口,以及接口与接口的关系以及特点?

类与类之间是继承关系，只支持单继承，但可以多层继承。类与接口是实现关系，可以单实现也可以多实现，并且还可以在继承一个类的同时实现多个接口；接口与接口是继承关系，并且可以多继承

9、抽象类和接口的区别?

抽象类中可以有非抽象方法，而接口中不能有非抽象方法； 抽象类中的成员变量可以是变量，也可以是常量。而接口中只能是常量；抽象类中有构造方法，接口中没有构造方法。

10、abstract不能和那些关键字共存,为什么?

abstract不能和final，互相矛盾，abstract强制子类重写，而final子类不能被重写；也不可以和private；被private修饰的子类无法继承也就不能被重写，static：静态方法不参与继承

13、请说说下面关键字分别是什么，有什么用?

private：修饰成员变量和成员方法，被修饰的成员变量和成员方法不能被继承

this：this代表本类的对象，谁调用就会代表谁

super：super代表父类的一个引用，可以通过super（），super.变量名。super（参数）来调用父类的数据

static：静态的，可以修饰成员变量和成员方法，修饰成员变量时，该变量为共享变量，该类的所有对象都可以调用，修饰成员方法时，方法中不能访问非静态变量，因为该方法优先于对象存在，静态方法不参与重写，可以通过类名.方法名调用该方法

final：可以修饰成员变量，局部变量，成员方法和类。修饰基本数据类型的变量时，该变量的值为常量，不能被改变，修饰引用数据类型时，指的时该变量的地址值不能被改变，修饰方法和类时，该方法或类可以被继承，但不能被重写

abstract：可以修饰类和方法，修饰类时，该类不能被实例化，可以通过子类访问父类的构造方法来完成父类数据的初始化，抽象类中可以定义成员变量，也可以定义常量，可以定义非抽象方法；修饰方法时，该方法不需要给出具体的实现，但在子类中必须要被重写

interface：定义接口，定义的都是一些扩展的功能，那些事物想要实现这写功能，需要实现该接口，接口中的成员变量是常量，并且是静态的；成员方法只能是抽象方法，接口不能创建对象 public interface 接口名{}

extends：继承，类和类之间产生耦合的关键字

implements：实现，和接口定义的类连接，来对一些额外的功能进行重写实现 类+implements+接口名{}

B:看程序写结果写出自己的分析理由，程序填空，改错，看程序写结果

1、给出以下代码，请问该程序的运行结果是什么？

interface Base {

**public static final int k = 0;//****静态常量

}

class Demo implements Base {

​ public static void main(String[] args) {

​ Demo d = new Demo();

​ System.out.println( d.k );

​ System.out.println( Demo.k );

​ System.out.println( Base.k );

​ }

}

结果：

0

0

0

**2、**给出以下代码，请问该程序的运行结果是什么？

class Super {

​ int index = 5;

​ public void printVal() {

​ System.out.println(“Super”);

​ }

}

class Sub extends Super {

​ int index = 2;

​ public void printVal(){

​ System.out.println(“Sub”);

​ }

}

class Demo {

​ public static void main(String[] args) {

​ Super sup = new Sub();

​ System.out.print(sup.index + “,”);

​ sup.printVal();

​ }

}

结果：5，Sub

**3、**给出以下代码，请问该程序的运行结果是什么？

class SuperEx {

String r;

String s;

public SuperEx(String a, String b) {

r = a;

s = b;

}

public void aMethod(){

System.out.println(“r:”+r);

}

}

class SubEx extends SuperEx {

public SubEx(String a, String b){

super(a, b);

}

public static void main(String[] args){

SuperEx a = new SuperEx(“Hi”, “Tom”);

SuperEx b = new SubEx(“Hi”, “Bart”);

**a.**aMethod();

**b.**aMethod();

}

public void aMethod(){

System.out.println(“r:”+r+“s:”+s);

}

}

结果：

r:Hi

r:His:Bart

**4、**给出以下代码，请问该程序的运行结果是什么？

class Demo {

public static void main (String[] args) {

Base b = new SubClass();

System.out.println(b.x);//

System.out.println(b.method() );//

}

}

class Base {

int x = 2;

int method(){

return x;

}

}

class SubClass extends Base {

int x = 3;

int method() {

return x;

}

}

结果：

2

3

**5、**给出以下代码，请问该程序的运行结果是什么？

class Demo extends SuperClass {

String s = “this”;

public static void main (String[] args) {

new Demo();

}

Demo(){

super.display();

}

void display(String s){

System.out.println("this: "+ s);

}

}

class SuperClass {

String s = “super”;

void display(String s){

System.out.println(“super:” + s);

}

}

运行错误