SCJP学习笔记

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比小写的小