Day01

 

 

01_junit介绍

测试代码有没有问题

02_junit单元测试

package com.itheima.junitdemo;

public class Demo {
    public static void main(String[] args){
    MyMath math = new MyMath();
    int add = math.add(3, 4);
    System.out.println("result="+add);
    }
}
package com.itheima.junitdemo;
public class MyMath {
    public int add(inti,int j) {
        return i+j;
    }
}

包里会出现一个名为“testMyMath.java”

package com.itheima.junitdemo;

import static org.junit.Assert.*;
import org.junit.Test;

public class testMyMath {

    @Test
    public void testAdd() {
        fail("Not yet implemented");
    }
}

如何测试呢？

在里面创建一个对象，通过对象调用add方法，再使用assertEquals方法，将实际值和期望值进行比较，选择testadd()右键单击run as运行，若测试成功，则左侧出现以下图形，运行条呈绿色，若测试失败，运行条呈红色。

package com.itheima.junitdemo;
import static org.junit.Assert.*;
import org.junit.Test;

public class testMyMath {

    @Test
    public void testAdd() {
        MyMath math = new MyMath();
    int result = math.add(2, 3);
//断言拿运行结果和期望结果进行比较如果相同说明测试成功
    assertEquals(5,result);
    }
}

这么做的好处，junit的好处

创建一个新类，对项目代码无影响，此方式可做任何测试，不对其他正常工程产生任何影响。

03_注解介绍

注解 jdk1.5加入的api

预制注解三个：

   @Deprecated 当前方法过时的，提醒后来的程序员，此方法在api中有更好的实现。

@Deprecated//过时的
    public int add(int i,int j){
        return i+j;
    }

@SuppressWarnings(“all”)  压制警告，可以关闭方法或某一行的警告，既可以放在某一代码前面，也可以放在方法前面。

@SuppressWarnings("all")//压制所有警告，
    public static void main(String[] args) {
        MyMath math=new MyMath();
        @SuppressWarnings("deprecation")//压制警告，可以关闭方法或同一行的警告
        int add=math.add(3, 4);
        @SuppressWarnings("unused")//压制警告
        int i=0;
        System.out.println("result="+add);
    }

@Override 当前方法覆盖父类的方法

@Override//复写父类的方法
    public void eat() {
        System.out.println("吃香的");
    }

04_xml的介绍

概念：XML是指可扩展标记语言，类似HTML，它被设计的宗旨是传输数据，或者说是描述数据的，并非显示数据。它没有预定义，需要用户自行定义标签。目前遵循的是W3C组织与2000年发布的XML1.0规范。

作用：描述有关系的数据，允许用户自定义标签，一个标签用于描述一段数据；一个标签分为开始标签和结束标签。在起始标签之间，又可以使用其它标签来实现数据关系的描述。XML的数据必须通过软件程序来解释执行或显示，如IE；这样的解析程序称之为Parser(解析器)。

1.可以在客户端（client）服务器（server）之间传递数据。

服务器装着服务端程序的高配置电脑cpu Intel志强处理器

2.用来保存有关系的数据

3.用来做配置文件在android当中界面的布局和文件，还有清单文件都是用xml文件来描述的

 

05_XML语法

中文常用的码表：gbk(2万个字汉字) gb2312（5000个字汉字） utf-8

一个XML文件分为如下几部分内容：

—文档声明必须出现在文档的第一行

最简单的语法：

用encoding属性说明文档所使用的字符编码，保存在磁盘上的文件编码要与声明的编码一致，如果不声明编码，默认的使用的是utf-8。如：

用standalone属性说明文档是否独立，即是否依赖其他文档。如

使用记事本编写：

 

浏览器预览效果：

 

06_元素

（1）XML元素是指XML文件中出现的标签。一个标签分为起始和结束标签（不能省略）。一个标签有如下几种书写形式：

包含标签主体：some cintent

不包含标签主体：

一个标签中可以使用嵌套若干个子标签，但所有标签必须合理的嵌套，不允许有交叉嵌套。

一个XML文档必须有且仅有一个根标签，其他标签都是这个根标签的子标签或孙标签。

（2）XML中不会忽略主题内容中出现的空格和换行（书写的时候用了这些符号，就会导致流量的浪费）

（3）命名规范一个XML元素可以包含字母、数字以及其它一些可见字符，但必须遵循下面的一些规范：

区分大小写，例如，

和

是两个不同的标记。

不能以xml（或XML、或Xml等）开头。

能包含空格。

称中间不能包含冒号（：）。

 

07_XML的属性注释&CDATA

一个元素可以有多个属性，每个属性都有它自己的名称和取值，例如：

属性要写在开始标签中

属性值一定用用引号(单引号或双引号)引起来

属性名称的命名规范与元素的命名规范相同

元素中的属性是不允许重复的

在XML技术中，标签属性所代表的信息也可以用子元素的形式中描述

xml version="1.0" encoding="UTF-8"?>
<Person>
 <preson name="liufeng">
  <firstname>fengfirstname>
  <lastname>liulastname>
 preson>Person>

注释

XML中的注释语法为:

注意:

XML声明之前不能有注释，即不能在文档的第一行

注释不能嵌套，例如:

```

 

CDATA区

所有XML文档中的文本均会被解析器解析

只有CDATA区段中的文本会被解析器忽略

语法：

 

08_XML的特殊字符

特殊字符	替代符号
&	&
<	<
>	>
“	"
,	&apos

 

09_XML约束

（1）为什么要使用约束

XML都是用户自定义的标签，若出现小小错误，软件程序将不能正确地获取文件中的内容而报错。

XML技术中心，可以编写一个文档来约束一个XML的书写规范，这个文档称为约束文档

（2）两个概念：

格式良好的XML：遵循XML语法的XML（合适良好不一定有效，有效的一定是格式良好）

有效的XML：遵循约束文档的XML

（3）约束的作用：

约束文档定义了XML中允许出现的元素名称，属性及元素出现的顺序

（4）常用的约束技术：XML DTD、XML Schema

（5）DTD快速入门

①DTD：文档类型定义

②作用：约束XML的书写规范

③注意：dtd可以在单独的文件中，扩展名是dtd,且必须使用utf-8编码

10_dtd约束介绍

引入外部DTD文档

XML 使用DOCTYPE语句来指明它遵循的DTD文档

有两种形式

①   当引用的DTD文档在本地时，采用如下方式:

IDOCTYPE 根元素SYSTEM"book.dtd">

如:

②   当引用的DTD文档在公共网络上，采用如下方式

如

Inc //DTD Web Application 2 3/EN"

http://java sun.com/dtd/web app_2_3.dtd>

 

DTD语法的细节

定义元素

DTD-定义元素

在DTD文档中用ELEMENT关键字来声明一个XML元素

语法

使用规则：

(#PCDATA)：指示元素的主体内容只能是普通的文本（parsed character Data）

EMPTY：用于指示元素的主体为空，

ANY：用于指示元素的主题内容为任意类型

（子元素）:指示元素中包含的子元素

定义子元素及描述它们的关系：

如果子元素用逗号分开，说明必须按照声明顺序去编写XML文档

如果了元表用”|”分开，说明任选其一

用+*？来表示元素出现的次数

如果子元素后面没有+*？说明必须出现一次

   +表示至少出现一次

   *表示可有可无

？表示0次或1次

DTD独立的dtd文档，扩展名dtd编码必须是utf-8

可以声明在xml文件中

通过dtd可以约束元素的名称元素出现的顺序出现的次数属性的名称属性的类型属性是否必须出现，属性的值是否可以重复

 

DTD-定义属性

在DTD文档中用ATTUST关键字来为一个元素市明属性

语法

属性值类型

CDAIA:表示属性的取值为普通的文本字符串

(a|b|c) 说明只能从中任选其一

ID表示属性的取值不能重复

设置说明

#REQUIRED：表示该属性必领出现

#IMPLIED：表示该属生可有可无

#FIXED：表示属性的取值为一个固定值语法HIXED“固定值”

 

DTD-定义引用实体

概念: 在DTD中定义，在XML中使用

语法

引用方式(主义是在XML中使用):&实体名称

DTD中定义：

XML中引用：

©nght

 

11_schema约束介绍

XML Schema也是一种用于定义和描述XML文档与内容的模式语言，其出现是为了克服DTD的局限性

XML Schema VS DTD

   XML Schema符合XML语法结构。

   DOM、SAX等XML API很容易解析出现XML、Schema文档中的内容。

   XML Schema对名称空间支持的非常好。(名称空间 name space:对应一个约束文档)

   XML Schema比XML DTD支持更多的数据类型，并支持用户自定义新的数据类型。

   XML Schema定义约束的能力非常强大，可以对XML实例文档作出细致的语义限制。

   XML Schema不能像DTD一样定义实体，比DTD更复杂，但Xml Schema现在已是w3c组织的标准，它正逐步取代DTD。

 

Schema约束快速入门

XML Schema文件自身就是一个XML文件，但它的扩展名通常为.xsd

一个XML Schema文档通常称之为模式文档（约束文档），遵循这个文档书写的xml文件称之为实例文档

和XML文件一样，一个XML Schema文档也必须有一个根节点，但这个根节点的名字为schema

编写了一个XML Schema约束文件后，通常需要把这个文件中声明的元素绑定到一个URI地址上，在XML Schema技术中有一个问题专业术语来描述这个过程，即把XML Schema文档声明的元素绑定到一个名词空间上，以后xml文件可以通过这个URI（即名称空间）来告诉解析引擎，xml文件中编写的元素来自哪里，被谁约束

schema约束文件

xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
  targetNamespace="http://www.itheima.com" 
  elementFormDefault="qualified">
  <xs:element name="书架">
   <xs:complexType>
     <xs:sequence maxOccurs="unbounded">
      <xs:element name="书">
       <xs:complexType>
        <xs:sequence>
          <xs:element name="书名" type="xs:string"/>
          <xs:element name="作者" type="xs:string"/>
          <xs:element name="售价" type="xs:string"/>
        xs:sequence>
       xs:complexType>
      xs:element>
     xs:sequence>
   xs:complexType>
  xs:element>
xs:schema>

xml 

xml version="1.0" encoding="UTF-8"?>
<p:书架 xmlns:p="http://www.itheima.com" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.itheima.com bin/bookSchema.xsd ">
  <p:书>
    <p:书名>p:书名p:书名>
    <p:作者>p:作者p:作者>
    <p:售价>p:售价p:售价>
  p:书>
p:书架>

schema

扩展名通常为.xsd,本身是一份xml文档

对名称空间支持的很好

支持类型比dtd更丰富约束更细致可以支持自定义的类型

schema正在逐步dtd在Android中清单文件和布局文件用到了schema约束技术

xml的约束技术作用规范xml文件的书写（标签属性文本）

xml约束常用的技术dtd schema

android用到的约束 schema

名称空间

 

12_schema约束和回顾

Dtd独立的dtd文档 扩展名dtd 编码必须是utf-8

可以声明在xml文件中

通过dtd可以约束元素的名称 元素出现的顺序 出现的次数 属性的名称 属性的类型 属性是都必须出现 属性的值是否可以重复

Schema

1.扩展名 xsd本身是一份xml文档

2， 对名称空间（namespace）支持的很好

3.支持的类型比dtd更丰富约束的更细致 可以支持自定义的类型

4.Schema正在逐步替换dtd 在android中清单文件和布局文件 用到了schema约束技术

 

1.Xml的约束技术 作用 规范xml文件的书写（标签 属性 文本）

2．  Xml约束 常用的技术 dtd schema

3.Android用到的约束 schema

4.名称空间 namespace

 

13_xml的解析和domj解析说明

 

Xml解析

Xml解析的三种方式：

Dom 解析

Sax解析

Pull解析

 

Dom解析

 

 

 

 

 

DOM的结构

  

链接

 

 

Dom解析

根据xml层次结构在内存中分配一个属性结构

在XML DOM每个元素 都会被解析为一个节点node ，而常用的节点类型又分为

  元素节点 Elemeht

  属性节点 Attr

  文本节点 Text

  文档节点 Document

优缺点

Dom解析xml的优点

因为分配了一个树形结构，很方便的实现增加修改删除的操作

缺点：

如果要解析的文件过大，一次性在内存中分配一个树形结构，造成内存的溢出

 

①   把整个文档先加载到内存中->Document 所以可以对文档进行修改

②   如果这个文件比较大 可能会导致内存溢出

 

DOM&SAX解析开发包

JAXP是sun公司推出的解析标准实现

Dom4J：开源组织推出的解析开发包

 

JAXP：（Java API for XML Processing）开发包是JavaSE的一部分，它由以下几个包及其子包组成：

 org.w3c.dom:提供DOM方式解析XML的标准接口

 org.xml.sax：提供SAX方式解析XML的标准接口

 javax.xml：提供了解析XML文档的类

javax.xml.parsers包中，定义了几个工厂类，用来获得DOM和SAX解析器对象

  DocumenBuilderFactory

  SAXParserFactory

 

编程思路 DocunmentBuilderFactory->DocumentBuilder->Document->通过节点获得NodeList->具体的Node

如果想修改TransformerFactory->Transformer->transform(Source,result)

import javax.swing.text.Document;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.NodeList;
public class DomparseTest {
@TEST
public void domParse() throws Exception{
        //获取DocumentBuilderFactory
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//获取DocumentBuilder
DocumentBuilder documentBuilder = builderFactory.newDocumentBuilder();
//通过DocumentBuilder据诶系xml文档获得Docment对象
Document document = documentBuilder.parse("book.xml");
//通过元素的名字可以找到元素的集合
NodeList nodeList = document.getElmentsByTagName("售价");
//nodeList.getLength();
For(int i=0;i){
Node node =nodeList.item(i);
String content = node.getTextContent();
System.out.println(content);
}
//找到第二个元素
Node node = nodeList.item(0);
//读出对应节点的文本内容
String content = node.getTextContent();
System.out.println(content);

@Test
Public void domModifyxml() throws Exception{
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = documentBuilderFactory.newDocumentBuilder();
Documnt document = builder.parse(“book.xml”);
Node node = nodeList.item(i);
//修改节点的内容
Node.setTextContent(“199.00元”);
TranformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFaactory.newTransformer();
//数据源
Source xmlSource = new DomSource(document);
Result outputTarget = new StreamResult(“book.xml”);
Transformer.transform(xmlSourse,outputTarget);
}
}

15_SAX解析

SAX解析的方式：边读边解析

当使用SAX方式读到特定的标签时候，自动调用相应大的方法进行操作

SAX解析XML的优点：

 不会造成内存溢出

SAX解析XML的缺点：

 不能修改XML文件

package com.nbdhyu.temp;

import java.util.logging.Handler;

import javax.sql.rowset.spi.XmlReader;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.junit.Test;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SaxParserTest {
    @Test
    public void saxParse() throws Exception{
        //获取工厂
        SAXParserFactory parserFactory=SAXParserFactory.newInstance();
SAXParser saxParser=parserFactory.newSAXParser();
        //获取xmlRead通过这个reader可以试着contenthandler
        XmlReader xmlReader=saxParser.getXMLReader();
        //给xmlReader设置contenthandler contenthandler是一个接口 里面太多的方法没实现
        //不去直接实现contenthandler 而是继承他默认的实现DefaultHandler
        xmlReader.setContentHandler(new Myhandle());
        //解析xml文档
        xmlReader.parse("book.xml");        
    }
    private class Myhandle extends DefaultHandler{
        @Override
        public void characters(char[] ch, int start, int length) throws SAXException {
            // 文本内容
        String text=new String(ch,start,length);
        System.out.println("文本内容");
        }
         @Override
        public void endDocument() throws SAXException {
            System.out.println("文档结束");                
        }
        @Override
        public void endElement(String uri, String localName, String qName) throws SAXException {
            System.out.println("结束标签<"+qName+">");    
        }
         @Override
        public void startDocument() throws SAXException {
            System.out.println("文档开始");        
        }
        @Override
        public void startElement(String uri, String localName, String qName, Attributes attributes)
                throws SAXException {
            System.out.println("开始标签");    
        };
    }
}
@Test
    public void saxParserTest2() throws Exception{
        SAXParserFactory parserFactory=SAXParserFactory.newInstance();
        SAXParse parser=parserFactory.newSAXParser();
        XmlReader reader=parser.getXMLReader();
        reader.setContentHandler(new DefaultHandler(){
            boolean isPrice=false;
            int count=0;
            @Override
            public void characters(char[] ch, int start, int length) throws SAXException {
                if (isPrice&&count=2) {
                    System.out.println(new String(ch,start,length));
                    
                }
            }

            @Override
            public void endElement(String uri, String localName, String qName) throws SAXException {
                // TODO Auto-generated method stub
                super.endElement(uri, localName, qName);
            }

            @Override
            public void startElement(String uri, String localName, String qName, Attributes attributes)
                    throws SAXException {
                if("售价",equals(qName)){
                    isPrice=true;
                    count++;
                }
            }    
        });
        reader.parse("book.xml");

    }

16_sax解析xml转换为arraylist

修改代码

@Test
    public void saxParse2list() {
        SAXParserFactory parserFactory=SAXParserFactory.newInstance();
        SAXParser parser=parserFactory.newSAXParser();
        XmlReader reader=parser.getXMLReader();
        reader.setContentHandler(new DefaultHandler(){
            ArrayListbookshelf=null;
            Book book=null;
            String tag=null;

            @Override
            public void characters(char[] ch, int start, int length) throws SAXException {
                if ("书名".equals(tag)) {
                    book.setTitle(new String(ch, start, length));
                }else if ("作者".equals(tag)) {
                    book.setAuther(new String(ch, start, length));
                }else if ("售价".equals(tag)) {
                    book.setPrice(new String(ch, start, length));
                }
            }
             @Override
            public void endElement(String uri, String localName, String qName) throws SAXException {
                //每次走到结束标签，就要把tag标签结束
                tag=null;
                if ("书架".equals(qName)) {
                   for(Book book1:bookshelf){
                       System.out.println(book1);
                   }
                }else if ("书".equals(qName)) {
                    //读到书结束标签 把book对象添加到集合中
                    bookshelf.add(book);
                }
            }
             @Override
            public void startElement(String uri, String localName, String qName, Attributes attributes)
                    throws SAXException {
                if ("书架".equals(qName)) {
                    //创建集合
                    bookshelf=new ArrayList();
                }else if ("书".equals(qName)) {
                    book=new Book();
}else if ("书名".equals(qName)) {
                    tag="书名";
                }else if ("作者".equals(qName)) {
                    tag="作者";
                }else if ("售价".equals(qName)) {
                    tag="售价";
                }
            }    
        });    
        reader.parse("book.xml");
    }

17_pull原理

首先，导入pull的jar包（两个JAR包）。原理其实就是sax解析

使用pull解析xml文件把xml中的内容放到集合里面

步骤：

1、  创建解析器工厂

2、  根据解析器工厂创建解析器

3、  把要操作的文件放到解析器里面

 

18_pull解析xml转换为集合

import java.awt.print.Book;
import java.io.File;
import java.io.FileInputStream;
import java.util.ArrayList;

public class PullParserTest {
    @Test
    public void pullTest() throws Exception{
        ArrayList books=null;
        Book book=null;
        boolean flag=true;
        //获取工厂
        XmlPullParserFactory parserFactory=XmlPullParseFactory.newInstance();
        //获取到xml的解析器
        XmlPullParser parser=PullParseFactory.newPullParser();
        //给解析器设置一个输入源
        //第一个参数输入流 第二个参数是文档用到的字符输入流
        parser.setInput(new FileInputStream(new File("book.xml")),"utf-8");
        //获取当前事件类型
        int eventType=parser.getEventType();
        while (eventType!=XMLPullParser.END_DOCUMENT) {
            switch (eventType) {
            case XmlPullParser.START_TAG:
            //开始标签    
                //parser.getName()获取当前事件对应的元素名字
                if("书架".equals(parser.getName())){
                    //创建一个集合
                    books=new ArrayList();
                }else if("书".equals(parser.getName())){
                    //创建一个book对象
                    book=new Book(); 
                }else if("书名".equals(parser.getName())){
                    //给book对象设置书名的属性
                    book.setTitle (parser.nextText());//parser.nextText()获取当前节点的下一个文本内容
                }else if("作者".equals(parser.getName())){
                    //给book对象设置作者的属性
                    book.setAuthor(parser.nextText());
                }else if("售价".equals(parser.getName())){
                    //给book对象设置售价的属性
                    book.setPrice(parser.nextText()); 
                }
                break;
            case XmlPullParser.END_TAG:
            //结束标签
                if("书".equals(parser.getName())){
                    //把book对象添加到集合中
                    books.add(book);
                    flag=false;
                }
            default:
                break;
            }        
            //调用parser.next方法解析下一个元素 用这个结果来更新eventtype,如果解析到文档结束，那么就会退出循环
            //如果不更新，就会是死循环了
            eventType=parser.next();
            
        }
        //遍历集合
        for (Book book1:books) {
            System.out.println(book1);
        }
    }
}

19_json介绍和解析

JSON（JavaScript Object Notation）JavaScript对象表示法，一种简单的数据格式，比xml更轻巧。JSON是JavaScript原生格式，这意味着在JavaScript中处理JSON数据不需要任何特殊的API或工具包

JSON的规则很简单：

 映射用冒号（“，”）表示，名称：值

 并列的数据之间用逗号（“，”）分隔，名称1：值1，名称2：值2

 映射的集合（对象）用大括号（“{}”）表示，（名称1：值1，名称2：值2）

 并列数据的集合（数组）用方括号（“[]”）表示

[

 {名称1：值1，名称2：值2}

 {名称1：值1，名称2：值2}

]

 元素值可具有的类型：string,number,object,srray,true,false,null

 

JSON的两种格式

写法[JSON对象1，JSON对象2····]

在数组里面有多个JSON对象，多喝JSON对象之间使用逗号隔开

具体数据的格式

[{“name”:”lucy”,”age”:20},{“name”:”mary”,”age”:30}]]

lucy

Json的解析

有很多开源的解析json框架，例如org.json,  json-lib,  gson等。

 

常见的api：

//将json字符串转成jsonobject对象

JSONObject jb=new JSONObject(String source);

Object get(String key)

Int getint(String key)

String getString(String key)

JSONArray getJSONArray(String key);

 

//将json字符串转出JSONArray对象

JSONArray jsArray =new JSONArray(String source);

package com.dhy.json;

import org.junit.Test;

public class JsonParseDeno {
    @Test
    public void jsonTest(){
        String jString="{"name":"张三","age":"20"}";
        //通过一个具有json格式的字符串就可以创建一个json对象
        JSONObject jb=new JSONObject(srting);
        //获取json对象之后 就可以通过key去取值，根据需求选择相应的getXXX方法
        //可以获取的数据类型 string int long double boolean object
        String name=Obj.getString("name");
        int age=Obj.getInt("age");
        System.out.println("名字"+name+"age"+age);
        
        String jsonArray="[{"name":"张三","age":"20"},"{"name":"李四","age":"22"}]";
        //根据一个具有json数组格式的字符串 创建一个json数组对象
        JSONArray array=new JSONArray(jsonArray);
        for (int i = 0; i < array.length(); i++) {
            //根据索引 取出每一个jsonobject
            jsonArray jsonObject=array.getJSONObject(i);
            name=jsonObject.getString("name");
            System.out.println(name);
        }
    }
}

20_内容回顾