sun認證 高分過scjp310-055
1、類成員可以隱藏，它們屬於自己的類，即沒有override的說法
2、構造函數沒有返回值void
3、System.out.println(null); //打印null
4、assert i<7: foo //foo必須有返回值
5、從static 方法中不能調用實例方法
6、static方法不能abstract，也就是說不能在接口中
7、內聚是講功能，和耦合無關
9、繼承和耦合無關
10、涉及到package時注意是否可以訪問
11、HashMap的Entry
12、StringBuilder s; s+""; 可以的，會自動調用toString()方法
13、override中的返回值可以是兼容類型，比如，子類
14、注意對象孤島現象
15、注意局部變量的隱藏性
16、Scanner
17、Formatter
18、有返回值的函數各個路徑都要有返回return，比如switch和if
19、注意異常捕獲的順序，父類異常不能放在子類異常之前
20、正則表達式
21、javabean的setter和getter規則
22、protect之類的可訪問性是指在類繼承實現時的可訪問，對實例無效，都是不可訪問的
23、int x=10;
int y;
if(x<100) y=x/0;
if(x>=100) y=x*0;
System.out.println("The value of y is:"+y); //這樣也是未初始化的變量
24、List<?> 可以接受任何東西但不能添加東西
List<? super Dog> list; //這個引用可以用來引用 ArrayList<Animal>這樣的類型
自然可以添加像Dog這樣的對象,可能添加的對象被轉換成了Object
List<? extends Dog> list 可以用來引用ArrayList<BabyDog>這樣的類型
所以不能添加Dog類型，對象被轉換爲Dog類型
25、數組有length屬性，String是length()方法
26、import java.util.*;
class Shape{}
class Circle extends Shape{}
class Rectangle extends Shape{}
public class Generics4{
public static void main(String[] args){
ArrayList<Circle> a=new ArrayList<Circle>();
a.add(new Circle());
ArrayList b=a;//賦值爲不安全類型
//從不安全類型到安全類型cast OK，runtime也ok，
//本來都轉換成了Object，只是安全類型有強制轉換而已，
//這裏沒有碰到這個錯誤的元素
ArrayList<Rectangle> c=(ArrayList<Rectangle>)b;
c.add(new Rectangle());
for(Object o:b){
System.out.println(o);
}
}
}
27、在定義時void foo(String... s)和void foo(String[] s)是等價的，會出現重複定義
但是調用的方法是不一樣的
28、String[] s={"1","2"};
29、取得Property: System.getProperty("FOO"); System.getProperties().get("FOO");
30、進行io操作要主要try、catch
31、public class Test{
public static void main(String[] args){
Test test=new Test();
test.new InnerTest().f();
}
final String s="Outer s";
class InnerTest{
String s="Inner s";
void f(){
System.out.println(Test.this.s); //從內部類引用外部類的成員
}
}
}
32、wait和sleep方法必須在try塊中且會拋出InterruptedException
wait還必須在同步塊中使用，否則拋出IllegalMonitorStateException
33、線程的很多操作不是馬上生效的，如：start,yield,sleep醒來後等
34、Map接口用的是put方法（和Collection接口的add類同）
35、Test extends Test1 在javac中.java文件和.class文件均被查找，一視同仁，所以要留心.java文件的位置
36、sleep和wait要try catch
37、如果new Boolean("true");或者任何大小寫不同，則此boolean==true,否則爲false;
38、parse方法要try catch
39、P348頁的表
40、成員方法無法覆蓋static方法
41、方法重寫 參數列表一致性 返回類型一致（基本類型）或者兼容（類類型）
訪問級別可放寬但不能加強 private不存在重寫問題，不能被繼承則不能重寫
RuntimeException可以被任意拋出
不能拋出新的檢查異常 只能是原方法的拋出異常的子類型
可以減少拋出的異常，不過如果用原來的類型進行引用，編譯器仍會認爲需要try catch
不能重寫final或者static方法
42、class MyException extends Exception{}
public class Test{
void f() throws MyException{
throw new MyException();
}
public static void main(String[] args) throws MyException{ //申明finally中拋出的異常
MyException e1=null;
Test t=new Test();
try{
t.f();
}catch(MyException e){
e1=e;
System.out.print("catch");
}finally{
System.out.print("finally");
throw e1;//在finally中拋出的語句必須被捕捉或者申明
}
System.out.print("End");//這句無法達到，編譯失敗
}
}
43、大寫字母的ASCII比小寫字母小，所以從小到大排在前面
44、ArithmeticException屬於RuntimeException
45、函數裏面throw new Exception 函數聲明必須有throws 除非被捕獲
46、P43，定義枚舉中常量的特定類體
47、enum Operator{
//枚舉常量方法體
PLUSONE{
int operate(int x){
return ++x;
}
}, //，號分割
MINUSONE{
int operate(int x){
return --x;
}
}; //；號結束
//這裏可以是abstract由上面覆蓋
abstract int operate(int x);
}
public class EnumTest{
public static void main(String[] args){
for(Operator o:Operator.values()){ //枚舉類型的所有常量
System.out.println(o+" "+o.operate(11));
}
}
}
48、import java.util.*;
public class Test{
public static void main(String[] args){
//LinkedHashMap保持輸入順序
Map<String,String> fruit=new LinkedHashMap<String,String>();
fruit.put("Apple","red");
fruit.put("Mango","yellow");
for(String key:fruit.keySet()){//返回key的集合
System.out.println(key+fruit.get(key));
}
}
}
49、不在一棵繼承樹上強制轉換直接compile error，否則如果轉換不當，compile正常，運行出錯
50、import static 用來導入一個類內部的東西
====
package pack1;
public class EnumClass{
public enum MyEnum{A,B,C};
}
import pack1.EnumClass.*; //也可以這樣導入內部類
//import pack1.EnumClass.MyEnum；//或者這樣
//import static pack1.EnumClass.MyEnum; //這樣也可以
//import static pack1.EnumClass.*; //還可以這樣,import static 要求最後一個.號的左邊是個類而不是包
public class Test{
public static void main(String[] args){
for(MyEnum o:MyEnum.values())
System.out.println(o);
}
}
51、Iterator it=list.iterator();
it.hasNext(); it.next(); //返回Object類型
Iterator<String> it=list.iterator(); //LinkedList<String>
it.hasNext(); it.next();//返回String類型
52、printf中如果隨便換控制字符，編譯沒有問題，但是運行會出錯，和c不一樣
53、synchronized(sa){
sa=new String("Done");//sa改變了所引用的對象
sa.notify(); //所以這裏會有非法監視狀態的異常
}
54、parse方法需要try catch
55、try{
BufferedWriter writer=new BufferedWriter(new FileWriter("abc.txt",true));
======追加模式
writer.append("word");
writer.close();
}catch(Exception e){} //注意try catch
56、format和parse方法要try catch
57、NumberFormat.parse 返回 Number format 返回 String
58、AssertionError 不是 Exception 所以不用處理它
59、class MyGenerics<T>{
//static T obj2; 無法從靜態上下文中引用非靜態類型
//static T getObj(){ 無法從靜態上下文中引用非靜態類 T
//return new T();
//}
//static void showObj(){ 無法從靜態上下文中引用非靜態類 T
//T obj=new T();
//obj.show();
//}
}
60、PriorityQueue offer 添加 peek 獲取最高優先級元素但不刪除，如果沒有了就返回null
poll 刪除最高優先級元素並返回它，如果沒有了就返回null
61、transient 和 static 變量反序列化時清零
62、public class Test implements Runnable{
public void run(){
String str="Hello"; //這個對象在常量池裏，所以兩個成員都指向了同各對象，如果是new String則不是了
synchronized(str){
try{
System.out.print(Thread.currentThread().getName());
Thread.sleep(500);
System.out.print(Thread.currentThread().getName());
}catch(InterruptedException e){}
}
}
public static void main(String[] args){
new Thread(new Test(),"A").start();
new Thread(new Test(),"B").start();
}
}
63、public class Test{
public abstract class InnerTest{
abstract void f();
}
public static void main(String[] args){
Test t=new Test();
Test.InnerTest test=t.new InnerTest(){ //InnerTest()
public void f(){ //留意f()的訪問性範圍protect還是public private
System.out.println("Inner f");
}
}; //分號不要忘記
}
}
64、P343 繼承/實現關係
65、class MyException extends Exception{}
public class Test{
void f() throws MyException {throw new MyException();}
public static void main(String[] args){
MyException e1;
Test t=new Test();
try{
t.f();
}catch(MyException e){
e1=e; //e1在這裏初始化是有條件的
System.out.print("catch1");
}finally{
try{
throw e1; //所以這裏會有沒有正確初始化的編譯錯誤，無法通過
}catch(Exception ex){
System.out.println("catch2");
}
}
System.out.println("End");
}
}
66、有條件初始化的未初始化編譯錯誤
67、Arrays.sort(array) 可以排序基本類型數組 Arrays.sort(Objects[],comparator) 不能排序基本類型數組，有Comparator的關係
Arrays.asList(T[])
Arrays.binarySearch(Object[],key) Arrays.binarySearch(primitive[],key)
Arrays.binarySearch(T[],key,Comparator) 在comparator排序的數組中搜索一個值，也不能排序基本類型數組
68、switch(int) 所以傳long之類的要強制轉換
69、當有函數返回值，執行分支條件語句時，要注意每個分支都要有返回值，初始化變量也是這樣，要留心有條件的初始化是不能編譯的
70、Object[] toArray(); //返回Object，而且是一個複製拷貝不是同個對象的不同引用
71、StringBuffer.equals 不是比較StringBuffer的字符串內容
72、int Integer.parseInt Integer Integer.valueOf("3")
73、Character 是 char的裝箱類型
74、Arrays.toString(array[])
75、printf的舍小數是四捨五入的
76、NumberFormat.getInstance(Locale.US);
try Number = numberFormat.parse catch
77、Object[] list.toArray() String[] list.toArray(new String[0])
78、泛型方法可以是static的
79、sychronized方法可以被未標記爲synchronized方法overriden，但是那個方法還是同步的
80、構造函數不能用synchronized進行同步修飾
81、//private static int y=5; //與y和x的順序有關
private static int x=getValue();
private static int y=5; //這樣的話x=0；
private static int getValue(){
return y;
}
82、enum Fish{A,B,C;} Fish f=Fish.valueOf("C");
83、Boolean[] bool=new Boolean[5]; 創建了一個Boolean的數組，元素Boolean對象還不存在
如果boolean[] bool=new boolean[5]; 那麼基本類型boolean存在了false
84、class TestInner{
int i=10;
TestInner(){
System.out.print("Outer");
}
static class MyInner{
MyInner(){
System.out.print(i); //static inner class 不能使用外部的成員變量
}
}
public static void main(String[] args){
new TestInner.MyInner();
}
}
85、class Exception1 extends Exception{}
class Exception2 extends Exception{}
class Exception3 extends RuntimeException{}
class A1{
void test() throws Exception1,Exception2{}
}
class A2 extends A1{
void test(){};
}
class A3 extends A2{
void test() throws //這裏因爲要覆蓋A2的方法，所以以A2爲準，這裏只能拋出RuntimeException了{};
}
86、要注意無法訪問的語句會導致編譯錯誤
87、float i=0;
final byte j=5;
final short s=4;
while(i<5){
switch((int)i+2){ //可以
default:
case j: //final，可以在編譯時決定
case s+2: //可以在編譯時決定，不過要小心標籤重複
}
i++;
}
88、float i=Float.NaN; float k=i; i==k -> false NaN不可比較的
89、class Base{
private void aMethod(int iBase){ //private，不可繼承，所以不影響override
System.out.println("Base");
}
}
public class Over extends Base{
public static void main(String[] args){
Base o=new Over(); //但是在轉到Base了之後，只是調用private的方法而不是動態的
//private阻止了多態，因爲private沒有this指針
int iBase=0;
o.aMethod(iBase);
}
public void aMethod(int iOver){
System.out.println("Over");
}
}
90、DateFormat.getDateInstance(DateFormat.SHORT,locale).format(date);
91、NumberFormat.getInstance(locale).format(number);
92、import java.io.*;
class B{
int i=2;
B(int i){
this.i=i;
}
B(){} //必須的，因爲不可串行化，所以恢復時需要提供一個沒有參數的構造函數讓jvm來重新構造父類
//否則在反串行化時會拋出異常
}
class A extends B implements Serializable{
int x=5;
A(int x){
super(x);
this.x=x;
}
}
public class SerializeTest1{
public static void main(String[] args) throws Exception{
File f=new File("a.txt");
ObjectOutputStream oos
=new ObjectOutputStream(new FileOutputStream(f));
oos.writeObject(new A(2));
oos.close();
ObjectInputStream ois
=new ObjectInputStream(new FileInputStream(f));
A obj=(A)ois.readObject();
System.out.println(obj.x);
ois.close();
}
}
93、import java.util.*;
public class Test{
public static void main(String[] args){
Set<MyClass> s=new TreeSet<MyClass>(); //TreeSet在輸出的時候有排序功能，所以要實現Comparable接口
//否則編譯沒有問題，但是在輸出的時候會類型轉換異常
s.add(new MyClass(2));
s.add(new MyClass(3));
s.add(new MyClass(1));
for(MyClass m:s)
System.out.println(m);
}
}
class MyClass implements java.io.Serializable,Comparable{
int i;
MyClass(int i){
this.i=i;
}
public String toString(){
return(""+i);
}
public int compareTo(Object o){
return i-((MyClass)o).i;
}
}
94、Hashtable table=new Hashtable();
table.put("Java","dddd");
table.put("Java","3eee"); //將覆蓋掉上面的value
95、明顯的不可能有的狀態如果用了也會導致編譯失敗，比如沒有某異常扔出的語句卻嘗試捕獲該異常
96、Thread.jion()也要try catch
97、class MyOuter{
private class MyInner{
float f(){ return 1.2f; }
}
MyInner getInner(){
return new MyInner();
}
}
public class Test{
public static void main(String[] args){
MyOuter out=new MyOuter();
//MyOuter.MyInner in=out.getInner(); //MyInner類的定義外面是看不到的
//System.out.println(out.getInner().f()); //所以f()無法訪問，雖然可以得到MyInner的引用
}
}
98、考裝箱時，要注意Integer[]和int[]是沒有什麼轉換的
99、public static void main(String[] args){
final Test t=new Test(); //方法內的匿名類可以訪問final局部變量，但是不能訪問一般局部變量
Test.InnerTest test=t.new InnerTest(){
public void f(){
t.f();
System.out.println("Sub Inner Test");
}
};
}
100、如果子類有覆寫父類的方法，則用父類引用子類對象時，用父類方法的訪問性
package eldon;
public class A{
protected void foo(){
System.out.println("A");
}
}
import eldon.A;
class B extends A{
protected void foo(){
System.out.println("B");
}
}
public class Test{
public static void main(String[] args){
A a=new B(); //這裏就不可訪問了，用父類對象方法的訪問性
a.foo();
}
}
101、int[] i=new int[1]{1} //是錯誤的，不能在這種情況下指定維數
類要檢查的東西
1、構造函數的返回值問題
2、static函數不能調用非static的函數
3、有package的類要留心訪問性
4、static final和abstract修飾符的矛盾性 1、interface默認public abstract方法，public static final變量
5、protected只能從子類方法定義中訪問
6、String[]和String...是等價的定義，只是訪問方式不一樣
7、//private static int y=5; //與y和x的順序有關
private static int x=getValue();
private static int y=5; //這樣的話x=0；
private static int getValue(){
return y;
}
函數要檢查的東西
1、局部變量的隱藏性和作用域
2、有返回值的函數各個路徑都要有return，否則編譯失敗
3、局部變量的有條件初始化必須所有條件都有初始化語句，否則編譯失敗，留心if和catch中的初始化
4、數值類型的精度變小，尤其是返回語句中,switch語句中
5、String[] s=new String[]{"a","b"};但是不能規定創建的維數
6、要進行try和catch的語句：
io操作、jion、sleep、wait、DateFormat(NumberFormat).parse、DateFormat(NumberFormat)format、聲明拋出檢查異常的方法
7、不要捕獲不可能出現的異常，這樣編譯會失敗
8、finally中拋出異常也要捕獲或拋出
9、要留意永遠不能到達的語句，這樣也會編譯失敗，往往是鐵定的異常拋出後面的或者是條件語句下的
10、throw new Exception() 則必然要捕獲或者拋出
11、強制類型轉換的編譯錯誤（不在一棵繼承樹上）和運行錯誤（在一棵樹上，但非此類型轉換）
12、AssertError所以不用try和catch
13、swhitch的標籤可以用final，以及finl+常量字面量的表達式，但是要小心標籤不能重複了
類的繼承要檢查的東西
1、成員變量的隱藏性
2、覆蓋方法時的合法性 1、返回值的協變性，子類父類協變可以，int和long不行
2、異常拋出的合法性
3、無法覆蓋static方法和final方法
4、private方法無所謂覆蓋，因爲不可見
5、訪問級別只能放寬
6、用父類引用子類，則方法體是子類的，聲明採用父類的，要留心這個
3、覆蓋要以直接父類爲準
內部類要檢查的東西
1、從內部類引用外部類成員 OuterClass.this.x;
2、創建匿名類時要檢查 1、；和()號不要漏了
2、繼承時的一切要注意的事情，包括覆蓋方法等
3、static嵌套類不能使用外部類的成員變量，除非是static或者final的
4、方法匿名類不能使用外部static和成員變量、局部變量，除非是final的
5、內部類定義如果不可訪問，那麼它的操作不能訪問，雖然可以用一個可以訪問的父類引用該對象
線程同步要檢查的東西
1、wait和notify方法要事先獲得該對象的鎖，注意中間偷偷換對象
2、不是馬上生效的方法：sleep不是馬上醒來，start不是馬上運行，yield不是馬上放棄運行
3、String的常量池問題，會導致多個引用引用在一個對象上
4、sychronized方法可以被未標記爲synchronized方法overriden，但是那個方法還是同步的
5、構造函數不能用synchronized進行同步修飾
異常和斷言要檢查的東西
1、assert bool:expr->要有返回值
2、異常檢查捕獲的順序要留心
泛型要檢查的東西
1、List<?> == List<? extends Object> 不能向集合添加內容
2、List<? super Animal>可以添加內容
3、從安全的到不安全的編譯Ok，特別是從不安全的可以轉換成任意一種安全的類型，運行只要不涉及元素類型轉換也OK
4、class MyGenerics<T>{
//static T obj2; 無法從靜態上下文中引用非靜態類型
//static T getObj(){ 無法從靜態上下文中引用非靜態類 T
//return new T();
//}
//static void showObj(){ 無法從靜態上下文中引用非靜態類 T
//T obj=new T();
//obj.show();
//}
}
但是
class MyGenerics{
static <T> T getOject(T obj){} //泛型方法是可以的
}
序列化要檢查的東西
1、這時IO操作要try和catch
2、每個成員要能夠序列化
3、不能序列化static和transient的成員，反序列化時清零
4、父類如果不能序列化則在反序列化時new一個，並且需要無參構造函數，否則運行報錯
垃圾回收要檢查的東西
1、不可訪問性-〉孤島的存在
Java Api的東西
1、StringBuilder可以自動調用toString方法
2、Scanner
3、正則表達式
4、數組length,String.length()
5、System.getProperty("FOO"); System.getProperties().get("FOO");
6、Map獨立，所以有put方法，其它的實現Collection接口，所以有add方法
7、RuntimeException: ArithmeticException
8、枚舉變量的特定類體
9、LinkedHashMap保持輸入順序
10、import static java.lang.System.out; 要求最後一個.的左邊是個類而不是包。import要求右邊是個類或者*
11、Iterator返回Object Iterator<String>返回String類型
12、printf中控制字符格式和參數類型要一致（兼容），否則報錯
13、try{BufferedWriter writer=new BufferedWriter(new FileWriter("abc.txt",true));}追加模式,io操作
14、try{Number.format返回String Number.parse返回Number}
15、PriorityQueue的peek，poll和offer，以及LinkedList實現了Queue的接口
16、Arrays.sort(array) 可以排序基本類型數組 Arrays.sort(Objects[],comparator) 不能排序基本類型數組，有Comparator的關係
Arrays.asList(T[])
Arrays.binarySearch(Object[],key) Arrays.binarySearch(primitive[],key)
Arrays.binarySearch(T[],key,Comparator) 在comparator排序的數組中搜索一個值，也不能排序基本類型數組
17、String[] toArray(new String[0]);
Object toArray()返回一份拷貝而不是原list對象的引用；Arrays.asList就是原Array對象的list引用
18、printf是四捨五入的
19、StringBuffer.equals不是比較字符串的內容
20、Integer.parseInt("3")-> int Integer.valueOf("3")->Integer //RuntimeException，不用管它
21、enum Fish{A,B,C;} Fish f=Fish.valueOf("C");
22、DateFormat.getDateInstance(DateFormat.SHORT,locale).format(date);
NumberFormat.getInstance(locale).format(number);
23、TreeSet在輸出的時候有排序功能，所以要實現Comparable接口，否則編譯沒有問題，但是在輸出的時候會類型轉換異常
24、map的put操作將採用最新的值，set的add不添加重複值，且返回false