sun认证 高分过scjp310-055

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