第一章 初识Java
1、计算机程序：为了让计算机执行某些操作或解决某个问题而编写的一系列有序指令的集合。
2、开发Java程序三步走：1）编写源程序
2）编译源程序
3）运行
注意：a、public 修饰的类的名称必须与Java文件名一致；
b、main方法作为程序入口，void必不可少；
c、Java对大小写敏感；
d、每一条Java语句必须以分号“；”结束！
e、不要漏写引号。
3、配置环境变量
Path：配置jdk命令文件的位置（bin目录）
Classpath：配置系统和用户类文件的位置（lib目录），classpath是只有在需要导入外界jar包时才需要，否则不用添加。
设置path路径：
环境变量---系统变量---编辑---复制jdk安装目录下的bin目录路径，在path路径末尾处黏贴。
例如path=D:\Program Files\Java\jdk1.6.0_30\bin；
设置Classpath路径：
1.复制lib目录下的路径，输入“.；”，添加dt.jar和tools.jar工具，配置完后可以在Dos环境下，利用记事本开发程序。
2.也可以在CMD中输入set classpath= D:\Program Files\Java\jdk1.6.0_30\lib\jar包;但是这种方式是临时的，当关闭cmd时，设置的classpath会自动消除；
4、 熟悉Eclipsec菜单及其功能，如新建一个项目，新建一个类，删除一个项目或类；类的全名; 项目名或类名重新命名（refator--rename）；导出、导入资源等。
5、 熟悉掌握\t和\n的显示格式控制
第二章 变量运算符
1、 变量：一个数据存储空间的表示
2、 变量的三要素：变量名、变量类型、变量值
3、 标示符：定义、规则（4条）
4、 关键字：不能用关键字命名变量
5、 数据类型（2大类）基本数据类型、引用数据类型（类、接口、数组）
基本数据类型：{数值、字符（char）、布尔（true、false）}
数值类型：byte、short、int、long
浮点类型：float、double
变量声明及使用（3步）int money=1000;
练习定义并使用变量！
6、 数据类型转换：自动（由低到高）、强制
数据类型的级别是：byte-char（short）-int-long-float-double。
7、 运算符：算数、关系、逻辑、条件[？表达式1：表达式2]、位运算符
赋值运算符主要包括：“+=”、“-=”、“*=”、“/=”、“%=”。算数运算符主要包括：“+”、“-”、“*”、“/”、“%”、“++”、“--”。
关系运算符主要包括：“==”、“！=”、“>”、“<”、“>=”、“<=”， “>”、“<”、“>=”、“<=”优先级高于“==”、“！=”。
逻辑运算符主要包括：“&”、“^”、“|”、“!”、“&&”、“||”，优先级别：“！”>“&”>“^”>“|”>“&&”>“||”。
位运算符：“&”、“|”、“^”、“~”、“<<”、“>>>”、“>>”。
条件运算符的语法：条件？表达式1：表达式2（首先对条件进行判断，如果结果为true，返回表达式1的值，如果为false，返回表达式2的值）
备注：如何从键盘上获取一个char类型的值呢？
char s=input.next().charAt(i);//这就是获取从键盘输入的字符串的第（i+1）个字符,使用这种方式需要先导入Scanner类；
第三章 流程控制
****选择结构****
1、if语句；if-else语句；//通常加上{}，使代码可读性强
if ( 条件 1) {
//代码块1
}
else if ( 条件2 ) {
//代码块2
}
else {
//代码块3
}
//注意语法规范性，层次清晰可见
多重条件之间互相排斥，总有一个要被执行
2、switch语句
Switch（变量或表达式）{
Case条件1：
//代码块1
Break；
Case条件2：
//代码块2
Break；
Default:
//默认执行的代码块
}
switch（）内必须为整型和字符型，字符串型不行，但有些新版本的可能已经支持字符串了，具体可以自己练习一下。
case之后的值不能相同，其后要加break语句以便及时退出
****循环结构****
1、while循环:注意循环条件怎么写，深刻理解执行步骤；
While（循环条件）
{循环体}
在语法中：关键字while后的小括号中的内容是循环条件。循环条件是一个布尔表达式，他的值为布尔类型“真”或“假”。大括号中的语句统称为循环操作，又称循环体。
While语句的执行步骤：
（1） 首先对循环条件的结果进行判断，如果是真，则执行循环语句。
（2） 执行完毕后继续对循环条件进行判断，如果是真，继续执行。
（3） 如果是假，则跳过循环语句，执行后面的语句。
2、do-while循环，程序先执行一次，再判断条件。和while基本相同不再重复。
上面两种循环不需要知道循环次数，对于循环次数已知的，就用for循环。
3、for循环：
格式：for(表达式1；表达式2；表达式3){
循环体；
}
For语句的执行步骤：
（1） 首先执行表达式1，一般是进行变量的初始化操作。
（2） 然后执行表达式2，即对循环条件进行判断。
（3） 如果为真，则执行循环体。
（4） 循环语句执行完毕后执行表达式3，改变循环变量的值，再次执行表达式2，结果为真，继续执行循环。
（5） 如果结果为假，终止循环，执行后面的语句。
表达式1和表达式3都可以执行多个操作，三个表达式都可以省略，不过表达式2一般不可省略，否则会陷入死循环
4、循环嵌套
外层循环执行一次，内层循环执行一遍
主要掌握内外循环条件！
5、break语句--只在循环场景应用，终止当前循环语句的执行，就是跳出整个循环，还可以用于终止switch语句的执行。
6、continue语句--结束所在循环的本次执行，继续下一次循环；也是只会出现在循环语句当中，注意3种循环使用它的不同之处。
7、return语句--退出当前方法，返回到上层调用方法处，每个方法都需要有return语句（如果返回值是void，不能写return语句），表示方法结束并返回结果。
第四章 数 组
数组是多个相同数据类型数据的组合，实现对这些数据的统一管理。数组中每个数据称为数组的一个元素。
一、一维数组
1、 数组是可以在内存中连续存储多个元素的结构。数组中的所有元素必须属于相同的数据类型。
定义数组的语法：
数据类型 [] 数组名=new 数据类型[数组长度]或
数据类型 数组名 []=new数据类型[数组长度]
在语法中：定义数组时一定要指定数组名和数组类型。必须书写“[]”，表示定义了一个数组，而不是一个普通的变量。“[数组长度]”决定连续分配的空间的个数，通过数组的length属性可获取此长度。数组的数据类型确定分配的每个空间的大小。
2、 数组中的元素通过数组下标进行访问，数组下标从0开始。
3、 使用arrays类提供的方法可以方便地对数组中的元素进行排序、查询等操作。
（1）比较两个数组是否相等
Array类的equals()方法用于比较两个数组是否相等。只有当两个数组长度相等，对应位置的元素也一一相等时，该方法返回true；否则返回false。
（2）对数组的元素进行升序排列
Arrays类的sort（）方法对数组的元素进行升序排列，即以从小到大的顺序排列。
（3）将数组转换成字符串
Arrays类中提供了专门输出数组内容的方法—toString()方法。该方法用于将一个数组转换成一个字符串。
（4）将数组所有元素赋值为相同的值
Arrays类的fill（array，val）方法用于把数组array的所有元素都赋值为val。
（5）查询元素在数组中的下标
Arrays类的binarySearch（）方法用于查询数组元素在数组中的下标。调用该方法时要求数组中的元素已经按升序排列。
4、 jdk 1.5之后提供了增强for循环，可以用来实现对数组和集合中数据的访问。
for(String name: names){
System.out.print(name);
}
其中String是数组中元素的类型，name是随意定义的一个变量，names是数组名。
二、二维数组
1、定义：int[][] numbers=new int[3][5];
初始化二维数组：
二维数组实际是一个一维数组，它的每个元素又是一个一维数组。初始化参见一维数组。
2、二位数组的遍历：主要是for循环的嵌套使用。
第五章 类和对象
面向对象编程
优点：代码可复用性，灵活，可扩展性，可靠性高等
三大特征：封装、继承、多态
1、对象：客观存在的实体，具有属性和方法，是类的一个具体实例。
2、类：是具有相同属性和方法对象的集合，它是一个概念，只存在于人的脑海之中，可以理解成一个模板。
创建类，定义属性和方法
创建类的一个对象（含有main方法），给成员变量赋值；调用行为（方法），实现输出效果。
回顾以前创建的Scanner类，在动态给成员变量赋值时用到
如: tom.name=input.next();
3、方法的重载： 方法名相同 参数项不同 ；
参数项不同是指参数的类型或者个数不能相同。
4、成员变量和局部变量的区别：
a，作用域不同： 作用域不同，局部变量仅限于定义它的方法，成员变量在类的内部和外部都可以访问
b，初始值不同，局部变量赋值后才能使用，成员变量可以直接使用
c，在同一个方法中，不允许同名的局部方法，在不同调用方法中可以重复；局部变量可以和成员变量同名，在方法内使用局部变量的优先级更高。
5、参数传递 对象、数组 、引用数据类型
备注：基本数据类型作为方法的参数，传的是数据，在方法内部的改变不会保留下来。
引用数据类型作为方法的参数，传的是地址，在方法内部的对参数的改变会保留下来，（字符串String在作为参数传递时具有基本数据类型的特点，数据在调用后不会发生改变，即在方法内部的改变不会保留下来）。
第六章 封装
1、封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
2、实现封装的步骤有三：a、属性私有化；b、设置get\set方法；c、设置必要的读取限制。
3、封装的作用：a、避免外部错误操作引起的影响；b、提高松耦合性、代码重用性。
4、This（类的当前实例）关键字的用法：
a、调用属性；b、调用方法；c、调用构造方法（在有多个构造方法中）如this(java);（调用时，语句只能放在构造方法的第一位置）
5、包机制：管理java文件；解决文件同名冲突。
作用：
注意事项：package语句必须放在代码第一行；不同包中的类需要导入才能有，包内部的类可以相互访问。包的结构类似了window操作系统中的文件件，多级之间用“.”隔开。
6. 访问修饰符（4种）
7. static关键字：修饰静态变量，在内存中只有一个，被类的所有实例所共享；所修饰的方法为静态方法，如main（）方法，此时可以用类名调用或者用实例调用；static还可以定义一段代码块，在类加载时会被执行。
实例变量必须通过类的实例进行访问，在被创建时分配内存空间。
8.对象数组
就是数组的每个元素都是对象。
第七章 继承和多态
一 继承
1、继承：一个类可以直接使用另一个类的属性和方法，也可以有自己的属性和方法；
在JAVA中只支持单继承，也就是说一个类只有一个直接父类。
2、子类不能继承父类什么呢？
a、子类无法继承父类的私有属性和方法；
b、子类无法继承父类的构造方法。
3、子类方法的重写（对父类方法的扩展）需要满足四个条件：
a、方法名必须相同；
b、参数列表必须相同；
c、返回值类型必须相同或者是其子类型；
d、不能缩小被重写方法的访问权限。
3、super关键字：代表当前对象的直接父类的默认引用。
注意：a、必须出现在子类中，而不是其他位置；
b、用以访问父类的属性、方法、构造方法；
c、通过它无法直接访问父类的私有（private）成员
4、继承的传递性：类A继承类B，类B继承类C，那么类A可以继承类C的属性和方法；
5、继承的单根性：一个类只能有一个父类。
6、Final关键字：所修饰类或者方法不能继承或者重写。
修饰成员变量可以直接赋值，还可以在构造方法内赋值，赋值完后不能再被修改（赋值）。
7、调用静态方法：一是直接用类名调用（通常）；二是创建类后，用类名调用。
static 可以修饰代码块，里面操作的都是静态的量。
8、Object类是所有类的父类，掌握其中的几个方法如，toString，equals等。
关于object 的方法的重写，重点掌握equals方法
二 多态
1、多态：是指不同的对象在面对同一行为，呈现出不同的执行效果，其作用是消除类型之间的耦合关系。
多态：子类重写父类方法，父类类型作为方法的参数类型；
调用时传的实参是子类的对象，执行的是实际对象的方法。
2、向上转型：子类对象赋值给父类引用。转型后子类特有的方法不能调用！只能调用父类的方法和子类重写父类的方法。
3、向下转型：如想调用狗狗特有方法（假如有：catch()方法）
Dog name=(Dog)dog;name.catch;
向下转型后才可以调用子类特有的方法
注意：instanceof 判断引用是否为指定类型
如：if(pet instanceof Bird){
Bird bird=(Bird)pet;把父类- 宠物类向下转型为子类- 小鸟类
bird.fly;}小鸟特有方法
4、实现多态的三个条件：
1）继承的存在
2）子类重写父类的方法
3）父类引用变量指向子类对象
5、多态的常用两种用法：
a) 父类类型作为方法的参数类型
b) 父类类型作为方法的返回值类型
第八章 抽象类接口
1、抽象类、接口与类是一个层次的概念，是Java中极其重要的概念。抽象类是从多个类中抽象出来的公共模板，提供子类均具有的功能。接口是从多个类中抽象出来的规范，体现的是规范和实体分离的原则，同时也有效的解决了Java单继承的缺陷。
2、抽象方法是定义在抽象类或者接口中的方法，相比普通方法而言，抽象方法不能有实现体，抽象方法要用abstract修饰符修饰。
3、抽象类和接口都不能实例化！
4、抽象类：一个不能被实例化的类，它可以具有抽象方法和普通方法。而普通方法在继承时，子类必须重写此方法。
public abstract class 类名称{
修饰符 abstract 返回类型 方法名（）；//抽象方法
修饰符 返回类型 方法名 （）{//普通方法
}
}
5、接口：public interface Person{
抽象方法
抽象方法
}
简单的说，接口是一个不能被实例化，且只能拥有抽象方法的类型。
注意：接口不使用class关键字定义；接口！=类；其子类必须实现Person接口的抽象方法！
6、区分抽象类和接口的异同
1）抽象类使用abstract声明，接口使用interface声明。
2）接口是一个完全的抽象类，所有的方法都没有实现，而抽象类可以有自己的实现方法，也可以没有。但它们都不能被实例化。
3）接口中定义的变量默认是是public static final类型，并且必须给初值，所以实现类中不能重新定义，也不能改变其值。而抽象类中的变量默认是friendly型，其值可以在子类中重新定义，也可以重新赋值。
4）在抽象类中可以有自己的数据成员，而在接口中，只能够有静态 的不能被修改的数据成员（也就是默认的 static final 的，不过在接口中一般不定义数据成员），并且所有的成员方法都是抽象的。
5）抽象类在Java语言中表示的是一种继承的关系，目的讲变化的与不变的东西分开，而接口的目的是则在于实现模块之间的松耦合。一个类只能继承一个程序类。但是，一个类可以实现多个接口。
6）抽象类的使用通过继承（extends），而接口的使用则是实现接口（implements）。
7）抽象类中的抽象方法的访问符不能为private，接口中的抽象方法则必须为public。
7、抽象类的作用：可以将已经实现的方法提供给子类使用，使代码可以被复用；同时抽象类中的抽象方法，保证了子类还具有自身的独特性。
8、接口的作用：接口，简单的说，就是通过多态方式，使用它可以很好隐藏代码的细节，从而解决代码维护不易的问题。
作用是便于代码维护！
第九章 异常
1、异常：程序在运行时发生的意外情况。
异常有很多种，而且有继承关系。
异常概述：runtimeException （运行时异常）和checkedException（已检查异常）。
掌握异常结构图！
2、常见的异常类型：
ArithmeticException
ArrayIndexOutOfBoundsException
NullPointerException
ClassNotFountException
NumberFormatException
InputMismatchException
注意： 通过条件语句不可以完全避免异常的发生。
3、使用try--catch处理异常
如果所捕获的异常类型和实际异常类型不匹配，程序同样会终止，
如果所捕获类型和实际类型一致，进入catch执行。
4、使用try--catch--finally处理异常
如果try中存在return，则会在执行完finally之后再去执行return，
也就是说，finally无论如何都会被执行。
使finally不执行的情况：停电、关闭程序（正常退出：System.exit(0)、不正常退出：System.exit(1)）、Eclipse控制台停止按钮。
5、了解try--finally处理异常，这时把异常交给Java虚拟机处理。
6、掌握多重catch块，各个catch块之间的关系是互斥的，只会执行其中一个。子类类型的catch块放前面，父类类型的catch块放后面。
7、Try--catch之间也可以进行嵌套。
快捷键是：右键---surround with添加。
8、throws声明抛出异常
通常有两种情况：
1）存在异常，自己不处理，让调用者处理；
2）让调用者明白存在异常。
throws可以抛出多个类型的异常，它们之间用逗号间隔，不分顺序。
9、区别Exception和Error：
Exception 表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况；
Error 表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况。
10、区别throws和throw：
1）、作用不同：throw用于程序员自行产生并抛出异常。throws用于声明在该方法内抛出了异常。
2）、使用的位置不同：throw位于方法内部，可以作为一个单独的语句使用。而throws必须跟在方法参数列表后面，不能单独使用。
3）、内容不同：throw抛出异常对象，只能是一个；throws后面跟的是异常类，可以跟多个。
11、自定义异常：可以继承Throwable、Exception、RuntimeException类。可以有四种构造方法：
常见两种://构造方法1
public MyException(){
super();
}
//构造方法2
public MyException(){
super();
}
第二本书
第一章 框架集合和泛型
1、框架集合类体系结构
Java集合框架位于java.util包中，提供了一套性能优良、使用方便的接口和类，是为了表示和操作集合而规定的一种统一的、标准的体系结构。 如果写程序时并不知道程序运行时会需要多少对象，或者需要更复杂的方式存储对象，--那么，可以使用Java中的集合框架来解决这类问题。
2、集合框架的接口介绍
Collection ：接口存储一组不唯一，无序的对象。
1）List接口存储一组 不唯一，有序（插入顺序）的对象；
2）Set接口存储一组 唯一，无序的对象；
3）Map接口存储一组 键值对象，提供key（键）到value（键）的映射。
3、List接口：
3.1实现类ArrayList实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问某个元素效率比较高。
ArrayList的方法：
1)获取集合长度方法size();
2)添加元素方法add(O)，或添加指定位置元素add(index，O)
3)删除某个元素方法remove()，或者删除指定位置元素remove(index)
4)通过指定位置获取对象方法get(index)
5)还有其他方法，使用时可查看API文档
3.2实现类LinkedList采用链表存储方式。插入、删除元素效率较高。
它的方法和ArrayList类的方法差不多，只不过多了对集合首段和末尾元素的添加和删除操作：比如又addFirst()、addLast()、removeFirst()、removeLast()。
上面两个实现类都是通过for循环遍历集合输出的！！！
4、set接口：方法中不存在get()方法
它是通过Itreator迭代器实现遍历输出的。
Iterator接口：表示对集合进行迭代的迭代器
它有两个方法：
1）hasNext方法：表示判断是否还有元素可以迭代；
2）Next方法：返回迭代的下一个元素。
可以通过调用集合对象的iterator方法来获得Iterator对象，such as，集合对象.iterator
Set接口常用类是HashSet类，它也有很多方法，如：
1）add(E e)方法，如果set中尚未包含指定元素，则添加指定元素；
2）clear()方法，从set中移除所有元素；
3）Contains(object o)方法：如果set包含指定元素，则返回true；
4）Iterator()方法 ：返回对次set元素中进行的迭代器；
5）Remove()方法
6）Size()方法等
5、Map接口：以键值对的方法存储数据
它最常用实现类是HashMap类。
不同于list接口的是，在Map接口的实现类是使用put方法存储数据的。如 O put(O key,O value)
它也有很多方法：
1）O get(O key)方法:根据键返回相关联的值，如果不存在指定的键，则返回null；
2）O remove(O key)方法：删除由指定的键映射的“键值对”；
3）int size()方法：返回元素个数
4）Set keySet方法：返回键的集合
5）Boolean containsKey(O key)：如果存在由指定的键映射的“键值对”，则返回true。
6）Collection values()方法等。
6、Collections类定义了一系列用以操作集合的静态方法
使用时可查看API帮助文档学习。
泛型
类1或者接口<类型实参>对象=new类2<类型实参>（）；
使用泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，使代码可以用于多种类型。使用泛型集合在创建集合对象时指定集合中元素的类型，从集合中取出元素时无需进行强制类型转换。
第二章 实用类
1、枚举类型：是指由一组固定的常量组成的类型。
[Modifier] enum enumName{
enumContantName1[,enumConstantName2..[;]]
}
Modifier是访问修饰符，如public等。
enum是关键字。
enumContantName1[,enumConstantName2..[;]]表示枚举常量列表，枚举常量之间以逗号隔开。
2、Java中的常用包及API介绍
Java.lang java.util java.text java.io java.sql ……
3、基本数据类型转换为包装类（对象类型）
两种构造方法：1）、public Type (type value)
2)、public Type (String value)（character除外）
每个包装类都有：
静态方法---
1）、public static Type valueOf (type value)
2）、public static Type valueOf (String value)
注：1)传给valueOf方法的字符串限制，和传给包装类的构造方法的字符串限制是相同的。如不能写成：
Double doubleValue=Double.valueOf(“abc”)
2)在character类中有两种常用的静态方法：
public static boolean isDigt(char ch)----确定指定字符是否是数字
public static boolean isLetter(char ch)---确定指定字符是为字母
4、（对象类）包装类转换成基本数据类型
public type typeValue();//用对象调用
5、字符串转换成基本数据类型（静态方法）
public static type parseType(String type)
如 int num=Integer.parseInt("36");
需要注意的是Character类没有此静态方法
6、基本数据类型转换成字符串
public static String toString(type value);
如：String sex=Character.toString('男');
String id=Integer.toString(25);
在实际开发中为了省事，通常在基本数据类型后面用加号连接一个空字符串来进行转换。
7、自动装箱和拆箱
装箱:基本数据类型转换为包装类的对象
拆箱：包装类对象转换为基本数据类型的值
8、Math类：提供了数学运算方法和两个静态常量E（自然对数的底数）和PI（圆周率）
它有很多方法：如 max()、min()、pow()、abs()、sqrt()等，在实际需要使用时可以查看API文档。
9、String类
特点：是一个String对象所包含的字符串内容永远不会被改变！
即String的对象是不可变长的字符串。
它有很多实用的方法，比如字符串的比较、截取、查找等
Trim()方法：返回一个去掉字符串前后空格的副本；
equalsIgnoreCase()不区分大小写比较；
Substring(int beginIndex,int endIndex);截取指定长度字符串；
indexOf()方法：返回字符所在位置，若不存在，则返回-1；
toLowerCase()方法：返回字符串的对应小写
toUpperCase()方法：返回字符串的对应大写（这两个方法有重载）
split()方法：拆分字符串
10、StringBuffer类：
特点是它的对象是可变长的字符串！，创建它时会预先分配一定长度的缓冲区，来满足增长的需要。
两种构造方法：一种不带参数（默认初始容量是16），一种带参（该字符串的初始容为16加上字符串参数的长度）。
它有很多方法，好多和String类差不多，这里介绍不同但常用的几个方法：
1）append()方法：能够把任何类型数据的字符串表示形式添加到StringBuffer对象的末尾。（有很多重载方法）
2）reverse()方法：翻转字符串
3）toString()方法：返回字符串类型的数据
11、java.util包常用类--Date类封装了当前的日期和时间，以毫秒来表示特定的日期。
抽象类Calendar提供了一组方法，可以获取一个时间的年、月、日的整型值。
要注意 Calendar()是抽象类，不能用new关键字来实例化，应如:
Calendar calendar=Calendar.getInstance();
获取当前的年月日时分秒
获取当前的年份：如
int year=calendar.get(Calendar.YEAR);
设置月份：如
calendar.set(Calendar.MONTH, 8);
判断某年是否为闰年？如下：
GregorianCalendargc=new GregorianCalendar();
gc.isLeapYear(year);
DateFormat：处理日期时间的类，它在java.text包下，是一个抽象类，提供了多种格式化和解析时间的方法。
格式化：日期--文本；解析：文本--日期
SimpleDateFormat类可以用户定义的日期--时间的模式完成格式化和解析的操作。
日期和时间模式是由日期和时间模式字符串指定；
模式字母：具有特定含义的字母。
如：yyyy年MM月dd日 HH：mm：ss
SimpleDateFormat常用的构造方法：
1)Public SimpleDateFormat()
SimpleDateFormat sdf=new SimpleDateFormat();
2)Public SimpleDateFormat(String pattern)
SimpleDateFormat simpleDateFormat=new SimpleDateFormat(yyyy-MM-dd hh-mm-ss);
SimpleDateFormat常用的方法：
1)public final String(Date date)
2)public Date parse(String source)
12、Random类是一个伪随机数生产器
13、种子数：在进行随机时，随机算法起源数字成为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数。
第三章 输入输出控制
1、文件：相关记录或放在一起的数据的集合。
2、File类及分隔符
构造方法有三种：1）File(String pathname),接受文件名作为字符串。2）File(String dir,String subpath),dir参数指定目录路径，subpath参数指定文件名。3）File(File parent,String subpath),parent参数指定目录路径，subpath参数指定文件名。如果程序只处理一个文件，那么使用第一种构造方法比较合适。如果程序处理的是一个公共目录中的若干子目录或文件，那么选用第二、三种构造方法较为合适。
3、File类仅仅用来描述File对象的属性，也就是来描述文件的属性，它并不对数据如何存储的加以获取。File类旨在提供抽象化，以独立于机器的方式处理文件或者是路径名。它有很多方法：例如，canRead(),canWrite(),equals(Object obj),getName(),等等。
4、流概念：Stream,一连串流动的字符以先进先出的方式或者接受数据的通道。一个流是输出输入设备的抽象表示。流具有方向性：输出流，读取数据；输入流：写入数据。
5、流对象：是指输入输出流的类对象。可以通过流对象讲文件的数据以流的方式读取到内存。数据源分为源数据源和目标数据源。
6、流的分类：1).按照方向（从程序角度观看）分为输入流和输出流。输入流只能从中读取信息，而不能像其中写入信息；输入流只能向其中写入数据，而不能从中读取数据。
2).按照操作数据单元的不同分为字节流和字符流。
7.流的基类：1）输出流-OutputStream和Writer
2）输入流-InputStream和Reader
以上四个基类都是抽象类，不能被实例化！
熟悉以上类的结构图和常用实现类。
8、InputStream常用方法：int read()：从输入流中读取单个字节，返回所读取的字节数据；int read(byte[] b)：从输入流中读取最多b.length长度的字节，并存储在字节数组b中，返回实际读取的字节数；int read(byte[] b,int off,int len)：从输入流中读取最多长度为len的字节，保存到字节数组b中，保存的位置从off开始 等等。
9、OutStream常用方法：void write(int c)：将指定字节输出到输出流中；void write(byte[] buf)：讲字节数组输出到输出流中；void flush()：清空缓存区 ……等等。以上方法在出现错误时都会抛出IOException的异常。所以在使用这些类或者方法操作数据时一定要注意抓取异常。
10、Reader的常用方法： int read()：从输入流读取单个字符，返回所读取的字符数据；int read(char[] c)：从输入流中读取长度为c.length的字符，保存到字符数组c中，返回实际读取的字符数；boolean ready()：如果要读的流已经准备好，则返回true，否则返回false；void close()……关闭输入流等等。
11、Writer的常用方法：write(String str)：讲字符串里包含的字符输出到指定的输出流；write(String str,int off,int len):讲str字符串里从off位置开始长度为len的字符输出到输出流中……等等。
注意：java的输出输入流不属于内存的资源，那么系统无法进行收回，如果不关闭，资源会被一直占用，无法对文件进行下一步的操作。所以在操作完流后，一定要关闭流！
12、FileInputStream是InputStream的子类，它有两种构造方法1)FileInputStream(File file)：file指定文件数据源2)FileInputStream(String name)：name指定文件数据源，包含路径信息。
13、FileOutputStream是OutputStream的子类，它有三种构造方法：1)FileOutputStream(File file)：file指定文件目标数据源；2)FileOutputStream(String name)：name指定文件目标数据源，包含路径信息；3)FileOutputStream(String name,booleanappend)：append若true，则在文件末尾添加数据，避免写入时把原内容覆盖。
注意：1）在创建FileOutputStream的实例时，如果相应的文件并不存在，就会自动创建一个空的文件。2）如果file或者name表示的路径尽管存在，代表一个目录，此时会抛出一个（文件没有找到）异常。3）在默认情况下，向文件写数据时将覆盖文件中原有的内容。
14、BufferedrReader(Reader in)：参数in指定被装饰的Reader类；BufferedReader(Reader in,int sz)：参数sz指定缓冲区的大小，以字符为单位。
15、BufferedWriter(Writer out)：创建一个使用默认大小输出缓冲区的缓冲字符输出流。BufferedWriter(Writer out,int sz)：创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
16、读写二进制文件常用类--DataInputStream和DataOutputStream。
第四章 注解和多线程
一 注解
语法：@Annotation(参数) 参数可以没有，也可以有一个或多个。
Java.lang：
提供了三种标准的注解类型，称为内建注解，分别是@Override ,@Deprecated,@Supperss.
Java.lang.annotation：
提供了四种元注解，用来修饰其他的注解定义。分别是@Target,@Retention,@Documented
以及@Inherited
二 多线程
1、进程：就是应用程序的执行实例
进程的特征：动态性、并发性、独立性
2、线程：进程的内部的一个单元，它是程序中一个单一的顺序控制流程。
线程的特点：
1）一个进程可以包含多个进程，而一个线程至少要有一个父进程。
2）线程可以有自己的堆栈、程序计数器和局部变量。
3）线程与父进程的其他线程共享进程所有的全部资源。
4）独立运行，采用抢占方式。
5）一个线程可以创建和删除另一个线程。
6）同一个进程的多个线程之间可以并发执行。
7）线程的调度管理是由进程来完成的。
注：编程时，必须确保线程不会妨碍同一进程的其他线程。
3、多线程开发的优势：一是可以改善用户体验，二是提高资源利用率。
线程的使用步骤：定义一个线程；创建线程的实例；启动线程；终止线程。
4、使用继承创建和启动线程 自定义类都继承Thread类，并重写run()方法，用实例名调用start()方法启动。
注意：为什么不应对象调用run()方法启动，而是用start()方法？
Start()方法的作用会使系统初始化一个新的线程，由这个线程来执行线程对象的run()方法。
5、使用Runnable接口创建和启动线程，创建一个类实现Runnable接口，然后在有参构造方法中作为参数传递。
6、两种创建方法的优缺点比较：
1）继承Thread类：优点-编写简单；可以使用this关键字直接访问当前线程；缺点-无法继承其他的类。
2）实现Runnable接口：优点-可以继承其的类；多个线程之间可以使用同一个Runnable对象。缺点-编程方式稍微复杂，如需访问当前线程，则需要调用Thread类的currentThread()方法。
7、线程的四种状态：新生--可运行--被阻塞--死亡。
8、线程的优先级：
1）默认情况下，一个线程继承其父类的优先级；
2）优先级表示为一个整数值；
3）优先级越高，执行的机会越大，反之越小；
4）高优先级的线程可以抢占低优先级线程的CPU资源。
9、线程的优先级整数表示：使用setPriority()方法，用线程对象调用即可。需要注意的是1）线程的优先级的范围可能根据操作系统的不同而不同。2）通常情况下，优先级最大值为10，最小值为1，默认优先级为5。
10、线程调度之join：作用是阻塞指定的线程等到另一个线程完成以后再继续执行。
11、线程调度之sleep：使之当前线程转入到阻塞状态。Thread.sleep(long millisecond);
12、线程调度之yield：使当前线程转变为可运行状态。
13、Sleep()方法和yield()方法的比较：1）sleep()方法使当前线程转入被阻塞状态，而yield()方法则使当前线程转入可运行状态。2）sleep()方法总是强制当前线程停止执行，而yield()方法则不一定。3）使用sleep()方法需要捕获异常，而使用yield()则不用捕获。
14、setDaemon()方法：设置对象我后台（守护）线程。
线程对象.setDaemon(boolean on);
应在线程对象调用start()方法前调用此方法，否则就会抛出异常！
15、线程之间的通信：使用synchronized关键字可以阻止并更新同一个资源共享，实现了同步，但是它并不能用来实现不用线程之间的消息传递。
线程间通信的实现：wait()方法：当前线程会从可运行状态转入到阻塞状态，知道调了wait方法所属的那个对象的notify()方法或者notifyAll()方法为止。notify()方法：唤醒因为调用wait方法而被挂起的那个线程，使此线程退出阻塞状态，变成可运行状态。notifyAll()方法：可以使所有因为调用wait方法而被挂起的线程都重新启动，优先级别最高的最先被执行，这时它要和wait方法同属一个对象！
第五章 网络编程技术
1、计算机网络：就是把地利分散的计算机与外部设备利用通信线路互联成一个系统，从而使众多的计算机可以方便的交互信息，共享资源。
2、计算机网络划分：局域网（LAN）、城域网（MAN）、广域网（WAN）。
3、OSI七层模型：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。
4、TCP/IP：传输协议控制，有4层模型，也可以说是5层，数据链路层包含数据链路层和物理层。
5、IP地址：32位表示，常用用4位分割并用十进制表示。由网络号和主机号组成。根据网络地址的不同，IP地址可以被分为5类：A类、B类、C类、D类、E类。
6、端口简介：相当于具体的地址，它只有整数，范围是从0到65535（2^16-1）；80端口是HTTP通信所使用的公认端口，端口号从0到1023，动态端口，通常从1024起分配。
7、域名：倒置原则。
8、网络服务器：包括WEB服务器、域名服务器、邮件服务器等。
9、TCP协议：面向连接、可靠的、基于字节流的、传输层通信协议。
10、UDP协议：面向非连接、不可靠、传输效率高、传输层通信协议，适用于一次传输少量数据、对可靠性要求不高的应用环境。
11、Socket ：套接字，应用程序通过它向网络发出请求或者应答网络请求，最早是UNIX上的一套网络程序通讯的标准，现在已被广泛移植到其他平台。Socket实质上提供了进程通信的端点，网络上两个程序一个双向的饿通讯链路实现数据的交换，这个双向链路的一端就称之为一个Socket。Socket位于TCP协议中的应用层和传输层，位于OSI七层模型中的会话层和传输层。
12、Socket分类：流式套接字：提供了一个面向连接，可靠的数据传输服务，数据无差错、无重复的发送，且按发送顺序接受；它对应的使用的是TCP协。数据包套接字：无连接服务。数据包以独立包形式被发送，不提供无差错保证，数据可能丢死或者重复，并且接受顺序无序；它对应的使用是UDP协议。原始套接字：一般程序不使用。
13、Socket通信的原理：要掌握！就像是打电话的过程。
14、Socket类的构造方法：Java中提供了9种，但我们只需掌握常用的两种。一是Socket(String host,int port)：向host主机的port端口发起连接请求；二是Socket(String host,int port,InetAddress localAddr,int localPort)：想host主机的port端口发送连接请求，发送请求的计算机为localAddr，端口为localPort。在这里，InetAddress类表示互联网协议地址，包含IP地址；InetAddress类是Java对IP地址的封装。
15、Socket类的常用方法：1）InetAddress getInetAddress()--返回与当前Socket对象关联的InetAddress对象；void shutdowmInput()--此套接字的输入流置于“流的末尾”；void shutdowmOutput()--禁用此套接字的输出流；InputStream getInputSteam()--返回Socket对象关联的InputStream对象，它是服务器端向客户端发送回来的数据流；OutputStream getOutputSteam()--返回Socket对象关联的OutputStream对象，它是客户端向服务器端发送的数据流；void close()--关闭该Socket对象建立的连接。
16、ServerSocket类的常用两个构造方法：1）ServerSocket()
--创建一个ServerSocket对象；2）ServerSocket(int port)--创建一个ServerSocket对象，并绑定到指定的端口。
17、ServerSocket类的常用方法：Socket accept()--侦听并接受到ServerSocket的连接。此方法在连接传入之前一直阻塞。void close()--是服务器释放占用的资源，并断开所有与客户端的连接。InetAddress getInetAddress()--返回当前服务器绑定的IP地址信息。
18、Socket编程步骤：
服务器端：
1）建立一个服务器Socket绑定指定端口并开始监听；
2）使用accept()方法阻塞等待监听，获得新的连接；
3）建立输入输出流；
4）在已有的协议上产生回话；
5）使用close()方法关闭流和Socket。
客户端：
1）建立客户端Socket连接，指定服务器的位置及端口；
2）得到Socket的读写流；
3）利用流按照一定的协议对Socket进行读写操作；
4）使用close()方法关闭流和Socket。
注意：通信中如果传递的是对象，那么该对象所对应的类必须实现Serializable接口！
19、多用户同时访问服务器，要用到多线程，服务器一直打开监听，有客户请求，就打开一条线程来响应客户请求。（注：一个Socket对应一个线程！）
20、DatagramPacket类的构造方法：DatagramPacket(byte[] buf,int length,InetAddress address,int port)--用来将长度为length的包发送到指定的主机上的指定端口号。
21、DatagramSocket类的常用两种构造方法：1）DatagramSocket()--创建一个DatagramSocket对象，并将其与本地主机上任何可用的端口绑定；2）DatagramSocket(int port)--创建一个DatagramSocket对象，并将其与本地主机上指定的端口绑定。
22、DatagramSocket类的常用方法：void send(DatagramSocket p)--发送指定的数据报；void receive(DatagramSocket p)--接受数据报。收到数据以后，存放在指定的DatagramPacket对象中；void close()……
23、使用UDP协议编程步骤：
服务器端：
1）创建服务器套接字，并绑定端口号；
2）确定数据包接受数据的数组大小；
3）创建接受类型的数据包，数据将存储在数组中；
4）通过套接字接受数据；
5）解析发送方发送的数据；
6）响应客户端，并发送；
7）释放资源。
客户端：
1）确定发送给服务器端的信息、服务器地址以及端口号；
2）创建书记包，发送指定长度的信息到指定服务器的指定端口；
3）创建DatagramSocket对象；
4）向服务器发送数据包；
5）接受服务器响应并打印显示；
6）释放资源。
第六章 XML
1、XML（Extensible Markup language）是可扩展标记语言。它的作用是存储数据、网络数据交互（甚至是不同的网络）、编写配置文件等。
2、XML的声明：<?xml version=”1.0” encoding ”UTF-8” ?>，词句一般是XML文档的第一行。其中version是文档符合XML1.0规范；encoding是文档字符编码，默认是”UTF-8”
3、根元素：每一个XML文档有且只有一个;其他元素都是成对出现的。在这里需要注意：1）所有的XML元素都必须有结束标签；2）XML标签对大小写敏感；3）XML必须正确的嵌套。
4、熟悉XML文档结构--树状，有节点、元素、文档内容组成。
5、空文档表示有三种：1）<title> </title> 2）<title><title> 3）<title/>
6、元素的属性表示：<元素名 属性名=”属性值” 属性名=”属性值”/>，在这里要注意的是：1）属性值用双引号包裹；2）一个元素可以有多个属性，属性和属性之间使用空格间隔。3）属性值中不能直接包含< “ & >等特殊符号。
7、掌握XML中5个预定义实体：如用<来表示<,&来表示&,"来表示”。
8、CDATA节：主要是将XML文档中的一些特殊内容转换为不需要我们XML文档去解析的内容。用于把整段文本解释为纯字符数据而不是标签的情况，包含大量的<,>,&,字符等。CDATA节中的所有字符都会被当做元素字符数据的常量部分，而不是XML标签。
语法：<![CDATA[
要显示的字符
]]>
9、注释：语法 <!--注释内容-->
注意：1）注释内容中不要出现“--”；
2）不要把注释放在标签中间；
3）注释不能嵌套。
10、DTD（文档类型定义）是用来藐视XML文档的结构：包含元素的定义规则、元素之间的关系规则、属性的定义规则。
11、DTD 文档的声明及引用（3种）
内部DTD文档 (students.xml)
<!DOCTYPE 根元素 [定义内容]>
外部DTD文档 (Students.xml Students.dtd)
<!DOCTYPE 根元素 SYSTEM “DTD文件路径”>
内外部DTD文档 结合
<!DOCTYPE 根元素 SYSTEM “DTD文件路径” [定义内容]>
12、DTD元素 <!ELEMENT NAME CONTENT>其中ELEMENT是关键字，NAME是元素名称，CONTENT是元素类型：元素类型分为四种--1）EMPTY 该元素一般不能包含子元素和文本，但可以有属性（空元素）2）#PCDATA 可以包含任何字符数据，但是不能在其中包含任何子元素3）纯元素类型 只包含子元素，并且这些子元素外没有文本4）ANY 该元素可以包含任何在DTD中定义的元素内容。
13、基于DTD有好多局限性，所有有必要了解另一种验证文档：Schema，它符合XML语法规则
14、操作XML数据（重点）XML文件不仅可以传输数据，还可以保存数据，我们要读取其中的信息，就要用到XML解析技术，常用的有两种：DOM（文档对象模型）和SAX。DOM是基于XML的树形结构来完成解析的，而SAX是基于事件的解析。它们解析的原理完全不同，DOM解析XML文档时，会根据读取的文档，构建一个驻留内存的树结构，然后代码就可以使用DOM接口来操作这个树结构了，它支持删除、修改、重新排列等多种功能。这种解析方式非常适用于多次访问XML的程序，但是DOM解析却是比较消耗资源的；而SAX解析时占用资源少，内存消耗小，一般在解析数据量较大的XML文档时会采用这种方式。
15、使用DOM解析XML文档的步骤主要有：
1）创建解析器工厂对象；
2）由解析器工厂对象创建解析器对象；
3）由解析器对象对指定的XML文件进行解析，构建响应的DOM树，创建DDocument对象；
4）以Document对象为起点对象DOM树的节点进行增删改查操作。
16、Document接口的常用方法:
1)getElementsByTagName(String tagName)--按文档顺序返回文档中指定标记名称的所有元素的集合；
2)createElement(String tagName)--创建指定标记名称的元素。
17、Node和Element是操作XML的重压接口。NOde表示文档树中任意一种类型的节点，可以是元素节点、属性节点或者是文本节点。而Element则只表示Node节点中的元素节点，即Node是Element的父接口。两个接口的常用方法：
Node： NodeList getChildNodes()--获取该元素的所有子节点，返回为节点集合；
Element： String getTagName()--获取元素名称。
18.dom解析简单应用
<doc>
<str name="content">
<h1>前言</h1>
<p>文章正文</p>
</str>
<str name="directory">/题材库/叙事</str>
<str name="keywords"><str/>
<str name="path">/题材库/叙事/2</str>
<date name="time">20##-08-28</date>
<str name="title">题目</str>
</doc>
如何获得文章正文、题目。
1、Dom获取根节点元素
document.getRootElement();
2、写一个递归的方法，把根结点root放进来
public void getElementList(Element element) {
List elements = element.elements();
if (elements.size() == 0) {
叶子节点，取出属性值
System.out.println(elements.attributeValue("name")+elements.attributeValue("value")+elements.attributeValue("color"));
} else {
// 有子元素
for (Iterator it = elements.iterator(); it.hasNext();) {
Element elem = (Element) it.next();
// 递归遍历
getElementList(elem);
}
}
}