1、工作空间的目录不能使用中文，不能带空格
2、约束
（1）所有java程序必须有包名
（2）所有java类名首字母必须大写
（3）所有java方法首字母名必须小写
（4）
3、java程序有两种运行方式，（Run as）（Debug as）
使用Debug as的两种应用场景：跟踪源代码和观察程序运行状态
F5跳入
F6跳过
F7跳出
跟踪源代码时
双击变量，右键watch
Drop to Frame跳回当前方法的第一行
Remove all breaknodes清除所有断点
Remove all expressions清除所有变量
断点调试后一定要终止运行断点调试的JVM
4、常用快捷键
内容提示Alt+/
快速修复Ctrl+1
在Eclipse中出现红色X，先Ctrl+1在说，看看是什么问题。
导包Ctrl+Shift+O
格式化代码块，排版代码Ctrl+Shift+F
（观察源码）回到上次代码块Alt+左方向键
（观察源码）回到下次代码块Alt+右方向键
注释代码 Ctrl+Shift+/
注释代码Ctrl+/
查看方法说明F2
重置透视图Windows->Perspective->Reset Perspective
更改为大写Ctrl+Shift+X
更改为小写Ctrl+Shift+Y
复制行Ctrl+Alt+向下键
向下移动行Alt+向下键
查看源码Ctrl+鼠标
查看某个类的源码Ctrl+Shift+T
5、Junit的使用
Junit是Java的测试工具
写一个测试对象
//Person.java
package cn.itcast;
public class Person {
public void run(){
System.out.println("run!!");
}
public void eat(){
System.out.println("eat!!");
}
}新建一个测试包（junit.test）
右键测试包，新建Junit Test Case
//
package junit.test;
import org.junit.Test;
import cn.itcast.Person;
public class PersonTest {
@Test
public void testEat() {
Person p = new Person();
p.eat();
}
@Test
public void testRun(){
Person p = new Person();
p.run();
}
}点击Run as Junit Test即可运行测试
下面可以做方法执行之前和执行之后执行的方法
package junit.test;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import cn.itcast.Person;
public class PersonTest3 {
@Before
public void setUp() throws Exception {
System.out.println("测试之前运行");
}
@Test
public void testEat() {
Person p = new Person();
p.eat();
}
@After
public void tearDown() throws Exception {
System.out.println("测试之后运行");
}
}还有类别调用之前和之后调用的方法
@BeforeClass
@AfterClass6、XML
Extensible Markup Language,翻译过来为可扩展标记语言。Xml技术是w3c组织发布的，目前推荐遵循的是XML组织在2000发布的XML1.0规范。
XML描述下面这种数据
在XML语言中，允许用户自定义标签，一个标签用于描述一段数据。例如
<?xml version="1.0" encoding="UTF-8"?>
<中国>
<北京>
<海淀></海淀>
<丰台></丰台>
</北京>
<湖南>
<长沙></长沙>
<岳阳></岳阳>
</湖南>
<湖北>
<武汉></武汉>
<荆州></荆州>
</湖北>
</中国>XML技术除了用于保存有关系的数据之外，它还经常用作软件配置文件，以描述程序模块之间的关系。
在一个软件系统中，为提高系统的灵活性，它所启动的模块通常由其配置文件决定。
例如一个软件在启动时，它需要启动A，B两个模块，而A,B两个模块在启动时，又分别需要启动A1，A2和B1，B2模块的支持，为了准确描述这种关系，吃屎使用XML文件最为合适。
XML语法
一个XML文件分为如下几个部分内容：
文档声明
元素
属性
注释
CDATA区，特殊字符
处理指令（processing instruction）
文档声明是下面这个样子
<?xml version="1.0"?>使用encoding属性说明文档的字符编码
<?xml version="1.0" encoding="GB2312" ?>XML文档是以哪种码表保存的，在XML文档中就应该设置响应encoding属性，以通知解析器以响应的编码打开。
在Eclipse写XML为自动保存为相应的格式。
使用standalone属性说明文档是否独立
<?xml version="1.0" encoding="gb2312" standalone="yes"?>元素就是标签
<a>www.itcast.cn</a>
<a></a>
<a/>XML文档必须有且仅有一个根标签，其他标签都是根标签的子孙标签
元素命名规范
（1）区分大小写
（2）不能以数字或者下划线开头
（3）不能以XLM，xml，Xml开头
（4）不能包含空格
（5）名称中间不能有冒号（：）
属性
一个标签可以有多个属性，每个属性都有自己的名称和取值。
<input name="text">属性值一定要用双引号或者单引号引起来
定义属性必须遵循与标签相同的命名规范
多学一招：在XML技术中，标签属性所代表的信息，也可以被改成用子元素的形式来描述
<input>
<name>text</name>
</input>注释
<!--注释-->文档声明之前不能有注释
CDATA区
character data
在编写XML文件时，有些内容可能不想让解析引擎解析执行，而是当作院士内容处理。
语法
<![CDATA[内容]]>转义字符
&|&
<|<
>|>
"|"
'|'处理指令
大多是指使用css或者js对XML文件改变表现样式。
<?xml-stylesheet type="text/css" href="config.css"?>7、XML约束
在XML技术里，可以编写一个文档来约束一个XML文档的书写规范，这个就称之为XML约束。
XML约束有什么用呢？
程序启动时是读取XML文件，所以要约束XML文档的标签。
XML约束技术
XML DTD技术
XML Schema技术
DTD（Document Type Definition）全程为文档类型定义
book.dtd
<!ELEMENT 书架 (书+)>
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>
<!ELEMENT 作者 (#PCDATA)>
<!ELEMENT 售价 (#PCDATA)>DTD文件应使用UTF-8或Unicode编码
<?xml version="1.0" ?>
<!DOCTYPE 书架 SYSTEM "book.dtd">
<书架>
<书>
<书名>Java就业培训教程</书名>
<作者>张孝祥</作者>
<售价>39.00元</售价>
</书>
<书>
<书名>JavaScript网页开发</书名>
<作者>张孝祥</作者>
<售价>28.00元</售价>
</书>
</书架>如果想要看xml写的是否正确，可以调用Microsoft.XMLDOM,这样就可以看到xml文档是否是按照dtd文件编写。
<!DOCTYPE html>
<html>
<head>
<script>
var xmldoc = new ActiveXObject("Microsoft.XMLDOM");
xmldoc.validateOnParse=true;
xmldoc.load("book.xml")
document.write("错误的原因：" + xmldoc.parseError.reason + "<br/>");
document.write("错误的行号：" + xmldoc.parseError.line + "<br/>");
</script>
</head>
<body>
</body>
</html>DTD也可以写在xml文件内
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<!DOCTYPE 书架 [
<!ELEMENT 书架 (书+)>
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>
<!ELEMENT 作者 (#PCDATA)>
<!ELEMENT 售价 (#PCDATA)>
]>
<书架>
<书>
<书名>Java就业培训教程</书名>
<作者>张孝祥</作者>
<售价>39.00元</售价>
</书>
<书>
<书名>JavaScript网页开发</书名>
<作者>张孝祥</作者>
<售价>28.00元</售价>
</书>
</书架>DOCTYPE声明语句有两种
当引用文件在本地时，采用如下方式
<!DOCTYPE 文档根节点 SYSTEM "DTD文件的URL">
<!DOCTYPE 书架 SYSTEM "book.dtd">当引用文档是一个公共文件时，采用如下方式：
<!DOCTYPE 文档根节点 PUBLIC "DTD名称" "DTD文件的URL">
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">DTD约束语法细节
元素定义
属性定义
实体定义
在DTD文档中使用ELEMENT声明一个XML元素，语法格式如下所示
<!ELEMENT 元素名称 元素类型>元素类型可以是元素内容，或类型
如为元素内容，则需要使用()括起来，
<!ELEMENT 书 (书名,作者,售价)>
<!ELEMENT 书名 (#PCDATA)>如为元素类型，则直接写，DTD规范定义了如下几种类型
EMPTY：用于定义空元素，例如
<br/><hr/>ANY:表示元素内容为任意类型
元素内容中可以使用如下方式，描述内容的组成关系
（1）用逗号分隔，表示内容的出现顺序必须与声明一致。
<!ELEMENT MYFILE (TITLE,AUTHOR,EMAIL)>（2）用|分隔，表示任选其一，即多个只能出现一个
<!ELEMENT MYFILE (TITLE|AUTHOR|EMAIL)>（3）元素内容使用空白符分离，表示出现顺序没有要求
<!ELEMENT MYFILE (TITLE AUTHOR EMAIL)>元素内容中也可以使用+，*，？等符号表示元素出现的次数：
+：一次或者多次(书+)
？：0次或者一次
*：0次或者多次
也可以使用圆括号批量设置
<!ELEMENT MYFILE ((TITLE*,AUTHOR?,EMAIL)*|COMMENT)>DTD属性定义
xml文档中的标签属性需通过ATTLIST为其设置属性
语法格式
<!ATTLIST 元素名
属性名1 属性值类型 设置说明
属性名2 属性值类型 设置说明
······
>属性声明举例
<!ATTLIST 商品
类别 CDATA #REQUIRED
颜色 CDATA #IMPLIED
>对应的XML文件
<商品 类别="服装" 颜色="黄色">...</商品>
<商品 类别="服装">...</商品>设置说明
#REQUIRED：必须设置该属性
#IMPLIED：可以设置也可以不设置
#FIXED：说明该属性的取值固定位一个值，在XML文件中不能为该属性设置其他值，单需要为该属性提供一个值。
直接使用默认值：在XML中可以设置该值也可以不设置该属性值，若没设置则使用默认值。举例
<!ATTLIST 页面作者
姓名 CDATA #IMPLIED
年龄 CDATA #IMPLIED
联系信息 CDATA #REQUIRED
网站职务 CDATA #FIXED "页面作者"
个人爱好 CDATA "上网"
>常用属性值类型
CDATA：表示属性值为普通文本字符串
ENUMERATED
ID
ENTITY实体
当是ENUMERATED时，表示属性的类型可以是一组取值列表，在XML文件中设置的属性值只能是这个列表中的某个值。
<?xml version="1.0" encoding="GB2312" standalone="yes"?>
<!DOCTYPE 购物篮 [
<!ELEMENT 肉 EMPTY>
<!ATTLIST 肉 品种 (鸡肉|牛肉|猪肉|鱼肉) "鸡肉">
]>
<购物篮>
<肉 品种="鱼肉"/>
<肉 品种="牛肉"/>
<肉/>
</购物篮>当是ID时，表示属性的设置值为一个唯一值
ID属性的值只能由字母，下划线开始，不能出现空白字符
<?xml version="1.0" encoding="gb2312" ?>
<!DOCTYPE 联系人列表[
<!ELEMENT 联系人列表 ANY>
<!ELEMENT 联系人 (姓名,EMAIL)>
<!ELEMENT 姓名 (#PCDATA)>
<!ELEMENT EMAIL (#PCDATA)>
<!ATTLIST 联系人 编号 ID #REQUIRED>
]>
<联系人列表>
<联系人 编号="1">
<姓名>张三</姓名>
<EMAIL>zhang@it315.com</EMAIL>
</联系人>
<联系人 编号="2">
<姓名>李四</姓名>
<EMAIL>li@it315.com</EMAIL>
</联系人>
</联系人列表>注意：编号不能以数字开头
实体用于为一段内容创建一个别名，以后在XML文档中就可以使用别名引用这段内容了。
在DTD中,
<!ENTITY...>用于定义一个实体实体分为两种类型：引用实体和参数实体
引用实体主要在XML文档中被应用
语法格式
<!ENTITY 实体名称 "实体内容">
<!ENTITY copyright "I am a programmer">引用方式
&实体名称;
<!ENTITY copyright "I am a programmer">
......
©right;参数实体被DTD文件自身使用
语法格式：
<!ENTITY % 实体名称 "实体内容">引用方式
%实体名称;
举例
<!ENTITY % TAG_NAMES "姓名|EMAIL|电话|地址">
<!ELEMENT 个人信息 (%TAG_NAMES;|生日)>
<!ELEMENT 客户信息 (%TAG_NAMES;|公司名)>再举例
<!ENTITY % common.attributes "id ID #IMPLIED
account CDATA #REQUIRED">
......
<!ATTLIST purchaseOrder %common.attributes;>
<!ATTLIST item %common.attributes;>8、XML编程（CRUD）
XML编程就是对XML进行增删改查
creat
read
update
delete
XML解析方式分为两种：dom和sax
dom：（Document Object Model）文档对象模型，是W3C组织推荐的处理XML的一种方式。
sax：（Simple API for XML）不是官方标准，但是它是XML社区事实上的标准，几乎所有的XML解析器都支持它。
XML解析器Crimson（sun），Xerces（ibm），Aelfred2（dom4j）
XML解析开发包
Jaxp，Jdom，dom4j（最好）
dom与sax的区别
dom读取xml文档时会把整个文档装在到document对象里面去，会把任何一个东西都解析成对象。
标签解释成Element对象
标签里面的内容解析成Text对象
属性会解析成Attribute对象
所有的对象都通过node接口
dom的优点：使用dom解析XML文档，实现crud特别方便
但是当XML文档非常大时，句不能读取XML文档了，java就会崩溃。
所以dom不适合操作大的XML文件。
Java虚拟机默认可以管理64MB的内存。
修改Java运行内存Run as Run configurations，选择Arguments ->VM arguments -Xmx80m
sax读一行解析一行
优点：解析速度快，对内存占用少，查找数据特别方便
只适合查找数据，不适合增删改。
9、Jaxp
JAXP开发包是J2SE的一部分，它由javax.xml、org.w3c.dom、org.xml.sax及其子包组成。
在javax.xml.parsers包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对xml文档进行解析的DOM或SAX的解析器对象。
javax.xml.parsers包中的DocumentBuilderFactory用于创建DOM模式的解析器对象，DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但是该类提供了一个newInstance方法，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象，并返回。
更新XML文档
javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出，例如把XML文件应用样式表后转成一个html文档。利用这个对象，当然也可以把Document对象又重新写入到一个XML文件中。
Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地。我们可以通过：
javax.xml.transform.dom.DOMSource类来关联要转换的document对象，
javax.xml.transform.stream.StreamResult对象来表示数据的目的地。
Transformer对象通过TransformerFactory获得。
package cn.itcast.jaxp;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.junit.Test;
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 Demo1 {
//使用jaxp操作xml文档
public static void main(String[] args) throws SAXException, IOException, ParserConfigurationException {
// TODO Auto-generated method stub
//获取工厂
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
//产生解析器
DocumentBuilder builder = factory.newDocumentBuilder();
//解析XML文档，得到代表文档的document
Document document = builder.parse(new File("src/xml/book.xml"));
read(document);
}
//获取节点的值
public static void read(Document document){
NodeList list =document.getElementsByTagName("售价");
Node price = list.item(0);
String value = price.getTextContent();
System.out.println(value);
}
//修改节点的值
@Test
public void update() throws Exception{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("src/xml/book.xml"));
Node price = document.getElementsByTagName("售价").item(0);
price.setTextContent("59.00元");
//把内存中的document写到xml文档
TransformerFactory tf = TransformerFactory.newInstance();
//得到转换器
Transformer ts = tf.newTransformer();
ts.transform(new DOMSource(document), new StreamResult(new File("src/xml/book.xml")));
}
//增加
@Test
public void add() throws Exception{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("src/xml/book.xml"));
//创建需要增加的节点
Node price = document.createElement("售价");
price.setTextContent("59元");
//得到需要增加的节点的父亲
Node parent = document.getElementsByTagName("书").item(0);
//把需要增加的节点增加到父结点上去
parent.appendChild(price);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer ts = tf.newTransformer();
ts.transform(new DOMSource(document), new StreamResult(new File("src/xml/book.xml")));
}
//向指定位置上插入节点
@Test
public void add2() throws Exception{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("src/xml/book.xml"));
Node node = document.createElement("售价");
node.setTextContent("39元");
Node brother = document.getElementsByTagName("书名").item(0);
Node parent = document.getElementsByTagName("书").item(0);
parent.insertBefore(node, brother);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer ts = tf.newTransformer();
ts.transform(new DOMSource(document), new StreamResult(new File("src/xml/book.xml")));
}
//删除节点
@Test
public void delete() throws Exception{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("src/xml/book.xml"));
Node node = document.getElementsByTagName("售价").item(2);
node.getParentNode().removeChild(node);
TransformerFactory tf = TransformerFactory.newInstance();
Transformer ts = tf.newTransformer();
ts.transform(new DOMSource(document), new StreamResult(new File("src/xml/book.xml")));
}
//操作xml文档属性
@Test
public void updateattribute() throws Exception{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.parse(new File("src/xml/book.xml"));
//操作xml文档的元素时，一般都把元素当做node对象，但是程序员如果发现node不好使时就把node强转成Element
//但是在节点转化之前，先判断节点类型
Element book = (Element)document.getElementsByTagName("书").item(0);
book.setAttribute("name", "yyyyyyyy");
TransformerFactory tf = TransformerFactory.newInstance();
Transformer ts = tf.newTransformer();
ts.transform(new DOMSource(document), new StreamResult(new File("src/xml/book.xml")));
}
}xml文件是这样的
<?xml version="1.0" encoding="utf-8" standalone="no"?><书架>
<书 name="yyyyyyyy">
<售价>109元</售价>
<售价>39元</售价>
<书名>Java就业培训教程</书名>
<作者>张孝祥</作者>
</书>
<书>
<书名>JavaScript网页开发</书名>
<作者>张孝祥</作者>
<售价>28.00元</售价>
</书>
</书架>自己写了一个操作XML文件的小例子。实现学生成绩管理系统
主要有三个功能，添加用户，删除用户，查询成绩。
文件结构如下
下面是代码
student.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?><exam>
<student>
<name>李四</name>
<location>大连</location>
<grade>97</grade>
</student>
</exam>//StudentDao.java
package cn.itcast.dao;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import cn.itcast.domain.Student;
import cn.itcast.utils.XmlUtils;
/**
* <student examid="222" idcart="111">
<name>张三</name>
<location>沈阳</location>
<grade>89</grade>
</student>
* @author Logan
*
*/
public class StudentDao {
public void add(Student student){
try{
Document document = XmlUtils.getDocument();
//student_node //ctrl+1 rename in file
Element student_node = document.createElement("student");
student_node.setAttribute("examid", student.getExamid());
student_node.setAttribute("idcard", student.getIdcard());
Element name = document.createElement("name");
name.setTextContent(student.getName());
Element location = document.createElement("location");
location.setTextContent(student.getLocation());
Element grade = document.createElement("grade");
grade.setTextContent(student.getGrade()+"");
student_node.appendChild(name);
student_node.appendChild(location);
student_node.appendChild(grade);
//得到exam节点，并把student挂上去
document.getElementsByTagName("exam").item(0).appendChild(student_node);
XmlUtils.write2Xml(document);
}catch(Exception e){
throw new RuntimeException(e);
}
}
//删除
public void delete(String name){
try{
Document document = XmlUtils.getDocument();
NodeList list = document.getElementsByTagName("name");
for(int i = 0;i<list.getLength();i++){
if(list.item(i).getTextContent().equals(name)){
Node name_node = document.getElementsByTagName("name").item(i);
Node location = document.getElementsByTagName("location").item(i);
Node grade = document.getElementsByTagName("grade").item(i);
Node student = document.getElementsByTagName("student").item(i);
location.getParentNode().removeChild(location);
grade.getParentNode().removeChild(grade);
name_node.getParentNode().removeChild(name_node);
student.getParentNode().removeChild(student);
break;
}
}
XmlUtils.write2Xml(document);
}catch(Exception e){
throw new RuntimeException(e);
}
}
//查找
public Student find(String examid){
try{
Document document = XmlUtils.getDocument();
NodeList list = document.getElementsByTagName("student");
Student student = new Student();
for(int i = 0;i<list.getLength();i++){
Element student_node = (Element) list.item(i);
if(student_node.getAttribute("examid").equals(examid)){
student.setExamid(examid);
student.setIdcard(student_node.getAttribute("idcard"));
NodeList list1 = list.item(i).getChildNodes();
for(int j=0;j<list1.getLength();j++){
if(list1.item(j).getNodeName().equals("name")){
student.setName(list1.item(j).getTextContent());
}else if(list1.item(j).getNodeName().equals("location")){
student.setLocation(list1.item(j).getTextContent());
}
else if(list1.item(j).getNodeName().equals("grade")){
student.setGrade(Double.parseDouble(list1.item(j).getTextContent()));
}
else{
//System.out.println("error");
}
}
}
}
return student;
}catch(Exception e){
throw new RuntimeException(e);
}
}
}
//Student.java
package cn.itcast.domain;
public class Student {
private String idcard;
private String examid;
private String name;
private String location;
private Double grade;
//alt+shift+s
public String getIdcard() {
return idcard;
}
public void setIdcard(String idcard) {
this.idcard = idcard;
}
public String getExamid() {
return examid;
}
public void setExamid(String examid) {
this.examid = examid;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLocation() {
return location;
}
public void setLocation(String location) {
this.location = location;
}
public double getGrade() {
return grade;
}
public void setGrade(double grade) {
this.grade = grade;
}//XmlUtils.java
package cn.itcast.utils;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
public class XmlUtils {
public static Document getDocument() throws ParserConfigurationException, SAXException, IOException{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
return builder.parse(new File("src/student.xml"));
}
public static void write2Xml(Document document) throws TransformerException{
TransformerFactory factory = TransformerFactory.newInstance();
Transformer tf = factory.newTransformer();
tf.transform(new DOMSource(document), new StreamResult(new File("src/student.xml")));
}
}//Main.java
package cn.itcast.view;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import cn.itcast.dao.StudentDao;
import cn.itcast.domain.Student;
public class Main {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
System.out.println("添加学生(a) 查找学生(b) 删除学生(c)");
System.out.print("请输入操作类型:");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String type = br.readLine();
if(type.equalsIgnoreCase("a")){
//添加学生
try{
System.out.print("请输入学生姓名：");
String name = br.readLine();
System.out.print("请输入学生准考证号：");
String examid = br.readLine();
System.out.print("请输入学生身份证号：");
String idcard = br.readLine();
System.out.print("请输入学生所在地：");
String location = br.readLine();
System.out.print("请输入学生成绩：");
String grade = br.readLine();
Student student = new Student();
student.setExamid(examid);
student.setGrade(Double.parseDouble(grade));
student.setIdcard(idcard);
student.setLocation(location);
student.setName(name);
StudentDao dao = new StudentDao();
dao.add(student);
System.out.println("恭喜，添加成功！");
}catch(Exception e){
System.out.println("对不起，录入失败！");
}
}else if(type.equalsIgnoreCase("b")){
//查找学生
System.out.print("请输入查找的学生准考证号：");
String examid = br.readLine();
StudentDao dao = new StudentDao();
Student student = dao.find(examid);
System.out.println("姓名："+student.getName()+",身份证号：" +student.getIdcard()
+",准考证号:"+student.getExamid()+",地区:"+student.getLocation()+",成绩:"+student.getGrade());
}else if(type.equalsIgnoreCase("c")){
//删除学生
System.out.print("请输入删除的学生姓名：");
String name = br.readLine();
StudentDao dao = new StudentDao();
dao.delete(name);
System.out.println("已删除"+name);
}else{
System.out.println("非法字符");
}
}
}
4007
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
