xmljava类
❶ 求教java类解析xml，具体点的语法。谢过啦
xml文件：
<?xml version="1.0" encoding="GB2312"?>
<RESULT>
<VALUE>
<NO>A1234</NO>
<ADDR>四川省XX县XX镇XX路X段XX号</ADDR>
</VALUE>
<VALUE>
<NO>B1234</NO>
<ADDR>四川省XX市XX乡XX村XX组</ADDR>
</VALUE>
</RESULT>
1）DOM
import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;
public class MyXMLReader{
public static void main(String arge[]){
long lasting =System.currentTimeMillis();
try{
File f=new File("data_10k.xml");
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
DocumentBuilder builder=factory.newDocumentBuilder();
Document doc = builder.parse(f);
NodeList nl = doc.getElementsByTagName("VALUE");
for (int i=0;i<nl.getLength();i++){
System.out.print("车牌号码:" +
doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
System.out.println("车主地址:" +
doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
}
}catch(Exception e){
e.printStackTrace();
}
2）SAX
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
public class MyXMLReader extends DefaultHandler {
java.util.Stack tags = new java.util.Stack();
public MyXMLReader() {
super();
}
public static void main(String args[]) {
long lasting = System.currentTimeMillis();
try {
SAXParserFactory sf = SAXParserFactory.newInstance();
SAXParser sp = sf.newSAXParser();
MyXMLReader reader = new MyXMLReader();
sp.parse(new InputSource("data_10k.xml"), reader);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + "毫秒");}
public void characters(char ch[], int start, int length) throws SAXException {
String tag = (String) tags.peek();
if (tag.equals("NO")) {
System.out.print("车牌号码：" + new String(ch, start, length));
}
if (tag.equals("ADDR")) {
System.out.println("地址:" + new String(ch, start, length));
}
}
public void startElement(String uri,String localName,String qName,Attributes attrs) {
tags.push(qName);}
}
3）JDOM
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
SAXBuilder builder = new SAXBuilder();
Document doc = builder.build(new File("data_10k.xml"));
Element foo = doc.getRootElement();
List allChildren = foo.getChildren();
for(int i=0;i<allChildren.size();i++) {
System.out.print("车牌号码:" +
((Element)allChildren.get(i)).getChild("NO").getText());
System.out.println("车主地址:" +
((Element)allChildren.get(i)).getChild("ADDR").getText());
}
} catch (Exception e) {
e.printStackTrace();
}
}
4）DOM4J
import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;
public class MyXMLReader {
public static void main(String arge[]) {
long lasting = System.currentTimeMillis();
try {
File f = new File("data_10k.xml");
SAXReader reader = new SAXReader();
Document doc = reader.read(f);
Element root = doc.getRootElement();
Element foo;
for (Iterator i = root.elementIterator("VALUE"); i.hasNext() {
foo = (Element) i.next();
System.out.print("车牌号码:" + foo.elementText("NO"));
System.out.println("车主地址:" + foo.elementText("ADDR"));
}
} catch (Exception e) {
e.printStackTrace();
}
)
❷ xml在java项目中起到的作用具体是什么
java项目中,xml文件一般都是用来存储一些配置信息
一般的编程, 多数用来存储配置信息 . 拿JDBC来说,可以把数据库连接字符串写到xml,如果要修改数据源,只需要改xml就可以了,没必要再去重新编译java文件,而且,这些配置信息放在一起,别的人来读你写的代码的时候,就方便了很多
框架中的xml , 除了配置信息 , 还可以写一些对应关系,其实也是一种配置信息 .拿struts来说,xml配置的是页面url对应后台java类(action)的关系,在配置和修改的时候,只需要改一个xml文件就可以了,没必要一个个的查找java代码
java项目完成之后,每个模块应该都是独立的,模块之间的关系都可以使用xml来进行维护,spring就是这样的一个框架
一个好的项目,需要有良好的可拓展性,如果把所有的逻辑关系还有配置信息都写入代码中,会使程序的可拓展性变差,为了解决这个问题,xml就可以对整个项目进行调度(spring)
还有使用xml作为数据储存,不过用起来很少,多数还是用来存放配置信息
❸ java中怎么将xml文件转换为实体类
这个问题很常见
就是java解析xml的问题，应用很多
解析主要有2种模式
1、DOM解析，这里里面包括JDOM，DOM4J等等，解析的思想类似，化为一类，这类解析思路清晰明白，元素读取直观，缺点是对大型xml文件解析会发生内存溢出错误，因为这类解析占用内存较高
2、SAX解析，此解析方法的思想是把xml看成文本读取入内存，然后以为事件触发模式检索元素信息，所以解析占用内存不高，适合大xml文档的解析
具体解析楼主随便找个例子看看就会了，比较简单
❹ 100分求高手帮我将xml文件转为java类
奋斗了20个小时，终于完成了，本类无需导入任何额外的包，底层细节全部在本类中完成！
说明，本类通过读入xml文件，并把信息正确分成存入到Guird列表中。通过调用getGuirdList()将返回结果集。要使用其中的某一项，只接到对象中用方法获取即可，希望能够满足楼主的需求！！
TransXml.java
import java.io.*;
import java.util.Vector;
import java.util.Scanner;
import java.io.InputStreamReader;
import java.util.LinkedList;
public class TransXml{
private String xmlAddress;
private Vector<Guird> guir;//表示一级子目录下的Guird向量
private FileInputStream inStr;
private InputStreamReader inRea;
private int whLayer=0;//标志表的层次，为0表示根表，为1表示第一层子表
private int whiLab=0;//表示当前标签是第几层
boolean isend=false;
boolean isguirs=false;
boolean isguir=false;
StringBuffer str=new StringBuffer();//表示<>中的词
String strVul;
StringBuffer value=new StringBuffer();//表示具体类容
boolean isWorld=false;
boolean isValue=false;
boolean isSubgu=false;
boolean notEnd=true;
LinkedList<Guird> linList;
public TransXml(){
}
public TransXml(String xmlAdd){
guir=new Vector<Guird>();
linList=new LinkedList<Guird>();
this.xmlAddress=xmlAdd;
System.out.println("开始读取xml文件");
try{
inStr=new FileInputStream(xmlAddress);
inRea=new InputStreamReader(inStr);
}catch(IOException e){
System.out.println("Xml文件地址无效");
}
System.out.println("开始读取xml文件完成！");
Translate();
}
public void Translate(){
Guird theGu=new Guird();
while(notEnd)
{
int tt=-1;
try{
tt=inRea.read();
}catch(IOException e){
System.out.println("字符读取失败！");
}
if(tt==-1){//文件已经读完了
notEnd=false;
break;
}
char ch=(char)tt;
if(ch=='<'){
//说明，前面如果有类容的话，内容完结
isValue=false;//说明内容已经完了
isWorld=true;//表示下面是<>里德内容
}
if(ch=='>'){
isWorld=false;//表示括号内的字符串结束了
strVul=str.toString();//表示当前的目录层次
if(strVul.equalsIgnoreCase("guirds")){//这是配置文件正式开始的标志
isguirs=true;
}else if(strVul.equalsIgnoreCase("guird")){//说明已经进入guird类
isguir=true;
}else if(strVul.equalsIgnoreCase("id")){//进入id属性
isValue=true;
}else if(strVul.equalsIgnoreCase("name")){//进入name属性
isValue=true;
}else if(strVul.equalsIgnoreCase("ename")){//进入ename属性
isValue=true;
}else if(strVul.equalsIgnoreCase("parentid")){//进入parentid属性
isValue=true;
}else if(strVul.equalsIgnoreCase("subguirds")){//进入subguirds属性,说明它还有一个字表
isSubgu=true;
linList.addLast(theGu);//做入栈操作,添加到结尾
whLayer++;//原始的值为0，它表示当前操作guird的级数
//那么下面的读取将是新的Guird类，所以要把现在的theGu保存后重新初始化
theGu=new Guird();//初始化，后面接着用
}else if(strVul.equalsIgnoreCase("/guirds")){//这是配置文件结束的标志
isguirs=false;//程序已经阅读完毕XML文件
notEnd=false;
}else if(strVul.equalsIgnoreCase("/guird")){//说明已经结束guird类
isguir=false;//说明一条记录已经完成，所以要对其存储
//theGu的属性是在</标签>前就写入完毕了,那么应该写入上级目录中，
//如果是定定及目录，则直接写入给定的Vector
if(whLayer>0){//说明还不是根目录
Guird tempguir=linList.getLast();
Vector<Guird> tempqq=(Vector)tempguir.getSubGuird();
if(tempqq==null){//说明前面的集合为空
tempqq=new Vector();
}
tempqq.add(theGu);//集合中增加这一项
tempguir.setSubGuird(tempqq);
linList.removeLast();//移动原来的换新的内容
linList.add(tempguir);
theGu=new Guird();//重新初始化供后面使用，并不要去改变whLayer值
}else if(whLayer==0){//这说明当前的theGu是指1级子目录，
guir.add(theGu);//添加一条记录到Vector
theGu=new Guird();// 重新初始化以便下次正确用到
}else{
System.out.println("xml文件标签错误！");
notEnd=false;
}
}else if(strVul.equalsIgnoreCase("/id")){//结束id属性
isValue=false;
theGu.setId(new Integer(value.toString()));
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/name")){//结束name属性
isValue=false;
theGu.setName(value.toString());
// System.out.println("这里写入的名字是："+theGu.getName());
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/ename")){//结束ename属性
isValue=false;
theGu.setEname(value.toString());
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/parentid")){//结束parentid属性
isValue=false;
theGu.setParentId(new Integer(value.toString()));
value=new StringBuffer();
}else if(strVul.equalsIgnoreCase("/subguirds")){//结束subguirds属性,字表完成
isSubgu=false;
//刚刚结束的这个Guird就是whLayer级子目录
//要判断是根类还是那一级子目录
whLayer--;//表示上一级目录
if(whLayer>0){
theGu=linList.getLast();//成为当前节点
//所以当前操作对象又将是刚从LinkedListed中取出的那个
linList.removeLast();//已经用过了，最后一个移除，相当于退栈
}
else if(whLayer==0){//根节点下
theGu=linList.getLast();
linList.removeLast();
}else{
notEnd=false;//因为whLayer不可能小于0
System.out.println(xmlAddress+"标签不完整！请检查！");
break;
}
}
strVul="";
str=new StringBuffer();//重新初始化，准备后面使用
}
if(isWorld==true){
if((char)tt!='<'&&(char)tt!='>')//因为具有延时性所以要增加这个条件
if(tt!=32&&tt!=9)//它不为空格和Tab,即在xml中标签内的内容将忽略Tab和空格
str.append((char)tt);
}
if(isValue==true){//当前是类容属性值
if((char)tt!='<'&&(char)tt!='>'){
if(tt!=32&&tt!=9)//它不为空格和Tab
value.append((char)tt);
}
}
/**
* 为什么这里注释掉了，因为前面以当发现value值取到最后一位后就设置isValue为false
* 但是要当下一个</>结尾标签完才会调用value值并进行操作，所以，value不能立刻变为空内容
* 那么当它被使用后，采设置新的对象是可取的
* else{
* value=new StringBuffer();//避免干扰下次
* }
*/
}
try{
inRea.close();
inStr.close();
}catch(IOException e){
System.out.println("流关闭失败！");
}
}
public Vector getGuirdList(){
return this.guir;//获得最终的子目录列表
}
/**
* 原来写的main方法进行测试，在这里就省略了
*/
}
Xml文件中<guirds>标签中，有几对<guird>标签就会返回几条结果，当然<guird>是指在<guirds>目录下的第一层标签，而其他的二级<guird>标签中的内容则存在相应的List<Guird> subGuird中。
That's all !
❺ 用java实现 xml文件转实体类
使用XStream完成 java 类与 XML 互换。
下面代码实现了以下4种基本功能：
1. object类型转换为xml类型，在控制台打印
2. xml类型转换为object类型，在控制台打印
3. 将object类型转换为xml类型，并写入XML文件
4. 读取XML文件，加载进相应Object类型
====================================================
1。加载 XStream 需要的jar包 xstream-1.4.2.jar
xpp3_min-1.1.4c.jar
xmlpull-1.1.3.1.jar
2。创建实体类User.java
package com.entity;
/**
* 实体类
*/
public class User {
private String userName;
private String passWord;
private String registeredTime;
public User() { }
public User(String userName, String passWord, String registeredTime) {
this.userName = userName;
this.passWord = passWord;
this.registeredTime = registeredTime;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public String getRegisteredTime() {
return registeredTime;
}
public void setRegisteredTime(String registeredTime) {
this.registeredTime = registeredTime;
}
}
3。编写功能实现类
package com.switcher;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.entity.User;
import com.thoughtworks.xstream.XStream;
/**
*
* 使用 XStream不用任何映射就能实现多数 Java 对象的序列化。
* 在生成的 XML中对象名变成了元素名，类中的字符串组成了 XML中的元素内容。
* 使用 XStream 序列化的类不需要实现 Serializable 接口。
* XStream 是一种序列化工具而不是数据绑定工具
* 不能从XML 或者 XML Schema Definition (XSD) 文件生成类。
*/
public class SwitchXML {
/*
* XStream 不关心序列化/逆序列化的类的字段的可见性。
* 序列化/逆序列化类的字段不需要 getter 和 setter 方法。
* 序列化/逆序列化的类不需要有默认构造函数。
*/
private XStream xStream = new XStream();
private String xmlPath = "D:/userdata.xml";
// 1. obj -> xml(object类型转换为xml类型)
public String printXML(User user) {
System.out.println("obj -> xml");
String xml = xStream.toXML(user);
System.out.println(xml);
return xml;
}
// 2. xml->obj(xml类型转换为object类型，并打印)
public void printObj(String xml) {
System.out.println("xml -> obj");
User u = (User) xStream.fromXML(xml);
System.out.println(u.getUserName() + " " + u.getPassWord() + " " + u.getRegisteredTime());
}
// 3. 将object类型转换为xml类型，并写入XML文件(其他格式也可以，比如txt文件)
public void writerXML(User user) {
try {
FileOutputStream fs = new FileOutputStream(xmlPath);
xStream.toXML(user, fs);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
// 4. 读取XML文件，加载进相应Object类型
public void readerXML() {
User user = new User();
FileInputStream fis = null;
try {
fis = new FileInputStream(xmlPath);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
xStream.fromXML(fis, user);
// 打印对象信息
System.out.println(user.toString());
// 打印对象的属性值
System.out.println(user.getUserName() + "-" + user.getPassWord() + "-"
+ user.getRegisteredTime());
}
public static void main(String[] args) {
// 用户名
String username = "admin";
// 密码
String password = "admin";
// 注册时间
Date now = new Date();
SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
String registeredtime = format.format(now);
User user = new User(username, password, registeredtime);
SwitchXML switchXML = new SwitchXML();
// 1. object类型转换为xml类型，在控制台打印
String xml = switchXML.printXML(user);
System.out.println("---------------------");
// 2. xml类型转换为object类型，在控制台打印
switchXML.printObj(xml);
System.out.println("---------------------");
// 3. 将object类型转换为xml类型，并写入XML文件
switchXML.writerXML(user);
System.out.println("---------------------");
// 4. 读取XML文件，加载进相应Object类型
switchXML.readerXML();
}
}
❻ 如何根据xml和schema文件生成java类（用程序实现）！
JAXB提供了可以从schema生成java类，下面简要介绍一下生成的步骤：
1：下载jaxb包 jaxb 2_1_9.zip ，在本博客中可以下载得到。解压后得到四个目录，包含bin、lib 、docs、example
2：在"cmd"里进入到bin目录，如C:/>cd C:/jaxb2.1.9/bin 回车
3：输入xjc c:/students.xsd -d c:/src -p com.entity 回车
注：-d 说明要生成的java类存放目录
-p 为生成java类指定的包名
students.xsd 为自己定义的Schema
❼ 怎么在java类中加载xml文件
JAVA与XML文件，可以说是软件开发的“黄金搭档”，而如何使用JAVA完成对XML文件的读取，是我们首先要解决的问题。
一、XML文件
这个示例文件包括了用来打开ORACLE数据库的各种参数
<?xml version="1.0" encoding="UTF-8"?>
<dbmsg>
<dbinfo>
<drivername>oracle.jdbc.driver.OracleDriver</drivername>
<sConnStr>jdbc:oracle:thin:@11.88.225.80:1521:VOUCHERDB</sConnStr>
<username>SYS AS SYSDBA</username>
<password>voucherdb</password>
</dbinfo>
</dbmsg>
二、编写类名为ReadXml的类，用于解析XML文件
我们要在应用程序中打开数据库，就必须完成对该文件中drivername、sConnStr、username、password的读取，通过查找有关资料，笔者编制了以下程序，用于读取文件名为filename的XML文件。
package voucher.basic;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
public class ReadXml {
private String drivername;
private String sConnStr;
private String username;
private String password;
public String getDrivername() {
return drivername;
}
public String getSConnStr() {
return sConnStr;
}
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
public void setDrivername(String drivername) {
this.drivername = drivername;
}
public void setSConnStr(String connStr) {
sConnStr = connStr;
}
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public ReadXml(String fileName){
DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();
try {
DocumentBuilder dombuilder=domfac.newDocumentBuilder();
InputStream is=new FileInputStream(fileName);
Document doc=dombuilder.parse(is);
Element root=doc.getDocumentElement();
NodeList dbinfo=root.getChildNodes();
if(dbinfo!=null){
for(int i=0;i<dbinfo.getLength();i++){
Node db=dbinfo.item(i);
for(Node node=db.getFirstChild();node!=null;node=node.getNextSibling()){
if(node.getNodeType()==Node.ELEMENT_NODE){
if(node.getNodeName().equals("drivername")){
setDrivername(node.getFirstChild().getNodeValue());
}
if(node.getNodeName().equals("sConnStr")){
setSConnStr(node.getFirstChild().getNodeValue());
}
if(node.getNodeName().equals("username")){
setUsername(node.getFirstChild().getNodeValue());
}
if(node.getNodeName().equals("password")){
setPassword(node.getFirstChild().getNodeValue());
}
}
}
}
}
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
这个以ReadXml命名的类，使用了参数为文件名的构造方法，用户只要将配置文件我名称传递给该方法，就可以完成对XML文件的解析，进而完成对相应参数数的读取。
三、如何获取XML文件全路径并读取配置参数
获取XML文件全路径的方法有两个，一是在servlet中获取，二是在单独的JAVA类中获取。
1.在servlet中获取XML文件的全路径并读取配置参数
程序片段String dirPath = getServletContext().getRealPath( "/WEB-INF");
String fileName = dirPath + "/conn.xml";
ReadXml xm = new ReadXml(fileName);
String DriverName = xm.getDrivername();
String connStr = xm.getSConnStr();
String user = xm.getUsername();
String pas = xm.getPassword();
将这段程序添加到servlet中dopost()之后即可完成参数的读取
2.在单独的JAVA类中获取全路径并读取配置参数
程序片段
String dirpath = System.getProperty("user.dir");
String xmlFile = dirpath + "/WebRoot/WEB-INF/conn.xml";
ReadXml rdxml = new ReadXml(xmlFile);
String driverName = rdxml.getDrivername();
String sConnStr = rdxml.getSConnStr();
String userName = rdxml.getUsername();
String passWord = rdxml.getPassword();
注：配置文件conn.xml保存在webroot/WEB-INF目录中。
❽ 如何在Mybatis的xml文件调用java类的方法
使用的是ognl表达式，struts招牌
在mybatis的映射xml文件调用java类的方法：
1.
SELECT *
FROM
EC_CORE_USER
WHERE
(user_name=#{userName} or mail =#{userName} or mobile_phone = '${@net.ytoec.framework.security.EncryptionDecryption@dSecret(userName)}') and user_password=#{userPassword}
入上面回代码所示。此处应注意，方答法必须为静态方法。
2.获取类里面的常量：
r.czmc='${@com.ytoxl.mole.datahub.kernel.dataobject.EcSystemLog@THE_AUDIT}'
3.判断是否为null:
<iftest="@org.apache.commons.lang.StringUtils@isNotBlank(province)">andjdo.province=#{province}</if>
❾ XML和JAVA是什么
正象HTML一样，可扩展置标语言XML（eXtensible Markup Language）也是一种置标语言。它同样依赖于描述一定规则的标签和能够读懂这些标签的应用处理工具来发挥它的强大功能。这一点，从XML的命名上也可窥见一斑。
“关于此规范的正确题目，亦即XML的正确全名，应该是Extensible Markup Language， eXtensible Markup Language只不过是一个拼写错误罢了。但是，现在简写XML不仅正确，而且正如它在本规范的标题中一样，是Extensible Markup Language的官方名称。
这个名称和简写是由James Clark最先提出的，其它可供选择的名称还包括小型标准置标语言MGML (Minimal Generalized Markup Language), 标准置标语言的小型结构MAGMA (Minimal Architecture For Generalized Markup Applications), 以及互联网置标结构语言SLIM (Structured Language for Internet Markup)。
——Extensible Markup Language (XML) 1.0 Specs, The Annotated Version. ”
从对XML的最初命名可以看出，XML的核心归根结底还是置标。不过，XML这个置标语言可比HTML的功能要强大的多了。
“人”如其名，XML的强大功能来自于“X”。也就是说，XML不但是置标语言，而且是可扩展的（eXtensible）置标语言。XML并非象HTML那样，提供了一组事先已经定义好了的标签，而是提供了一个标准，利用这个标准，你可以根据实际需要定义自己的新的置标语言，并为你的这个置标语言规定它特有的一套标签。准确的说，XML是一种源置标语言，它允许你根据它所提供的规则，制定各种各样的置标语言。这也正是XML语言制定之初的目标所在。
“XML的制定目标为：
XML应该可以在互联网上直接使用（*就象HTML那样好用）。
XML应该支持各种不同的应用方式（*不但包括浏览，还包括对内容的分析）。
XML应该与SGML兼容（*子承父业嘛，后面我们会讲到，SGML是XML的直接先驱）。
处理XML文件的应用程序应该容易编写（*计算机系的研究生花上两周的工夫就该差不多了）。
XML中的可选特性的数量应该减到最小，最好减至没有（*可选特性经常造成混淆）。
XML文件应该具有良好的可读性，并且比较清晰（*别象HTML那样，如果不借助浏览器，要想读它简直就是对你意志力和耐心的考验）。
用XML设计新的置标语言应该方便快捷（你不必再去经历标准制定的繁琐程序了）。
XML设计的置标语言应该正式、简洁（不然怎么易写易读？）。
XML文件应该容易编制（想想要用“记事本”写个HTML是一件多么可怕的工作）。
XML标记的简洁性并不重要（你不必再去费尽心机减少标记）。
——Extensible Markup Language (XML) 1.0 Specs, The Annotated Version.”
JAVA介绍
一、前言
『Java』从1995年的暑假开始在计算机业界就受到了高度注意，特别是在Internet和多 媒体(Multimedia)相关产品类方面。Java为何有如此这么大的魅力？人作如此的比喻： Java在全球资讯网(World Wide Web, WWW)地位就如同电子表格(Spreadsheet)与个人计 算机(PC)的关系。那Java究竟有那些特色呢？
Java是一种软件技术
是一种由美国SUN计算机公司(Sun Microsystems, Inc.)所研究而成的语言
是一种为 Internet发展的计算机语言
是一种使网页(Web Page)产生生动活泼画面的语言
是一种使网页(Web Page)由静态(Static)转变为动态(Dynamic)的语言
是一种语言，用以产生「小应用程序(Applet(s))」
是一种简化的C++语言 是一种安全的语言，具有阻绝计算机病毒传输的功能
是一种将安全性(Security)列为第一优先考虑的语言
是一种使用者不需花费很多时间学习的语言
是一种突破用户端机器环境和CPU结构的语言
是一种「写一次，即可在任何机器上执行(Write OnceRun Anywhere)」的语言是有史以来，第一套允 使用者将应用程序(Applications)通过Internet从远端的服务器(Remote Server)传输到本地端的机器 上(LocalMachine)并执行
是一种应用程序提供者不需要知道使用者的计算机硬件(如：Sun, Intel, 或MAC等)与软件(如：SW- UNIX, MAC O/S, Windows, 或NT等)环境的语言(Kestenbaum, 1995)。
下面将依序地介绍Java，首先是Java的发展历史与Java语言介绍，其次依序是Java Applet和HotJava的简单介绍。
二、Java FAQ
下面以问答的方式来说明Java的发展历史与其背景(下列内容整理自 Java FAQ list and Tutorial和The Java Language: A White Paper，读者若欲深 入了解，请自行参阅原文)：
Java何时开始发展？(When)
最早大概可追溯至1991年四月份，Sun的绿色计划(Green Project)开始着手于发展消费性电子产品(Consumer Electronics)，所使用的语言是C、C++、及Oak (为Java语 言的前身)，后因语言本身和市场的问题， 使得消费性电子产品的发展无法达到当初 预期的目标，再加上网络的兴起， 绿色计划也因此而改变发展的方向，这已是1994 年了。
为何称之为Java？(Why) "Java"是美国SUN计算机公司Java发展小组历经无数次的激烈讨论之后才被选择出。 生动(Liveliness)、动画(Animation)、速度(Speed)、交互性(Interactivity)为当 初选择名字时所欲表达出的特色。"Java"是在无数的建议中脱颖而出的，而"Java" 不是由几个单字的首字所组成， 而是从许多程序设计师钟爱的热腾腾、香浓咖啡中 产生灵感的。
谁开发了Java？(Who) Java是美国SUN计算机公司Java发展小组开发的，早期的成员(绿色工程)是Patrick Naughton, James Gosling, & Mike Sheridan，而现在大家较为熟悉的成员是James Gosling。
在那里开发了Java？(Where)
也就是问Java的出生地？答案是美国。
如何可以找到所需的Java信息？(How to)
在网路上，您可以连到Sun公司的Java WWW网站，URL是http://java.sun.com/，或是 http://www.javasoft.com/。在那里几乎可以找到您所需要的所有Java信息，但是语 言多少是一个障碍， 至少对某些人而言；没关系，目前国内已有很多个网站提供中文 Java信息。在清华和中科院的FTP站点上有不少有关资料。想象以后应会有更多的站点提供相关信息。
如何才能看到Java的效果？(How Do I)
首先您需要有含有Java解释器的浏览器(Browser)，例如：Netscpae公司的Netscape Navigator 2.0以上或是Sun公司的HotJava浏览器，对个人计算机使用者而言，操作 系统需是Windows 95或是Windows NT。
Java是因为撰写C++语言程序时的困难而研制开的，起先，只是一个消费性电子产品 大计划中的一部份，C++语言是当初被考虑采用的，但从一开始的编译问题一直到最 后的一连串问题迫使得放弃C++语言，而有Java语言的产生。Sun是要Java成为一个简 单(Simple)、面向对象的(Object Oriented)、 分布式的(Distributed)、解释的(Interpreted)、健壮的(Robust)、安全的(Secure)、 结构中立的(Architecture Neutral)、可移植的(Portable)、高效能的(High Performance)、多线程的(Multithreaded)、动态的(Dynamic)的程序语言(摘译自 TheJava Language: A White Paper, 1995)。
在Sun的Java语言白皮书中明白地说明上述Java语言的技巧。若以木工为比喻，一个面 向对象的木工，他(她)最主要的重点是即将要做的木椅子，其次才是所需要的工具； 反之；一个以非面向对象的木工，他(她)所关心的只是工具。最近的即插即用(Plug and Play)亦是面向对象设计的重点。 分布式的(Distributed)：Java有一个很周全的程薪录JAVA介绍 。
一、
『Java』从1995年的暑假开始在计算机业界就受到了高度注意，特别是在Internet和 多媒体(Multimedia)相关产品类方面。Java为何有如此这么大的魅力？人作如此的比喻： Java在全球资讯网(World Wide Web, WWW)地位就如同电子表格(Spreadsheet)与个人计 算机TTP和FTP等TCP/IP通讯协定相配合。Java应用程序(Applications) 能在网路上开启及连结使用物件，就如同透过URLs连结使用一个本地文件系统(Local File System)。 健壮的(Robust)：由Java所编写出的程序能在多种情况下执行而具有其稳定性。Java与 C/C++最大不同点是Java有一个指针模型(Pointer Model)来排除内存被覆盖(Overwriting Memory)和毁损数据(Corrupting Data)的可能性。
安全的(Secure)：Java是被设计用于网络及分布式的环境中，安全性自必是一个很 重要的考虑。Java拥有数个阶层的互锁(Interlocking)保护措施，能有效地防止病 毒的侵入和破坏行为的发生。
结构中立的(Architecture Neutral)：一般而言，网络是由很多不同机型的机器所 组合而成的，CPU和作业系统体系结构均有所不同；因此，如何使一个应用程序可以 在每一种机器上执行，是一个难题。所幸，Java的编译器产生一种结构中立的目标 文件格式(Object File Format)；这使得编译码得以在很多种处理器中执行。
可移植的(Portable)：原始资料型式的大小是被指定的，例如"float"一直是表示一 个32位元IEEE 754浮点运算数字，因绝大多数的CPU都具有此共同特征。程序库属于 系统的一部份，它定义了一些可移植的程序接口，Java本身具备有很好的可移植性。
解释的(Interpreted)：Java解释器能直接地在任何机器上执行Java位元码(Bytecodes)， 因此在进行程序连结时，时间的节省，这对于缩短程序的开发过程，有极大的帮助。
高效能的(High Performance)：Java位元码迅速地能被转换成机器码(Machine Code)， 从位元码转换到机器码的效能几乎与C与C++没有分别。
多线程的(Multi threaded)：Java语言具有多线程的功能，这对于交互回应能力及 即时执行行为是有帮助的。
动态的(Dynamic)：Java比C或C++语言更具有动态性，更能适应时刻在变的环境， Java不会因程序库的更新，而必须重新编译程序。
此外，Hank Shiffman (Making Sense of Java)亦针一般对Java的错误看法及观 念提出他的说明，特在此摘译如下：
"Java是一种编写Web Pages的一种语言，就如同HTML和VRML一样" 事实上，Java并不像是HTML此一类的描述语言(Description Language)，而是一种 编程语言(Programming Language)。描述语言标明内容和位置，而编程语言描述一 种产生结果的过程。
2. "Java语言容易学习和使用，不像C、C++和其它程序语言"
Java是一种编程语言。Java容易学吗？Java或许是比C或C++容易学，但仍是一种编程语言，而不是一种描述语言。
3. "Java码是可移植的，但C及C++不是"
Java原代码(Source Code)是比C语言来得可移植一点，差别在于Java的目标码。 Java码在一种机器上进行编译，而能在所有的机器上执行， 只要那部机器上有 Java解释器。
4. "Java能被拓展而在机器上执行任何事情"
理论上，Java Applet (Java小应用程序)能做任何事情，如模拟3D VRML模型、播放电影、产生音频....等。但事实上，一个小应用程序(Applet)仅能在那一页上被执行，而无法在那一页之外执行。同时，Java亦受限于程序库的功能。
5. "Java是适合于建立大型的应用程序"
如果Java适合于大型程序，则Java就不适合应用于Web浏览器了。第一个商业 性的Java Applets (Applix's Java-Based Spreadsheet) 并不是全然使用Java， 它只使用Java作为用户接口，而所有的处理工作， 是用CGI码。
6. "Java是解释执行的，Basic是解释执行的，因此Java=Basic"
虽然Java的确是使用解释器，但事实上，Java则与C或C++等完全编译语言较为相近，但与Basic或APL等完全解译语言较不相近。
7. "Java删除了CGI命令稿(Scripts)和程序的需求"
Java Applets将会取代部份CGI的用途。在有些情况，Java Applets能够取代一些服务器端代码(Server-Side Code)，但大多数的情况，基于安全性理由或是效 能的考虑，Java仍无法全然取代CGI Scripts。
8. "Netscape's JavaScript是与Java有相关"
除了名称之外，Java和JavaScript是有一点点相关。JavaScript是一种命令稿语 言，是可以在HTML页中使用。Java码并未出现在HTML中，而在HTML中通过一个链 结来链结编译码组。Java和JavaScript之间的关系就如同C语言和C Shell一般。
❿ eclipse如何在编辑xml时能自动提示Java类
那太智能了，对电脑的要求也会很高
~
~
~
~