学习Java语言必需掌握的知识点

    已经工作几年了，虽然接触过行业里许多新的知识，但是基础知识是立足的根本，偶尔翻一翻这些在大学里做的笔记，感觉还是不错滴。让我们梦回到那时求知的痕迹吧。

 

一、            java基本概况

1.1 java简介（java是一种程序设计语言）

1.2 java特性(11个特性)

简单性、面向对象、网络技能（分布式的）、健壮性、安全性、体系结构中立、可移植性、解释性、高性能、多线程、动态性

1.3 java结构(jdk、jvm与jre)

jdk：(Java Development Kit)是java开发用的，是整个java的核心，包括java运行环境、java工具、java基础类库。(里面有编译器)

jre：是运行java程序用的，如果你只是需要运行程序，那只装jre就可以了。Jre是java运行时，用于执行java程序。

jvm：jre和jdk都需要jvm的支持，jvm是运行和编译java程序的核心。Jvm是java虚拟机，将java的class字节码文件编译（解释）成二进制文件执行程序。

1.4 java环境

1.4.1安装jdk及配置、测试环境（三大环境变量）(windows|linux)

JAVA_HOME:（JDK安装位置）”Program Files\java\jdk1.6.0_16”

Path:”%JAVA HOME%\bin;”

ClassPath: （JDK安装位置）”%JAVA HOME%\jre\lib\rt.jar;”

或者：PATH：.\ Java\jdk1.6.0_04\bin    CLASSPATH: .

1.4.2eclipse 与netBean开发工具(熟悉工具的界面和操作，能够使用即可)

1.5 第一个Helloword程序（注：记事本默写）

PublicClass hello{

  Public static void main(String arg[]){

    System.out.printle(“Helloword”);

}

}

二、java语言基础（名称，描述，定义，例子，备注）

2.1标识符、关键字、保留字

标识符、关键字、保留字

名称：标识符；定义：由任意顺序的字母、数字、下划线、美元符号$组成，第一个字母不能是数字，不能是保留关键字；描述：指用户自定义的类名、变量名、接口名、方法名；例子：合法的：name、user_age1、$page，不合法的：5word、int、Username(字符不能有空格)；备注：命名法则：文件｜文件夹方式命名。

名称：关键字；定义：对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名；描述：java语言中已经被赋予特定意义的一些单词，不可以把这些字符作为标识符来使用。例子：Java关键字

 

int	public	this	finally	boolean	abstract
continue	float	long	short	throw	throws
return	break	for	static	new	interface
if	goto	default	byte	do	case
strictfp	package	super	void	try	switch
else	catch	implements	private	final	class
extends	volatile	while	synchronized	instanceof	char
protected	import	transient	implemends	default	double

 

friendly，sizeof不是java的关键字，并且java关键字都是小写的

保留字：指现有Java版本尚未使用但以后版本可能会作为关键字使用的单词；例子：Java保留字

 

byValue	cast	false	future	generic	inner
operator	outer	rest	true	var	goto
const	null

2.2量（常量、变量）

量的分类：常量和变量

名称：变量；定义：指一个内容可变的数据存储空间的表示（在程序中使用变量内容可改变）；描述：由变量类型和变量名或初始值组成（type 标识符[＝初始值]）；例子：intage; Boolean b=true; float f1,f2,f3。

名称：常量；定义：指在程序中不能改变的量（与变量性质相反）；描述：由final 类型名称＝值组成(final type 名称＝值)；例子：finalfloat PI=3.1415926F;备注：常量名称一般定义为大写字母。

量的使用：直接打印输出；传递；对象名.变量名（实例变量）；类名.变量名（静态变量）；

量的作用范围：指量在程序中所拥有的权限。

量[变量]－全局变量（成员变量）｜局部变量

成员变量：指在类中（在方法外面）声明的变量，作用域是整个类，也可以说是类的属性。分类：静态变量：创建的变量与对象无关（属于成员变量），当不必引用对象时可以直接用类来访问静态变量；为多个实例分配一个内存空间；实例变量：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量；实例变量位于堆区中，其生命周期取决于实例的生命周期。

例子：

public class VariantTest

{

public static int staticVar = 0;

public int instanceVar = 0;

public VariantTest（）

{

staticVar++;

instanceVar++;

System.out.println（“staticVar = ”++staticVar “， instanceVar = ” ++instanceVar）;

}

}

量[常量]－系统常量｜程序常量

修饰符	类	成员方法	构造方法	成员变量	局部变量
Abstract(抽象)	√	√	×	×	×
Static(静态)	×	√	×	√	×
Public(公共)	√	√	√	√	×
Private(私有)	×	√	√	√	×
Protected保护)	×	√	√	√	×
Synchronized（同生）	×	√	×	×	×
Final(固定)	√	√	×	√	√

 

访问控制符	访问级别	同类	同包	子类	不同包
public	公开	√	√	√	√
Protected	保护	√	√	√	×
无	默认	√	√	×	×
private	私有	√	×	×	×

2.3数据类型，类型转型，相等性测试

数据类型分类：基本数据类型和字符串类型、引用类型（内存占用字节数，取值范围，默认值）

基本数据类型（8个）：整型：byte(1字节)、short(2字节)、int(4字节)、long(8字节)，浮点型：float(4字节)、double(8字节)；Boolean(1位)：ture、false；字符型：Char (2字节)

定义：基本类型的值是一个数字，一个字符或一个布尔值，其内容存在栈中，变量直接指向数值内容；

基本数据类型包括byte、int、char、long、float、double、boolean和short。

例子：

public class SimpleTypes{

　　publicstatic void main( String args[] ){

　　byte b=0x55;

　　shorts=0x55ff;

　　inti=1000000;

　　longl=0xfffL;

　　char c='c';

　　floatf=0.23F;

　　doubled=0.7E-3;

　　booleanbool=true;

　　System.out.println("b= "+b);

　　System.out.println("s= "+s);

　　System.out.println("i= "+i);

　　System.out.println("c= "+c);

　　System.out.println("f= "+f);

　　System.out.println("d= "+d);

　　System.out.println("bool= "+bool);

　　}

　　}

　　编译并运行该程序,输出结果为:

　　C:\>java SimpleTypes

　　b = 85

　　s = 22015

　　i = 1000000

　　l = 4095

　　c = c

　　f = 0.23

　　d = 0.0007

　　bool = true 

转义字符:

\n

 

回车(\u000a)

 

\t

 

水平制表符(\u0009)

 

\b

 

空格(\u0008)

 

\r

 

换行(\u000d)

 

\f

 

换页(\u000c)

 

\'

 

单引号(\u0027)

 

\"

 

双引号(\u0022)

 

\\

 

反斜杠(\u005c)

 

\ddd

 

三位八进制

 

\udddd

 

四位十六进制

字符串类型，是用String表示的类型，①直接赋值，如：Stringstr=”hello”(直接存储在栈里，寻找具有hello的字符串，如果已经有则直接指向hello，如果没有过就开辟一个hello空间);②用new创建字符串对象，如：String str=new String(” hello”)(每创建一个new对象，就在堆中开辟一个对象空间，栈中的地址指向堆的内容);

引用类型：类类型，接口类型，数组类型

定义：引用类型的值是指向内存空间的引用，就是地址，变量引用（地址）存在栈中，而对象存在堆中。
引用数据类型包括:类,数组,接口

基本数据类型和引用类型的区别主要在于基本数据类型的量和内容是分配在栈上的，而引用类型的量被分配在栈内存里，而真正内容是分配在堆上的，栈通过指针指向堆上的内容。
实例：我们分析一下”==“和equals（）的区别。
①定义两个string对象（引用类型）

stringa="abc";  //a指向堆中一个对象的地址
string b="abc";  //b指向堆中另一个对象的地址
然后
if(a==b){system.out.println("a==b");}
else
{system.out.println("a!=b");}
程序输出a!=b
原因:a和b的地址是不相同的，a==b比较的是两个变量的地址，所以地址不相等；
②定义两个基本类型
int a=4;
int b=4;
if(a==b){system.out.println("a==b");}
else
{system.out.println("a!=b");}
输出：a==b
原因：==比较的是两个变量的内容
结论：不论是基本数据类型还是引用类型，他们都会先在栈中分配一块内存，对于基本类型来说，这块区域包含的是基本类型的内容；而对于对象类型来说，这块区域包含的是指向真正内容的指针，真正的内容被手动的分配在堆上

User user;             .栈区    局部变量

UserDAOuserDao;     .方法区  静态成员变量

User[] users;           .堆区   实例变量

类型转型：自动类型转换和强制类型转换

自动类型转换:由低精度类型向高精度数据类型的转换，如：bytebt=5;int it=bt;

强制类型转换:与自动转换相反，如：inti=16;byte bt=(byte)i;

相等性测试：＝＝和equals()

2.4操作符(运算符)

分类：算术运算符，布尔运算符，关系运算符，位运算符，赋值运算符，条件运算符，字符串运算符，逗号运算符，其他运算符；

①算术运算符：

　　单目：+ (取正)  - (取负)  ++ (自增1)  - - (自减1)，如：i=0,j=0; j=i++(i=0,j=1);j=++i(i=1,j=1)

　　双目：+  -  *  /  %（取余）

三目：a>b?true:false 

说明：当a大于b的时候，为true（也就是冒号之前的值），否则为false；这整个运算符包括一个关系运算符（可以是“>”"<""!="等等），一个“？”，一个“：”，冒号前后需要有两个表达式或者是值或者是对象。

②关系运算：

　　= =(等于)，!= (不等于)，> (大于)，< (小于)， >= (大于等于) ，<= (小于等于)。

③位运算符：

位运算符　与（&）、非（~）、或（|）、异或（^）

&：当两边操作数的位同时为1时，结果为1，否则为0。如1100&1010=1000

　　| ：当两边操作数的位有一边为1时，结果为1，否则为0。如1100|1010=1110

　　~：0变1,1变0 。如~1010=0101

　　^：两边的位不同时，结果为1，否则为0.如1100^1010=0110

④逻辑运算符：

　　与（&&）、非（!）、或（||）

⑤赋值运算符：

=  +=  -=  *=  /=  %=  &=  ^=  |=  <<=  >>=

⑥其他

运算符优先级

　　按优先级从高到低排列如下：[ ] ( ) ++ -- ! ～ instanceof * / % + - << >>>>> <> < = > \ == != &^& & || ? := op= 。（口决：算关位逻赋）。

注：instanceof：测试某个对象是否是指定类或其子类的实例,。是Java的一个二元操作符，Java的保留关键字；作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据。可以用在继承中的子类的实例是否为父类的实现。instanceof 一般情况下用在对象类型的强制转换。如：if(myObjectinstanceofMyClass){MyClassanothermyObject=(MyClass)myObject;…}是判定myObject是否是MyClass的实例或是其子类的实例。

<<：左移，如：

>>：右移(带符号)

>>>：添零右移

没有必要去记忆运算符号的优先级别,在编写程序时可尽量的使用括号来实现你想要的运算次序,以免产生难以阅读或含糊不清的计算顺序.运算符的结合性决定了并列相同级别的运算符的先后顺序,例如,加减的结合性是从左到右,8-5+3 相当于(8-5)+3.逻辑否运算符的结合性是右到左, x 相当于!(!x).表3.4是Java所有运算符的优先级和结合性。

    当运算符进行数值运算时，结果类型默认高精度者，如：longa=1.23456,float b=2.123, c=a+b,c为long型。

2.5表达式

指用运算符连接起来的符合Java 规则的式子，如：c=a+b

2.6语句

赋值语句：

流程控制语句：

判断语句（if三种语句,switch语句）

①    简单if条件语句，描述：当表达式返回true 时，执行语句1（或语句块）；当表达式返回false 时，直接执行下面的语句。如：if ( x>90 ) System.out.println("Good!");

②    if…else…语句，描述：当布尔表达式返回true 时执行语句块1，否则执行语句块2；如：if (x>60)
System.out.println("Pass!");
else
System.out.println("No pass!");

③    if…else if…语句，描述：多分支语句，如：

   int score;
char grade;
score=Integer.parseInt(args[0]);
if (score>=90)
grade=’A’;
else if(score>=80)
grade=’B’;
else if (score>=70)
grade=’C’;
else if (score>=60)
grade=’D’;
else
grade=’F’;
System.out.println("Score="+score+" Grade="+grade);

④    switch语句：描述：适合于用某个值来检测一个变量是否符合某个条件；

switch(条件表达式){

      case 常量表达式1:

        语句块1；

break;

…

 case 常量表达式n:

        语句块n；

break;

      default:

        语句块n+1；

break;

如：int week=3;

Switch(week){

Case 1:

System.out.println(“星期一”);

Break;

Case 2:

System.out.println(“星期二”);

Break;

Case 3:

System.out.println(“星期三”);

Break;

…

default:

System.out.println(“请输入有效数字！”);

}

      

 循环语句（for语句，while语句，dowhile语句）

for语句：

for（初始化语句；循环条件；迭代语句）{

   语句序列（循环体）

}

如：计算1~100各数字的和

Intsum=0;

For(inti=0;i<=100;i++){

   Sum=sum+i;

}

System.out.println(sum);

while语句:

while(条件表达式){

   循环体

}

如：1~10相加

Int i=0;

Intsum=0;

While(i<=0){

   Sum=sum+i;

   i++;

}

System.out.println(sum);

Do{

   循环体

}while(循环条件);

如：1~10相加

Int i=0;

Int sum

Do{

   Sum=sum+i;

   i=i+1;

}while(i<=10);

System.out.println(sum);

 

跳转语句（break语句，continue语句）

break语句:在执行循环时可以中断循环，强迫跳出循环；一般用在循环语句中。

如：输出1~100各数字的整数和

Int sum=0;

Int control=1;

While(true){

   Sum+=control++;

   If(control>100){

      System.out.pritnln(sum);

      Break;

}

}

 continue语句:用于结束本次(指定条件)循环直接跳过执行循环体的剩余部分语句。

如：输出1~100中可以整除10的数

For(int i=1;i<100;i++){

If(i%10 !=0){

   Continue;

}

System.out.println(i+”、”);

}

 

其他语句：foreach语句

关于循环综合例子：

①输出格式化的九九乘法表：

For(int i=0;i<=9;i++){

   For(int j=0;j<=i;j++){

      String str=j+”*”+i+”=”+j*i;

      System.out.print(str+”\t”);

}

System.out.println();

}

②输出一个棱形

Public static void main(String[] args){

  For(int i=1;i<=7;i+=2){

   For(int kong=7;kong>i-1;kong--){

     System.out.print(“ “);

}

For(intxing=1;xing<=i;xing++){

  System.out.print(“*“);

}

System.out.println();

}

For(intj=1;j<=5;j+=2){

  For(int kong1=1;kong1<j+3;kong1++){

    System.out.print(“ “);

}

For(intxing1=5;xing1>=j;xing1--){

  System.out.print(“*“);

}

System.out.println();

}

}

 ③阶乘:实现一个计算阶乘的方法，公式：n!=n*(n-1)*(n-2)…*2*1

Public static void main(String[] args){

  Int n=16;

  Long result=1;

  If((n<0)||(n>17)){

    System.out.println(“n的取值范围是0~17，大于17会超出long类型范围”);

}

Else if(n==0){

  System.out.println(“0的阶乘等于1”);

}

Else{

  For(int i=n;i>0;i--){

    Result*=i;

}

System.out.println(n+“的阶乘等于:”+result);

}

}

④素数:素数是大于1的整数，并且其正因子只有1和它本身。下面：查找40个素数，然后分别在4行中输出，每行显示10个。

Public static void main(String[] args){

  Final intNUMBER_FOR_PRIMES=40;  //声明素数的数量

  Final intNUMBER_FOR_EVERY_LINE=10;级 //声明每行输出多少素数

  Int count=0;  //素数计数器

  Int number=2;   //用于判断素数的数字

  While(count< NUMBER_FOR_PRIMES){

Boolean isPrime=true;    //是否素数的状态变量

For(int i=2;i<=number/2;i++){

  If(number%i==0){

  isPrime=false;

  break;

}

}

If(isPrime){      //如果是素数

  Count++;      //累加素数计数器

  System.out.print (number+”\t”);    //输出素数，不换行

  If(count% NUMBER_FOR_EVERY_LINE==0){    //如果已输出10个素数

   System.out.println();      //换行

}

}

Number++;      //自增用于判断的数字

}

}

 

 

2.7代码块

在Java中使用“｛｝”括起来的代码称为代码块，根据代码块的定义位置及声明的关键字不同，代码块可以分为以下四种：普通代码块、构造块、静态块、同步代码块

1、 普通代码块：直接在一个方法中出现的“｛｝”就称为普通代码块。

public class CodeDemo01 {        public static void main(String  args[])        {               //定义一个普通代码块               {                      //定义一个局部变量                      int x =10 ;                      System.out.println("普通代码块中的x = " + x) ;               }               int x = 100 ;               System.out.println("代码块之外的x = " + x ) ;        } }

2、 构造块：直接在类中定义的代码块称为构造块。

可以看出构造块会重复调用多次，构造块会优先于构造方法执行。

class  Demo {        //定义构造快        {               System.out.println("**************构造块*************") ;        }        //定义构造方法        public Demo()        {               System.out.println("**************构造方法*************") ;        } } public  class CodeDemo02 {        public static void main(String  args[])        {               //实例化三个对象               new Demo() ;               new Demo() ;               new Demo() ;        } }

3、 静态块：使用static关键字声明的代码块，称为静态块，静态块的主要目的是用来为静态属性初始化。

静态块优先于主方法执行，静态块优先于构造块执行，而且执行一次。

 

class  Demo {        //定义构造快        {               System.out.println("**************构造块*************") ;        }        //定义静态代码块        static        {               System.out.println("**************类中静态块*************") ;        }        //定义构造方法        public Demo()        {               System.out.println("**************构造方法*************") ;        } } public  class CodeDemo03 {        //在主类中定义的静态代码块        static        {               System.out.println("**************主类中的静态块*************") ;        }        public static void main(String  args[])        {               //实例化三个对象               new Demo() ;               new Demo() ;               new Demo() ;        } }

思考：

要求在屏幕上打印输出“HelloWorld！”，但是不能用主方法。

使用静态块代替主方法，并结束程序：

 

public  class CodeDemo04 {        static        {               System.out.println("Hello World  !!!" ) ;               System.exit(1) ;        } }

       在静态块中加入系统退出后，以保证程序不再继续搜索主方法，但是程序知识娱乐使用，本身没有任何意义。

4、同步代码块

　同步代码块主要出现在多线程中。

2.8文件结构 

package XXX;//一个包

import java.util;//可以有多个

class 类名

{

 //略主要是方法和变量

}

 

2.9注释（两种方式）

/*

*文档注释

*/

//单行注释

/*   多行注释   */

快捷键：ctrl+/

 三、java编程基础

3.1对象（万事万物都是对象）

3.1.1含义：对象是具有状态,行为,标识的个体，是问题空间中的元素以及解决方案空间中的的表示物，将类实例化，就形成了对象。

3.1.2对象的特性：

对象具有状态，用数据值来描述它的状态。 

对象具有行为，能对对象操作。

程序是对象的集合，对象通过消息传递告知彼此所要做的事。
每个对象都分配有自己的存储空间，可容纳其他对象。
每个对象都有一个类型。
同一类的所有对象能接收相同的消息 

例如：一辆汽车的设计图纸永远不能用来驾驶出行，必须用它生产出真正的汽车才能使用。这辆汽车的设计图纸可以看作之前设计的类，而真正的汽车（例如红色轿车）可以看作对象只有对象才能被程序使用，而且同一类型的对象还有不同的属性，例如颜色、高度、速度等。另外，对象还可以执行类设计的方法，即对象的行为，例如开车、换档、加油、转向、刹车等。

3.1.3创建类的实例对象：

类名对象名=new 类构造方法();

如：String name=new String(“一个新的字符串对象”);

注：自己写的类只能用new语句创建，但String类可以用双引号的字面量创建对象。

3.1.4访问对象的属性和行为：

对象名.属性

如：String carColor=whiteCar.color;

whiteCar.color=”白色”;

对象名.成员方法名();

如：whiteCar.gear(3);

whiteCar.drive();

3.1.5对象的销毁：

Java的垃圾回收机制可以自动销毁不再使用的对象，同时可以显式的为对象赋值null值，使对象不再被使用。如：whiteCar=null;

3.2类

类是用来定义一组对象共同具有的状态和行为的模板。对象（也就是类的实例）在使用之前，必须定义该对象的类，知道了对象的类型才能够访问它的属性和行为。对象的行为被定义成类的方法，对象的属性被定义为类成员变量。面向对象程序设计的重点是类的设计，并不是对象的设计。

3.2.1参数、方法、属性及属性值、返回值

3.2.1.1参数：指定传递给方法处理的值。包括形参和实参：形参是方法定义时用到的参数，有类型，如：public void printInfo(String info){…}；实参是调用方法时实际传入的参数，如：System.out.println(“hello”);

3.2.1.2方法：是对象行为的描述。语法：[修饰符] 返回值类型方法名（形参表）{…方法体；return返回值}

3.2.1.3属性及属性值：属性是对象的特征表现，对应类的成员变量，如name、age、sex；属性值是这个对象中的属性的值 - -! 也就是类声明的成员变量的值，如：Stringname=”jin”。

3.2.1.4返回值: 指调用完方法返回给你的一些需要的信息，我们在声明方法时指定要返回的值的类型，在方法内用return xx来指定返回的值，默认不返回值。 

3.2.2声明、权限、作用域

3.2.2.1声明：告诉编译器将使用的指定类型的名称，在JAVA中任何属性和方法在使用前都要先声明，等于在C语言中的定义，如：Stringname；

3.2.2.2权限修饰符：

pravite 只能在同一个类中访问

protected，可以在同一个类、同一个包、不同包中的子类访问

默认：在同一个类、同一个包中访问

public 同一个类，同一个包、不同包中的子类、不同包中的非子类

static 可以修饰变量、类、方法、静态块！

用了static，可以不用new一个这个类的实例就可以直接用类进行访问，而且无论new了多少个实例，这个变量都只有一份（公共的），所有实例见到的值都是相同的。

final 可以修饰变量、方法

final 修饰的方法不能被重写！修饰的值不能被改变（数值类型值不变、引用类型引用不变！）修饰的类不能被继承！<都有一个不能被改变的意思>

abstract可以修饰类、方法、接口

抽象方法没有方法体！

表明被修饰的是抽象的，需要被实现，等待被完善！

抽象类可以继承为抽象的，也可以被继承为不抽象的，关键是看里面有没有抽象方法，如果有肯定是抽象类！当然抽象类也可以有非抽象方法！

所以 final 不能和 abstract 放在一起！一个不能实现、一个必须实现 

3.2.3静态和非静态（static）

3.2.4初始化、实例化、构造器（this|super）、方法重载、类的加载、类初始化、继承初始化、方法初始化、3.2.5成员初始化、构造器初始化

3.2.6父类、子类、内部类、外部类、嵌套类（方法与作用域）

3.2.7类变量、成员变量、静态变量、实例变量        

3.2.8Finall关键字（类、方法、数据类型）

3.2.9构造函数、析构函数

3.2.10垃圾回收及清理

3.2.11对象内存模型（指针）：堆栈stack-对象的引用和堆heap-对象的数据

3.2.12其他

3.3接口interface、包package

3.3.1装箱，拆箱

3.3.2继承，多重继承，组合

3.3.3抽象类和抽象方法，工厂方法

3.3.4适配接口和嵌套接口

3.4.5 package，import，Implements，Extemds用法

3.4字符串String和StringBuibler

String方法：创建new、追加+、长度length、截取substring、分割split、清除trim、查找indexOf、比较StringBuibler方法：创建new、追加append、插入insert，删除delete

字符串编码：Unicode，Utf-8，ASCII，GBK  

3.5数组Array                       

创建数组、遍历数组、数组排序（冒泡算法）

3.6枚举Enum

创建枚举、遍历枚举

3.7集合Collections

选代器 Iterator (字典、散列表、属性－properties)

Vector与Queue 排队规则顺序

Collection

Map 键值对

List 重复元素.顺序

Set 无重复元素

3.8异常与错误处理

Try-catch-finally（层次结构）                                           

备注：

泛型、反射、容器、队列、算法与排序、正值表达式

四、java web

Jsp(request| reponse) Ation(Get|Post)

session,cookie,applition

AjAx,Js,Json

Java注释

五、java Tread

5.1线程，多线程，线程组，线程池

5.2创建，执行，停止，生命周期，休眠，优先级，死锁，高度，让步，中继，协作，同步，异步

六、java IO

6.1文件，目录（创建、判断、编辑、删除）    参考实例

6.2输入，输出，错误（in,out,error）(InputStream,OutputSteam,FileInputStream,FileOutPutStream)参考实例

6.3读，写 [方式] (read,write)（FileRead,FileWrite）参考实例

6.4压缩，解压缩参考实例

6.5对象系列化

6.6 XML参考实例

6.7 prefertices参考实例

6.8 其他

七、java Net

7.1 Socket和NIO参考实例

7.2 HTTP和URL参考实例

7.3 TCP/IP 与UDP

八、java DataBase

API(driver，connection，statement，resultset)

九、java Text, Image, Sound

9.1 Text文本操作

9.2 Image图片操作参考实例

9.3 Sound声音操作

十、java Bean(组件)

基本概念：结构、属性、方法、事件（BDK）

十一、Java RMI, WebServers

参考实例

十二、Java Secarity

12.1编码

12.2 MD5

12.3 DES

12.4 Hash

12.5 SHA

12.6 Baseby

十三、java JUI(AWT和Swing)

基本概念：控件、事件、委托

界面：参考实例

十四、java JDK(Framework) (SSH)

Strust+spring+hibernate构架体系

十五、java Desiga mode(设计模式)

二十三种设计模式

十六、java 综合