JAVA:一些比较混淆和乱目的错误事…

一.

public class Child｛

    public void Child(){

        System.out.print("   ");// 这个在JAVA中会是一个警告，提示和类名相同[是一个和类名同名的“方法” ]，但是在C#中，直接编译错误

    }

    public child(){}     //错误，小写的child会被当成是方法，而方法需要提供返回类型

｝

============================================

二.

this：是在对象内部指代自身的引用，∴this只能调用实例变量，实例方法和构造方法；this不能调用局部变量也不能调用类变量和类方法

super：代表对当前对象的直接父类对象的默认引用，在子类中通过super关键字来访问父类成员

        注意：super必须是出现在子类中（子类的方法和构造方法中），而不是其他地方；可以访问父类的成员（比如父类的属性、方法、构造方法）；注意访问的权限（无法通过super访问private成员）

    eg：

      super.name       //访问直接父类的name属性，不能是private的

      super.print()     //访问直接父类的print()方法

      super(name)       //访问直接父类的对应构造方法，"只能出现在构造方法中"

   

============================================

三.

关于static静态代码块：

它是优先执行的（高于基类的构造函数），且只执行一次，是在它的类创建对象之前被访问

或者说：一般的，静态代码段的优先级别高于构造函数，且父类内的优先级别最高

eg：

class Base {

    static int a=1;

    public Base(){

        System.out.println("constructor of Base");

    }

    static {

        System.out.println("init Base");

    }

    static void print(){

        System.out.println("Base method");

    }

}

------

class Sub extends Base{

    public Sub(){

        System.out.println("constructor of Sub");

    }

    static int b=2;

    static {

        System.out.println("init Sub");

    }

}

------

public class Traversc {

    public static void main(String[] args){

        Sub.print();

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

    }

}

则输出：

init Base

Base method

init Sub

a=2

--------------------------

这个时候把测试类的代码顺序互换下：

public class Traversc {

    public static void main(String[] args){

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

        Sub.print();

    }

}

则输出：

init Base

init Sub

a=2

Base method

--------------------------

增加代码：

public class Traversc {

    public static void main(String[] args){

        Sub s=new Sub();

        System.out.println("a="+Sub.a);

        Sub.print();

    }

}

则输出:

init Base

init Sub

constructor of Base     //在new Sub()前先new Base()

constructor of Sub

a=1

Base method

===========================================

四.

关于overload：必须方法名相同，形参不同；对其的访问修饰符无关，和返回类型无关【重载是在同一个类中】

public int getSomething(int i){ return 1;}    

public int getSomething(int i,int b){return 1;}   //正确

        private int getSomething(String a){return 1;}     //正确

        public void getSomething(int i,String b){}       //正确

-------------------

关于override：重写方法和被重写方法必须具有相同的方法名、形参列表、返回类型或是其子类，重写方法的不能缩小被重写方法的访问权限【重写是在不同类中】

               

============================================

五.

写出6个java.lang.Object的方法：

toString();

wait();

notify();

equals(Object obj)

getClass()

hashCode()

============================================

六.

JAVA中类的三大特性：

封装：encapsulation，封装就是把类的属性声明为私有，不允许外部程序直接访问，并提供公有的方法来对该成员进行存取，这么做可以隐藏类的实现细节，让使用者通过程序员规定的方法来访问数据，可以方便的       加入存取控制语句，限制不合理操作

继承：inheritance，JAVA中只支持单继承（即一个子类只能够有一个父类）（可通过实现接口来变相实现多继承），所有的JAVA类都直接或间接地集成了java.lang.Object类；对于用户自己定义的类，如果不写访问       修饰符，则表示只能在本包中可见 ，但是不能用private和protected，对于类中定义的private访问修饰符的属性不能被继承；

      -----------------------------

      [继承条件下构造方法的调用规则]如下：

          A.如果子类的构造方法没有通过super显示调用父类的有参构造方法，也没有通过this调用自身的其他构造方法，那么系统会默认先调用父类的无参构造方法。

          B.如果子类的构造方法中通过super显示调用父类的有参构造方法，那将执行父类相应构造方法，而不执行子类无参构造方法。

          C.如果子类的构造方法中通过this显示调用自身的其他构造方法，在相应的构造方法中应用以上两条规则。

          D.特别注意的是，如果存在多级集成关系，在创建子类对象时，以上规则会多次向更高一级父类应用，直到执行顶级父类Object类的无参构造函数位止。    

      1.在构造方法中如果有this语句或super语句出现，只能是第一条语句。

      2.在一个构造方法中不允许同时出现this和super语句。

    ★ 3.在类方法中不允许出现this或super关键字。

      4.在实例方法中this和super语句不要求是第一条语句，可以共存。

多态：polymorphism:多态是具有表现多种形态的能力的特征，或者说：同一个实现接口，使用不同的实例来执行不同的操作

      涉及一：upcasting向上转换：子类到父类的转换 eg：   Pet pet=new Dog();

      在JAVA中实现多态的方式：使用父类作为方法的形参，用instanceof来进行判断后，new出相对应的实例

          eg：类TT中声明方法：public static void eat(Pet pet)｛pet.eat();｝

              调用方式:Pet pet=new Dog();   TT.eat(pet); //这个时候调用的是Dog类中的eat()方法

              PS：父类对象没法调用子类中的特有方法，也就是说如果eat方法不是子类重写的（即父类中没eat方法），那么上面的调用是不成立的

 

      涉及二：downcasting向下转换：父类转换为子类，是将一个指向子类对象的父类引用赋给一个子类的引用（主要是用来使父类的引用对象可以使用子类的特有方法）

          eg：Pet pet=new Dog();

              Dog dog=(Dog)pet;     //通过强转来实现

              dog.playDisc();       //playDisc方法是Dog子类特有的，否则不强转的话会报ClassCastException异常

      --------------------------------

      实现多态的三个条件：

              1.继承是多态的基础，没有继承就没有多态 

              2.子类重写父类的方法（多态下调用子类重写后的方法）

          ★   3.父类引用变量指向子类对象（子类到父类的转换：upcasting）

   

=============================================

七.

final关键字

使用final修饰引用型变量，变量的值是固定不变的，而变量所指向的对象的属性值是可变的，比如:

public static void main(String[] args){

    final Dog dog=new dog("GG");

    dog.name="BB";     //正确，name是引用变量的属性

    dog=new Doggie(); //错误，不能重新指向，因为是final修饰的dog

}

final可以用来修饰：类，方法和属性，不能修饰构造方法

用final修饰的类，不能再被继承。用final修饰的方法，不能被子类重写。用final修饰的变量将变成常量，只能赋值一次

===============================================

八.

abstract

可以用来修饰类和方法，不能修饰属性和构造方法

abstract不能和private同时修饰一个方法   //∵抽象方法是让子类进行重写的，而子类无法继承private修饰的东西，更不用说重写了

abstract不能和static同时修饰一个方法   //static修饰的方法可以通过类名直接点出来，难道要访问一个没有实现的方法？

abstract不能和final同时修饰一个方法或类   //final修饰的方法不能被修改，同理抽象类只有让子类继承才能实例化，而final修饰的类不允许被子类继承

abstract可以和public同时使用

===============================================

九.

接口表示一种约定，表示一种能力；接口体现了预定和实现相分离的原则

接口可以继承接口

语法: [修饰符] interface 接口名 extends 父接口1,父接口2,...{     //如果修饰符是default，则表示仅本包中可见

          常量定义,

          方法定义 

      }

其他类实现接口：

语法：

      class 类名 extends 父类名 implements 接口1,接口2{

          类的内容

      }

-----------------------------

JAVA中接口中的：1.所有方法都是抽象方法(可理解为接口是特殊的抽象类，自动调用public abstract修饰，即接口中只有全局抽象方法)，实现接口的类必须实现所有的抽象方法（除非实现的类也是抽象类）;

                2.属性都是全局静态常量，必须在定义的时候指定初始值【即接口中不能定义变量，接口中的属性自动用public static final修饰】

                3.不可以被new，接口中不能有构造方法

                4.实现类可以实现多个接口（JAVA中的多继承），但一个类只能有一个直接父类 

                5.一个接口可以继承多个接口，但接口不能继承类（extends必须位于implements前面）          

-------------------------------

C#中的接口：

            1.接口之间通过“：”实现继承关系     [修饰符] interface 接口名：父接口1，父接口2。。。{}

            2.接口定义零个或多个成员，成员主要是方法、属性和索引器。接口中不能包含常量、变量或构造方法，也不能包含任何静态成员

            3.接口中成员访问权限是public，定义接口的时候“显示指定任何修饰符”都是非法的

            4.按照惯例，C#接口中的名字以大写字幕“I”开头

----------------------------------

JAVA和C#中就接口存在的区别：

1.Java中通过extends继承父接口，通过implements实现接口；C#中都是通过“冒号”

2.Java接口中的成员变量(属性)一律是常量，自动用public static final修饰；C#接口中不允许有成员变量，但可以有属性

3.Java接口中属性和方法都可以使用public修饰;C#中默认public，但不允许显示使用public修饰

4.Java接口中可以定义静态常量和方法；C#接口中不允许包含任何静态成员（方法、属性、索引器）

-------------------------------------

一般在使用接口的时候，通过声明父接口引用指向实现类对象

比如声明了一个方法fun(FaterImpl imp){....}

调用的时候：

Sub subImpl=new Sub();     //这个Sub类实现了FaterImpl这接口

fun(subImpl);

==================================================

十.

关于JAVA中的异常：

1、Java的异常处理可以通过5个关键字来实现：try，catch，finally，throw，throws

2、try-catch-finally块中，try必须要有，catch-finally块为可选，但至少要有其中一个存在

3、机试在try和catch块中存在return语句，finally块中语句也会执行

4、发生异常时的执行顺序是：执行try块或catch中return之前的语句--->执行finally中的语句--->执行try或catch中的return语句退出

5、finally块中的语句不执行的唯一情况是：在异常代码中执行了System.ext(1);将退出虚拟机

6、可以有多重catch块，但只要有一个执行到了，其后的catch块将不再执行，一般最后一个设置Exception类[属CHECK异常]（排列顺序必须是从子类到父类）

----------------------------------

一些应用：

thorws Exception：一般在方法体中抛出了异常，那么谁掉用这方法，就要对其进行try-catch

eg：public static void divide() throws Excetpion{...}

throw的应用：在进行一些判别时，可以直接输出异常，比如：

public void setSex(String sex) throws Exception{

    if("男".eauqls(sex)||"女".eauqls(sex)){ this.sex=sex; }

    else {throw new Exception("性别必须是男或女！");}

}

调用： try{

            setSex("MALE");   //此时就会异常报错:"性别必须是男或女！"

          }catch(Exception e){

              e.printStackTrace();

          }

throw和throws的区别： 

1.作用不同：throw用于程序员自行产生异常并抛出，throws用于声明在该方法内抛出了异常

2.使用的位置不同：throw位于方法体内部、可以作为单独语句使用。throws必须跟在方法参数列表的后面、不能单独使用

3.内容不同：throw抛出一个异常对象，而且只能是一个。throws后面跟一场累，而且可以跟很多个一场类

----------------------------------

异常的分类：

            check异常又称为非运行时异常（需要强制try-catch或抛出异常）：SQLException、ClassNotFoundExcetpion等：要求程序员必须捕获或声明抛出这种异常，否则会编译错误【处理方式：通过try-catch在当前位置捕获并处理异常，通过throws声明抛出异常交给上一级调用方法处理】

            runtime异常：ArithmeticException、NullPointExcetpion、NumberFormatExcetpion等：不要求程序员必须对他进行处理

==================================================

十一.

log4j的使用：

1：创建log4j.properties文件:

log4j.rootLogger=debug,stdout,logfile

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.Target=System.err

log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

log4j.appender.logfile=org.apache.log4j.FileAppender

log4j.appender.logfile.File=tt.log

log4j.appender.logfile.layout=org.apache.log4j.PatternLayout

log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mi:ss} %l %F %m %p

说明：%d 用于设置时间格式

      %F 用来输出文件名

      %l 用来输出日志事件的发生位置

      %m 用来输出代码中指定的消息

      %n换行

在程序中调用log4j

import org.apache.log4j.Logger;

声明对象： private static Logger logg=Logger.getLogger(类名.class.getName());

logg.debug("错误消息XXX");

控制台输出的话在catch等块中:logg.error("错误消息XXX");

==================================================

十二.

集合框架:位于java.util包中

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。集合框架都包含三块内容：对外的接口，接口的实现和对集合运算的算法

Collections是类||Collection是接口

Java集合框架共有两大类接口：Collection和Map，其中Collection又分为List Set；通常说JAVA集合框架共有三大类接口：List Set和Map，区别如下：

List集合：有序不唯一，实现List接口的常用类有ArrayList和LinkedList

Set集合：无序唯一

Map:键唯一，值不唯一，key不要求有序，value允许重复

----------------------------------

ArrayList和LinkedList：因为里面放的都是对象，所以在遍历和取的时候需要进行强转[除非使用的是泛型]

ArrayList：有点在于遍历和随机访问元素的效率比较高

LinkedList：有点在于插入、删除元素的效率比较高(有特有方法：addFirst(),addLast(),removeFirst(),removeLast())

共有的方法：

size()：获得该集合的大小

contains()：判断是否包含某一对象名

remove()：移除，需要指定索引号或者对象名

add()：添加，默认顺序添加

get():根据索引或者对象名获得内容

例子：

Dog dd1=new Dog();

Dog dd2=new Dog();

Dog dd3=new Dog();

List dogs=new ArrayList();

dogs.add(dd1);

dogs.add(1,dd2);

dogs.add(2,dd3);

for(int i=0;i<dogs.size();i++){

    Dog d=(Dog)dogs.get(i);   //这里要进行强转

    System.out.println(d.getName()+d.getStrain();)

}

PS:

LinkedList的对象只能由LinkedList声明： LinkedList lk=new LinkedList();

而ArrayList的对象可以由其父类List声明：   List ll=new ArrayList();

------------------------------------

Vector(矢量)和ArrayList的区别

1.Vector出现较早，是线程安全的，而ArrayList重速度轻安全，是线程非安全的，所以当运行到多线程环境中时，需要程序员自己管理线程的同步问题

2.当长度需要增长时，Vector默认增长为原来的一倍，而ArrayList只增长50%，有利于节约内存空间

PS：在开发过程中，最好使用新版本的ArrayList

----------------

MAP：key--value,通过put方法添加元素，通过keySet()和values()方法返回集合的键和值，containsKey()方法判断是否存在指定的键映射

Map countries=new Map();

countries.put("CN","中国");

countries.put("UK","英国");

countries.put("JP","日本");

System.out.println(countries.keySet()); //输出所有的键 [CN,UK,JP]

System.out.println(countries.values()); //输出所有的值 [中国，英国，日本]

System.out.println(countries);           //输出所有的键-值对 [CN=中国，UK=英国,JP=日本]

System.out.println(countries.get("CN").toString())   //中国   ,因为存在MAP中的都是对象，需要进行转换

countries.remove("UK");   //删除UK这一键，包括内容

countries.size();   //获得集合的大小

----------------------------

Iterator迭代器：适用于Collection接口(List和Set接口)，MAP不适用

eg：

List dogs=new ArrayList();

Iterator it=dogs.iterator();

while(it.hasNext()){

    Dog dog=(Dog)it.next();

    System.out.println(dog.getName+dog.getStrain());

}

如果使用的是泛型集合，比如：

List<Dog> dogs=new ArrayList<Dog>();

dogs.add("dd1");

Iterator<Dog> it=dogs.interator();

Dog dog=dogs.get(0); //这个时候就不需要进行强转，直接使用

String dName=dog.getName();

while(it.hasNext()){

    dog=it.next();

    System.out.println(dog.getName()+dog.getStrain());

}

-----------------------------------

数组和集合的区别:

1.数组可以存储基本数据类型，而集合只能存储对象(可以以包装类型式存储基本数据类型)。

2.数组长度固定，集合长度可以动态改变。

3.定义数组时必须指定数组元素类型，集合默认其中所有元素都是Object

4.无法直接获取数组实际存储的元素个数，lengthon过来获取数组的长度；但可以通过size()直接获取集合中实际存储的元素个数

5.集合有多种实现方式不同的使用场合，而不像数组仅采用分配连续空间方式。

6.集合以接口和类的形式存在，具有封装、继承和多态等的特性，通过简单的方法和属性调用即可实现各种复杂的操作，大大提高软件的开发效率

JDK中有一个Arrays类专门用来操作数组

JDK中有一个Collections类，专门用来操作集合

==================================================

十三.

JDBC由一组使用JAVA语言编写的类和接口组成，可以为多种关系数据库提供统一访问

JDBC API主要做三件事情：与数据库建立连接，发送SQL命令，处理结果：

DriverManager类：根据数据库的不同，管理相应的JDBC驱动

Connection接口：负责连接数据库并担任传送数据的任务

Statement接口：由Connection产生，负责执行SQL语句

ResultSet接口：负责保存和处理Statement所执行后产生的查询结果

PreparedStatement接口：Statement的子接口，也由Connection产生，同样负责执行SQL语句，与Statement接口相比，具有高安全性，高性能，高可读性和高可维护性的特点

-----------------------------------

BaseDao类：

public class BaseDao(){

public Connection conn = null;

public PreparedStatement pstmt = null;

public ResultSet rs =null;

private String driver = "oracle.jdbc.driver.OracleDriver";

private String url = "jdbc:oracle:thin:@localhost:1521:orcl";

private String user = "SCOTT";

private String pwd = "tiger";

//建立连接

    public void getConnection(){

    try{

    Class.forName(driver);

          conn = DriverManager.getConnection(url,user,pwd);

        }catch(ClassNotFoundException e){

    e.printStackTrace();

        }catch(SQLException e){

        e.printStackTrace();        

        }    

    }

    //关闭连接

    public void closeAll(){

    try{

    if(null!=rs){

    rs.close();

    }

    if(null!=pstmt){

    pstmt.close();

    }

    if(null!=conn){

    conn.close();

    }

    }catch(SQLException e){

    e.printStackTrace();

    }

    }

    //执行SQL语句

    public ResultSet executeSQL(String sqlStr,String [] param){

    getConnection();

    try{

    pstmt = conn.prepareStatement(sqlStr);

    if(null!param){

    for(int i=0;i<param.length;i++){

    pstmt.setString(i+1,param[i]);

    }

    }

    rs = pstmt.executeQuery();

    }catch(SQLException e){

    e.printStackTrace();

    }

    return rs;

    }

    //执行更新SQL

    public int executeUpdateSQL(String sqlStr,String [] param){

    getConnection();

    int length = 0;

    try{

    pstmt = conn.prepareStatement(sqlStr);

    if(null!=param){

    for(int i=0;i<param.length;i++){

    pstmt.setString(i+1,param[i]);

    }

    }

    length = pstmt.executeUpdate();

    }catch(SQLException e){

    e.printStackTrace();

    }finally{

    closeAll();

    }

    return length;

    }

}

--------------------------------------

关于ResultSet：

ResultSet对象的next()方法将光标指向下一行，最初光标位于第一行之前，因此第一次调用next()方法将光标置于第一行上。

          另外要获取ResultSet对象(假设rs)的内容

          则：rs.getInt(1)//表示第一列

              rs.getString("uname")//表示uname字段                                        

-------------------------------------

关于PreparedStatement对象：

主要是用来设置占位符(?)的内容,比如：

pstmt.setInt(1,2) //将第一个参数设置为2

pstmt.setString(2,"SSS") //将第二个参数设置为字符串"SSS"

-------------------------------------

一些建议：良好的编程风格：应该在不需要ResultSet对象、Statement对象和Connection对象时显式的关闭他们[顺序为先关ResultSet---再Statement---最后Connection对象]

==================================================

十四.

Oracle基本概念（详细见oracle笔记整理）：

ORACLE 是基于 "客户/服务器" 系统结构

数据库：不是传统意义上所说的数据库：在物理上表现为控制文件、日志文件、数据文件；在逻辑上表现为表空间

数据库实例：如果把数据库简单理解为硬盘上的文件，具有永久性，那么数据库实例就是在内存中处于运行状态的数据库，是临时的

数据文件：.dbf文件，存储表中的记录、索引、存储过程、视图、数据字典定义等，一个数据文件中可能存储多个数据库表的数据，而一个数据库表的数据也可能存放在多个数据文件中，即数据库表和数据文件不存在一一对应的关系

控制文件：.ctl文件，是一个二进制文件，存储着：datafile和logfile的名字和位置，它是DB启动的必须文件

日志文件：.log文件，成组使用

表空间：每个数据库都由若干个表空间构成，一个表空间可以存储多个数据文件，但一个数据文件只能属于一个表空间，表空间是属于DB的逻辑结构，创建DB的时候系统会自动创建SYSTEM、SYSAUX、TEMP、UNDO、USERS等表空间

-----------------------------

SYS用户和SYSTEM用户是建立好DB就存在的，其中SYS只能以SYSDBA或SYSOPER角色登录系统，SYSTEM用户只能以NORMAL方式登录

只有正确配置了监听器和本地NET服务名后才能用第三方或(JAVA开发工具)连接上

------------------------------

B树索引：是oracle最常用的索引，也是默认索引类型

位图索引：适用于低基数列，“性别列”，即该列的值被重复使用超过100次时可考虑

唯一索引：ORACLE自动为主键列创建唯一索引

另外创建索引的时候，通常最频繁访问的列应置在列表的最前面

-------------------------

导出：exp scott/tiger@orcl file=d:\back.dmp tables=emp,tb_01

导入：imp scott/tiger@orcl file=d:\back.dmp ignore=y full=y

==================================================

十四.

数据的持久化:指将程序中的数据在瞬时状态和持久状态间转换的机制

持久化的操作包括：保存、删除、修改、读取和查找等

DAO：DATA ACCESS OBJECT(数据存储对象)，位于业务逻辑和持久化数据之间实现对持久化数据的访问；DAO模式实现了将数据访问和业务逻辑相分离，对上层提供面向对象的数据访问接口

DAO模式由5部成：DAO接口、DAO实现类、实体类、数据库连接和关闭工具类

DAO模式是分层开发思想的一种具体体现

分层开发中，需要坚持2大原则：封装性原则和顺序性原则

实体类用于传递数据

==================================================

十五.

XML相关：

XML和XHTML的区别：前者可以自定义标签，但不支持显示形式和页面排版，后者相反；另外XHTML实际上就是引入了外部DTD的XML文档

XML主要用来存储数据和交换数据以及数据配置

---------------------------------------------

定义XML文档结构有2种形式：DTD和XSD

DTD:Document Type Definition文档类型定义，DTD可以定义在文档内部，也可以定义在文档外部

DTD eg：

<!DOCTYPE pets [

<!ELEMENT pets (dogs,penguins)>

<!ELEMENT dogs (dog*)>

<!ELEMENT penguins (penguin+)>

<!ELEMENT dog (name,health,love,strain?)>

<!ATTLIST dog id CDATA #REQUIRED>

<!ELEMENT penguin (name,health,love,sex)>

<!ATTLIST penguin id CDATA #REQUIRED>

<!ELEMENT name (#PCDATA)>

<!ELEMENT health (#PCDATA)>

<!ELEMENT love (#PCDATA)>

<!ELEMENT strain (#PCDATA)>

<!ELEMENT sex (#PCDATA)>

]>

//将以上保存为pets.dtd文件

然后在XML中进行外部引用:

<?xml version="1.0" encoding="UTF-8">

<!--引用外部DTD文件 -->

<!DOCTYPE pets SYSTEM "pets.dtd" >

<!--引入CSS文件>

<?xml-stylesheet type="text/css" href="pets.css"?>

XSD:是继DTD之后，用来规范和描述XML文档结构的第二代标准，与DTD相比，XSD本身就是XML文档结构，支持更多的数据类型，具有很强的扩展能力，提供对XML文档信息的更多描述

-------------------------------------------

目前解析XML技术只要是DOM和SAX

DOM:Document Object Model文档对象模型，DOM把XML文档映射成一个倒挂的树

解析步骤：1.创建解析器工厂对象

          2.由解析工厂对象创建解析器对象

          3.由解析器对象对XML进行解析

          4.以Document对象为起点对DOM树的节点进行增删改查操作

eg：

XML结构：

<pets>

  <dogs>

    <dog>

      <name>狗一号</name>

      <health>80</health>

      <love>100</love>

      <strain>拉布拉多犬</strain>

    </dog>

    <dog>

      <name>狗2号</name>

      <health>40</health>

      <love>70</love>

      <strain>雪橇犬</strain>

    </dog>

  </dogs>

</pets>

JAVA调用：

public class TestDOM{

public static void main(String [] args){

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

try{

DocumentBuilder db = dbf.newDocumentBuilder();

Document doc = db.parse("test.xml");

NodeList testList = doc.getElementsByTagName_r("dog");

System.out.println("文档中共有"+testList.getLength()+"条狗");

for(int i=0;i<testList.getLength();i++){

Node dog = testList.item(i); //获取第i个元素的信息

Element ele = (Element)dog;

String attValue = ele.getAttribute("id");

System.out.println("id 属性值是："+attValue);

    //循环读取该子节点下的所有节点

for(Node node = dog.getFirstChild();node!=null;node=node.getNextSibling()){

if(node.getNodeType()==Node.ELEMENT_NODE){

String name = node.getNodeName();

String value = node.getFirstChild().getNodeValue();//元素节点的子节点是内容节点

System.out.println(name+":"+value);

}

} 

}

}

}

}

--------

SAX:Simple API for XML,它不像DOM那样需要建立一个完整的文档数，而是在读取文档时激活一系列事件

与DOM相比，SAX能提供更好的性能优势，SAX模型最大的有点是内存消耗小，因为整个文档无需一次加载到内存中，这是的SAX可以解析大于系统内存的XML文档，无需像DOM那样为所有节点创建对象

SAX的缺点:必须实现多个事件处理程序以便能够处理所有盗来的时间，而且必须在应用程序中维护这个事件状态

==================================================

十五.

在JAVA中，文件的输入输出功能是通过流来实现的

原理图：

source.txt--->输入流---中转站---输出流类--->target.txt

    源-------[           程序               ]----目标

文件读写实例：一般创建一个FileIO类

public class FileIO{

        //文件的输入

public String readFile(String filepath){

Reader fr = null;

StringBuffer sb = new StringBuffer();

int length = 0;

char [] ch = new char[1024];

try{

fr = new FileReader(filepath);

length = fr.read(ch);

while(length!=-1){

sb.append(ch);

length = fr.read(ch); //因为前面的fr.read(ch)已经把指定文件中的内容全部读取出来了，所以这个时候再往数组ch中输入内容时，读到的已经是文件尾，直接返回-1（read是接下去读，而不是重新再读，"读过算过"）

}

}catch(FileNotFoundException e){

e.printStackTrace();

}catch(IOException e){

e.printStackTrace();

}finally{

try{

if(null!=fr) fr.close();

}catch(IOException e){

e.printStackTrace();

}

}

return sb.toString();

}

//文件的输出

public void writeFile(String filepath,String str){

Writer fr = null;

try{

fr = new FileWriter(filepath);

fr.write(str);

}catch(IOException e){

e.printStackTrace();

}finally{

try{

if(null!=fr) fr.close();

}catch(IOException e){

e.printStackTrace();

}

}

}

}