JavaWeb_Eclipse的使用

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

@AfterClass

6、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[内容]]>

转义字符

&|&amp;
<|&lt;
>|&gt;
"|&quot;
'|&apos;

处理指令
大多是指使用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">
......
&copyright;

参数实体被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("非法字符");
        }

    }

}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值