Java面向对象编程思想

一：Java面向对象的编程思想：

1.Java具有面向对象的三大特征：

封装：通过java的类来实现数据和操作方法的封装，对外界可以将每一个Java类都视为一个黑箱，只需要调用该黑箱提供的方法即可完成你想要的操作。

继承：通过类的继承，便于将统一的功能集中在父类中，实现代码的重用和可维护性多态：通过重载、重写与覆盖，实现不同类的不同形态特征。

以上这三大特征是通过具体的类、抽象类与接口技术来体现的。

2.把封装的类进行实例化，可以生成多个对象，这些对象通过消息传递来进行交互(消息传

递即激活指定的某个对象的方法，以改变其状态或让它产生一定的行为)，最终完成复杂的任务。

3.一个类的使用过程，包括封装类，生成实例、使用实例进行三个操作3个过程。

4.一个类就是变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的

行为。

5.封装的类不是对象，要使用该封装的类进行操作，必须先生成这个类的一个实例-------

对象。对象的生成包括声明、实例化和初始化3个方面的内容。通常的格式为：

ClassName objectName=new ClassName([paramlist]);

ClassName 声明了一个类型为ClassName的对象。其中ClassName是组合类型(包括类和接口)。对象的声明并不为对象分配内存空间。

运算符new 为对象分配内存空间，实例化一个对象。new 调用对象的构造方法，返回对该对象的一个引用(即该对象所在的内存地址)。用new可以为一个类实例化多个不同的对象。这些对象占用不同的内存空间，因此改变其中一个对象的状态不会影响到其他对象的状态。

生成对象的最后一步是执行构造方法，进行初始化。由于对构造方法可以进行重写，所以通过对给出不同个数或者类型的参数会分别调用不同的构造方法

new 运算符返回对一个对象的应用，但与，C，C++中的指针不同，对象的引用是指向一个中间的数据结构，它存储有关数据类型的信息及当前对象所在堆的地址，而对于对象所在实际的内存地址是不可操作的，这就保证了安全性。

6.对于具有共同属性，又有自己特点的对象，就不能够通过单一的封装来实现了。此时可

以通过继承来实现。通过父类和子类，实现了类的层次，可以从最一般的开始，逐步特殊化，定义一系列子类。同时，通过继承也实现了代码的复用，是程序的复杂性线性增长，而不是呈几何增长。

7.继承是面向对象的基石，因为他允许创建分等级层次的类。运用继承，你能够创建一个

通用类，它定义了一系列相关项目的一般特性。该类可以被具体的类继承，每个具体的类都增加一些自己的特有的东西。在Java术语中，被继承的类叫做超类(supperclass)，继承超类的类叫做子类(subclass)。因此，子类是超类的一个专用版本，它继承了超类定义的所有实例变量和方法，并且为它自己增添了独特元素。

继承是使用已经存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性的继承父类。

8.尽管子类包括超类所有的成员，但它不能访问超类中被声明为private的成员。只能被它

自己类中的其他成员访问，子类没有方法访问。

9.父类和子类的相互转换：在Java中可以将子类的引用赋给父类的对象，那么这时子类中

那些不是从父类继承来的成员将不再可见，我们可以再通过强制类型转换将这个父类再转换成子类类型，那些成员又变得可见了，由此可见，将子类引用赋给父类对象时，Java

虚拟机并没有将那些非继承成员丢弃。例如：

Bus bus=new Bus();

Car car=bus;

System.out.println(car.p);在编译时将产生错误，在car中p是不可见的。

下面将得到正确的结果，子类非继承域又可访问，没有被丢弃。

Bus bus2=(Bus)car;

System.out.println(bus2.z);

10.使用this和supper

Java拥有两个保留关键字this和supper,这两个关键字在继承的子类中使用。

this：

引用当前类的变量和方法。可以防止父类中也有相同的变量或者方法造成错乱。

super :

它引用当前对象的直接父类中的成员(用来访问直接父类中被隐藏的父类中成员数据或者函数，基类与派生类中有相同成员定义时)

另外还有两种用法：

this(参数)引用当前类的构造函数。格式如下：

this(实参)

类似的super（参数）调用基类中的某一个构造函数

11.在子类的构造函数中，如果我们不显示的调用super（）完成父类的构造，系统会自动

调用父类的构造函数，但是这样存在很多的问题。如果在父类的构造函数中我们自己定义了构造函数，那么系统提供给我们不带参数且函数体只是一对大括号的构造函数将被收回，这时在子类的构造函数中，如果我们不显式指定哪一个supper(),就会默认那个不带参数的父类构造函数，而如果我们自己定义的父类构造函数又全是不需要参数的话，就会产生编译错误

12.在实现了类的继承后，子类就拥有了父类可见的变量和方法，就可以引用这些变量和方

法了。但是，，同时子类也可以有同父类同名的变量和方法，在同一个类的内部，也可以拥有同名的、参数列表不同的方法，这就是多态，即同一个名字有多种实现状态。

Java多态是通过方法重写和方法的重载来实现的。

(1).覆盖：继承了父类的同名无参函数

当子类从父类继承一个无参方法，而又定义了一个同样的无参方法，则子类新写的方法覆盖父类的方法，称为覆盖(注意返回值类型也必须相同，否则编译出错)。

(2).重载：继承了父类的同名有参函数

当子类继承了父类的一个同名函数，且方法不同，则称为重载。通过方法重载，子类可以重新实现父类的方法，使其具有自己的特征。

(3)重写：当前类的同名方法

通过方法重写，一个类中可以有多个具有相同名字的方法，由传递他们的不同参数个数和类型的参数来决定使用哪种方法。因此，重写的名称是当前类中的同名函数，不是父类中的函数名。

由以上可以知道，只有覆盖和重载是针对父类的，而重写是针对当前类的。

注意：对于方法的访问限制修饰词，子类方法要比父类的访问权限更高，例如父类为public ,那么子类为private则出现错误。子类抛出的异常应该是父类抛出异常或其子类。

13.在面向对象的概念中，所有的对象都是通过类来描述的，但是反过来却不是这样的，不

是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的

对象，这样的类就是抽象类。抽象类往往用来表示我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

14.抽象类可以有自己的数据成员，也可以有非abstract得成员方法，也可以由抽象方法，

抽象方法只有函数定义部分，没有函数体，函数的具体实现要在子类中编写。

15.抽象类的继承：抽象类是一种特殊的类，必须通过继承才能够使用，继承的方法与普通

的类没有什么区别使用extends关键字，不同的是，它必须实现所有的abstract方法。

16.不能被继承的类----------最终类(final)

在设计类时，如果这个类不需要子类，类的实现细节不允许改变，并确信这个类不会被再扩展，那么就设计为final类。Final类不被继承，因此final 类的成员方法没有机会被覆盖，默认都是final 的。

(1)final类不能被继承，没有子类，final类中的方法默认是final的。

(2)final方法不能被子类的方法覆盖，但可以被继承。

(3)final 成员变量表示常量，只能被赋值一次，赋值后值不能再改变

(4)final 不能修饰构造方法

(5)另外注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的

方法默认是final类型的

(6)使用final方法的原因有两个：

把方法锁定，防止任何继承类修改它的意义和实现。

高效，编译器在遇到调用final方法时会转入内嵌机制，大大提高执行效率

对于final static类型的成员变量，static 使得变量只存在一个副本，final使得它不能改变

(7).final成员只能被初始化一次。

Final成员必须在声明时或者在构造方法中被初始化，而不能在其他的地方被初始化。

17.多重继承：Java中通过接口可以实现多重继承。使多个不相关的类可以具有相同的方法。

18.Java中的接口是一系列方法的声明，是一些方法特征的集合，接口只有方法的特征没有

方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为。

19.在Java语言规范中，一个方法的特征仅包括方法的名字、参数的数目和类型，而不包括

方法的返回类型、参数的名字及抛出来的异常。在Java编译器检查方法的重载时，会根据这些条件判断两个方法是否是重载方法。但在Java编译器检查方法的置换时，则会进一步检查两个方法(分超类型和子类型)的返回值类型和抛出的异常是否相同。

20.接口继承和实现继承的规则不同，一个类只能有一个直接父类，但可以实现多个接口。

21.接口的存在可以使Java中的对象向上转型为多个基类型，并且和抽象类一样可以防止他

人创建该类的对象，因为接口不允许创建对象。

22.Interfa 关键字用来声明一个接口，它可以产生一个完全抽象的类，并且不提供任何具体

实现。接口的特性整理如下：

(1).接口中的方法可以有参数列表和返回值类型，但不能有任何方法体

(2).接口中可以包含字段，但是会被隐式的声明为static和final

(3).接口中的字段只是被存储在该接口的静态存储区内，而不属于该接口

(4).接口中的方法可以被声明为public或不声明，但结果都会按照public类型处理

(5)实现一个接口时，需要将被定义的方法声明为public类型，否则为默认访问类型，Java

编译器不允许这种情况

(6).如果没有实现接口中的所有方法，那么创建的仍然是一个接口

(7).扩展一个接口来生成新的接口应使用关键字extends，实现一个接口使用implements.

(8).要定义一个接口类，需要从以下几个方面入手：

putlic interface 接口名{

}

(9).Java接口的方法只能是抽象和公开的，Java接口不能有构造器。Java接口本身没有

任何实现，因为接口不涉及表象，而只是表述public 行为，所以接口比Java抽象类更抽象化。

(10).Java接口可以是public 的静态的和final属性

(11).要使用一个接口，在定义一个类时，必须使用implements来申明接口类。

23.接口与抽象类的区别：

Java接口和Java抽象类电表的就是抽象类型，就是我们需要提出的抽象层的具体表现。

OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性、可扩展性，就必须是面向接口的编程、面向抽象的编程，正确的使用接口、抽象类这些有用的抽象类型作为结构层次上的顶层。

(1)抽象类可以提供实现的方法，接口不能提供

Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这就是Java抽象类的唯一一个优点，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么所有的子类一下子就可以得到这个新方法。而Java接口做不到这一点，如果一个Java接口里加入了一个新方法，所有实现这个接口的类就无法成功的通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。

(2).抽象类只能继承一个，而可以实现多个接口

一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现类处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。在这一点上，Java接口的优势就出来了，任何一个实现了Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。

总结：Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主的行为，而且具有其他次要行为。结合(1),(2)点中抽象类和Java接口的各自优势，最经典的设计模式出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java接口在最上面，然后紧跟着抽象类，这就将两者的最大优点都发挥到极致了。这个模式就是默认适配模式。

实现代码如下：

//定义接口方法

public interface ClassName{

public void func1();//定义接口方法

}

//定义实现抽象类

public abstract class ClassName2{

public void func2(){}//定义实现方法

}

//定义实现类

public class ClassName3 extends ClassName2 implements ClassName1

{

public void func1(){//实现接口函数

func2();//调用抽象类函数

}

}

23.如何选择接口和抽象类：

接口在某些地方和抽象类有相似的地方，但是采用哪种方式来声明类主要参考一下两点：

(1).如果要创建不带任何方法定义和成员变量的基类，那么就应该选择接口而不是抽象

类。

(2)如果知道某个类应该是基类，那么第一个选择的应该是让它成为接口，只有在必须要

有方法定义和成员变量时，才应该选择抽象类。因为抽象类中允许存在一个或多个被具体实现的方法，只要方法没有被全部实现该类仍然是抽象类。

24.静态类，内部类和匿名类是Java为我们提供的几个出色的工具。

a.避免创建类的实例，可以直接使用静态类

b.使相关的类都能够存在于同一个源代码文件中，这要归功于内部类

c.避免一个程序产生大量非常小的类，这要归功于匿名类

25.静态类、匿名类、内部类和异常类的概念和使用：

a.Java静态类：静态方法，静态变量、静态代码块、静态内部类

b.Java匿名类：匿名类的定义、使用实例、处理swing事件

c.Java内部类：内部类的定义、使用实例、局部内部类、引用外部类对象

d.Java异常类：Java异常层次结构、捕捉处理机制、自定义异常。

二．Java异常类：（Exception class）

1．异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。例如代码中少了一个分号，那么运行出来结果提示错误https://www.wendangku.net/doc/3115106298.html,ng.Error；如果用System.out.println(1/0)那么是因为用0做了除数，会抛出https://www.wendangku.net/doc/3115106298.html,ng.ArithmeticException的异常。

2.Java对异常处理是按异常匪类处理的，不同的异常有不同的分类，每种异常都对应一个类

型(class)每个异常都对应一个异常（类的）对象。

3. 异常有两个来源：一是Java语言本身定义的一些基本异常类型；二是用户通过继承

Exception类或者其子类自己定义的异常。

4.异常的对象有两个来源：一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，他总是要抛出，比如除数为0的异常；二是程序员自己跑出的异常，这个异常可以使程序员自己定义的，也可以是Java语言中定义的，用throw关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。

5. Java把异常当做对象来处理，并定义一个基类https://www.wendangku.net/doc/3115106298.html,ng.Throwable作为所有异常的超类。

它有两个子类，分别为Error和Exception，分别表示错误和异常。其中异常又分运行时异常和非运行时异常，这两种异常有很大的区别，也称为不检查异常和检查异常。

-

6.a.error和Exception：

Error是程序无法处理的错误，比如OutOfMemory Error、ThreadDeath等。这些异常发生时，Java虚拟机一般会选择线程终止。常见的有程序进入死循环、内存泄露等。这种情况，程序无法解决，只能通过其他的方法干预。

Exception是程序本身可以处理的异常，这种异常分为运行时异常和非运行时异常。在程序中应当尽量去处理这些异常。

7.常见的异常：

算术异常类：ArithmeticException;

空指针异常类：NullPointerException;

类型强制转换异常：ClassCastException;

数组负下标异常：NegativeArraySizeException;

数组下标越界异常：ArrayIndexOutOfBoundsException;

违背安全原则异常：SecurityException;

文件已结束异常：EOFException;

未见未找到异常：FileNotFoundException;

字符转换为数字异常：NumberFormatException;

操作数据库异常：SQLException;

输入/输出异常：IOException;

方法未找到异常：NoSuchMethodException;

8.Java的异常处理涉及到5个关键字，分别是try、catch、throw、throws

在Java中，异常处理的完整语法：

try {

//尝试运行的程序代码

} catch (异常类型异常的变量名) {

//异常处理代码

}finally{

//异常发生，方法返回之前，总要执行的代码

}

9.创建Exception或者RuntimeException的子类即可得到一个自定义的异常类。在异常类中可以重载父类Exception中的函数，用以实现自己的代码。

三．Java常用实体类：

1.系统类：System除了输入/输出流功能以外还有：

访问系统属性

访问环境变量

加载文件和库(可以用在JNI调用中)

快速复制数组

取得系统时间

系统退出命令

执行垃圾回收

System类中的变量和参数全部是静态的，因此可以直接通过类名system来引用，不需要实例化system对象。

2.使用System.getProperties()函数将取得一个Properties对象，该对象包含了所有系统属性的键值对。将其转化为迭代器Enumeration然后用while()循环显示输出所有的key和value

3.使用System.getenv()函数取得一个Map对象，该对象包含了所有环境变量的键值对。然后转化为迭代器对象it然后使用while()循环显示所有的key和value

4.使用System的函数arraycopy()快速的复制数组

void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

5.运行时类Runtime除了在System中的功能以外还有如下功能：

查看系统内存

终止JVM虚拟机

运行系统程序

使用关闭钩子

6.String和StringBuffe的执行效率对比：

package com.str;

/**

*

*@author wuping

*

*/

public class CompareStringAndStringBuffer {

public static void main(String[] args) {

long start=System.currentTimeMillis();

String str="";

for (int i = 0; i <10000; i++) {

str+=","+i;

}

long end=System.currentTimeMillis();

System.out.println(end-start);

StringBuffer str2=new StringBuffer();

start=System.currentTimeMillis();

for (int i = 0; i <10000; i++) {

str2.append(",").append(i);

}

end = System.currentTimeMillis();

System.out.println(end-start);

}

}

前者发费了812ms后者发费了0ms这是因为，string对象的每一次累加都会先将累加的字符串创建一个实例对象然后再累加，等于是创建了10000个实例。而StringBuffer每次都是修改原有的实例对象，只是创建了一个实例。而创建实例需要申请内存地址，写入数据的过程，大量的这种操作会消耗大量的CPU计算资源。

7.equals()用来比较两个字符串的值，而不是比较其对象是否相通。如果使用==比较两个字符串对象a==b，那么只有在这两个实例指向同一个字符串对象时才会返回true.

8.如果要将字符串按照某一个字符串拆分一个字符串数组，可以使用split(String regex); 8.string类还提供了两个静态方法来对字符串进行格式化输出：例子：

str=String.format("%1$tY年%1$tm月%1$td日%1$tH时%1$tm分%1$ts秒",new Date());

9.线程安全的可变字符串类StringBuffer：是一个线程安全的可变字符串类，它类似于String 的字符串，不同的是它通过某些方法调用可以改变该序列的长度和内容。它可以将字符串缓存区安全的用于多个线程，可以在必要时对这些方法进行同步，因此在任意特定实例上的所有操作好像是串行顺序发生的，该顺序与所涉及的每个线程进行的方法调用顺序一致。StringBuffer上的主要操作是append()和insert()方法。每个方法都能有效的将给定的数据转换成字符串，然后将该字符串的字符添加或插入到字符串缓存区中。append()方法始终将这些字符串添加到缓存区的末端；而insert()方法则在指定的点添加字符。

10.可变字符串类StringBuilder是一个可变的字符序列。此类提供一个与StringBuffer兼容的API但不保证该类被设计用作StringBuffer的一个简易替换。用在字符串缓存区被单个线程使用的时候(这种情况很普遍)。如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer快。但是StringBuilder的实例用于多个线程是不安全的，如果要在多个线程中使用字符串，则建议使用StringBuffer.

11.对于String ，StringBuffer和StringBuilder的选择：

a.如果偶尔对简单的字符串常量进行拼接，那么可以使用String，它足够简单而且轻量级

b.如果需要经常进行字符串拼接、累加操作，使用StringBuilder或者StringBuffer

c.如果在单线程的环境中，建议使用StringBuilder，它要比StringBuffer快，如果是在多线程的环境中建议使用StringBuffer，它是现成安全的。

因此StringBuilder实际上是我们的首选，只有在多线程时才可以考虑使用StringBuffer，只有在字符串的拼接足够简单时才使用String.

12.Calendar类：

与其他的语言环境敏感类一样，Calendar提供了一个类方法getInstance，已获得此类型的一个通用的对象。Calendar的getInstance方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化。

Calendar now = Calendar.getInstance();

四．Java常用集合类

1.Iterator和Enumeration：迭代器与枚举，迭代器是枚举的最新实现，它的函数简单而且提供了删除元素的函数，最新的类的实现推荐使用iterator

2.Collections与Collection的区别：

a.Collection是个Java.util下的接口，它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java类库中有很多具体的实现Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。

b.Collections是个Java.util下的实体类，它包含了各种有关集合操作的静态方法，提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作，就像一个工具类，服务与Java的Collection框架。

3. Collection 层次结构中的根接口。Collection 表示一组对象，这些对象也称为collection 的元素。一些collection 允许有重复的元素，而另一些则不允许。一些collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接实现：它提供更具体的子接口（如Set 和List）实现。此接口通常用来传递collection，并在需要最大普遍性的地方操作这些collection。该接口为其实现类提供了统一的操作接口的方法。

（1）新增一个或多个元素

（2）删除一个或多个元素

（3）判断是否包含一个或多个元素

（4）产生元素集合的数组对象

实现该接口的子类都可以使用上面的这些函数功能。

4. Arrays与数组：此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

五．Java反射编程与动态代理

1.Java反射（Reflection）机制是在运行状态中，对于任意一个类，都能够查找这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息及动态调用对象的方法的功能称为Java语言的反射机制。Java的反射机制主要提供了下列功能：（1）在运行时判断任意一个对象所属的类

（2）在运行时判断任意一个类所具有的成员变量和方法

（3）在运行时构造任意一个类的对象

（4）在运行时调用任意一个对象的方法和变量。

（5）生成动态代理(Dynamic Proxy)

2.Java提供了一套独特的反射API来描述类，使得Java程序在运行时可以获得任何一个类的字节码信息，包括类的修饰符（public ,static 等）、基类（超类、父类）、实现的接口、字段和方法等信息，并可以根据字节码信息来创建该类的实例对象，改变对象的字段内容和调用对象方法。Class是Java反射中的一个核心类，它代表了内存中的一个Java类。通过它可以取得类的各种操作属性，这些属性是通过https://www.wendangku.net/doc/3115106298.html,ng.reflect包中的反射API来描述的。

（1）Constructor用来描述一个类的构造方法

（2）Field:用来描述一个类的成员变量

（3）Method：用来描述一个类的方法

（4）Modifer用来描述类内个元素的修饰符

（5）Array用来对数组进行操作

3.Java动态代理：

所谓动态代理，即通过代理类Proxy的代理，接口和实现类之间可以不直接发生联系，而可以在运行期（Runtime）实现动态关联。

Java动态代理类位于https://www.wendangku.net/doc/3115106298.html,ng.reflect包下，一般主要涉及到以下两个类：

Object invoke(Object obj,Method method,Object[] args);

在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数组

Proxy:该类即为动态代理类，作用类实现了InvocationHandler接口的代理类，其中主要包含以下函数：

Protected Proxy(InvocationHandler h):构造函数，用于给内部的h赋值

Static Class getProxyClass (ClassLoader loader,Class[] interfaces):获得一个代理类，其中loader 是类装载器，interfaces是真实的类所拥有的全部接口的数组。

Static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h):返回

代理类的一个实例，返回后的代理类可以当做被代理类使用。

4.所谓Dynamic Proxy是这样一种类：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后改class就宣称它实现了这些Interface 。你当然可以把该class的实例当做这些interface中任何一个来用。当然，这个Dynamic Proxy其实就是一个Proxy，它不会替你做实质性的工作，在生成它的实例时必须提供一个handler，由它接管实际工作。

六．XML与属性文件

1.在面对XML解析的各种技术时，常常遇到各种名词，如DOM.SAX、JAXP、JDOM、DOM4J 、Xerces、Crimson、StAX等，他们之间存在着各种联系与区别：

DOM和SAX是两种解析XML文件的方案，也是两套解析XML的底层API,DOM将XML文件的内容一次性读入内存中再进行操作，采用建立树形结构的方式访问XML文档。而SAX采用的事件模型，按树形结构遍历XML文件，一次只取出节点处的内容到内存中进行操作。这两者的特点是非常接近底层，是最基本的访问XML的API使用起来不太方便。

JAXP是SUN在以上的两套API的基础上开发出来的操作XML的API兼有DOM和SAX的两种模式，其目的就是为了向编程人员提供更为直观、便捷的API

JDOM和DOM4J是现在比较流行的开源Java XML解析实现，现在更多的应用采用DOM4J和JDOM其操作接口更为简便。

Xerces和Crimson是继承自JAXP的实现

StAX是基于流的XML解析模式

2．DOM定义了一个Node接口，用于表示文档树中的一个节点。从这个接口派生出来更多的具体接口。使用DOM解析XML文件需要经过以下几步。

(1).创建DOM解析器的工厂实例，javax.xml.parsers.DocumentBuilderFactory类的实例就是我们要的解析工厂。该类提供了一个newInstance()函数用来直接取得工厂的实例。DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();

(2).通过DocumentBuilderFactory=factory.newDocumentBuilder();

(3)根据一个XML的文件对象创建org.w3c.dom.Document对象

File file=new File(“src/books.xml”);

Document doc =builder(file);

(4)取得元素的根节点：

Element root =doc.getDocumentElement();

(5)取得子节点列表

NodeList books =root.getChildNodes();

(6)取得属性值

String isbn=book.getAttributes().getNamedItem(“isbn”).getNodeValue();

(7)取得节点值

String name=node.getFirstChild().getNodeValue();

六：多线程

1.线程的定义：线程是一个程序里面的不同的执行路径。进程是一个静态的概念，在机器中运行的实际上都是线程。

2.VM启动时会有一个由主方法（public static void main （）{}）

3.每个线程都是通过某个特定的Thread对象所对应的方法run()来完成其操作的。方法run （）称为线程体。通过Thread类的start()方法来启动一个线程。