2016.6.10自学笔记(异常、类的练习题)

这门课被空置了好久，来做几个练习复习一下罢工之前的知识——异常和匿名类。

1.写出程序结果:

 class Demo{

   public static void func(){

     try{

       throw new Exception();

     }

     finally

     {

        System.out.println("B");

     }

}

public staticvoid main(String[] args){

  try{

  func();

  System.out.println(“A”);

}

catch(Exception e){

  System.out.println(“C”)

}

System.out.println(“D”)

}

  }

  由于抛出了一个异常但是没有处理，即如果func方法放上声明了该异常，结果是？B C D所以编译失败。

2.写出程序结果:

  class Test{

  Test(){

  System.out.println(“Test”);

}

}

class Demoextends Test{

  Demo(){

  super();

  System.out.println(“Demo”);

}

public staticvoid main(String[] args){

  new Demo();

  new Test();

}

}

子类的实例化过程，所以结果是：

Test

Demo

Test

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方法是子类特有的，而建立对象的话是建的父类对象。(编译看父类，运行看子类)

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();

     Demo d = new Demo();

     for(f.show('A');f.show('B')&&(i<2);f.show('C')){

       i++;

       d.show('D');

     }

    }

   boolean show(char a){

     System.out.println(a);

     return false;

    }

  }

  结果:A

      B

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的get()方法中，返回的是一个B类的对象，因为A接口中没有定义test方法，所以在编译的时候不会通过。

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){

     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().newInner();

  ti.show();

}

}

编译失败。非静态内部类不能定义静态成员。内部类中如果定义了静态成员，该内部类必须被静态修饰。

9.选择题，写出错误答案错误的原因，用单行注释的方式。

 class Demo{

  int show(int a,int b){return0;}

}

下面哪些函数可以存在于Demo的子类中。

A.    public int show(int a,int b){return0;}//可以，覆盖。

B.     private int show(int a,int b){return0;}//不可以，权限不够。

C.     private int show(int a,long b){return0;}//可以，和父类里不是一个函数，并不是覆盖，相当于重载。

D.    public short show(int a,int b){return0;}//不可以，因为该函数不可以和给定函数出现在同一类中，或者子父类中。

E.     static int show(int a,int b){return0;}//不可以，静态只能覆盖。

10.写出this关键字的含义，final有哪些特点？

this：代表本类对象，哪个对象调用this所在函数，this就代表哪个对象。

final:1.修饰类，变量(成员变量,静态变量,局部变量),函数.

2.修饰的类不可以被继承。

3.修饰的函数不可以被覆盖。

4.修饰的变量是一个常量，只能赋值一次。

 

OK，今天的练习就先做到这了，这几天帮着家里收水果，耽误了学习，浓浓的负罪感啊，我会在今后的生活中补回来的。