java6题库

1. 

void notifyAll()

解除所有那些在该对象上调用wait方法的线程的阻塞状态。该方法只能在同步方法或同步块内部调用。如果当前线程不是锁的持有者，该方法抛出一个 IllegalMonitorStateException异常。


void notify()


随机选择一个在该对象上调用wait方法的线程，解除其阻塞状态。该方法只能在同步方法或同步块内部调用。如果当前线程不是锁的持有者，该方法抛出一个I llegalMonitorStateException异常。


void wait()


导致线程进入等待状态，直到它被其他线程通过notify()或者notifyAll唤醒。该方法只能在同步方法中调用。如果当前线程不是锁的持有者，该方法抛出一个 IllegalMonitorStateException异常。


void wait(long millis)和void wait(long millis,int nanos)


导致线程进入等待状态直到它被通知或者经过指定的时间。这些方法只能在同步方法中调用。如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException 异常。

Object.wait()和Object.notify()和Object.notifyall()必须写在synchronized方法内部或者synchronized块内部，这是因为：这几个方法要求当前正在运行object.wait()方法的线 程拥有object的对象锁。即使你确实知道当前上下文线程确实拥有了对象锁，也不能将object.wait()这样的语句写在当前上下文中。

2.

Runnable r = newRunnable() {
public voidrun() {
System.out.print("Cat");
}
};
Thread t = newThread(r) {
public voidrun() {
System.out.print("Dog");
}
};
t.start();

输出dog

3.

     抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。原因如下：抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个吧方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？

接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用，因为接口可以让所有的类去实现（非继承），不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。

       private方法不能被继承

	由于子类不能窄化接口 (里氏代换原则)
	父类public  子类不能变protected  private
	父类 protected  子类不能 private  但是能够往上提升成public

        java类中成员缺省的修饰符是不写修饰符，理解为friendly(default)，拥有的权限是包权限。
       成员变量或成员方法声明为默认权限，则其是包级可见，同一个包内的类可以访问到这个属性或方法。若是类声明为默认权限，则同一个包下的类                                       都可以访问到该类，并可以实例化该类（当然如果这个类不具有实例化的能力除外，比如该类没有提供public的构造函数）


Java权限有四个，分别为public,protected,默认,private，其开放程度依次降低
public可供所有类访问
protected继承可见
private只能类本身内部的方法可以访问

4.定义变量不能使用$和~

5.

	public enumTitle {
12. MR("Mr."), MRS("Mrs."), MS("Ms.");
13.  private finalString title;
14.  privateTitle(String t) { title = t; }
15.  publicString format(String last, String first) {
16.  returntitle + " " + first + " " + last;
17. }
18. }
public static voidmain(String[] args) {
System.out.println(Title.MR.format("Doe", "John"));
}

输出Mr John Doe

6.

    接口中的成员变量只能使用public ，static，final来修饰

7.静态的方法必须引用静态的成员变量

8.垃圾回收

       classSnoochy {
Boochy booch;
publicSnoochy() { booch = newBoochy(this); }
}
classBoochy {
Snoochy snooch;
publicBoochy(Snoochy s) { snooch = s; }
}
And the statements:
public static voidmain(String[] args) {
Snoochy snoog = newSnoochy();
snoog = null; //Línea 23
// more code here
}

都会回收Snoochy，Boochy

9.

if(i=5)
	{
		
	}

错误

10.

   static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

11.

           switch的case不要忘写break；

12.

          	 如何理解Exception,Error和Throwable 
    		Throwable是Exception和Error的父类. 
  	  	Error表示错误，一般是系统级的错误！ 
     		Exception一般是程序运行期间的错误！ 
    
    	通常在使用  try{}catch(Exception e){} 这种结构的时候,只能找到一半的错误，也就是说只能捕获Exception范围内的异常 并处理使得程序能够正	常运行.而Error范围内的错误就无法捕获并处理. 
  	 通过 try{}catch(Throwable a){} 的方式能够处理，但是一般情况下不这样做。 
   原因在于查看Error下面的子类，VirtualMachineError，ThreadDeath，LinkageError，从名字上看出来这些错误都是非常非常严重的，到底是否需要去捕获或者处理呢? 
   
    Error的产生一般是JVM或者是操作系统的问题，JAVA 文档中对Error的说明是:"Error是Throwable的子类，它的出现说明出现了严重的问题。一般应用程序除非有理由，否则不应该捕捉Error,通常这是非常反常的情况". 


    Exception的产生主要是在程序运行期间发生的一些不正常事件中止了程序的运行，可以通过JAVA异常处理机制捕获异常并处理，使得程序正常运行下去。这些异常（不正常事件）有别于Error错误,它们通常是可修复的，程序员可以处理的。 


2.运行时异常和受检查异常 
    1)运行时异常,属于RuntimeException类及子类范围的类（以及衍生类）都属于运行时异常。 
     2)受检查异常,在Exception范围内,除了运行时异常的类都是受检查异常类,为checked exception 
    3)它们之间的区别在于: 例如在代码中写了 throw new Exception(); 和 throw new RuntimeException(); 
  
    两者都会在运行期间抛出异常！ 
     但是在编译阶段前者的属于抛出一个受检查异常，要求对它进行显式的try..catch 捕获处理或者向上一层方法抛出,否则在编译期间就显示错误！ 
     后者抛出是运行时异常，在编译阶段不予检查,语法上不会显示任何错误！ 
     所以简单的通过throw手动抛出受检查异常 和抛出运行时异常，前者要求显式处理，后者不要求作出处理。 
  3.throw 和throws的区别 
    1)throw 是手动抛出异常,throw new **Exception(); 抛出的是某一个异常类型的实例. 
    2)throws 是方法抛出异常,写在方法声明处 public void show()throws **Exception,**Exception{} 紧跟throws后的是异常类型，而非异常实例,且可以声明抛出多个异常,同时这些异常类型大多都为 受检查异常类型。 
     3)throw 是程序员手动抛出异常，一般可用在某种流程控制，需要显示操作失误情况下可对外抛出异常，进入catch代码块，明示操作有误等。 
     throws 方法抛出异常，通常是告知调用此方法者，本方法有可能抛出一个异常，在调用时应当要进行异常监控。且因为throws方法抛出异常为受检查异常类型，这样就从语法上要求更需要对受检查异常类型作出捕获，或者再次向上抛出。 

    因为方法声明出 throws ClassNotFoundException 就告诉了方法调用者 本方法有可能会发生 ClassNotFoundException 异常，因为需要在调用此方法时格外注意。且此异常类型是受检查类型，那么在编译阶段就更要求用户调用时必须加上 try..catch(){}语句块，或者再次往上方法声明抛出 ClassNotFoundException 交由上层方法声明抛出 。 

7.静态变量的初始化

     Java静态变量的初始化（static块的本质）
在网上看到了下面的一段代码：
public class Test {   
    static {   
         _i = 20;   
     }   
    public static int _i = 10;   
       
    public static void main(String[] args) {   
         System.out.println(_i);   
     }   
}  
public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }
上述代码会打印出什么结果来呢？10还是20？本文将以此代码为引子，着重讨论一下静态变量的初始化问题。
问题1：静态变量如何初始化
Java类中可以定义一个static块，用于静态变量的初始化。如：
public class Test {   
    public static int _i;   
    static {   
         _i = 10;   
     }   
}  
public class Test { public static int _i; static { _i = 10; } }
当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：
public class Test {   
    public static int _i = 10;   
}  
public class Test { public static int _i = 10; }
那么上述两例在本质上有什么区别吗？回答是没有区别。两例代码编译之后的字节码完全一致，通过 “javap -c”查看到的字节码如下：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
}
通过字节码还可以看出，当类的定义中不含有static块时，编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前 提下。如果静态变量没有初始化操作，则编译器不会为之提供默认的static块。如：
public class Test {   
    public static int _i;   
}  
public class Test { public static int _i; }
其字节码的表现形式为：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
}
由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：
public class Test {   
    public static int _i = init();   
       
    private static int init() {   
        return 10;   
     }   
}  
public class Test { public static int _i = init(); private static int init() { return 10; } }
其本质与下面的代码相同：
public class Test {   
    public static int _i;   
    static {   
         _i = init();   
     }   
       
    private static int init() {   
        return 10;   
     }   
}  
public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }
问题2：JDK如何处理static块
类定义中可以存在多个static块吗？回答是可以。如：
public class Test {   
    public static int _i;   
    static {   
         _i = 10;   
     }   
       
    public static void main(String[] args) {   
     }   
       
    static {   
         _i = 20;   
     }   
}  
public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }
此类编译之后的字节码为：
public class Test extends java.lang.Object{
public static int _i;
public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
public static void main(java.lang.String[]);
Code:
0: return
static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return
}
观察static{}部分可以看出，上例的代码与下面的代码效果一致：
public class Test {   
    public static int _i;   
       
    public static void main(String[] args) {   
     }   
       
    static {   
         _i = 10;   
         _i = 20;   
     }   
}  
public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }
此例可以证明，不仅类定义中可以有多个static块，而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static 块。
问题3：如何看待静态变量的声明
静态变量存放在常量池之中。如何证明呢？如：
public class Test {   
    public static int _i = 10;   
}  
public class Test { public static int _i = 10; }
使用“javap -c -verbose”查看其字节码的内容如下：
public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;
{
public static int _i;


public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable: 
line 2: 0
static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable: 
line 3: 0
}
我们看到，常量池中const #2指向的就是Test._i，也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是：
静态变量的声明与初始化是两个不同的操作；
静态变量的声明在编译时已经明确了内存的位置。
如：
public class Test {   
    public static int _i = 10;   
}  
public class Test { public static int _i = 10; }
上述代码的本质可以视为：
public class Test {   
    // 静态变量的声明   
    public static int _i;   
  
    // 静态变量的初始化   
    static {   
         _i = 10;   
     }   
}  
public class Test { // 静态变量的声明 public static int _i; // 静态变量的初始化 static { _i = 10; } }
由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：
public class Test {   
    // 静态变量的初始化   
    static {   
         _i = 10;   
     }   
       
    // 静态变量的声明   
    public static int _i;   
}  
public class Test { // 静态变量的初始化 static { _i = 10; } // 静态变量的声明 public static int _i; }
对初始问题的解答
解答了上述三个问题，让我们再来看看开篇提到的问题。代码如下：
public class Test {   
    static {   
         _i = 20;   
     }   
    public static int _i = 10;   
       
    public static void main(String[] args) {   
         System.out.println(_i);   
     }   
}  
public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }
其本质可以用下面的代码表示：
public class Test {   
    static {   
         _i = 20;   
     }   
    public static int _i;   
    static {   
         _i = 10;   
     }   
       
    public static void main(String[] args) {   
         System.out.println(_i);   
     }   
}  
public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }
再简化一下，可以表示为：
public class Test {   
    public static int _i;   
       
    static {   
         _i = 20;   
         _i = 10;   
     }   
       
    public static void main(String[] args) {   
         System.out.println(_i);   
     }   
}  
public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }
至此，代码已经明确告诉我们打印结果是什么了！
引用出处：http://hi.baidu.com/suofang/blog/item/362d4ea77fa5c099d14358cf.html
一个类的静态变量只会在类的字节码文件加载完后初始化一次，当new一个新的对象时，则不会再初始化这个静态变量，例：
package study;


public class TT2 {
private  TT1 tt=new TT1();
private  static TT1 tt2=new TT1();
public static void main(String[] args) {
TT2 t1=new TT2();
TT2 t2=new TT2();
System.out.println(t1.tt==t2.tt);
System.out.println(t1.tt2==t2.tt2);
System.out.println(t1.tt2);
t2.tt2=new TT1();
System.out.println(t1.tt2==t2.tt2);
System.out.println(t1.tt2);
}
output：
false 
        true 
        study.TT1@c17164 
        true 
        study.TT1@1fb8ee3

9.

        static int[] a;

         static{

                 a=new int[2];

            }正确

     但是static{

             a[0]=1;错误

           }