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();
}
}
}
}














  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值