参加SCJP认证时学习的笔记

http://blog.csdn.net/pwy_19831104/article/details/4695952


参加SCJP认证时学习的笔记
分类： JAVA认证 2009-10-19 01:54 180人阅读 评论(1) 收藏 举报
把SCJP认证的参考书看了2遍,但迟迟未考,因为没有钱。。。今年终于狠下心花了700元在网上买了张转让的考试券(原价1400,SUN其实挺黑的),5月份报名考了90多分,也算了却了一桩心事。下面是我当时的学习笔记,都是一些很基础的知识。

一.语言基础
1.JAVA语言标识符:开头以字母,"_","$"开头，后跟字母,"_","$",数字。
2.System.gc()  或者Runtime.getRuntime().gc()  通知JVM调用垃圾回收器来回收已废弃的对象。
3.import-->导入包中的类;import static-->导入包中类的静态变量和方法。 
4.类中的成员变量可自动初始化,局部变量使用前必须指定初始值。
5.数组长度在用new语句创建时长度已指定,且一旦指定长度不可再改变,1)如一开始用常量来初始化数组长度,如后面要改变数组长度则编译错误。2)如开始用变量来初始化数组长度，如后面改变数组长度则不会发生编译错误,但是数组长度不变;用new新建数组时,必须指定数组大小。
6.顶层类不能用private / protected 修饰。
7.可变参数必须是参数列表中的最后一个参数,且一个方法中只能有一个可变参数。
8.给一个变量赋值null,则该变量则符合回收的条件,失去存在的意义。
9.当作用域不同的两个变量名称相同时,作用域小的变量覆盖作用域大的变量值。
10.println() 方法输出的结果是一个十进制数。
11.当程序员指定初始化数组时,datatype arrayname ={data1,data2,data3....}必须提供所有元素的初始化值。
12.指定数组长度的数值类型只能是byte,short,int不能是long。
13.方法体内的局部变量不能用static修饰。
14.i=0; i=i++; 结果i=0 。


二.JAVA运算符
1.当两个操作数的数据类型为char,byte,short和int时,运算结果的数据类型都为int。
2./ 当除运算的右操作数取值为0时,如果操作数均为整数,则会抛出ArithmeticException异常,如果至少有一个为浮点数,则结果为一个Infinity值。
3.% 当取模运算中有负数为操作数时,运算的结果取决于左操作数,即和左操作数的符号一致。
4.当取模运算的右操作数为0时,如果操作数为一整数,则会抛出算数异常ArithmeticException,如至少有一个是浮点数,则结果为一个NaN值。
5.移位运算的操作数只能是整型,即char,byte,short,int,long,进行移位运算时,总是现将其他类型转换为int和long型。
6. <<左移位运算:左移时,最高位被舍弃,最低位补0  ----等同于×2运算。
    >>右移位运算:右移时,最高位若为正,则插0,若最高位为负,则插1----等同于/2运算
    >>>无符号移位运算:移入位始终补0
7.instanceof 比较运算符,左操作数是一个对象引用表达式,通常为一个引用变量或数组元素,可以取值null,则比较结果仅返回false,不会抛出任何异常。右操作数必须是一个类、接口或数组,但不能是java.lang.Class或一个代表类名称的字符串对象。当右操作数是一个接口时,表明比较的目的是判断左操作数是否实现了此接口。instanceof运算符不能用于测试一个对象和一个无类型定义数组的比较,因此必须明确指定数组的类型。
8.位操作运算的操作数只能是整型,即char,byte,short,int,long,进行移位运算时,总是现将其他类型转换为int和long型。按位非运算不能用于布尔型数值,且不能将布尔型数值和其他数值混合使用。
9.按位取反运算(~)采用取负减1法: ~i =(-i) -1
10.逻辑与(&&)、逻辑或(||)不同于按位与(&)、按位或(|)运算,会存在逻辑短路。
11.条件运算符<布尔表达式>?表达式0:表达式1 ,表达式0、1的类型必须和共同的目标变量类型兼容。
12.赋值运算符(=)的左操作数的类型取值范围必须大于等于右操作数的类型取值范围。
13. ==和equals()的区别:   == 引用类型比较引用,基本类型比较值;equals()方法只能比较引用类型,对类File,String,Data及封装类来说是比较类型及其内容。
14.用==进行比较时,两边的数据类型必须一致,可互相转换的数据类型除外。
15.计算顺序从左至右,赋值顺序从右至左,先计算后赋值。
16.不能将NaN当做一个普通数应用于运算中,如z==Double.NaN 返回false。
17.+用来连接字符串时,要求两个操作数都必须是字符串。引用类型数据和基本类型数据是不能一起混合运算。
18.JAVA运算符列表:
    单操作数运算符: ++, -- , + , - , ! , ~ , ()
    算术运算符:+ ,- ,* , / ,%
    移位运算符:<< ,>> ,>>>
    比较运算符:< ,<= ,> , >= ,!= , == , instanceof
    位操作运算符:& , | , ^ , ~
    逻辑运算符: && , || , !


三.JAVA修饰符
1.抽象类可以存在抽象方法,但也可以不包含抽象方法。
2.抽象类表明未完全实现的概念,所以不能被实例化,也不能被final和private修饰。
3.final基本类型变量必须初始化,系统不会赋默认值,否则编译错误。final引用类型变量引用初始化对象后,无法再引用其他对象。final方法无法被重载但是可以被过载,final类无法被继承。
4.final是唯一可用于方法内局部变量的修饰符。
5.native只能修饰方法而不能修饰类和变量,native方法如同一个抽象方法,没有实际的方法体,而且可以被private修饰。
6.静态类的属性被所有类实例所共享,即任何一个类实例改变了静态属性的值,所有类实例拥有的这个静态类属性值都会同步得到改变。
7.一个静态方法不能被重载为一个非静态方法,但是可以被过载为一个非静态方法。
8.静态代码块主要用于初始化,仅被执行一次,即首次装载类时被执行,非静态代码块在每当创建类实例时执行,其运行在父类构造器之后,所在构造器之前,多个非静态代码块顺序取决于在类中定义的次序。
9.synchronized只能用来修饰方法,不能用来修饰构造器。
10.transient只能用来修饰类成员变量,不能修饰局部变量,transient变量不能被序列化。一个静态变量不管是否被transient修饰都无法被序列化,一个private变量一经序列化处理后,就可以通过读取一个文件,或者拦截网络传输来得到它。
11.同一个类的两个实例可以互相访问内部private属性成员。
12.执行顺序:初始代码块 -- 构造器 --方法体语句。


四.类型转换及造型
1.引用类型的转换:1)类可以转换成类(该类的超类),接口(该类实现的接口),不能转换成数组。
                          2)接口可以转换成类(Object类),接口(该接口的超接口),不能转换成数组。
                          3)数组可以转换成类(Object类),接口(Cloneable接口和Serializable接口),数组(能转换成目标数组元素类型)。
2.引用类型的造型:1)非final类可造型为非final类(存在继承关系,不要求顺序),final类(非final类的超类),接口(总是ok),数组(类型为Object)
                           2)final类可造型为非final类(final类的超类),final类(和被转换final类是同一个类),接口(该final类实现的接口)
                           3)接口可造型为非final类(总是ok),final类(final类实现了该接口或Serializable接口)
                           4)数组可造型为非final类(Object类),数组(可造型的的元素类型)     
3.超类实例不能造型为子类实例,可以通过编译,但运行期会抛出ClassCastException。                                                                                                                                    
                                             
五.程序流控制
1.swith 结构中的选择因子的数据类型只能是 char,byte,short,int或enum。
2.只有执行System.exit()方法或出现error错误时,finally语句块才不会获得执行而退出程序。
3.在一个方法中如果用throw语句抛出一个异常,则必须在方法声明中采用throws语句声明方法体中抛出的异常,并且声明的异常必须是方法体中抛出的异常或其超类。
4.重载方法抛出的异常只能是被重载方法抛出异常的子类或者与其一样或者不抛出任何异常。
5.当同时初始化多个控制循环次数的变量为同一数据类型时,一起声明,形式为datatype vary 1=value1, vary 2 =value2.
6.标签必须配合循环体和循环语句使用。
7.catch语句中捕获的异常必须为方法抛出异常的超类或其自身。


六.面向对象
1.this引用的是当前创造的类实例对象的句柄;super引用的是当前创建类实例对象的父类的句柄。
2.接口默认是public,abstract,接口的成员属性变量默认为public,static,final类型,接口的成员方法默认为public,abstract,非final类型。
3.构造器必须与类型相同,无返回值,且只能有public,private,protected修饰。
4.子类可以继承父类的所有属性和方法,但是构造器除外,它不能被继承。
5.在同一个类中的不同构造器中调用其他构造器需要使用this(...)的形式,而且必须是在构造器的第一行调用。
6.在子类中直接调用父类的构造器,必须使用super(...)语句,而且必须放在其构造器中的第一行。super()语句只能在构造器中被调用。
7.不能在构造器中同时使用this和super。
8.构造器可以抛出异常,并且如果父类默认构造器抛出一个异常,子类的默认构造器应该处理由父类抛出的异常。
9.在执行子类构造器时,如果没有明确指明调用父类的某个构造器,则系统自动调用父类无参的构造器。
10.接口没有构造器,抽象类的构造器在其实现类实例化时被调用。
11.枚举类直接继承于Object类,枚举声明的位置有两个地方:类外部和类内部,但不是在方法体中定义枚举集。在类内部定义的枚举,需要通过所在的类名来引用(在方法体内的引用除外)。在类外部定义枚举时,只能被public 修饰或不被修饰。
12.枚举中的构造器不能由程序员来调用完成枚举的实例化,它是由系统通过枚举值后面定义的参数来自动调用枚举的构造器。
13.自定义枚举可以重载其父类Enum中定义的toString()方法打印输出指定值,如果未重载toString()方法打印输出的是枚举常量。
14.JavaBean组建是具有属性的Java,其属性一般为private属性。JavaBean组建中更改属性值的方法称为setter方法,获取属性值的方法称为getter方法,两种都为public。如果属性成员不是布尔类型,则getter方法的必须是getXXX()方法,XXX为大写的属性名,如果属性是布尔类型,则getter方法必须为getXXX或者isXXX。
15.重载---父类中的一个方法在子类中获得重新定义,但是方法名、参数列表必须相同,返回值可以不同,但是被重载方法的返回类型必须为重载方法返回类型的父类。重载方法不能比原来被重载的方法访问范围窄。重载方法抛出的异常只能是被重载方法抛出异常的子类或相同或不抛出异常。静态方法只能重载为一个静态方法,非静态方法只能重载为一个非静态方法。父类中被子类重载的方法每个最多只能被重载一次,子类中的重载方法可以通过super.xxx()来访问父类中被重载的方法,但是只能访问其直接父类,不能越级访问。
    过载---多个方法拥有一个名字,但是每个方法的参数列表必须不同,即参数的个数不同或参数的排列顺序不同或参数的类型不同。一个静态方法可以被过载为一个静态方法,也可被过载为一个非静态方法。
    重载与过载的区别:1)过载方法彼此之间相互独立,实质上是不同的方法;重载方法和被重载方法之间是取代的关系。
                               2)过载方法存在于一个类中,数量没有限制;重载方法和被重载方法分别存在于子类和父类中,其子类中最多有一个重载方法。
                               3)过载方法必须要用不同的参数列表;重载方法和被重载方法的参数列表必须相同。
                               4)过载方法之间的返回类型可以随意选取;重载方法和被重载方法必须要有相同的返回类型(或为子类)
                               5)过载方法之间对修饰符和抛出的异常无限制;重载方法的不能比被重载的方法访问范围窄,抛出的异常也只能为被重载方法抛出异常的子类或相同或无异常
16.定义在方法体外的非静态内部类引用形式:new out_class().new in_class(),如其他类成员一样附属于类实例。定义在方法体外的静态内部类附属于外部类,而不是外部类实例,引用形式:new out_class().in_class()。在方法体中定义的内部类如同方法成员一样附属于方法体,只能在方法体中用new直接创建实例,并且只能在方法体中被访问。
17.类生成的.class文件名称形式:先是封装类的名字,再跟随一个$,再跟随一个内部类的名字,如果是匿名内部类,则$后面跟随数字。
18.静态内部类只能访问静态变量,非静态内部类其内部属性不能声明为静态的。
19.一个定义在方法体中的内部类不能加任何访问修饰符,且只能访问方法中定义的被声明为final的局部变量。
20.匿名内部类的定义形式:new  XXXX(){ /*class body */ },匿名内部类可以继承其他类或实现接口,但是不能同时继承其他类又实现接口。匿名内部类不能有任何明确的构造器。匿名内部类默认为final的,且不能被abstract和static修饰。
21.父类如没有无参默认构造器,而子类的构造器中又没有指定调用哪个父类的构造器时,系统会自动寻找父类的无参构造器,从而发生编译错误。
22.封装类的自动装箱和拆箱不能改变原有数据类型范围。
23.类的初始化顺序:static对象-->非static 对象,同类型按先后顺序。


七.线程
1.声明一个线程的两种方式:1)实现runnable接口,并实现其上定义的唯一一个方法run()方法。2）扩展Thread类并重载其定义的run()方法。
2.Thread类本身已实现了Runnable接口,因此可以把一个Thread类的实例传递进另一个Thread类的构造器中。
3.通过调用Thread类实例(而不是Runnable实例)上的start()方法来启动线程,执行run()方法。但调用start()方法只是启动线程,并不意味着线程可以立刻得到执行,这取决于线程获取资源的情况和CPU的占有情况。
4.只能在Thread对象上调用一次start()方法,如果在同一个Thread对象上多次调用start()方法,则会导致RuntimeException异常抛出。
5.线程在生命周期中的5种状态:
   1)新建状态 当一个线程类实例被创建时,线程处于新建状态。此时的线程已初始化分配了资源,但还没有在该线程调用start()方法,此时线程是一个活的线程,但是还不是一个执行      线程。
   2)就绪状态 当start()方法获得调用,线程首先进入就绪状态。此时线程已具备可运行条件,进入线程队列,排队等待CPU,一旦获得CPU使用权,就可进入运行状态。
   3)运行状态 当就绪状态的线程被调度获得CPU资源时,便进入运行状态,定义在线程体中的run()方法被调用,从方法体的第一条语句开始执行。
   4)堵塞状态 处于运行状态的线程因事件的发生,而导致让出CPU的使用权,并终止当前执行,进入堵塞状态。处于阻塞状态的线程,只有当引起阻塞的原因被消除后,先必须转入就绪        状态,才可在获取CPU使用权从原来的中止处开始继续执行。
   5)死亡状态 线程死亡的原因有两个a.一个正常运行的线程执行完全部工作,即执行完了run()方法,并正常退出。b)一个线程被提前强制终止,例如调用destroy()方法终止线程。处          于死亡状态的线程不能被重新启动,即不具有重新运行的能力。如果用start()方法启动一个处于死亡状态的线程,则会抛出IllegalThreadStateException。
6.Thread类上定义了一些控制线程状态的方法,分别为:
   * void start()  使该线程开始执行;Java虚拟机调用该线程的run()方法。
   *void stop() 用于强制当前线程停止执行。
   * static void yield() 暂停当前正在执行的线程对象,并执行其他线程。
   * static void sleep(long millis) throws InterruptedException 在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。
   * final void join() throws InterruptedException 等待该线程终止。
   * final void join(long millis) throws InterruptedException 等待该线程终止的时间最长为millis毫秒,超时为0意味着要一直等下去。
   * final void join(long millis, int nanos) throws InterruptedException 等待该线程终止的时间最长为millis毫秒+nanos纳秒,参数nanos取值范围为0~999999,单位十亿分之一秒。
7.sleep()是一个静态方法,它使当前执行的线程休眠,不释放任何锁。sleep()方法仅可以保证休眠的线程至少休眠在sleep()方法的参数中指定的时间,但不能保证刚醒来的线程何时实    际返回到运行状态,这是因为线程在休眠结束时,只能重新进入就绪状态。一个线程不能让另一个线程休眠。
8.每个线程都有优先级,优先级是一个取值范围1~10的整数,具有优先级高的线程优先执行。在Thread类上定义了3个静态整型常量MAX_PRIORITY / MIN_PRIORITY /       NORM_PRIORITY代表最大优先级/最小优先级/默认优先级,3个常量分别对应的整型值为10 , 1 ,5 。
9.使用Thread对象上的setPriority()方法可以为线程设置优先级,但是优先级是没有保证的。如果没有明确地设置线程的优先级,那么线程优先级与创建该线程的线程具有同等优先级
10.yield()方法的目的是让具有相同优先级线程之间能够适当地轮转,以允许具有相同优先级的其他线程获得运行的机会,但不保证一定发生,线程可能让步,但也可能又立即重新进入      运行状态。最可能保证的是在任何指定的时间,当一个线程在运行时,其优先级通常不会比处于可运行状态的线程的优先级低。
11.当一个线程调用另一个线程的join()方法时,当前运行的线程将进入等待状态,直到它加入的线程完成为止。
12.Object类上定义了wait()方法用于阻塞线程。
    * final void wait() throws InterruptedException 导致当前的线程等待,直到其他线程调用此对象的notify()或notifyAll()方法。
    * final void wait(long timeout) throws InterruptedException 导致当前的线程等待,直到其他线程调用此对象的notify()或notifyAll()方法或超过指定的时间量。
    * final void wait(long timeout, int nanos) throws InterruptedException 导致当前的线程等待,直到其他线程调用此对象的notify()或notifyAll()方法或其他某个线程等待,或已超过      某个实际时间量。
13.通过调用setDaemon(boolean)方法,可以将一个线程设置为后台线程,该方法应在线程启动前调用,否则会抛出IllegalTreadStateException异常来。
14.synchronized关键字用于修饰同步化代码,为避免两个线程同时试图访问某一数据而造成数据损毁。每个对象都包含一个锁,当调用任何被声明为同步的方法时,对象就会被锁定,       不可再调用该对象上的其他同步方法,除非第一个方法完成结束,并解除了锁定。
15.synchronized只能用于修饰方法和代码块,不能用于修饰类和变量。它有两种形式,一种是修饰方法,形式为synchronized return_type method_name(){} ;一种是修饰代码块,形式      为synchronized(object_name){}。synchronized方法不能修饰构造器。
16.只有一个线程可以访问某个实例的同步代码,但是多个线程可以访问同一个对象的非同步代码。
17.wait() , notify(),notifyAll()方法都是定义在Object类中的,用于实现线程间的交互。3个方法必须从同步环境中调用,但Thread类本身并没有这3个方法的定义。调用wait()和              notify()方法时,该线程当前必须具有这个对象的锁。当在对象上调用wait()方法时,执行该代码的线程立即释放它在对象上的锁。然而在调用notify()方法时,并不意味着这时线程       会放弃其锁。如果线程仍然在完成同步代码,则线程在移出同步代码前不会释放其锁。因此调用notify()方法不意味着这时该锁将变得可用。
18.notify()方法用于向在相同对象等待池内,正处于等待状态的一个并且是唯一一个线程发送信号。notifyAll()方法的工作方式与notify()方法相同,只不过它是把信号发送给在该对象    上等待的所有线程。notifyAll()方法不能指定通知哪个等待的线程。
19.当被锁定的对象试图访问另一个被锁定的对象,而该对象又要访问第一个被锁定的对象时,便发生死锁现象。即两个线程彼此间都在等待对方线程释放其锁,而这些锁永远也不会       获得释放。
20.非静态同步方法访问静态属性是线程不安全的,只有静态同步方法访问才是线程安全的。同一个类中的同步静态方法不会被两个线程同时访问。
21.interrupt()方法中断线程，interrupted()判断线程是否中断

八.输入/输出
1.File类是文件和目录路径名的抽象表示形式.File类不用于实际的读写文件数据,其主要用于较高层次的操作文件,例如建立新文件、查找文件、删除文件、建立目录等。File类实例只是文件的代表,并不是文件本身,因此File类实例代表的文件,如果在文件系统中不存在,File类也不会在文件系统中自动创建该文件.File类的实例是不可变的,也就是说一旦创建File对象表示的抽象路径名将永不改变。
构造函数    File(String pathname)          File(String parent,String child)
常用方法   *boolean crateNewFile()             当且仅当不存在具有此抽象路径名所指定的名称的文件时,原子的创建由此抽象路径名指定的一个新的空文件。
                *boolean delete()                      删除此对象路径名表示的文件或目录,如果此路径名表示一个目录,则此目录必须为空才能删除。
                *boolean exists()                       测试此抽象路径名表示的文件或目录是否存在。
                *boolean isDirectory()                测试此抽象路径名表示的文件是否是一个目录。
                *boolean isFile()                        测试此对象抽象路径名表示的文件是否是一个标准文件。
                *boolean mkdir()                       创建此抽象路径名指定的目录。
                *boolean renameTo(File dest)     重新命名此抽象路径名表示的文件。
                *String getAbsolutePath()           获取文件类对象的绝对路径。            
2.FileReader类用来读取字符文件,属于低级I/O类,只能读取单个字符或固定数量的字符数据。
构造函数   FileReader(File file)                    在给定File中读取数据,并创建一个新的FileReader
                FileReader(String fileName)        在给定文件名的情况下,从中读取数据并创建一个新的FileReader。
常用方法   *int read()                                                       读取单个字符
                *int read(char[] cbuf, int offset, int length)          将字符流读入数组中的某一部分。
3.BufferedReader类用于从字符输入流中读取文本,缓冲各个字符,从而提供字符、数组和行的高效率读取。
构造函数   BufferedReader(Reader in)               创建一个使用默认大小输入缓冲区的缓冲字符输入流。
                BufferedReader(Reader in , int sz)     创建一个使用指定大小输入缓冲区的缓冲字符输入流。
常用方法   *int read()                                             读取单个字符
                *int read(char [] cbuf, int off, int len)       将字符读入数组的某一部分
                *String readLine()                                  读取一个文本行
                *void close()                                          关闭该流
4.FileWriter类用来写入字符文件,属于低级I/O类,只能写入单个字符或固定数量的字符数据。
构造函数   FileWriter(File file)                     在给出File对象的情况下,构造一个FileWriter对象。
                FileWriter(String fileName)        在给定文件名的情况下,构造一个FileWriter对象。
常用方法   *void write()                                                       写入单个字符
                *void write(char[] cbuf, int offset, int length)          写入数组中的某一部分。
5.BufferedWriter类用于将文本写入字符输出流,缓冲各个字符,从而提供单个字符、数组和字符串的高效写入。
构造函数   BufferedWriter(Writer out)                                     创建一个使用默认大小输出缓冲区的缓冲字符输出流。
                BufferedWriter(Writer out , int sz)                          创建一个使用指定大小输出缓冲区的缓冲字符输出流。
常用方法   *void write()                                                       写入单个字符
                *void write(char[] cbuf, int offset, int length)          写入数组中的某一部分。
                *void newLine()                                                   写入一个行分隔符
                *void flush()                                                        刷新该流的缓冲
                *void close()                                                        关闭该流
6.PrintWriter类用于向文本输出流打印对象的格式化表示形式,此类实现在PrintStream中的所有print方法。
构造函数   PrintWriter(File file)                                              使用指定文件穿件不具有自动行刷新的新PrintWriter
                PrintWriter(Writer out)                                          使用不带自动行刷新的新PrintWriter
常用方法   PrintWriter append(char)                                       将指定字符追加到此writer
                PrintWriter format(String format,Object...args)        使用指定格式字符串和参数将一个格式化字符串写入此writer中
                PrintWriter printf(String format,Object...args)          使用指定格式字符串和参数将一个格式化字符串写入此writer中的便捷方法
7.序列化分为两大部分序列化和反序列化,序列化是将对象数据分解成字节流,以便存储在文件中或在网络上传输,反序列化就是打开字节流并重构对象。对象序列化不仅保留了一个对象的数据,而且递归保留对象引用的每个对象的数据。
8.实现java.io.Serializable接口的类对象就可以启动其序列化功能转换成字节流或从字节流恢复。可序列化类的所有子类都是可序列化的,但不是每个类都可以序列化,如涉及线程类
9.一个类只要其自身实现了Serializable接口,而其父类没有实现Serializable接口,其依然可以进行序列化操作。不过在其进行反序列化时,系统会首先调用父类构造器先实例化父类,因为无法获取序列化的父类对象。
10.java.io包有两个序列化对象的类,ObjectOutputStream负责将对象写入字节流,ObjectInputStream负责从字节流重构对象。ObjectOutputStream类扩展DataOutput接口,其中writerObject()方法用于递归序列化对象及其引用的其他对象。ObjectInputStream类扩展DataInput接口,其中readObject()方法用于反序列化对象。每次调用readObject()方法都返回流中下一个Object。对象字节流并不传输类的字节码,而是包括类名及其签名。readObject()收到对象时,JVM装入头中指定的类,如果找不到这个类,则readObject()方法抛出ClassNotFoundException异常。
11.序列化时,类的所有数据成员均可序列化除了声明为transient或static的成员。将变量声明为transient后,序列化过程就无法将其加进对象字节流中,没有从transient数据成员发送的数据,在数据反序列化时,无法重建该数据成员,因为这个数据成员不向流中写入任何数据。为了定制序列化,需要提供writeObject()方法和readObject()方法来处理这些数据成员。使用writeObject()与readObject()时,必须按写入的顺序读取这些数据成员。
12.transient修饰符只能用于修饰变量,不能用于修饰类和方法。本地变量不能被transient修饰。
13.一旦变量被transient修饰,该变量不再是对象持久状态的一部分,该变量内容在序列化后无法获得访问。
14.transient修饰符的作用是保证变量的安全性,因为即使是私有变量,一经序列化处理,就可以通过读取一个文件,或者拦截网络传输得到它。
15.File f = new File("hello.test") 只完成创建一个代表文件"hello.test"的实例,而没有实际创建一个hello.test文件。 new FileOutputStream(f) 执行过程先判断指定的hello.test文件是否存在,如果存在,就打开该文件,如果不存在,就创建一个新文件并打开。如果无法创建新文件,则FileNotFoundException异常被抛出,打开文件后可对其进行读写操作。而new FileReader(f)在执行过程中则会抛出异常FileNotFoundException。
16.*FileReader类用于读取字符流,其上只提供读取字符的方法没有提供读取其他数据类型的方法。
     *PipedInputStream类用于连接到传送输出流,因此其构造器PipedInputStream(PipedOutputStream src)不能接收File对象,并且其只提供读取字节的方法,没有提供读取其他数据                                类型的方法。
     *DataInputStream类用于从基础输入流中读取基本java数据类型,因此其构造器DataInputStream(InputStream in)不能接收File对象。
17.java.io.RandomAccessFile 类的seek()方法: public void seek(long pos) throws IOException,该方法用于设置文件指针偏移量,该偏移量相对于文件起始处,是一个读取、写入字节的位置。偏移量可以超过文件结束点,但不会改变文件的长度。只有在偏移量超过文件结束点,且有数据写入后,才会改变文件的长度。
18.java.io.RandomAccessFile类当访问的文件不存在时,如果以只读模式("r")创建,则FileNotFoundException被抛出,如果以读写模式("rw")创建,则一个0长度的文件被创建。该类实现了DataOutputStream接口,所以可以向文件直接写入基本类型数据。
19.java.lang包中的System类,一般用作基本的IO控制台打印输出信息。out是定义在System类上的一个公共静态常量,其类型为PrintStream,调用其上的System.out.print()方法打印输出信息。
20.顶层类实现了Serializable接口,但是其成员类没有实现Serializable接口,则在序列化过程中会出现java.io.NotSerializableException异常。
21.在访问流时,如果流已关闭,则会抛出IOException异常。
22.当指定的文件为只读时,创建FileWriter类实例会抛出IOException异常。

九.基础包
1.Java中每个基本数据类型都有一个对应的封装类。所有的封装类都可直接以对应的基本类型数据作为构造器参数来构造实例,除了Character封装类外,其他的封装类也都可以以字符串作为构造器参数来构造实例。
   boolean     Boolean                 char       Character              int        Integer                float           Float
   byte          Byte                      short      Short                    long      Long                   double       Double
2.封装类是不可变类,一旦赋值其值就不能再改变。
3.封装类中包含的数值可以通过equals()方法来进行比较,可以通过xxxValue()方法来提取,即将封装类转换为基本类型。封装类也提供了静态parseXXX(String s)方法来将字符串s解析为基本类型,如果字符串包含非正确数字形式,则会抛出NumberFormatException异常。封装类也提供了静态valueOf(String s)方法来将字符串s解析为封装类型,如果字符串包含非正确数字形式,则会抛出NumberFormatException异常。
   Byte       byteValue()               Integer     intValue()            Float       floatValue()
   Short     shortValue()              Long        longValue()          Double    doubleValue()
4.封装类对象可以取值为null值,在拆箱时,会抛出NullPointerException异常。
5.String类是final类,不可以被任何子类继承。String类是不可变类,调用其上定义的可改变字符串内容的方法,将返回一个新字符串,而原有字符串将保持不变。
6.java.lang.包的String类中定义的常用方法:
   *char charAt(int index)                                         // 返回指定索引处的char值
   *int compareTo(String arnotherString)                   // 按字典顺序比较两个字符串,如果前后相等,返回0;如果前小于后,返回负数,如前大于后,返回正数。
   *int conpareToIgnoreCase(Sring str)                      // 不考虑大小写,按字典顺序比较两个字符串
   *String concat(String str)                                      // 将指定字符串联到此字符串的结尾
   *boolean contentEquals(StringBuffer sb)                // 当且仅当此String表示与指定的StringBuffer相同的字符序列时,才返回true
   *boolean equalsIgnoreCase(String anotherStr)        // 将此String与另一个String进行比较,不考虑大小写
   *boolean equals(Object anObject)                         // 比较此字符串与指定的对象
   *int hashCode()                                                   // 返回此字符串的哈希吗
   *int indexOf(int ch)                                              // 返回指定字符在此字符串中第一次出现处的索引
   *int indexOf(int ch,int fromIndex)                          // 从指定的索引开始搜索,返回在此字符串中第一次出现指定字符处的索引
   *int indexOf(String str)                                         // 返回第一次出现的指定子字符串在此字符串中的索引
   *int indexOf(String str,int fromIndex)                    // 从指定的索引开始搜索,返回在此字符串中第一次出现指定子字符串的索引
   *int lastIndexOf(int ch)                                         // 返回最后一次出现的指定字符在此字符串中的索引
   *int lastIndexOf(int ch,int fromIndex)                     // 从指定的索引开始搜索,返回最后一次出现的指定字符在此字符串中的索引
   *int lastIndexOf(String str)                                    // 返回最后一次出现的指定子字符串在此字符串中的索引
   *int lastIndexOf(String str,int fromIndex)               // 从指定的索引开始搜索,返回最后一次出现的指定子字符串在此字符串中的索引
   *int length()                                                        // 返回此字符串的的长度
   *String replace(char oldChar,char newChar)            // 返回一个新的字符串,它是通过用newChar替换此字符串中出现的所有oldChar而生成的
   *String[] split(String regex)                                   // 根据给定的正则表达式的匹配来拆分此字符串
   *boolean startsWith(String prefix)                          // 测试此字符串似乎否以指定前缀开始
   *boolean startsWith(String prefix,int offset)             // 测试此字符串似乎否以指定前缀开始,该前缀以指定索引开始
   *String substring(int beginIndex)                           // 返回一个子字符串
   *String substring(int beginIndex,int endIndex)        // 返回一个子字符串
   *String toLowCase()                                             // 将此字符串都转换成小写
   *String toUpperCase()                                          // 将此字符串都转换成大写
   *String toString()                                                 // 返回此字符串对象本身
   *String trim()                                                       // 返回字符串的副本,忽略前缀空白和后缀空白
7.StringBuffer和StringBuilder类都是final类,不可以被子类继承。StringBuffer和StringBulider都是可变类,StringBuffer类是线程安全的,而StringBuilder是线程不安全的,因此StringBuilder比StringBuffer速度快。这两个类具有相同的API。
8.java.lang包的StringBuffer类中定义的常用方法:
   *StringBuffer append(String? str)                            //将指定的字符串追加到此字符序列,也可接收StringBuffer参数
   *int capacity()                                                       //返回当前容量
   *char charAt(int index)                                          //返回此序列中指定索引处的char值
   *StringBuffer delete(int start,int end)                       //移除此序列中的子字符串的字符
   *StringBuffer deleteCharAt(int index)                      //移除此序列指定位置的char值
   *void ensureCapacity(int minimumCapacity)            //确保容量至少等于指定的值
   *int indexOf(String str)                                          //返回第一次出现的指定子字符串在该字符串中索引
   *int indexOf(String str, int fromIndex)                    // 从指定的索引处开始,返回第一次出现的指定子字符串在该字符串中索引
   *StringBuffer insert(int offset,String str)                  // 将字符串插入此字符序列中
   *int lastIndexOf(String str)                                     // 返回最右边出现的指定子字符串在此字符串中的索引
   *int lastIndexOf(String str,int fromIndex)                 // 从指定的索引处开始,返回最右边出现的指定子字符串在此字符串中的索引
   *int length()                                                          //返回长度(字符数)
   *StringBuffer replace(int start,int end,String str)        //使用给定String中的字符替换此序列的子字符串中的字符
   *StringBuffer reverse()                                           //将此字符序列用其反转形式取代
   *void setCharAt(int index,char ch)                           //将给定索引处的字符设置为ch
   *void setLongth(int newLength)                              //设置字符序列的长度
   *String substring(int start)                                      //返回一个新的String
   *String substring(int start, int end)                           //返回一个新的String
   *String toString()                                                   //返回此序列中数据的字符串表示形式
9.String类中未定义reverse()、append()和insert()方法。String类中的+连接符不能用于StringBuffer
10.String类重载了Object类的equals()方法,用来对对象的内容做比较。StringBuffer类并没有重载Object类的equals()方法,所以调用StringBuffer类的equals()方法,其实是比较对象的句柄。
11.java.util.regex.Pattern类是正则表达式的编译表现形式,指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 因此，典型的调用顺序是:
     Pattern p = Pattern.compile("a*b");                     // 将给定的正则表达式编译到模式中,并赋值给模式实例p
     Matcher m = p.matcher("aaaaab");                      // 调用模式p的方法matcher()创建匹配器
     boolean b = m.matches();                                  //调用匹配器的matches()方法尝试将整个输入序列与该模式匹配
     boolean c = m.lookingAt();                                // lookingAt()方法尝试将输入序列从头开始与该模式匹配
     boolean e = m.find();                                        // find()方法将扫描输入序列以查找与该模式匹配的下一个子序列
在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句boolean b = Pattern.matches("a*b","aaaaab");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。
12.Matcher类中定义的常用方法:
    * boolean matchers()                                         // 尝试将整个输入序列与该模式匹配
    * Pattern pattern()                                             // 返回由此匹配器解释的模式
    * boolean find()                                                // 尝试查找与该模式匹配器的输入序列的下一个子序列
    * boolean find(int start)                                     // 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列
    * int start()                                                      // 返回以前匹配的初始索引
    * int start(int group)                                         // 返回在以前的匹配操作期间,由给定组所捕获的子序列的初始索引
    * String group()                                               // 返回由以前匹配操作所匹配的输入子序列
    * String group(int group)                                  // 返回在以前匹配操作期间由给定组捕获的输入子序列
13.java.util.Scanner类是一个使用正则表达式来分析基本类型和字符串的简单文本扫描器。Scanner类使用分隔符模式将其输入分解为标记，默认情况下该分隔符模式与空白匹配,
也可以调用useDelimiter(String pattern)来设置分割符号,然后使用不同的next()方法将得到的标记转换为不同类型的值。
14.Scanner类上的hasNextXXX()方法仅会测试下一个标记的值,而不会实际地获得该标记,也不会移动到下一个标记;而nextXXX()方法既能获得下一个标记,也能移动到下一个标记。
15.java.io.PrintStream类新增的两个方法format()和printf(),用于格式化输出数据。
16.NumberFormat类是一个抽象类,不能通过构造器实例化,只能通过静态NumberFormat.getInstance()方法来获取NumberFormat类实例。
17.正则表达式常用元素:
    //                    反斜线字符
    /n                   新行
    /r                    回车符
    [abc]               a、b或c
    [^abc]             任何字符,除了a、b或c
    [a-zA-Z]           a到z或A到Z,两头的字母包括在内
    .                      任何字符
    /d                    数字[0...9]
    /D                   非数字[0...9]
    /s                    空白字符[/t/n/x0B/f/r]
    /S                    非空白字符[^/s]
    /w                   单词字符[a-zA-Z_0-9]
    /W                   非单词字符[^/w]
    X?                    X,一次或一次也没有
    X*                    X, 零次或多次
    X+                   X,一次或多次
18.Collection: 最基本的接口,定义了集合操作的各种方法
             List: 一个允许重复项的集合接口,通过索引操纵集合元素
             Queue:一个通常以先进先出的方式排列元素的集合接口
             Set:一个不支持重复项的集合接口
                     SortedSet:一个有顺序,不支持重复项的集合接口
    Map:一个支持按关键字检索的集合接口,但关键字必须唯一
             SortedMap:一个支持有顺序的值、键映射接口
19.List接口的重要特征是顺序性,它可以保证元素按照规定的顺序排列。List会生成一个ListIterator,利用它可在一个列表里实现向两个方向的遍历,同时可以插入和删除位于列表中部的元素。
20.ArrayList实现了List接口,作为一个常规用途的对象容器使用,用于替换原先的Vector,允许快速访问元素,但在从列表中部插入和删除元素时,速度较慢。一般只应该应用ListIterator对一个ArrayList进行向前和向后遍历,不要用它删除和插入元素,与LinkedList相比,其效率要低很多。
21.Vector可以实现可增长的对象数组,与数组一样,它包含可以使用整数索引进行访问的组件,但是Vector的大小可以根据需要增大或缩小,以适应创建Vector后进行添加或移除项的操作。与新集合的实现不同,Vector是同步的。
22.LinkedList提供优化的顺序访问性能,同时可以高效地在列表中部进行插入和删除操作。但在随机访问时,速度相当慢,此时应换用ArrayList,该类也提供了addFist()、addLast()、getFirst()、getLast()、removeFirst()以及removeLast()方法,以便将其作为一个队列以及一个双向队列使用。
23.Queue接口队列通常以FIFO的方式排序各个元素,不过优先级队列和LIFO队列例外,前者根据提供的比较器或元素的自然顺序对元素进行排序,后者按LIFO得方式对元素进行排序。无论使用哪种方式,队列的头都是调用remove()或poll()所移除的元素。在FIFO队列中,所有的新元素都插入队列的末尾。其他种类的队列可能使用不同的元素放置规则,每个Queue实现必须指定其顺序属性。
24.PriorityQueue是一个给予优先级堆的极大优先级队列。此队列按照在构造时所指定的顺序对元素进行排序,既可以根据元素的自然顺序,也可以根据Comparator来指定排序,这取决于使用哪种构造方法。优先级队列不允许null元素,依靠自然排序的优先级队列还不允许插入不可比较的对象,次队列的头是按指定排序方式的最小元素。如果多个元素都是最小值,则头是其中一个元素---选择方法是任意的。队列检索操作poll、remove、peek和element访问处于队列头的元素。优先级队列是无界的,但是有一个内部容量,控制着用于存储队列元素的数组大小。它总是至少与队列的大小相同。随着不断向优先级队列添加元素,其容量会自动增加。
25.添加到Set接口中的每个元素都必须是独一无二的,否则Set接口就不会添加重复的元素。添加到Set接口里的对象必须定义equals()方法,从而建立对象的唯一性。Set接口拥有与Collection接口完全相同的接口,一个Set接口不能保证自己可以按任何特定的顺序维持自己的元素。
26.HashSet用于非常小的以外的所有Set,其包含的对象必须定义有hashCode()方法。此类实现Set接口,由哈希表支持。它不保证集合的迭代顺序,特别是它不保证该顺序恒久不变。此类允许使用null元素。
27.LinkedHashSet具有可预知迭代顺序的Set接口的哈希表和链接列表实现。此实现与HashSet的不同之处在于,后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,即按照将元素插入到集合中的顺序进行迭代。注意,插入顺序不受在集合中重新插入的元素的影响。
28.TreeSet基于红黑树机制,这样可以获得一个顺序集合,此类保证排序后的set按照升序排列元素,根据使用的构造方法不同,可能会按照元素的自然顺序进行排序,或按照在创建Set时所提供的比较器进行排序。此实现为基本操作(add、remove和contains)提供了可保证的log时间开销。
29.Map接口支持键-值对应关系,以便通过一个键查找相应的值。
30.HashMap实现了Map接口,构成一个散列表。针对键-值映射对进行插入和检索,具有最稳定的性能。可通过设置散列表构造器的容量和装载因子对这一性能进行调整。
31.HashTable实现一个哈希表,该哈希表将键映射到相应的值。任何非null对象都可以用作键或值。
32.TreeMap基于红黑树机制,查看键或者键-值对时,它们会按固定的顺序排列。TreeMap最大的好处就是我们得到的是已排好序的结果。TreeMap是含有subMap()方法的唯一一种Map,利用它可以返回树的一部分。
33.LinkedHashMap是Map接口的哈希表和链接列表实现,具有可预知的迭代顺序。此实现与HashMap的不同之处在于,后者维护者一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序,该迭代顺序通常就是将键插入到映射中的顺序。注意,插入顺序不受在集合中重新插入的元素的影响。
34.定义在java.util包中的Comparable接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序。实现此接口的对象列表和数组可以通过Collections.sort和Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射表中的键或有序集合中的元素,无需指定比较器。实现Comparable接口的类必须实现其上定义的唯一一个compareTo()方法,返回值为负整数、零或正整数,代表此对象是小于、等于或大于指定对象。
35.定义在java.util包中的Comparator接口比较函数强行对某些对象collection进行整体排序。可以讲Comparator传递给sort方法,从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构的顺序。实现Comparator接口的类必须实现其上定义的compare(T o1,T o2)方法用来比较排序的两个参数。随第一个参数小于、等于或大于第二个参数二分别返回负整数、零或正整数。
36.java.util包中的Arrays和Collections类都定义有sort()和binarysearch()方法。sort()方法用于根据元素的自然顺序对指定列表按升序进行排序或根据制定比较器产生的顺序对指定列表进行排序。binarysearch()方法用于搜索特定的元素。如果存在匹配的元素,则binarysearch()方法返回匹配元素的索引;如果没有匹配的元素,则binarysearch()方法返回(-(插入点)-1)。插入点被定义为将键插入列表的那一点,即第一个大于此键的元素索引。如果列表中的元素都小于指定的键,则为list.size()。
37.Arrays类的asList()方法用于从一个数组创建一个列表,并将它们链接起来。
38.Collections类的reverse()方法用于反转指定列表中元素的顺序。
39.泛型多态赋值只应用于泛型主题集合,而不是泛型类型参数。
40.通配符语法允许泛型方法接受方法参数的声明类型的子类型或父类型。使用通配符时,集合只能访问不能被修改。
41.<?>代表可以保存任何类型对象。
42.泛型声明约定T表示类型,E表示元素。
43.泛型类型标示符可以用在类、方法或变量声明中,编译时将替换实际的类型。
44.在一个方法声明中可以使用多个参数化类型。不能将T用作返回类型。如果在方法的参数中使用T，则必须在返回类型前申明<T>。
45.java.util.Date类表示特定的瞬间,精确到毫秒,被存储为long值。Date类中定义的常用方法如下所示:
    Date()                                            //分配Date对象并初始化此对象,以表示分配它的时间
    boolean after(Date when)                 //测试此日期是否在指定日期之后
    boolean before(Date when)              //测试此日期是否在指定日期之前
    int compareTo(Date anotherDate)     //比较两个日期的顺序
    boolean equals(Object obj)              //比较两个日期的相等性
    String toString()                             //把此Date对象转换为String:dow mon dd hh:mm:ss zzz yyyy形式,其中dow是一周中的某一天(Sun Mon Tue Wed Thu Fri Sat)
46.java.util.Calendar 类是一个抽象类,它为特定瞬间与一组诸如YEAR,MONTH,DAY_OF_MONTH,HOUR等日历字段之间的转换提供一些方法,并为操作日历字段之间的转换提供了一些方法,并为操作日历字段提供了一些方法。Calendar是一个抽象类,因此不能被实例化,只能通过静态方法Calendar.getInstance()方法来获取Calendar类实例。Calendar类中定义的常用的方法:
    void add(int field, int amount)         //根据日历的规则为给定的日历字段添加或减去指定的时间量
    static Calendar getInstance()           //使用默认时区和语言环境获得一个日历
    int get(int field)                             //返回给定日历字段的值
    void roll(int field,boolean up)          //在给定的时间字段上添加或减去单个时间单元,不更改更大的字段
    void roll(int field,int amount)          //向指定日历字段添加指定时间量,不更改更大的字段
47.java.text.DateFormat 是一个抽象类,用于日期/时间的格式化,它以与语言无关的方式格式化并分析日期或时间。DataFormat类不能被实例化,只能通过静态方法DateFormat.getInstance()或DateFormat.getDateInstance()方法来获取DateFormat类实例。DateFormat类中定义的常用方法如下:
    DateFormat  getInstance()             //获得为日期和时间使用SHORT风格的默认日期/时间formatter
    DateFormat  getDateInstance()      //获得日期formatter，该formatter具有默认语言环境的默认格式化风格
    String format(Date date)               //将一个Date格式化为日期/时间字符串
    Date parse(String source)             //从给定字符串的开始分析文本,以生成一个日期
48.java.util.Locale类对象表表示了特定的地理、政治和文化地区。其中有两个构造器Locale(String language)和Locale(String language,String country)。Locale类中定义的常用方法如下:
    Locale getDefault()                        //静态方法返回一个Locale实例
    String getDisplayCountry()            //返回适合向用户显示的语言环境国家名
    String getDisplayLanguage()         //返回适合向用户显示的语言环境语言名

分享到：