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修饰变量
|
收藏
淘帖
踩
