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 杂项 1、print(null)->null 2、内聚、耦合、继承彼此讲的不是同一件事情，因此无关 3、javaBean的set和get、is 4、大写的AscII比小写的小
