SCJP 考点（山寨版大纲）

<!--[if !supportLists]-->1、  <!--[endif]-->类成员可以隐藏，它们属于自己的类，即没有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比小写的小

 

 

 

 

 

 

一.基础知识:
   a.类成员变量会初始化,局部变量必须手工初始化.
   b.main方法,必须是static,而且返回值必须为void,其参数必须为字符串数组.同时该方法可以重载.
   c.注意基本数据类型取值范围.
   d.变量名的取名.如开始必须为_,$和字母.
   f.GC机制.
 
 二.运算符:
   a.逻辑判断中.短路逻辑&&,||,并且其左右必须有为boolean类型.而&,|左右的值可为int,boolean,char.
   b.>>,<<和>>>区别
   c.3/0会抛出异常,而3.0/0则显示NaN,而8.0%2采取是8.0循环相减2.0求余方法.
     同时,NaN是不能相比较的,只能用isNaN方法来比较.
   d.var1+var2++ +" "+var2=?是采用先将(var1+var2)++
   e.==基本类型比较大小,引用类型比较地址(还有时钟问题).equal()方法比较其值.
     注意是StringBuffer并没有重写equal方法,故永远返回为false.这是因为返回表示比较对象的地址.
   f.+=运算符连接字符串中.左边必须为字符串
   g.~可采用取负减1法.即~i=(-i)-1;

 三.Java修饰符:
   a.final,abstract
   b.native,其正确定义方式为public native void test();
   c.方法内局部变量不能为static
   d.非静态方法的调用是运行期决定的.而静态方法的调用是在编辑期决定的.
   e.外部类访问内部类的实例需要外部类:如
       OuterClass.InnerClass inner=new OuterClass().new InnerClass();
   f.synchronized只能修饰方法和代码块.native修饰方法不能有方法体.transient只能修饰变量,表示不可序列化.
   g.static i=100类成员变量,可用this.i访问.

 四.类型转换和造型:
   a.        char-->int-->long-->float-->double
     byte-->short-->
   b.byte x=5;
     byte y=x<<2;
     会编辑出错,因其将x转换为int后<<2后要将其放入byte.故需要强制转换.
   c.float f=1/3.因其1/3结果为1,故以上表达式正确
 
 五.控制程序流程:
   a.break,continue对label
   b.boolean m=true;
     if(m=false)
       System.out.println("结果1");
     else
       System.out.println("结果2");
     由于m是=赋值为false,故执行打印结果2
   c.异常处理
     try{
       throw new Exception()
     }catch(Exception e){
       System.out.println("结果1");
     }finally{
       System.out.println("结果2");
     }
     System.out.println("结果3");

     由于catch与finally没有return.故打印所有结果
  d.标签必须在循环前
  e.线程捕获异常是interruptedEXception
  f.如方法体内有throw异常,但方法体无异常声明,再其调用时加上try/catch仍会编译出错.
 
 六.对象和类:(Overriding 重写 Overloading 重载)
  a.重写方法定义时抛出的异常只能是被重写方法抛出异常的子类或者一样.或者不抛出任何异常.
  b.一个静态方法只能被重载为一个静态方法,而不能被重载为一个非静态方法.同样,非静态方法不可重写静态方法.
  c.内部类不能与外部类同名.同时要注意父类是否有默认构造函数来允许继承.同时定义在方法中的内部类前面不能有修饰符.
  d.构造函数不能有返回值.否则为普通方法.
  e.内部类定义在块中的只能访问它块中的final类型变量.同时内部类定义在类中,则可访问其所在类的所有属性,包括私有属性.
    但定义在一个方法中的内部类.其访问范围仅限制在方法体中.同时,创建其实例还需要外部类.如:
    class A{
      public int x;
      private int y;
      class B{
        protected void method1(){
        }
        class C{
          private void method2(){
          }
        }//end class C
      }//end class B
    }//end Class A
    其method2方法可访问类A中x,y,类B中method1方法.
  f.完全封装类指所有的成员变量定义为private,而将访问这些变量的方法定义为非private类型,这样可在类的外部间接访问这些变量.
  g.重载时方法之间参数列表必须不同,而决定参数列表不同因素是参数的类型个数,顺序.
  h.编译java代码时,如有内部类,则先封装类的名字.然后跟随一个$,再跟随内部类的名字.如是匿名内部类,则编译器会简单生成数字.把
    它们作为内部类标识符使用,然后加上$符和外部类标识符的后面.
  i.静态成员变量初始化优先于其他类成员变量.
  j.class Parent{
 void method1(){
  System.out.println("Parent's method1()");
 }
 
 public void method2(){
  System.out.println("Parent's method2()");
  method1();
 }
    }

    public class Hello extends Parent{
 public void method1(){
  System.out.println("Child's method1()");
 }
 
 public static void main(String [] args){
  Parent p=new Hello();
  p.method2();
 }
    }
    其结果为Parent's method2(),Child's method1();
    但将父类Parent中method1方法改为private void method1().则Parent's method2(),Parent's method1();
  k.接口中定义的变量是final,故不可再以后改变.
 
 七.Java线程:
  a.创建线程两种方式,一种是继承Thread类,另一种是实现Runnable接口.都必须在run()方法中定义具体的线程执行功能.
    而start()方法只是使线程从等待状态变为可运行状态.
  b.线程状态转换,线程从执行状态转为等待状态或撤消状态时可有中断异常导致线程撤销,sleep导致线程转入休眠状态.具有高优先权会使
    当前线程让出CPU使用权,转为等待状态.或调用输入流的read()方法会因为无效数据读取,而导致线程处于堵塞等待状态.
  c.notify()方法和wait()方法存在是为了实现共享锁机制.
  d.线程异常.当线程从执行状态转为等待状态时.wait()方法会抛出InterruptedException异常,当wait中参数timeout参数取值为负数
    或参数nanos取值超出0-999999范围时,会抛出IllegalArgumentException异常;如果当前线程不是对象监视器的所有者,则会抛出
    IllegalMonitorStateException异常.
  e.线程resume()方法,该方法的作用是恢复被挂起的(suspended)线程,该方法首先调用该线程的无参的checkAccess方法,这可能会导致
    在当前线程上抛出SecurityException异常.如果该线程是活的(alive)但是被挂起(suspend),它被恢复并继续它的执行进程.
    sleep()方法使当前线程停止执行,进入休眠状态,stop()方法用于强制当前线程停止执行,但此方法已作废.yield()方法用于临时停止
    当前执行的线程.转而执行其他线程.wait()方法用于使当前线程转入等待状态.notify和notifyAll方法用于唤醒等待的线程.

 八.用户界面组件:
  a.当调用组件repaint方法时,其默认的行为是调用update方法来重新绘制组件.update方法执行的过程为先消除背景.然后调用paint方法
    重新绘制组件.为了避免图像闪烁,可重载update方法,跳过清除操作.
  b.BorderLayout布局管理器把整个界面区域划分为上,下,左,右,中5个区域来容纳指定区域的组件.FlowLayout布局管理器依据添加组件
    的次序,按照从左到右,从上到下的原则来排列组件.GridLayout布局管理器通过指定的行,列数把整个界面区域划分为不同的网格区域,
    依据从左到右,从上到下的顺序在网络中排列组件;CardLayout布局管理器把组件安排在不同的"卡片容器"中,这些卡片容器相互重叠,
    一次只能显示一个,但标题可同时显示出来,以便激活相应的容器;GridBagLayout布局管理器通过与每个组件相联系的GridBagConstraints
    对象来布置组件.
  c.Applet调用getParameter方法可获取指定的参数值,但其返回值总是以字符串作为返回值,因此为了获取正确的参数值,需进行类型转换.
  d.在Java中所有的事件监听器接口中定义的方法,其返回值为void.
  e.在Applet中,如只有一个组件实例,你在init中添加多次add,但只有最后一条添加语句有效.如:
    import java.applet.*;
    import java.awt.*;
 
    public class Test extends Applet{
   Button okButton=new Button("OK");
        public void init(){
          add(okButton);
   add(okButton);
          add(okButton);
          add(okButton);

          add(new Button("Cancel"));
          add(new Button("Cancel"));
          add(new Button("Cancel"));
          add(new Button("Cancel"));

          setSize(300,300);
        }
    }
    屏幕上只会显示出5个Button,4个Cancel,1个OK.

 九.输入和输出:
  a.RandomAccessFile如使用rw(读写)模式,则文件不存在,不会抛出FileNotFoundException异常,而会创建一个新文件.其只有两种访问模式.
    r(只读)模式,rw(读写)模式.
  b.向文件写基本数据类型:
    import java.io.*;
    class Write{
 public static void main(String [] args){
  File file=new File("temp.test");
  FileOutputStream stream=new FileOutputStream(file);
  DataOutputStream filter=new DataOutputStream(stream);
  for(int i=0;i<10;i++)
   filter.writeInt(i);
   }
    }
  c.ServlerSocket,Socket实现基于TCP/IP客户端/服务器端的连接.DatagramPacket,DatagramSocket实现UDP

 十.语言包和实用包:
  a.Collection接口定义了15个方法:add(Object o);addAll(Collection c),clear(),contains(Object o),containsAll(Collection c)
    equals(Object o),hashCode(),isEmpty(),itearator(),remove(Object o),removeAll(Collection c),retainAll(Collection c)
    size(),toArray()和toArray(Object [] a);
  b.Map是一个支持按关键字检索的集合,但关键字必须唯一.Set是一个无顺序,拒绝重复项的集合类,List是一个有顺序且允许重复项的集合类,
    Collection是所有集合类的接口的根接口.Enumeration实现一个按顺序访问元素的集合类.LinkedList集合类.该集合类实现了List接口,
    允许元素从集合中任意位置被添加,删除,还可排序元素.故队列和堆栈可实现此类.
  c.Vector类用来存储对象,不能存储基本类型数据.
  d.在向Set集合添加重复合新项时,则返回值为false,但不会抛出异常来.
  e.封装类是不可变的,即一被创建,其内容不可再改变.
  f.float f4=Integer.MIN_VALUE;//MIN_VALUE=-2147483648
    float f5=Integer.MAX_VALUE;//MAX_VALUE= 2147483647
    float f6=-2147483655f;
    System.out.println(Math.round(f6));
    由于f6小于MIN_VALUE,故返回MIN_VALUE;
  g.Boolean b1=new Boolean("TRUE");
    Boolean b2=new Boolean("true");
    Boolean b3=new Boolean("JUNK");
    System.out.println(""+b1+b2+b3);
    其结果为truetruefalse.如果打印时没有"",则会编译出错.
  h.floating/double值大小为:-infinity-->Negative Numbers/Fractions-->-0.0-->+0.0-->Positive Numbers/Fractions-->infinity

自测题:
 1.以下哪些是正确的标识符?
  a._class;
  b.$value$;
  c.zer@;
  d.￥ngstr;
  e.2muchuq;

 2.以下代码会输出什么？
　 public class test{
    public static void main(String [] args){
 String space="";
        String composite=space+"hello"+space+space;
 composite.concat("world");
 String trimmed=composite.trim();
 System.out.println(trimmed.length());
    }
  }
  a.5;b.6;c.7;d.12;e.13