1.写出程序结果:
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();
Demo d=new Demo();
for(f.show('A');f.show('B');f.show('C')){
i++;
d.show('D');
}
}
boolean show(char a){
System.out.println(a);
return false;
}
}
运行结果:
for循环的表达式:
for(表达式1;表达式2;表达式3){
表达式4;
}
执行的顺序为:
1)第一次循环(初始化循环):1-2-4-3
首先执行表达式1(一般为初始化语句),再执行表达式2(一般为条件判断语句),判断表达式1是否符合表达式2的条件,如果符合,则执行表达式4再执行表达式3,否则停止执行。
2)下次的循环:2-4-3
首先执行表达式2,判断表达式3是否符合表达式2的条件;如果符合,继续执行表达式4,否则停止执行,最后执行表达式3.如果往复,直到表达式3不再满足表达式2的条件。
总结:总的来说,执行顺序是一致的,先进行条件判断(表达式2),再执行函数体(表达式4),最后执行表达式3。如此往复,区别在于,条件判断的对象,在第一次判断时,是执行表达式1,初始化对象,后续的判断对象是执行后的结果(表达式3)。
2.写出程序结果:
interface A
{
}
class B implements A
{
public String test(){
return "yes";
}
}
class Demo
{
static A get (){ //编写一个返回值类型为A的方法get,即返回A类型的B对象。
return new B();
}
public static void main(String[] args){
A a=get(); //多态,父类引用子类对象
System.out.println(a.test());
}
}
运行结果:编译失败,接口A中没有定义test方法。
3.写出程序结果:
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)
{
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);
}
}
运行结果:
- 根据子类的实例化过程,子类中所有的构造函数默认都会访问父类中空参数的构造函数。因为每一个构造函数的第一行都有一条默认的语句super()。
- 所以Demo构造函数会先访问super();即打印B,父类i变为2。
- 父类初始化之后,到子类初始化,所以打印C并且i从2变为5。
4.补足代码:
interface Inter
{
void show(int a,int b);
void func();
}
class Demo
{
public static void main(String[] args){
//补足代码,调用两个函数,要求使用匿名内部类
}
}
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){
System.out.println(a+" "+b);
}
public void func(){
System.out.println("haha");
}
};
in.show(1,2);
in.func();
}
}
运行结果:
5.写出程序结果
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();
}
}
运行结果:编译失败。非静态内部类中不能定义静态成员。如果内部类中出现静态成员,则该内部类也必须被静态修饰。
6.写出错误答案错误的原因,用单行注释的方式。
class Demo{
int show(int a,int b);
}
public int show(int a,int b){return 0};
正确。覆盖。private int show(int a,int b){return 0};
错误。权限不够。private int show(int a,long b){return 0};
正确。参数类型不同,相当于重载。public short show(int a,int b){return 0;}
错误。函数返回值类型不同,不能存在于子类中,不然编译会报错。static int show(int a,int b){return 0};
错误。静态只能调用静态。
7.写出程序结果:
class Demo
{
public static void func(){
try{
throw new Exception();//抛出了异常,执行不到下面的语句
/*
改为showExce()不会出现编译错误;
即调用一个有可能出错的方法,但是也有可能没有出错(因为方法内的语句被封装无法知道),所以之后的语句也有可能可以执行。
*/
System.out.println("A");
}
catch(Exception e){
System.out.println("B");
}
}
public static void showExce() throws Exception{//声明可能会出现异常
throw new Exception(); //把抛出异常封装在方法当中,外部不了解内部情况
}
public static void main(String[] args){
try{
func();
}
catch(Exception e){
System.out.println("C");
}
System.out.println("D");
}
}
输出结果:编译失败
8.判断
class Demo
{
public void func(){
//位置1
new Inner();
}
class Inner
{
}
public static void main(String[] args){
Demo d= new Demo();
//位置2
}
}
- A.在位置1写 new Inner();//正确
- B.在位置2写 new Inner();//错误,主函数是静态的,所以如果内部类要被主函数调用需要static修饰
- C.在位置3写 new d.Inner();//错误,格式不正确。相当于new new Demo().Inner();应该为:d.new Inner()
- D.在位置4写 new Demo.Inner();//错误,Demo不是静态的。应该为:new Demo().new Inner();
9.补足代码:
interface Test
{
void func();
}
class Demo
{
public static void main(String[] args){
//补足代码;(匿名内部类)
}
void show(Test t){
t.func();
}
}
实现:
interface Test
{
void func();
}
class Demo
{
public static void main(String[] args){//主函数为静态,不能直接调用show()
new Demo().show(new Test()
{
public void func(){};
});
}
void show(Test t){
t.func();
}
}
- 因为主函数为静态的所以不能直接调用show方法,只能通过对象调用。即new Demo().show()
- 但是show方法里的参数是接口,所以需要传递一个接口类型的对象。我们看到接口只有一个方法,所以可以传匿名内部类。即new Demo().show(new Test(){});
- 再实现接口的func方法,就完成了对非静态函数show的调用:
new Demo().show(new Test()
{
public void func(){};
});
对于可以在主函数中通过对象调用非静态函数:
当类被加载的时候静态方法和静态属性(全局静态变量)被加载到内存中,但此时没有被实例化的类在内存中是不存在的,所以静态方法无法访问非静态的成员。在类被实例化的时候,在内存中会给这个类开辟一些内存空间保存这个类的对象,这个时候就可以用静态方法去访问非静态的全部变量。