1.
写出程序结果
class Demo
{
public static void func()//throws Exception//此处应该声明异常//2步
{
try
{
throw new Exception();//3步
}
finally
{
System.out.println("B");
}
}
public static void main(String[] args)
{
try
{
func();//1步
System.out.println("A");//第4步
}
catch(Exception e)//第5步
{
System.out.println("C");
}
System.out.println("D");//第6步
}
}
执行结果:
编译失败:未声明异常
如果func函数上声明了该异常。结果是?B C D
如果func函数上加上了声明了该异常,执行过程是:
1,执行主函数的 第1步 ,
2,执行到第2步,
3,执行到第3步,抛出异常对象,执行finally里面的语句,输出B
4,因为第3步抛出异常对象,所以System.out.println("A");语句是执行不到的
5,执行第5步,处理异常,执行catch块里的语句
6,最后执行第6步
====================================================================
2.
写出程序结果
class Test
{
Test()
{
System.out.println("Test");//2步//5步
}
}
class Demo extends Test
{
Demo()
{
//super();//这里有隐式的super();语句,
System.out.println("Demo");//3步
}
public static void main(String[] args)
{
new Demo();//1步
new Test();//4步
}
}
执行结果:
Test
Demo
Test
考的子类的实例化过程。
分析:继承当中的构造函数,在调用子类构造函数的时候,默认会先执行父类的构造函数,
然后再执行子类的构造函数,即子类构造函数中的第一行默认都有隐式super();
这也就导致了,当执行到Demo()方法的时候,会等待,会去先执行Test()构造方法,
然后再回来执行Demo()方法。
第4步,new父类对象,就直接走父类的构造方法。
====================================================================
3.
写出程序结果
interface A{}
class B implements A
{
public String func()
{
return "func";
}
}
class Demo
{
public static void main(String[] args)
{
A a=new B();
System.out.println(a.func());
}
}
执行结果:
编译失败:因为A接口中并未定义func方法。
分析:多态,父类引用执行子类对象,此时父类引用只能使用父类中已经定义的方法、成员,
无法访问子类中特有的成员方法、成员,而func()方法是子类中特有的方法,所以
父类引用不能使用该方法,父类引用要想使用子类中特有的成员方法、变量必须强壮之后
才能使用-----B a1 = (B)a;这样a1就能调用子类方法了
====================================================================
4.
写出程序结果
class Fu
{
boolean show(char a)
{
System.out.println(a);
return true;
}
}
class Demo extends Fu
{
public static void main(String[] args)
{
int i=0;
Fu f=new Demo();//1步//show方法不是构造方法,所以show在执行的时候看子类的show方法,子类重写了父类方法,执行子类show方法
Demo d=new Demo();//2步
for(f.show('A'); f.show('B')&&(i<2);f.show('C'))//3步//4步
{
i++;
d.show('D');
}
}
boolean show(char a)
{
System.out.println(a);
return false;
}
}
执行结果:
A B
分析:
1,多态,父类引用执行子类对象,new子类对象自动时,默认初始化成员----注意:创建对象的时候,只默认初始化成员变量、构造方法,不包括普通方法,构造方法是new对象的时候自动调用,但是普通方法是什么使用调用,什么时候才执行
2,子类,new对象
3,f.show('A');f是父类引用指向了子类对象,子类中重写了show方法,所以执行子类中的show方法。输出打印‘A’,并返回false
4,f.show('B');和第三步分析的一样,也是执行子类当中的show方法,所以输出打印‘B’,并返回false
f.show('B')&&(i<2),&&右边的就不用看了,左边返回的是false,那么整体这个条件表达式的结果就是false,所以不符合执行for循环条件,执行结束!
====================================================================
5.
写出程序结果
interface A{}
class B implements A
{
public String test()
{
return "yes";
}
}
class Demo
{
static A get()
{
return new B();
}
public static void main(String[] args)
{
A a=get();
System.out.println(a.test());
}
}
编译失败,因为A接口中没有定义test方法。
分析:
多态,父类引用执行子类对象,所以也就是说a只能调用父类中的方法,(补充:父类中的方法是所有表现形态子类中的公共部分的抽取)
不能调用子类Demo中特有的方法,要想调用子类中特有的方法必须强制类型转换 Demo c = (Demo)a;
====================================================================
6.
写出程序结果:
class Super
{
int i=0;
public Super(String a)
{
System.out.println("A");
i=1;
}
public Super()
{
System.out.println("B");
i+=2;
}
}
class Demo extends Super
{
public Demo(String a)
{
//super();
System.out.println("C");
i=5;
}
public static void main(String[] args)
{
int i=4;
Super d=new Demo("A");
System.out.println(d.i);
}
}
执行结果:B C 5
考察:继承中的多态
====================================================================
7.
interface Inter
{
void show(int a,int b);
void func();
}
class Demo
{
public static void main(String[] args)
{
//补足代码;调用两个函数,要求用匿名内部类
/*Inter in = new Inter()
{
public void show(int a,int b)
{
}
public void func()
{
}
};
in.show(4,5);
in.func();
*/ //注释部分为不足代码部分
}
}
====================================================================
8.
写出程序结果
class TD
{
int y=6;
class Inner//内部类
{
static int y=3;//定义了静态方法
void show()
{
System.out.println(y);
}
}
}
class TC
{
public static void main(String[] args)
{
TD.Inner ti=new TD().new Inner();
ti.show();
}
}
编译失败,非静态内部类中不可以定义静态成员。
内部类中如果定义了静态成员,该内部类必须被静态修饰。
====================================================================
9.
选择题,写出错误答案错误的原因,用单行注释的方式。
class Demo
{
int show(int a,int b){return 0;}
}
下面那些函数可以存在于Demo的子类中。
A.public int show(int a,int b){return 0;}//可以,覆盖。
B.private int show(int a,int b){return 0;}//不可以,权限不够。
C.private int show(int a,long b){return 0;}//可以,和父类不是一个函数。没有覆盖,相当于重载。
D.public short show(int a,int b){return 0;}//不可以,因为该函数不可以和给定函数出现在同一类中,或者子父类中。既不符合重写,也不符合重载
E.static int show(int a,int b){return 0;}//不可以,静态只能覆盖静态。
====================================================================
10.
写出this关键字的含义,final有哪些特点?
this:代表本类对象,哪个对象调用this所在函数,this就代表哪个对象。
final:
1,修饰类,变量(成员变量,静态变量,局部变量),函数。
2,修饰的类不可以被继承。
3,修饰的函数不可以被覆盖。
4,修饰的变量是一个常量,只能赋值一次。
5,内部类只能访问局部当中的final修饰变量
|