【SCJP】J@Whiz1.4做题笔记

Test1：【2006.7.5】

1.assignment statement also has a value equal to the value being assigned.
2.Local variables are not initialized when they are instantiated at method nvocation.
3.The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls(null values and null key).
4.It is important to understand that the condition of assert statement must be a boolean, and not anything else;otherwise a compile time error occurs.
5.Do not use assertions for argument checking in public methods. Do not use assertions to do any work that your application requires for correct operation.
6.static initializers 不能在一个方法里面存在.可以把它看成一个方法，明显一个方法是不能在另一个方法里面定义的.So we can think a static initializers just a method which run exactly once,at class-loaded time.
7.同名local varibles 只能看到块外，不能看到块内，方向总是向外向上看(平级也看不到)。如若看到则视为重复，所以通常可以把同名local varibles放在块后面而不是前面。这些块（block） such as {},if{},while{},try{} and so on总之是有{}存在的地方.
8.一个void的方法里面可有return，但是一个不是void的方法却不能缺少return。
9.abstract方法必须定义在abstract类里面，在abstract类里面还可以有non-abstract方法，这样的方法不需要在subclass中实现。abstract类可以继承non-abstract类。
10.System.out.println方法argument可以是primitive variables and literrals（除byte，short），也可以是Object references，此时自动调用object.tostring()方法。此方法中的+运算符不能适用于未重载+运算符的两类型之间。如Integer+Integer,int+Integer.
11.boolean never take part in convertion or casting.
12.assert:true通过，false 抛出assertionError with a message of Expression2 if it exsits.
13.一个abstract class里面可以没有abstract method，但是只要有一个abstract method，class就必须declear为abstract 。
13.assertionError和runtimeException一样不需要catch，也就是说不需要用在try里面。
14.System.out.println方法argument和AssertionError constructor的argument一样：none，int，long，char，float，double，boolean and Object.
15.二维数组可以定义成：int[] array[] = new int[2][2];它的初始化可以只初始左边size，右边size在运行是判断是否初始化。如：
16.千万看清是"="还是"==",已经在这上面栽太多次了。
17.如果父类和子类都没有定义任何构造方法，则隐式调用了默认构造。如果父类定义了有参构造，那么在任何时候都必须在父类中定义Parent()，否则在子类中会出错.调用子类的构造方法必须在类中实现，即使Child()也是如此，必须在调用前定义。
18.调用yield()方法后，若是没>=当前优先级的thread处于ready状态的话，当前thread则立即重新运行。
19."hamburger".substring(4, 8) returns "urge"，所有的index指向的都是从左往右数index个数后，接下来的那个字符。
20.Every lable should be associated with a loop.
21.null是一个特殊的String可以用作Boolean的构造参数，返回false。其他warrper用null作构造参数时会抛出runtimeExcepion(NumberFormatException).

Test2：

inner class、method 和 staitc的关系总结：
1.访问变量：
static inner class 不能访问非静态的outer变量,跟静态方法类似（比如main方法中不能直接访问非静态member varibles）。构造必须是：new Outer.Inner(),而不是new Outer().new Inner().
2.修饰符：
static inner class只能用作member class，在method里面的inner class不能为static和public、private、protect。即使是在static method里面也不行（可以改成final）。
3.定义静态变量：
非static inner class中不能定义static varibles，只能在static inner class中才行。这种情况和一个非静态的方法类似，在一个非静态的方法中，不能定义静态的变量（而应改定义为final类型），只有在静态的方法中才能定义静态变量。
所以，总结以上可以知道：static varibles只能定在3种情况下：(1)class member varibles.(2)static inner class (3)static methods.除这三种外的任何情况都是非法。

Thread，Runnable
1.Thread的run方法不是abstrat，所以它的子类没有overridd run()的方法时，将调用Thread的run方法，这个方法不做任何事情。
2.任何implements Runnable的class都必须实现run方法，否则要在class前加上abstract标记，表示它还有事情没有完成。

overridd和modiffer
1、static：
static-->static(OK)、static-->nonstatic(error)、nonstatic-->static(error)
2、final
final、nonfinal-->nonfinal(error)、nonfinal-->final、nonfinal(OK)
3、syschronized
syschronized-->nonsynchronized(OK)、nonsynchronized-->synchonized(OK)、synchonized-->synchoinzed(OK)
4、native
native-->nonnative(OK)、native-->native(OK)、nonnative-->native(OK)
5、abstract
abstract方法不存在overrid，只是实现。
注：所有non-->non都OK

二维数组问题：
1.定义初始化：
int[] array[] = new int[2][2];它的初始化可以只初始左边size，右边size在运行是判断是否初始化。如：int[][] a = new int[10][].右边的可以单独初始化，并且长度可以不同，如array[1] = new int[1],array[0] =new int[2].所有element都自动初始化为0，不管在class里面还是method里面（这是数组的一个特性）。
2.print
println(array):乱码。prinlt(array[0]):只初始化左边size为null，两个size都初始化了则为乱码。println(array[0][0]):定义过为0，没定义抛出runtimeExcepion。
（为什么是乱码还没搞清楚）

null用途：
(1)new Boolean(null)，返回false
(2)Cat aMethod(){return null}，返回一个Cat的referrence

cast本质
所有的cast只是在指向同一object的两个reference之间进行，所指向的object始终没有变，如果所指的object不同，则两个reference是不能cast的。[2.53]

interface
5. The variables in an interface are implicitly public, final and static. If the interface, itself, is declared as public the methods     and variables are implicitly public.
18. Interfaces cannot be final and should not be declared abstract
20. Interface methods cannot be native, static, synchronized, final, private, protected or abstract. They are implicitly       public, abstract and non-static

constructor
11.when an object is constructed the variables are initialized first and then the constructor is executed.[2.18]
22. A constructor cannot be native, abstract, static, synchronized or final.
67.this() and super() must be the first statement in any constructor and so both cannot be used together in the same constructor.
88.Abstract classes can have constructors, and it can be called by super() when its subclassed.
92.Constructors are not inherited so it is not possible to override them.
93.A constructor body can include a return statement provided no value is returned.
94.A constructor never returns a value. If you specify a return value, the JVM (Java virtual machine) will interpret it as a method.
95.If a class contains no constructor declarations, then a default constructor that takes no arguments is supplied. This default constructor invokes the no-argument constructor of the super class via super() call (if there is any super class, except java.lang.Object).
102.Classes defined in methods can be anonymous, in which case they must be instantiated at the same point they are defined. These classes cannot have explicit constructor and may implement interface or extend other classes
122.The Math class has a private constructor, it cannot be instantiated.
132.java.lang.Character has only a single constructor that takes a char (character) as an argument.

 Test3【2006.7.6】

[3]深入理解：为什么member varibles不用初始化？
在一个类被实例化的时候，它会在调用构造函数之前自动对所有的member varibles按照类型进行初始化（如int为0，Object为null），这也是为什么3.3和2.18题中首先执行3个new函数，尽管构造函数中并没有调用他们。

[30]后绑定Base base = new Subclass()和继承Subclass sub = new Subclass()
1.member varibles
后绑定无法访问子类member varibles，只能访问父类。继承先访问子类member varibles，检查没有然后访问父类。
2.method
两者一样：
    调用的method是动态的过程:首先检查子类有没有overriding这个方法，如果有的话调用子类方法，此时就像操作子类对象一样，不能在这个方法里面访问到父类的私有成员。如果检查到没有overriding的话再调用父类方法，此时就像操作父类对象一样，可以在这个方法里面访问到父类的私有成员。

private可视性
可以在在类的内部以任何方式访问（除static方法要使用new），类以外其他任何地方都不能直接访问（包括该类的实例），必须通过方法访问。

[6]线程的几种方法：
1.sleep()、wait()必须在try，catch内,而其他则不需要。
2.Tread的方法：sleep()，start(),run(),stop(),yield(),interrupt()。Object的方法：wait()，notify(),notifyAll()。（共9种，称之为9种武器）
3.静态方法：sleep(),yield().
4.9种方法全部都是void类型。

关于constructor补充两条原则
1.如果一个Someclass中没有定义任何constructor，则可以看成自动加入: SomeClass(){super();}
2.如果一个constructor中没有任何code，则可以看成自动加入: super();

[32,19]interface（补充完整）
1.interface前面只能有两种修饰符：abstract和public
2.varibles前面只能有3种修饰符：final、static和public。默认为fianl、static和public（如果interface为public的话）
3.method起面只能有两种修饰符：abstract和public.默认为abstract和public（如果interface为public的话）
4.Interfaces 没有 constructors。
5.因为varibles默认为final，所以必须要赋初值。

[38]assert
AssertionError和RuntimeExcepion一样不是CheckedException，不需要catch。但并不是说不能用catch，还是可以用来处理一些特殊需要。而CheckedExcption就必须要handdle.

[39]Float.NaN && Double.NaN
All comparisons involving NaN and a non-NaN would always result in false, moreover comparisons involving two NaN values will also result in false.
Float.NaN == Float.NaN results in false.
Float.NaN != Float.NaN results in true.

[42]
A divide by zero will cause an exception ONLY with integer arithmetic. Floating point arithmetic will simply assign the result to be infinity and no exception is thrown.

 Test4：【2006.7.7】

[10]interface再次补充：
An interface can extend any number of interfaces.

关于final的一点说明：
1.final varibles：必须要赋初值，赋值后可定义在method或innerclass中.
2.final method：不能overriding；不能为abstract.
3.fianl class：不能extends，其方法默认为final；不能为abstract.

[16]IdentityHashMap的特别之处：
1.Map：if (k1==null ? k2==null : k1.equals(k2)).
2.IdentityHashMap：if (k1==k2).

[17]Object的几种常用方法：
1.equals:通常用来判断两个references是否指向同一个object。if(o1==o2)
2.hashCode:通常返回int型内存偏移量，如果o1.equals(o2)为true的话，返回相同hashCode。
3.toString:返回String为 classname@hashcode(16进制)

[25]null instanceof 任何class都return false.

[30]对数组，永远记住一条原则：
数组变量在使用前，一定要使用new进行初始化。

Test5：【2006.7.8】

[7]charactor的不同之处：
1、它只有一个构造函数
2、它和Boolean一样不在6×6，xxxValue之列，它只有charValue，不继承自Object.lang.Number.

[21]constructor的几点完善：
1.如果一个Someclass中没有定义任何constructor，则可以看成自动加入: SomeClass(){super();}
2.如果一个constructor中没有super或者this，则可以看成自动在第一行加入: super();
3.子类所调用的所有super所对应的constructor都必须定义在父类中（包括以上两条可看成自动加入的）。
4.可以为private，但不能被继承，也不能被其他类访问；修饰符只能为public或者private。
5.可以有retrun，但是必须返回为空，如return；
6.constructor不能被overriding，也没有通常意义上的继承，只能用super调用父类constructor。
7.调用顺序：子类-->父类，执行顺序：父类-->子类；
8.在执行前，先对所有的member varibles赋默认初值。

[30,60]hashcode和equals的关系：
hashcode的个子定义（必须同时满足）：
1、hashcode的自身定义：同一对象多次调用hashcode()返回一个不变的Integer。
2.和equlas联合定义：通过equals返回true的两个对象调用的hashcode()返回一样的Inetger。
overriding hashcode()时equals()要注意：
1.overriding后的equals所能满足的true条件必须符合以上第二定义。[60题第3选项]
2.overriding后的equals如果符合某个class的特征，这个class.hashcode()可以作为overriding后的hashcode()方法的返回值。[60题第1选项]

Thread点点滴滴(继续补充）：
1、the order in which Threads attempt to access a locked object can't be determined .
2.Using the synchronized keyword in the method declaration, requires a thread obtain the lock for this object before it   can execute the method.
3.Every object has a lock and at any moment, that lock is controlled by at most one single thread.

[61]assertion的enable问题：
1、Assume that the code is compiled and run with assertions enabled.
2、Assume that the code is compiled enabled  run with assertions disenabled.(java AssretionTest.class)
3、Assume that the code is compiled and run with assertions disenabled.
区别及用途:
1.使用assert做keyword编译不会报错，expresstion1总是eavlute，如果为false的话expresstion2开始eavlute。
2.使用assert做keyword编译不会报错，assert这一行相当于被注释掉了。
3.使用assert做keyword编译会报错。

[36]
All the wrapper classes are final and implements Serializable interface either directly(Charactor&Boolean) or by extending Number Class(other six) which implements Serializable.

Test6：【2006.7.9】

[5]数组的初始化方式：
1.int a [] = new int[];
2.int [] a = new int[]{1,2,4};
3.int [][] a = new int[2][];
4.int [] a[] = new int[][]{{1,2,3},{2,3,4},{2,3}};
5.int a[][] = {{1,2,3},{2,3,4},{2,3}};
6.int[] a = new short[5];  //错误用法，不能在数组间进行primitive型convert或cast

[18]Thread的几点理解：
1、sleep可以又main Thread调用，也可以又current Thread调用，一个在main方法里面，一个在run方法里面，
2、当调用start方法后，thread的具体运行顺序对JVM来说有2种方法判断：
(1)优先级。(2)调用方法，比如有join方法调用等。

[18]catch excepion：
1.catch一个try永远也不会抛出的excepion，编译会报错。
2.不管怎么样，多个catch时，exception必须从上到下为：子类-->父类；
3.throw一个throws不到的excepion会报错，也就是说throws的excepion必须是throw的excepion的父类或者同类，不能是子类或不相干的类。
4.所有throws的excepion都必须要完整catch，否则会报错。
5.可以不在method中throw异常，但如果throws了一个excepion，就必须在try中包含这个method，否则会出现第1条的错误，而既然throws excepion就必须catch，造成无法解决的矛盾。

[53]main thread：
1、It is the thread from which other "child" threads will be spawned.
2、It must be the last thread to finish execution. When the main thread stops, the program terminates.
3、By default it has normal priority of 5.

Test7：【2006.7.10】

[9]assertion的expresstion问题：
1、expresstion1必须为boolean。
2、expresstion1必须evalute后有一个返回值（如int、string等），也就是说如果它是一个方法调用的话，return不能为void。

[20]赋值顺序
1.＝右边如果是表达式的话，这个表达式必须已经先赋值过了。如：int x=y;y=1;会报错，因为y没有先赋值。
2＝右边如果是方法返回值的话，该返回值必须先赋初值，否则返回为0或null。见7.20。

[36]The Class class has no public constructor.实际上没有一个独立的constructor，只能从别的方法中创建。

[44]有些方法调用了也跟没调用一样，比如：
String s1 = new String("hehe");
String s2 = s1.tolowerCase();
那么，s2 = s1.tolowerCase();实际上是和s1=s2等价的。类似方法如toupperCase().