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);
}
}
运行错误