java学习重点笔记专业资料

Java学习笔记

Java概述

java语言是解释执行，java源码是通过编译生成一种特殊.class中间字解码文献，然后再有JVM进行解释执行。

java语言对指针进行了上层封装，它保证可以通过这个指针（引用）来访问有效内存单元。

java语言不容许多继承，使继承关系成树装图，每个类都只能由一种父类。

java语言开发效率高，但执行效率低。（相称于c++55%）

java垃圾回收机制，在java中new对象不需要向c++同样进行delete操作，JVM会依照状况回收垃圾对象。（懒汉机制，等待资源没有时候才回收）咱们只可以建议JVM进行垃圾回收，例如（System.gc()RunTime.gc()这两个办法就是建议JVM进行垃圾回收办法）

JDK，java开发工具包（类库和运营命令），JRE，java运营环境，JVM，java虚拟机（解释执行核心，对字节码进行翻译成运营环境机器码，它可以屏蔽平台差别。JVM是不跨平台。）

JAVA_HOME,指明JDK安装位置，CLASSPATH，指明类文献位置，PATH，指明命令可执行文献位置。

java源文献文献名必要和文献中定义publicclass类名（大小写页要相似）相似。

java源代码中main办法定义写法。main办法是程序入口。

publicstaticvoidmain(String[]args){

System.out.println("Helloworld")；

}

java源文献也要先编译，使用javacxxx.java格式命令得来编译，使用javaxxx来运营。

定义包构造要放在有效代码第一行，packagexxx.xxx，包定义在一种程序中只能由一种，在加上包定义之后编译可以使用javac-d途径xxxx.java,这个-d这个命令行参数可以指定包构造位置“.”代表当前目录。在运营时要使用类全名

javaxxx.xxx.xxxx用包名以点分隔。运营时要在包构造上一层目录来运营。

java中注释

单行注释//......

多行注释/*.......*/

文档注释/**........<p>(换行标签)*/,用javadoc命令可以依照原码中文档注释生成注释文档（html格式）。文档注释中可以使用html标签。

javadoc-d途径（指定注释文档保存途径）

文档注释普通写在类定义之前，办法之前，属性之前。

在文档注释中可以用@author表达程序作者，@version表达程序版本，前两个注释符号要写在类定义之前，用于办法注释@param对参数进行注释,@return对返回值进行注释@throws对抛出异常注释。

jar命令用于打一种xxx.jar文献

用法：jar{ctxu}[vfm0Mi][jar-文献][manifest-文献][-C目录]文献名...

选项：

-c创立新存档

-t列出存档内容列表

-x展开存档中命名（或所有〕文献

-u更新已存在存档

-v生成详细输出到原则输出上

-f指定存档文献名

-m包括来自标明文献标明信息

-0只存储方式；未用ZIP压缩格式

-M不产生所有项清单（manifest〕文献

-i为指定jar文献产生索引信息

-C变化到指定目录，并且包括下列文献：

如果一种文献名是一种目录，它将被递归解决。

清单（manifest〕文献名和存档文献名都需要被指定，按'm'和'f'标志指定相似顺序

示例1：将两个class文献存档到一种名为'classes.jar'存档文献中：

jarcvfclasses.jarFoo.classBar.class

示例2：用一种存在清单（manifest）文献'mymanifest'将foo/目录下所有

文献存档到一种名为'classes.jar'存档文献中：

jarcvfmclasses.jarmymanifest-Cfoo/。

普通在使用使用jarcvf文献名.jar文献所在途径（xxx/xxx/xxx.class）也可以压缩一种目录,只要在制定途径是指定为文献夹，jar命令命令行参数在使用时可以以“-”开头，也可以不用。

java程序运营过程，一方面是启动java虚拟机，然后就是去找.class文献，先是从系统类库中找（系统之会在跟目录下查找，因此需要完整类名），如果找不到话会去CLASSPATH所设立目录去找。然后加载到java虚拟机中。

系统会在每个java程序中隐含导入了java.lang这个包，import包名，导入包中类文献。

java.lang包，这是一种基本包。

java.util包,这个包是工具类包。

java.io包,这个包是用于输入输出操作

包,这个包是用于网络编程。

java.awt，java.swing，javax.swing，java.event等包用于图形编程用包。

applactionjava应用程序，java应用程序中必要有一种main()办法。

标记符和核心字

Java代码中“；”、“{}”、“”

Java语句以分号分隔，Java代码块包括在大括号内，忽视空格.标记符

1)用以命名类、办法和变量、以及包遵守JAVA命名规范类以每个单词都以大写字母开头。办法和变量第一种字母不大写，其她照旧。

2)只能以字符、“_”或“$”开头；

3)无长度限制。

java中核心字

goto和const在java中虽然不再使用但是还作为核心字存在

java中没有sizeof这个核心字了，java中boolean类型值只能用true和false，且这两值也是核心字。

java语言中没有无符号这个核心字（unsigned）

java中数据类型

1)整型

byte1字节 8位-128到127

short2字节 16位-2^15到2^15-1

int4字节 32位-2^31到2^31-1

long8字节 64位-2^63到2^63-1

2)浮点类型

float4字节 32位

double8字节 64位

3)字符类型

char2字节 16位

4)布尔型

booleanfalse/true

注：1)char是无符号16位整数,字面值必要用单引号括起来；‘a’

2)String是类，非原始数据类型；

3)长整型数字有一种后缀为“L”或“l”，八进制前缀为“0”，十六进制前缀为“0x”；

4)黙认浮点类型为double；

5)float数据类型有一种后缀为“f”或“F”,Double数据类型后可跟后缀“D”或“d“

6)char类型也可以用通用转译字符，但是不能用ASCII码。可以用“\u0000”这种格式，由于char型中使用是unicode编码方式。

注：整型值存储，正数存储原码（二进制码），负数则存储补码（原码按位取反末位加一）。

注：实型值在存储时会损失精度，因此不要直接比较两个实型值。系统默认实型都是double型，要使用时要在数据后加个f，或者强行转换。强转（占字节数大类型转到占字节数小类型）时会放弃高位值只取低位值。

java中数字数据类型减灾由占字节数小类型到占字节数大类型可以有自动转换，反之则需要强行转换，char型和int型之间可以互相转换。char和short不能像户转换。

注意：隐式类型转换；

a运算符b，如果a，b中有任意一种是double型，前面运算成果就是double型，如果a，b中有任意一种是float型，前面运算成果就是float型，如果a，b中有任意一种是long型，前面运算成果就是long型，如果a，b中没有double、float、long型，那么其成果就为int型。

所有基本数据类型在使用时会事先分派空间，只自身就存在空间中，在传递时，就是值传递，不是引用传递。

在类中定义办法在返回值前加上static修饰符就可以在main办法中调用了。如果不用static那就需要在main办法中创立对象，使用对象来调用对象办法。

publicclassTest{

publicstaticvoidmain(String[]args){

Testt=newTest()；

intb=1；

intc=2；

int[]a=newint[10]；

t.sqort(a)；

add(b,c)

}

publicint[]sqort(int[]a){

.......

}

staticintadd(b,c){

.......

}

}

java中运算符（java运算符优先级和结合性和c++相似）

System.out.println(3/2)按整型计算得1

1)>>=前面是零补零，前面是一补一；

2)>>>=无符号右移（强制右移都会移进一），

>>=和>>>=对于负数不同样

正数：右移n位等于除以2n次方

负数：变成正数。

3)&&短路与，前面为假，表达式为假，背面操作不会进行，&会对所有条件进行判断。

4)||短路或，前面为真，表达式为真，背面操作不会进行，|会对所有条件进行判断。

例：

if(a<3&(b=a)==0)b赋值

if(a<3&&(b=a)==0)b不赋值

5)instanceof，是用于判断一种对象与否属于某个类型

6)java中求余运算符“%”可以对两个实型变量求余

注：按位与是为了让某些位置一，按位或是令某些位置零，按位异或是令某些位取反。

注：使用左右位移和无符号右移运算符用法是变量名<<=位移位数，变量名>>=位移位数(前两个运算符是不会忽视整形符号位，也称逻辑位移),变量名>>>=位移位数

注意：左右位移和无符号右移运算符只能用于整形及其兼容类型（byte，int，short，long）

注意：java程序运营过程，一方面是启动java虚拟机，然后就是去找。class文献，先是从系统类库中找（系统之会在跟目录下查找，因此需要完整类名），如果找不到话会去CLASSPATH所设立目录去找。然后加载到java虚拟机中。如果要使用到其她在JAVA_HOME中没有类或者是其她公司提供第三方。jar（jar包）文献时，要把它途径及文献名加到CLASSPATH中。

java流程控制

控制流

if()

if()….else

if()…..elseif()….else

注意：else只是和其上面同层近来if()来配对。

switch(){

case'a':……..

case1:……break；

default:

…………

}

注解：switch()内数据类型为byteshortcharint类型，只有以上四种类型才可以在switch()中使用。case块中不加break时顺序执行下面语句。

循环语句

for(inti=0；i<n；i++){}

while(){}

do{}while()；-----------注意加分号

例子：

loop:for(inti=0；i<n；i++)

{

for(intj=0；j<m；j++)

{

if(3==j)

{

breakloop；//--loop为标签只能用在循环语句中，用于循环跳到外层循环

}

}

}

辨析：

intx,a=6,b=7；

x=a+++b++；//----------a=7,b=8,x=13

intx=6；x=~x；//----------------6二进制0110取反得11001再转成补码（取反加一） 10111＝－7

break，跳出本层循环，执行背面代码，continue，提前终结本次循环，再一次进行循环或循环条件满足或不满足后退出循环。break标签名；continue标签名；这两条语句知识表达跳出有标签循环和提前终结本次有标签循环，只能用在循环语句（多层循环嵌套）中，循环嵌套中用于跳到外层循环。

注意：for循环在使用时一定要注意不要忘掉()中两个"；"，死循环写法for(；；){}或者是用

while(true){}

注意：System.out.println("..."+a)在使用这个语句时，它会将其中非字符串（String）值转换成字符串（不是所有数据类型都可以）。

java中数组Array，其包括两个某些，分别是数组引用和数组空间两某些。

声明数组

1)一组相似类型(可以是类)数据集合；

2)一种数组是一种对象；

3)声明一种数组没有创立一种对象；

4)数组能如下列形式声明：

int[]i或inti[]

Car[]c或Carc[]

*C++中只能Carc[]

*JAVA中推荐用Car[]c；

5)数组定义如：

int[]a（数组引用声明）=newint[10]（数组空间声明，并把空间首地址赋值给数组引用）

int[]a；

a=newint[20]；

创立数组

1)创立基本数据类型数组int[]i=newint[2]；

2)创立引用数据类型数组Car[]c=newCar[100]；

3)数组创立后有初始值。

数字类型为0布尔类型为false引用类型为null

注意：访问没有初始化数组中值，是会抛出异常（NullPointerException）,java中只保证一位数组地址是持续，二维数组事实上是一维数组中有存储了一维数组引用。

初始化数组

1)初始化、创立、和声明分开

int[]i；

i=newint[2]；

i[0]=0；

i[1]=1；

2）初始化、创立、和声明在同一时间

int[]i={0,1}；

Car[]c={newCar(),newCar()}；

多维数组

1）有效定义

int[][]i1=newint[2][3]；（同步给定一维，二维空间）

int[][]i2=newint[2][]；（给定一维空间，二维空间待定）

i2[0]=newint[2],i2[1]=newint[3]；

*C++中int[][]=newint[][3]；有效

2）无效定义

int[][]i1=newint[][3]；

3）数组长度------------数组属性length（在二维数组中这个属性只代表第一维长度）

int[]i=newint[5]；

intlen=i.length；//len=5；

Student[][]st=newStudent[4][6]；

len=st.length；//len=4；

len=st[0].length；//len=6；

数组拷贝

System.arrayCopy(Objectsrc，intsrcPos，Objectdest，intdestPos，intlength)；

src源数组，srcPos从第几位开始拷贝，dest目的数组，destPos目的数组放置起始位置，length，表达要拷贝长度。

拷贝一种数组到另一种数组。

类对象创立和对象数组

一种xxx.Java文献中可以定义各种类但是只能由一种public修饰类，也只能以这个类类名作为.java文献名。

java中类对象创立，要先创立这个对象引用，例如：Carc；然后用new这个核心字创立一种对象实例（对象空间）例如：c=newCar()；，然后对象实例空间首地址赋值给对象引用。各种对象引用可以同步引用自同一种对象实例，但是对象引用只能引用一种对象实例。

对象引用和对象实例间就像是牵着气球线和气球同样。

注意：只有一种没有被任何对象引用所引用对象实例才会边城垃圾等待被垃圾回收。

对象数组

例：Car[]c=newCar[3]；

c[0]=newCar()；

注意：存储基本类型数组数据是直接存储在数组空间中，而对象数组在数组空间中存储则是对象引用。

定义在类中类属性是实例变量，定义在类办法中变量是局部变量。实例变量是保存在对象空间中，而局部变量则是在办法调用分派空间，调用结束后就释放空间。

注意：在类定义中属性定义和办法定义必要写在类里。

注意：系统会自动初始化实例变量，数字类型为0，布尔类型为false，引用类型为null。局部变量需要初始化，必要赋初值。如果不赋初值无法通过编译。

Java中办法调用中参数传递有两种，一种是对于参数是基本类型使用是值传递（直接传参数值），另一种是引用传递，它是用于参数是类对象，它传递是这个对象引用。

面向对象思想

anythingisObject（万物皆对象）

抽象，从对详细对象中抽取有用信息。

对象有其固有属性，对象办法，即对象行为（对象能做什么）

对象自身是简朴（功能简朴），各种对象可以构成复杂系统（对象之间彼此调用对方办法）

对象应当是各司其职（功能简朴），各尽所能（把自己功能作到最佳）。（弱耦合性实现了前面所述对象特点）

对象耦合性，是对象之间联系，对象和系统之间联系。对象耦合性要尽量弱，也就是对象之间联系尽量弱，对象和系统之间联系尽量弱。

系统可插入性，是在系统中加入新对象之后系统稳定性。

对象可替代性，是在系统中替代原有对象之后系统稳定性。

复用性，即对象可否被重复使用，对象功能越简朴，复用性就越好。（对象耦合性弱，复用性就比较强）

面向过程是先有算法，后又数据构造（怎么解决问题）

面向对象是先有对象（数据构造），后有算法。（用什么做）

类是某些有着相似属性集合抽象。

类是一种类对象模板，对象是类详细化。

类是一种新数据类型，类对象。

注意：局部变量作用范畴是在定义她代码块以内，局部变量要先赋值后使用，在以一种重叠作用于范畴内不容许两个局部变量命名冲突。局部变量局部优先，且在于实例变量同名时会副该局部变量。

变量涉及简朴变量（原始数据类型），对象变量。

办法定义：

1，办法修饰符（各种修饰符浮现顺序无关）|

2，办法返回值类型|顺

3，办法名|序

4，办法参数表|向

5，办法中容许抛出异常|下

java中不可以在返回语句后写任何代码。JVM+解释器=JRE，JRE+类库=JDK

java中办法重载（overload）办法名相似，参数表不同，返回值类型可以不同。调用时要给出明确参数并拟定调用某一办法。在编译时，编译器会依照参数选取恰当办法，因此重载也叫编译时多态。

就近向上匹配原则

如果办法参数表中数据类型和调用时给出参数类型不尽相似时会依照向上匹配就近原则。（类型就近向上转化匹配）

注意：调用时要给出明确参数并拟定调用某一办法，否则编译会出错。

对象使用者（调用其她对象办法）对象（对象中办法被调用时依照参数进行自己进行选取）

一类办法，但跟据不同参数会有差别，对象回依照参数判断，对对象调用者透明。

创立对象过程：1，分派空间2，初始化属性3，调用构造办法（有前提，不考虑继承关系）

构造办法写法：没有返回值类型，构造办法办法命名必要和类名相似。如果在类中不写构造办法，系统会提供一种无参构造办法。

注意：最佳在写类时提供一种无参构造办法。

获得对象方式

通过new（在堆空间中申请分派空间），new类名（），可以通过这种形式或一种对象，这时对象是无法使用，必要把她地址存储近一种对象变量才可以使用。例如：Carc=newCar()；

有参构造办法在被调用时，在用new核心字或对象时初始化，例如：Carc=newCar("yellow")

对象变量中存储是对象引用（地址封装形式）

this核心字

表达当前对象（哪个对象调用了办法，哪个对象就是当前对象），可以用来区别实例变量和局部变量。this(),她表达掉用本类其她构造办法，注，只能写在构造办法第一行。

java中参数传递，简朴类型变量传递是数值，对象变量传递则传递一种引用（地址）

面向对象三大特性

封装、继承、多态。

java中封装

封装，一种对象和外界联系应当通过一种统一接口，应当公开公开，应当隐藏隐藏。（对象属性应当隐藏），一种对象内部是透明，就是把对象内部可透明性和隐藏特性区别开，该透明透明，该隐藏隐藏。

（封装属性）java中类属性访问权限默认值不是private，要想隐藏该属性或办法，就可以加private（私有）修饰符，来限制只可以在类内部进行访问。

对于类中私有属性，要对其给出一对办法（getXxx(),setXxx()）访问私有属性，保证对私有属性操作安全性。

办法封装

对于办法封装，该公开公开，该隐藏隐藏。办法公开是办法声明（定义），即（只须懂得参数和返回值就可以调用该办法），隐藏办法实现会使实现变化对架构影响最小化。。

封装会使办法实现变化对架构影响最小化。

完全封装，类属性所有私有化，并且提供一对办法来访问属性。

java中继承

继承，是对有着共同特性多类事物，进行再抽象成一种类。这个类就是多类事物父类。父类意义在于可以抽取多类事物共性。

java中继承要使用extends核心字，并且java中只容许单继承，也就是一种类只能有一种父类。

这样就是继承关系呈树状，体现了java简朴性。

子类只能继承在父类中可以访问属性和办法（事实上父类中私有属性和办法也会被继承但子类中无法访问罢了）。

访问控制修饰符（可以修饰属性和办法）

private修饰符，表达只有本类内部可以访问。

default修饰符，办法不加修饰符，会默以为default，表达在同一种包中可以访问，父子类在同一包中，子类可以继承父类相应内容。（可以修饰类）

protected（保护）修饰符，表达同一包中可以访问，不同包子类也可以访问继承。

public修饰符，表达公开，在任何地方都可以访问。（可以修饰类）

修饰符权限是由上而下逐渐变宽。

继承意义

在于子类可以在父类基本之上对父类功能进行发展,继承可以使系统耦合性减少，也就是使对象间联系便松散，使多类对象间联系用其父类对象代替。

注意：构造办法不能被继承。

父类属性及办法拟定

要从子类角度来看子类间共性，当所有子类均有这个属性时，就应当考虑与否该放在父类中，办法也是如此，办法可以被看作是对象行为，而类办法这时这一类对象所共有行为，因此也应当在办法拟定期注意是不是所有子类型中都需要有这种办法，并且会依照不同类型行为方式也不同才可以覆盖着个办法。

java中办法覆盖

子类中有和父类中可访问（可继承到子类）同名同返回类型同参数表办法，就会覆盖从父类继承来办法。

注意：在jdk1.4此前规定办法覆盖时，需要办法返回值，参数表，办法名必要严格相似，而在jdk1.5中办法覆盖，子类中覆盖办法返回值可以是父类中被覆盖办法返回值类型子类型。

注意：子类办法覆盖父类办法时，办法修饰符要么相似，要么子类中办法修饰符表达访问权限要宽于父类。父类中私有办法，不能被继承到子类，就是说子类中虽然将其覆盖了也不会有多态。

覆盖意义：对从父类中继承办法发展。

注意：父子类中有同名属性不叫子类覆盖父类属性，叫做属性遮盖（shadow）。

当构造有继承关系对象环节

1，递归构造父类对象

2，分派空间

3，初始化本类实例变量（属性）

4，调用本类构造办法

注意：子类对象中其实包括着父类对象，也就是父类对象加上子类对象，才是完整子类对象实例。

super核心字

super()，表达在子类构造办法中调用父类构造办法（可以通过这种办法在子类构造办法中初始化父类中属性），super()也只能出当前构造办法第一句上.super(),在子类构造方中指明构造父类时调用哪一种父类构造办法构造父类。

super,这里所示是一种父类对象，可以通过super来使用父类中可以访问办法（可以在父类中定义setXxx()，getXxx()办法来访问父类中私有属性），super可以屏蔽父子类中同名属性冲突。

注意：在写类时候，一定要写默认无参构造办法，如果一种构造办法第一句既不是this(),也不是super()时，那么就会在这里隐含调用她父类无参构造办法，即隐具有super()。

少覆盖原则：

既子类应当尽量少覆盖父类办法，如果覆盖了父类大多数办法，那就应当考虑与否应当有继承关系

java中多态（以子类覆盖了父类办法为前提）

多态，把子类对象主观看作是其父类型对象，那么父类型就可以是诸各种类型。

多态，编译时多态（办法重载）

运营时多态（多态）

编译时类型，也就是可以被看作类型，主观认定。

运营时类型，也就是实际对象实例类型，客观不可变化（也是被看作类型子类型）

对于一种对象来说，在对象产生时，运营时类型就已经拟定不会再变化，编译时类型可以和运营时类型不同。在对象变量声明时可以拟定其运营时类型，但是编译时类型对象变量背后所指向运营时类型则可以是其本类型或者是其子类型。

多态三特性

1，对象实例拟定则不可变化（客观不可变化）

2，只能调用编译时类型所定义办法。

3，运营时会依照运营时类型去调用相应类型中定义办法。

多态意义：在需要使用一类对象共性时，可以用多来屏蔽掉其子类中差别。

注意：类属性是没有多态，只会依照编译时类型访问。只有子类覆盖了父类办法，且把子类对象党作父类类型来看时才会有多态。要注意区别子类中办法重载。对于办法重载，则是会使用编译时类型来进行相应办法调用。

两种复用

1，白箱复用，也就是继承复用，父类中可以被子类访问到就可以被继承，这样会有些不需要内容被继承下来，因此这种方式不太好。

2，黑箱复用，也叫组合复用，也就是把要复用代码类对象作为本类中一种属性，然后再通过办法委托来实现由选取复用，办法委托就是在本类办法内部通过该类对象调用要使用类办法。

注意：尽量用组合复用代替继承复用。

多态使用

多态用于参数，可以在办法参数中传入其父类类型，在运营时会依照实际运营时类型来在办法中进行相应操作。

多态用于返回值，可以在办法返回值类型上是用其实际返回值父类型，在有效期返回值时也不比关怀其实际类型。

多态可以使代码变得更通用，以适应需求变化。也就是定义在父类中办法，可以在子类中有不同实现将其覆盖，在为父类型对象变量赋值相应需要功能子类对象实例。

java中修饰符

static表达静态，它可以修饰属性，办法和代码块。

1，static修饰属性（类变量），那么这个属性就可以用类名.属性名来访问，也就是使这个属性成为本类类变量，为本类对象所共有。这个属性就是全类公有。（共有类变量与对象无关，只和类关于）。

类加载过程，类自身也是保存在文献中（字节码文献保存着类信息），java会通过I/O流把类文献（字节码文献）读入JVM（java虚拟机），这个过程成为类加载.JVM（java虚拟机）会通过类途径（CLASSPATH）来找字节码文献。

类变量，会在加载时自动初始化，初始化规则和实例变量相似。

注意：类中实例变量是在创立对象时被初始化，被static修饰属性，也就是类变量，是在类加载时被创立并进行初始化，类加载过程是进行一次。也就是类变量只会被创立一次。

2，static修饰办法（静态办法），会使这个办法成为整个类所公有办法，可以用类名。办法名访问。

注意：static修饰办法，不直接能访问（可以通过组合方式访问）本类中非静态(static)成员（涉及办法和属性），本类非静态（static）办法可以访问本类静态成员（涉及办法和属性），可以调用静态办法。静态办法要慎重使用。在静态办法中不能浮现this核心字。

注意：父类中是静态办法，子类中不能覆盖为非静态办法，在符合覆盖规则前提下，在父子类中，父类中静态办法可以被子类中静态办法覆盖，但是没有多态。（在使用对象调用静态办法时其实是调用编译时类型静态办法）

注意：父子类中，静态办法只能被静态办法覆盖，非静态办法只能被非静态办法覆盖。

java中main办法必要写成static是由于在类加载时无法创立对象，由于静态办法可以不通过对象调用，因此在类main办法所在类加载时就可以通过main办法入口来运营程序。

注意：组合方式，就是需要在办法中创立一种所需要对象，并用这个对象来调用任意所需该对象内容，不会再受只能访问静态约束。

3，static修饰初始代码块，这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一种类。

动态初始代码块，写在类体中“{}”，这个代码块是在生成对象初始化属性是运营。这种代码块叫动态初始代码块。

类在什么时候会被加载，构造（创立）对象时会加载类，调用类中静态办法或访问静态属性也是会加载这个静态办法真正所在类。在构造子类对象时必会先加载父类，类加载会有延迟加载原则，只有在必要加载时才会加载。

final修饰符，可以修饰变量，办法，类

1，final修饰变量

被fianl修饰变量就会变成常量（常量应当大写），一旦赋值不能变化，（可以在初始化时直接赋值，也可以在构造办法里也可以赋值，只能在这两种办法里二选一，不能不为常量赋值），fianl常量不会有默认初始值，对于直接在初始化是赋值时final修饰符常和static修饰符一起使用。

2，final修饰办法，被final修饰办法将不能被其子类覆盖，保持办法稳定不能被覆盖。

3，final修饰类，被final修饰类将不能被继承。final类中办法也都是final。

注意：final，不能用来修饰构造办法，在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类类加载。静态常量如果其值可以拟定，就不会加载该类，如果不能拟定则会加载该常量所在类。

不变模式：对象一旦创立属性就不会变化。用final修饰属性，也用final修饰类（强不变模式），用final修饰属性（弱不变模式）。

不变模式典型体现：java.lang.String类，不变模式可以实现对象共享（可以用一种对象实例赋值给各种对象变量。）

池化思想，把需要共享数据放在池中（节约空间，共享数据）只有String类可以用“”中字面值创立对象。在String类中，以字面值创立时，会到Java办法空间串池空间中去查找，如果有就返回串池中字符串地址，并把这个地址付给对象变量。如果没有则会在串池里创立一种字符串对象，并返回其地址付购对象变量，当另一种以字面值创立对象时则会重复上述过程。

如果是new在堆空间中创立String类对象，则不会有上述过程。

String类中intern()办法会将在堆空间中创立String类对象中字符串和串池中比对，如果有相似串就返回这个串串池中地址。

不变模式在对于对象进行修改，添加操作是使相称麻烦，她会产生诸多中间垃圾对象。创立和销毁资源开销是相称大。

String类在字符串连接时会先效率很低，就是由于它所产生对象书性是不可以修改，当连接字符串时也就是只能创立新对象。

对于诸多字符串连接，应当使用StringBuffer类，在使用这个类对象来进行字符串连接时就不会有多余中间对象生成，从而优化了效率。

abstract（抽象）修饰符，可以修饰类和办法

1，abstract修饰类，会使这个类成为一种抽象类，这个类将不能生成对象实例，但可以做为对象变量声明类型，也就是编译时类型，抽象类就像当于一类半成品，需要子类继承并覆盖其中抽象办法。

2，abstract修饰办法，会使这个办法变成抽象办法，也就是只有声明（定义）而没有实现，实现某些以"；"代替。需要子类继承实现（覆盖）。

注意：有抽象办法类一定是抽象类。但是抽象类中不一定都是抽象办法，也可以全是详细办法。

abstract修饰符在修饰类时必要放在类名前。

abstract修饰办法就是规定其子类覆盖（实现）这个办法。调用时可以以多态方式调用子类覆盖（实现）后办法，也就是说抽象办法必要在其子类中实现，除非子类自身也是抽象类。

注意：父类是抽象类，其中有抽象办法，那么子类继承父类，并把父类中所有抽象办法都实现（覆盖）了，子类才有创立对象实例能力，否则子类也必要是抽象类。抽象类中可以有构造办法，是子类在构造子类对象时需要调用父类（抽象类）构造办法。

final和abstract，private和abstract，static和abstract，这些是不能放在一起修饰符，由于abstract修饰办法是必要在其子类中实现（覆盖），才干以多态方式调用，以上修饰符在修饰办法时期子类都覆盖不了这个办法，final是不可以覆盖，private是不可以继承到子类，因此也就不能覆盖，static是可以覆盖，但是在调用时会调用编译时类型办法，由于调用是父类办法，而父类办法又是抽象办法，又不可以调用，因此上修饰符不能放在一起。

抽象（abstract）办法代表了某种原则，定义原则，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类继承抽象办法实现）。

办法一时间想不到怎么被实现，或故意要子类去实现而定义某种原则，这个办法可以被定义为抽象。(abstract)

模板办法模式：用abstract把制定原则和实现原则分开，制定原则就是模板，实现就是按模板原则来实现，也就是继承模板，实现模板中相应功能办法。模板中不容许修改办法可以用fianl来修饰，这个办法不能使抽象办法，为保证安全，封装，把模板中不公开某些用protected（保护）修饰。

Java中接口

接口是一种程序构造，是特殊抽象类。接口中办法必要都是公开抽象办法（publicabstract），接口中属性都是公开静态常量（publicstaticfinal）。

声明一种接口用 interface 核心字,接口也是一种类型，编译之后也有生成相应字节码，她声明规范也要符合类型定义(一种源文献中只能有一种public interface，接口名和源文献名相似，有public interface，就不能在写public class了)。接口中属性可以不加修饰符，办法也不用加修饰符。

接口也可以继承，但是只能由接口继承，在用类去继承时要换用implements 核心字，这时类和接口也不叫做继承关系，而是实现关系，但其实质也是继承。

一种类可以继承也只能继承此外一种类，但是可以实现各种接口，其语法是在implements背面写接口名，各种接口以“，”分隔。

接口之间是可以多继承，其语法和类继承语法是相似，在接口多继承时，在extends后写接口名如果要继承各种接口，接口名以“，”分隔，接口继承关系只是把其父接口中抽象办法继承到子接口中。要实现接口就必要实现接口中所有办法。

一种类可以在继承一种类同步，也可以实现一种或各种接口。采用接口就绕开了单继承限制。

接口类型也可以做为编译时类型使用，但其实际运营时类型必要是完全实现接口类对象实例，这样就使多态变得很灵活了，

注意：实现接口时，在实现(覆盖)抽象办法时，注意必要要在办法返回值类型前加public修饰符。如果没有完全实现接口中办法，那么这个类就只可以是个抽象类，不能创立对象。接口是实质就是特殊抽象类。接口没有构造办法。

接口意义：

1，接口可以实现多继承。

2，用接口可以实现混合类型（主类型，副类型），java中可以通过接口分出主次类型。主类型使用继承，副类型，使用接口实现。

3，接口进一步深化了原则思想，接口自身就是一种原则，她起到了减少耦合性作用，接口可以使办法定义和实现相分离，也就是将接口定义者和实现者相分离，接口也可以用于减少模块间或系统间耦合性。针对接口编程可以屏蔽不同实现间差别，看到只是实现好功能，

接口：定义原则，

接口实现：实现原则

接口调用者：原则使用

针对接口编程原则，也就是按照原则实现。

接口回调：先有接口定义（接口实现者），再有接口使用者，最后把接口实现对象传入接口使用者中，接口使用者会通过接口来调用接口实现者办法。

接口回调：接口定义者定义好了原则，接口使用者先写好了使用代码，接口实现者写好实现之后把实现对象传入接口使用者中。她调用接口中办法也就是掉用接口实现中办法。这种过程叫做接口回调。

尽量使用接口类型作为编译时类型，尽量将抽取到共性行为写在接口中。

用若干个小接口取代一种大接口。（接口隔离原则）

把一种类功能作成接口，只暴露想暴露办法，接口隔离原则可以实现更高层次封装，针对对象不同，暴露办法也不同。

java中根类Object

java中所有类父类或直接或间接或隐含都是Object类。

java不容许循环继承，也就是互相继承是不可以。

Object类中finalize()一种对象被垃圾收集时候，最后会由JVM调用这个对象finalize办法

Object类中有一种String toString()办法，返回该对象字符串表达。Object类中toString()办法她返回是类名加上她地址一种字符串。在子类中推荐覆盖toString()办法。

Object类中boolean equals(Objecto)办法是用来比较对象内容与否相等，其返回值是boolean类型值，相似为真，不同则为假。事实上还是比较对象地址与否相似。String类覆盖了equals()办法，她比较是对象中内容与否相似。子类中也推荐覆盖Object类中继承equals()办法

equals()覆盖原则：

自反性：x.equals(x)为true

对称性：y.equals(x)和x.equals(y)值要相似，要么都为true，要么都为false。

传递性：x.equals(y)为true，y.equals(z)也为true，那么x.equals(z)一定也为true。

覆盖equals()办法环节：

booleanequals(Objecto)

{

if(this==o)returntrue；//1,看看是不是一种对象

if(o==null)returntrue；//2,看看对象是不是空

if(!(oinstanceof本类类名))returnfalse；//看看是不是本类对象

......//依照本类设计。

}

封装类

java为每一种简朴数据类型提供了一种封装类，使每个简朴数据类型可以被Object来装载。

除了int（Integer）和char（Character），别的类型首字母大写即成封装类类型名。

转换字符方式：

intI=10；

Strings=I+””；

Strings1=String.valueOf(i)；

IntI=10；

IntergerI_class=newinteger(I)；

封装类、字符串、基本类型间转换

Interger--------------------(Double(x.toString))------------>Double

String-----------------(Integer.valueOf())---------------->Integer

Integer-----------------(x.toString())--------------------->String

int----------------------(100+””)------------------------->String

String------------------(Integer.parseInt())--------------->int

Integer-----------------(IValue())--------------->int

学会查看javadoc协助文档。要先关注要用法返回值类型，也就是要获得内容类型，然后看办法名，JDK中办法名基本上是见名知义，参数表，就是看需要什么才可以获得需要那些内容，也要看自己可以提供什么。

注意：“==”在任何时候都是比较地址，这种比较永远不会被覆盖。

程序员自己编写类和JDK类是一种合伙关系。（由于多态存在，也许存在咱们调用JDK类状况，也也许存在JDK自动调用咱们类状况。）

注意：类型转换中double\Interger\String之间转换最多。

（注：所有使用内部类地方都可以不用内部类，但使用内部类可以使程序更加简洁，便于命名规范和划分层次构造）。

内部类是指在一种外部类内部再定义一种类。

*内部类可为静态，可用protected和private修饰。（而外部类不可以：顶级类只能使用public和default）。

*java文献中没有publicclass，容许类名和文献不同名。

内部类

内部类也就是定义在类内部类。

内部类分类

1，成员内部类、

2，局部内部类、

3，静态内部类、

4，匿名内部类（图形是要用到，必要掌握）。

成员内部类

四个访问权限修饰符都可以修饰成员内部类。

内部类和外部类在编译时时不同两个类，内部类对外部类没有任何依赖。

内部类是一种编译时语法，在编译时生成各自字节码文献，内部类和外部类没关于系。

内部类中可以访问外部类私有成员。

作为外部类一种成员存在，与外部类属性、办法并列。

内部类和外部类实例变量可以共存。

在内部类中访问实例变量：this.属性

在内部类访问外部类实例变量：外部类名，this.属性。

在外部类外部访问内部类，使用out.inner。

成员内部类特点：

1.内部类作为外部类成员，可以访问外部类私有成员或属性。（虽然将外部类声明为private，但是对于处在其内部内部类还是可见。）

2.用内部类定义在外部类中不可访问属性。这样就在外部类中实现了比外部类private还要小访问权限。

注意：内部类是个编译时概念，一旦编译成功，就会成为完全不同两类。

对于一种名为outer外部类和其内部定义名为inner内部类。编译

完毕后浮现outer.class和outer$inner.class两类。

3.成员内部类不能具有静态成员。

建立内部类对象时应注意：

在外部类内部可以直接使用inners=newinner()；（由于外部类懂得inner是哪个类，因此可以生成对象。）

而在外部类外部，要生成（new）一种内部类对象，需要一方面建立一种外部类对象（外部类可用），然后在生成一种内部类对象，内部类类名是外部类类名.内部类类名。

Outero=newOuter()；

Outer.Innerin=o.new.Inner()

静态内部类

（注意：前三种内部类与变量类似，因此可以对照参照变量）

静态内部类定义在类中，任何办法外，用staticclass定义。

静态内部类只能访问外部类静态成员。

生成（new）一种静态内部类不需要外部类成员：这是静态内部类和成员内部类区别。

静态内部类对象可以直接生成：

Outer.Innerin=newOuter.Inner()；

而不需要通过生成外部类对象来生成，这样事实上使静态内部类成为了一种顶级类。静态内部类不可用private来进行定义。

注意：当类与接口（或者是接口与接口）发生办法命名冲突时候，此时必要

使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类

才干实现真正多继承。

例子：

对于两个类，拥有相似办法：

classPeople

{

run()；

}

interfaceMachine

{

run()；

}

有一种robot类：classRobotextendsPeopleimplementMachine，run()不可直接实现。

interfaceMachine

{

voidrun()；

}

classPerson

{

voidrun()

{

System.out.println("run")；

}

}

classRobotextendsPerson

{

privateclassMachineHeartimplementsMachine

{

publicvoidrun()

{

System.out.println("heartrun")；

}

}

publicvoidrun()

{

System.out.println("Robotrun")；

}

MachinegetMachine()

{

returnnewMachineHeart()；

}

}

classTest

{

publicstaticvoidmain(String[]args)

{

Robotrobot=newRobot()；

Machinem=robot.getMachine()；

m.run()；

robot.run()；

}

}

局部内部类

在办法中定义内部类称为局部内部类。

与局部变量类似，在局部内部类前不加修饰符public和private，其范畴为定义它代码块。

注意：局部内部类不但可以访问外部类私有实例变量，但可以访问外部类局

部常量（也就是局部变量必要为final）。

在类外不可直接访问局部内部类（保证局部内部类对外是不可见）。

在办法中才干调用其局部内部类。

通过内部类和接口达到一种强制弱耦合，用局部内部类来实现接口，并在办法中返回接口类型，使局部内部类不可见，屏蔽实现类可见性。

局部内部类写法

publicclassTestLocalInnerClass

{

publicstaticvoidmain(String[]args)

{

Outero=newOuter()；

finalinta=9；

o.print(a)；

}

}

classOuter

{

privateintindex=100；

publicvoidprint(finalinta)

{

finalintb=10；

System.out.println(a)；

classInner

{

publicvoidprint()

{

System.out.println(index)；

System.out.println(a)；

System.out.println(b)；

}

}

Inneri=newInner()；

i.print()；

}

}

匿名内部类

匿名内部类是一种特殊局部内部类，它是通过匿名类实现接口。

匿名内部类特点：

1，一种类用于继承其她类或是实现接口，并不需要增长额外办法，只是对继承办法事先或是覆盖。

2，只是为了获得一种对象实例，不许要懂得其实际类型。

3，类名没故意义，也就是不需要使用到。

注意：一种匿名内部类一定是在new背面，用其隐含实现一种接口或实现一

个类，没有类名，依照多态，咱们使用其父类名。

因其为局部内部类，那么局部内部类所有限制都对其生效。

匿名内部类是唯一一种无构造办法类。

大某些匿名内部类是用于接口回调用。

匿名内部类在编译时候由系统自动起名Out$1.class。

如果一种对象编译时类型是接口，那么其运营类型为实现这个接口类。

因匿名内部类无构造办法，因此其使用范畴非常有限。

当需要各种对象时使用局部内部类，因而局部内部类应用相对比较多。匿名内部类中不能定义构造办法。

匿名内部类写法：

interfaceA

{

voidia()；

}

classB

{

publicAbc()

{

returnnewA

{

voidia()

{

}

}；

}

}

使用匿名内部类：

Bb=newB()；

Aa=b.bc()；

a.ia()；

Exception（例外/异常）

对于程序也许浮现错误应当做出预案。

例外是程序中所有出乎意料成果。（关系到系统健壮性）

java会将所有异常封装成为一种对象，其主线父类为Throwable。

异常分类

Error和Exception。

一种Error对象表达一种程序错误，指是底层、低档、不可恢复严重错误。此时程序一定会退出，由于已经失去了运营所必要物理环境。对于Error错误咱们无法进行解决，由于咱们是通过程序来应对错误，可是程序已经退出了。

咱们可以解决Throwable类中只有Exception类对象（例外/异常）。

Exception有两个子类：

Runtimeexception（未检查异常）可以在编程时避免，可解决可不解决

非Runtimeexception（已检查异常）必要进行解决。

注意：无论是未检查异常还是已检查异常在编译时候都不会被发现，在编译过程中检查是程序语法错误，而异常是一种运营时程序出错概念。

在Exception中，所有非未检查异常都是已检查异常，没有此外异常！！

未检查异常是由于程序员没有进行必要检查，由于她疏忽和错误而引起异常。一定是属于虚拟机内部异常（例如空指针）。

应对未检查异常就是养成良好检查习惯。

已检查异常是不可避免，对于已检查异常必要实现定义好应对办法。

已检查异常必定跨越出了虚拟机范畴。（例如“未找到文献”）

异常传递

如何解决已检查异常（对于所有已检查异常都要进行解决）：

一方面理解异常形成机制：

当一种办法中有一条语句浮现了异常，它就会throw（抛出）一种例外对象（throw异常对象），然后背面语句不会执行返回上一级办法，其上一级办法接受到了例外对象之后，有也许对这个异常进行解决，也也许将这个异常转到它上一级。

注意：当一种办法中浮现异常，没有进行异常解决，办法就会把异常对象作为返回值返回。如果有异常进入虚拟机，那么虚拟机就会立即中断程序执行。

异常解决方式

非RuntimeException（已检查异常）异常必要解决。如果不解决编译出错。

对于接受到已检查异常有两种解决方式：throws和try..catch(...){}办法。

注意：出错办法有也许是JDK，也也许是程序员写程序，无论谁写，抛出一定用throw。

在办法定义中声明办法也许抛出异常，用（throws异常类名，异常类名），声明这个办法将不解决异常，并把异常交给上一级办法解决。可以抛出是实际产生异常父类异常对象。

例：publicvoidprint()throwsException。

对于办法a，如果它定义了throwsException。那么当它调用办法b返回异常对象时，办法a并不解决，而将这个异常对象向上一级返回，如果所有办法均不进行解决，返回到主办法，程序中断。（要避免所有办法都返回用法，由于这样浮现一种很小异常就会令程序中断）。

如果在办法程序中有一行thrownewException()，返回错误，那么其后程序不执行。由于错误返回后，背面程序必定没有机会执行，那么JAVA以为后来程序没有存在必要。

Try..catch捕获异常

对于try……catch格式：

try{也许浮现错误代码块}catch(exceptione){进行解决代码}；

对象变量声明

用这种办法，如果代码对的，那么程序不通过catch语句直接向下运营；

如果代码不对的，则将返回异常对象和e进行匹配，如果匹配成功，则解决其背面异常解决代码。（如果用exception来声明e话，由于exception为所有exception对象父类，所有必定匹配成功）。解决完代码后这个例外就完全解决完毕，程序会接着从浮现异常地方向下执行（是从浮现异常地方还是在catch背面呢？运用程序进行验证）。最后程序正常退出。

try块中代码如果没有浮现异常，就会跳过catch，正常执行。

try中如果发现错误，即跳出try块去匹配catch，那么try背面语句就不会被执行。

一种try可以跟进各种catch语句，用于解决不同状况。当一种try只能匹配一种catch。

咱们可以写各种catch语句，但是不能将父类型exception位置写在子类型excepiton之前，由于这样父类型必定先于子类型被匹配，所有子类型就成为废话，java中是不容许写废话，因此编译会出错。

在try，catch后还可以再跟一子句finally。其中代码语句无论如何（无论有无异常）都会被执行（由于finally子句这个特性，因此普通将释放资源，关闭连接语句写在里面）。finally中代码在和try中代码冲突时，finally中代码一定会被执行且会忽视try中代码。但是System.exit(0)；(虚拟机退出语句)则不会去执行fianlly中代码。

try{..}catch(..){..}

try{..}catch(..){}finally{..}

try{..}finally{}

以上三种写法都可以.

如果在程序中书写了检查（抛出）exception但是没有对这个也许浮现检查成果进行解决，那么程序就会报错。而如果只有解决状况（try）而没有相应catch子句，则编译还是通但是。

如何懂得在编写程序中会浮现例外呢

1.调用办法，查看API中查看办法中与否有已检查错误。

2.在编译过程中看提示信息，然后加上相应解决。

Throwable有一种message属性，在使用catch时候可以调用：

Catch(IOExceptione){System.out.println(e.message())}；

Catch(IOExceptione){e.printStackTrace()}；

以上两条语句都是可以打印出错过程信息，告诉咱们出错类型所历通过程，在调试中非常有用。

开发中两个道理：

①如何控制try范畴：依照操作连动性和有关性，如果前面程序代码块抛出错误影响了背面程序代码运营，那么这个咱们就说这两个程序代码存在关联，应当放在同一种try中。

②对已经查出来例外，有throw(悲观)和trycatch（积极）两种解决办法。

对于throws把异常抛到trycatch可以较好地解决例外位置（即放在具备对例外进行解决能力位置）。如果没有解决能力就继续上抛。

当咱们自己定义一种例外类时候必要使其继承excepiton或者RuntimeException。

throw是一种语句，用来做抛出例外功能。

而throws是表达如果下级办法中如果有例外抛出，那么本办法不做解决，继续向上抛出。

throws后跟是例外类型。

注意：办法覆盖中，如果子类办法抛出例外是父类办法抛出例外父类型，那么编译就会出错：子类无法覆盖父类。

结论：子类办法不可比父类办法抛出更多例外。子类抛出例外或者与父类抛出例外一致，或者是父类抛出例外子类型。或者子类型不抛出例外。如果父类型无throws时，子类型也不容许浮现throws。此时只能使用trycatch。

断言是一种调试工具（assert）

断言(assert)其后跟是布尔类型表达式，如果表达式成果为真不影响程序运营。如果为假系统浮现低档错误，在屏幕上浮现assert信息。

Assert只是用于调试。在产品编译完毕后上线assert代码就被删除了。

集合类

集合（集合类对象）是用来管理其她若干对象，它类似于C++原则模板库中容器，但是在JAVA集合类对象中可以用来存储各种类型对象。

接口和类共同构成了一种集合框架，集合概念，一种对象可以装载各种对象，这个对象就是集合对象。

集合框架

1，接口

Collection用来管理各种对象，集合中每个元素都是对象。

Map，Map中没有对象，而是键值对，由Key，value构成键值对，Key是不可重复。value是可以相似,一种Key和一种value一一相应。

集合中用到类，接口在java.util包中，在使用时注意将其引入import。

Collection接口（如下简介其子接口）

1)List一种List实现类对象在管理各种对象时会按顺序组织对象（即按照将对象放入顺序存储），List实现类对象是有顺序，List实现类对象中内容是是可重复。（注意，顺序和排序区别）

2)Set一种Set实现类表达一种数学概念上集合，Set实现类对象中元素是无顺序，也就是不会按照输入顺序来存储，Set实现类对象中元素是不重复。

3)SortedSet,她是Set子接口，她实现类会对集合中元素进行排序。但是要指定排序规则，她会按排序规则进行排序。

Map接口（如下简介其子接口）

SortedMap，这个接口实现类同样可以实现，但是是对键值对中Key进行排序，这个接口实现类也是要指定排序规则。

List接口实现类

1>ArrayList是接近于功能集合类，ArryList实质就是一种会自动增长数组，ArrayList是用封装数组来实现List接口。

Collection实现类对象遍历方式是用迭代来实现。

在使用迭代器时先要活得一种迭代器对象，Iterator（迭代器接口）这是一种接口，迭代器是在集合类中实现，也就是说，她是一种内部类（匿名内部类）实现。

Iterator接口中定义惯用办法办法hasNext()，next()。

hasNext(),这个办法会使用一种游标，并通过判断游标指向位置与否存储有对象。

next()办法也是Iterator接口中定义好办法，这个办法会使游标指向下一种元素位置，游标会跳过第一种元素，并返回其中内容。

Collections这是一种工具类，也是java.util包中，这个类中sort(list接口实现类对象)办法，其参数是一种集合类对象，这个办法使用来对集合类对象进行排序。后来，我将以集合这个名字来称呼集合类对象。，对于字符串对象内容集合来说会按字典顺序排序（升序），对于数字内容集合排序也会按照升序排序。

排序可一份为两某些内容，一种是排序规则，也就是按照什么来进行排序，并且排成什么样顺序。第二个就是排序算法，她决定了排序效率。

在对自定义集合内容类型排序时，需要先定义那个类型排序规则。

Comparable接口，这个接口中只定义了一种compareTo(Objecto)，办法返回至类型是整型，如果当前对象不不大于参数对象就返回正数，当前对象等于参数对象是就返回0，当前对象不大于参数对象时就返回负值，这样写就是升序排列，反之则是进行降序排列，在实现这个接口中办法时，返回值定义方式，只有这两种。

依照指定类型排序规则实现了Comparable接口，那么就可以对存有这个类型集合进行整体排序。Comparable接口，也叫做可比较接口。这个接口在java.lang包下。只要实现了这个接口，就是可排序。

接下来简介此外一种对自定义类型对象集合整体排序办法，也就是实现比较器接口（Comparator），这个接口中定义了一种compare(Objecto1，Objecto2)办法来比较两个对象，这个办法返回值定义和上面简介那个办法是同样。

注意：在API，协助文档中以上两个办法参数类型是T，这代表模板类型，也就是集合中存储内容类型，在JDK1。4中其参数就是Object类型，模板类型详细内容会在最后JDK5。0新特性中讲到。

Comparator接口可以在匿名内部类中实现，Collections中sort(集合了对象，比较器)办法，可以对自定义类型内容集合进行整体排序。

2>LinkedList，它是List接口实现类，其底层是用双向循环链表来实现。

注意：ArrayList查询效率比较高，增删动作效率比较差，合用于查询比较

频繁，增删动作较少元素管理集合。

LinkedList查询效率低，但是增删效率很高。合用于增删动作比较频繁，查询次数较少元素管理集合。

ArrayList，LinkedList都是线程不安全。

实现堆栈

1，数组（ArrayList，增删效率比较低，不适合）

2，LinkedList（实现堆栈好办法）

3，java。util。Stack类，Stack是Vector子类，Vector类是一种线程安全（是一种重量级类），并继承了Vector办法，Verctor类（这个类也是List接口实现类）和ArrayList功能近乎相似。（不推荐使用Stack类来实现堆栈）。

Set接口实现类

HashSet

Set实现类集合对象中不可以有重复元素，HashSet也同样她是使用了一种标记来拟定元素不重复，HashSet用一种算法来保证HashSet中元素是不重复，HashSet底层实现还是数组。

Object类中hashCode()办法是所有子类都会继承这个办法，这个办法会用Hash算法算出一种Hash（哈希）码值返回，HashSet会用Hash码值去和数组长度取模，模（这个模就是对象要存储在数组中位置）相似时才会判断数组中元素和要加入对象内容与否相似，如果不同才会添加进去。

Hash算法是一种散列算法。

注意：因此要存入HashSet集合对象中自定义类必要覆盖hashCode(),equals()两个办法，才干保证集合中元素容不重复。在覆盖和hashCode()办法时，要使相似对象hashCode()办法返回相似值，覆盖equals()办法再判断其内容。为了保证效率，因此在覆盖hashCode()办法时，也要尽量使不同对象尽量返回不同Hash码值。

如果数组中元素和要加入对象hashCode()返回了相似Hash值（相似对象）,才会用equals()办法来判断两个对象内容与否相似。

SortedSet接口是Set子接口。

TreeSet是SortedSet接口实现类，她可以对集合中元素进行排序。

要存储在TreeSet中自定义类对象，这个类要么是已经实现了Comparable接口，要么是能给出Comparator比较器，TreeSet可以自动过滤掉重复元素因此不用重载hashCode()办法，TreeSet会依照比较规则判断元素内容与否相似，TreeSet会在元素存入世就进行了排序。（在TreeSet给出排序规则时，一定要注意对象内容相等条件，一定要注旨在主观以为两个对象内容相似时，才可以使用比较少条件来进行判断）

在要排序时才使用TreeSet类（存储效率比较低），HashSet存储效率比较高，在需要为HashSet对象排序时，就可以把HashSet中元素放入TreeSet。

Map接口实现类

Map中只可以存储键值对（Key，value），其中Key是不可以重复。Key和value是一一相应。

HashMap是Map接口实现类，Key时无序存储，其中Key是不可以重复，它也是通过Hash码值来保证Key不重复，Key和value是一一相应。如果要加入键值对和HashMap中键值对Key是相似就会将这个集合中Key所队应value值进行覆盖，在使用自定义类型作为Key时，那就是要覆盖hashCode(),equals()办法，也就是和HashSet中要放入自定义类型是解决办法相似。这个类对象是线程不安全。

在遍历Map时，要使用其keySet()办法获得Key一种Set集合，可以通过遍历这个Set，用get()办法来获得Key所相应value，也就遍历了Map。

H