Java学习笔记day26-xml&枚举&注解

XML

​ XML是一种可扩展的标记语言；标签语言是通过标签来描述数据的一门语言；可扩展是指标签的名字是可以自定义的。

作用：

• 用于存储数据和传输数据
• 作为软件的配置文件

XML标签规则

XML语法规则

• XML文件的后缀名：xml
• 文档声明必须是第一行第一列
  • <?xml version="1.0" encoding= "UTF-8" standalone= "yes" ?>
  • version：该属性是必须存在的
  • encoding：该属性不是必须的，表示xml文件的字符编码方式
  • standalone：该属性不是必须的，描述XML文件是否依赖其他的xml文件，取值为yes/no
• 必须存在一个根标签，有且只能有一个
• XML文件中可以定义注释信息
• XML文件中可以存在以下特殊字符
  • 
• XML文件中可以存在CDATA区<![CDATA[ ...内容... ]]>

<?xml version="1.0" encoding="UTF-8" ?>
<!--注释的内容-->
<!--本xml文件用来描述多个学生信息-->
<students>
    <!--第一个学生信息-->
    <student id="1">
        <name>小花</name>
        <age>18</age>
        <info>学生&lt;&gt;的信息</info>
        <!--内容可以是任意内容-->
        <message><![CDATA[ 内容 ]]></message>
    </student>
    <!--第二个学生信息-->
    <student id="2">
        <name>小豆</name>
        <age>16</age>
    </student>
</students>

dom4j解析xml文件

​ 首先将dom4j的jar包导入libs文件中

package xmlparse;

public class Student {
    private String id;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package xmlparse;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

public class XmlParse {
    public static void main(String[] args) throws DocumentException {
        //获取一个解析器对象
        SAXReader saxReader  = new SAXReader();
        //利用解析器把xml文件加载到内存中，并返回一个文档对象
        Document read = saxReader.read(new File("day26\\src\\xml\\student.xml"));
        //获取到根标签
        Element rootElement = read.getRootElement();
        //通过根标签来获取student标签
        //elements()：可以获取调用者所有的子标签，会把这些标签放到一个集合中返回
        //List list = rootElement.elements();
        //elements("标签名")：可以获取调用者所有的指定子标签，会把这些标签放到一个集合中返回
        List<Element> list = rootElement.elements("student");
        //System.out.println(list.size());
        //用来装学生对象
        ArrayList<Student> listStu = new ArrayList<>();
        //遍历集合，得到每一个student标签
        for (Element element : list) {
            //element依次表示每一个student标签
            //获取id这个属性
            Attribute attribute = element.attribute("id");
            //获取id的属性值
            String id = attribute.getValue();
            //获取name标签
            //element("标签名")：获取调用者指定的子标签
            Element nameElement = element.element("name");
            //获取这个标签的标签体内容
            String name = nameElement.getText();
            //获取age标签
            Element ageElement = element.element("age");
            String age = ageElement.getText();
//            System.out.println(id);
//            System.out.println(name);
//            System.out.println(age);
            Student st = new Student(id,name,Integer.parseInt(age));
            listStu.add(st);
        }
        for (Student student : listStu) {
            System.out.println(student);
        }
    }
}

DTD约束

• 能在xml中引入约束文档
• 能够简单阅读约束文档
• 根据约束编写xml文档

编写dtd文件persondtd.dtd
<!ELEMENT persons (person)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>

在xml中引入本地dtd约束
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons SYSTEM 'persondtd.dtd'>
<persons>
    <person>
        <name>小虎</name>
        <age>15</age>
    </person>
</persons>

引入DTD约束的三种方法

• 引入本地dtd
• 在xml文件内部引入
• 引入网络dtd

在xml文件内部引入
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons[
        <!ELEMENT persons (person)>
        <!ELEMENT person (name,age)>
        <!ELEMENT name (#PCDATA)>
        <!ELEMENT age (#PCDATA)>
        ]>
<persons>
    <person>
        <name>小虎</name>
        <age>15</age>
    </person>
</persons>

引入网络dtd
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE person PUBLIC "dtd文件的名称" "dtd文档的URL">
<persons>
    <person>
        <name>小虎</name>
        <age>15</age>
    </person>
</persons>

DTD语法规则

定义元素：

定义属性：

定义一个属性的格式为：<!ATTLIST 元素名称 属性名称 属性的类型 属性的约束>

栗子：<!ATTLIST person id CDATA #FIXED "p1">

属性的类型：

CDATA类型：普通字符串

属性的约束：

#REQUIRED：必须的

#IMPLIED：属性不是必须的

#FIXED value：属性值是固定的

schema约束

schema和dtd的区别

1. schema约束文件也是一个xml文件，符合xml的语法，这个文件的后缀名.xsd
2. 一个xml中可以引用多个schema约束文件，多个schema使用名称空间区分(名称空间类似于java包名)
3. dtd里面元素类型的取值比较单一常见的是PCDATA类型，但是在schema里面可以支持很多个数据类型
4. schema语法更加复杂，Schema文件用来约束一个xml文件，同时也被别的文件约束着

案例

1. 创建一个文件，这个文件后缀名为.xsd;
2. 定义文档声明
3. schema文件的根标签为：
4. 在中定义属性：xmlns=http://www.w3.org/2001/XML.Schema
5. 在中定义属性：targetNamespace=唯一的URL地址。指定当前这个schema文件的名称空间
6. 在中定义属性：elementFormDefault=“qualified”,表示当前schema文件是一个质量良好的文件
7. 通过element定义元素
8. 判断当前元素是简单元素还是复杂元素

编写schema约束
<?xml version="1.0" encoding="UTF-8" ?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.ahua.cn/javase"
        elementFormDefault="qualified"
>
    <!--    定义persons复杂元素-->
    <element name="persons">
        <complexType>
            <sequence>
                <!--定义person复杂元素-->
                <element name="person">
                    <complexType>
                        <sequence>
                            <!--定义name和age-->
                            <element name="name" type="string"></element>
                            <element name="age" type="string"></element>
                        </sequence>
                    </complexType>
                </element>
            </sequence>
        </complexType>
    </element>
</schema>

引入schema

引入schema约束
<?xml version="1.0" encoding="UTF-8" ?>
<persons
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.ahua.cn/javase"
        xsi:schemaLocation="http://www.ahua.cn/javase person.xsd"
>
    <person>
        <name>阿三</name>
        <age>13</age>
    </person>
</persons>

Schema定义属性

			   <!--定义person复杂元素-->
               <element name="person">
                    <complexType>
                        <sequence>
                            <!--定义name和age-->
                            <element name="name" type="string"></element>
                            <element name="age" type="string"></element>
                        </sequence>
                        在person下的sequence标签外，complexType标签内
                        <attribute name="id" type="string" use="required"></attribute>
                        
                    </complexType>
                </element>

枚举

概述

​ 指将变量的值一一列举出来，变量的值只限于列举出来的值的范围内。

定义格式：

public enum s{
	枚举项1,枚举项2,枚举项3;
}

练习

​ 定义一个枚举类，用来表示春，夏，秋，冬这四个固定值；

package meiju;

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

枚举的特点

1. 所有枚举类都是Enum的子类
2. 我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
3. 每一个枚举项其实就是该枚举的一个对象
4. 枚举也是一个类，也可以去定义成员变量
5. 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的
6. 枚举类可以有构造器，但必须是private的，它默认的也是private的
7. 枚举类也可以有抽象方法，但是枚举项必须重写该方法

枚举的方法

方法名	说明
String name()	获取枚举项的名称
int ordinal()	返回枚举项在枚举类中的索引值
int compareTo(E o)	比较两个枚举项在枚举类中的索引值
String toString()	返回枚举常量的名称
static T valueOf(Class type,String name)	获取指定枚举类中的指定名称的枚举值
values()	获得所有的枚举项

public class EnumTest {
    public static void main(String[] args) {
        //获取枚举项的名称
        String name = Season.SPRING.name();
        System.out.println(name);
        System.out.println("----------------------");
        //返回枚举项在枚举类中的索引值
        int index1 = Season.SPRING.ordinal();
        int index2 = Season.SUMMER.ordinal();
        int index3 = Season.AUTUMN.ordinal();
        int index4 = Season.WINTER.ordinal();
        System.out.println(index1+" "+index2+" "+index3+" "+index4);
        System.out.println("----------------------");
        //比较两个枚举项，返回的是索引值的差值
        int result = Season.SPRING.compareTo(Season.WINTER);
        System.out.println(result);
        System.out.println("----------------------");
        //返回枚举常量的名称
        String s = Season.SPRING.toString();
        System.out.println(s);
        System.out.println("----------------------");
        //获取指定枚举类中的指定名称的枚举值
        Season summer = Enum.valueOf(Season.class, "SUMMER");
        System.out.println(summer);
        System.out.println(Season.SUMMER == summer);
        System.out.println("----------------------");
        //获得所有的枚举项
        Season[] values = Season.values();
        for (Season value : values) {
            System.out.println(value);
        }
    }
}

注解

注解的作用：对程序进行标注和解释

注解名	说明
@Override	描述子类重写父类的方法
@Deprecated	描述方法过时
@SuppressWarnings	压制警告

自定义注解

格式：

public @interface 注解名称{
public 属性类型 属性名 () default 默认值;
}
示例：
public @interface Test{
public int a () default 23;
}

示例：

package anno;

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

package anno;

public @interface Anno2 {
}

package anno;

public @interface Anno1 {
    //定义一个基本类型的属性
    int a () default 23;
    //定义一个String类型的属性
    public String name ();
    //定义一个Class类型的属性
    public Class clazz() default Anno2.class;
    //定义一个注解类型的属性
    public Anno2 anno() default @Anno2;
    //定义一个枚举类型的属性
    public Season season() default Season.SPRING;
    //以上类型的一维数组
    public int[] arr() default {1,2,3,4,5};
    public Season[] seasons() default {Season.SPRING,Season.SUMMER};
}

package anno;

//在使用注解的时候，如果注解里的属性没有指定默认值
//那么我们就需要手动给出注解属性的设置值
@Anno1(name = "ahua")
public class AnnoTest {
}

元注解

元注解：就是描述注解的注解

元注解名	说明
@Target	指定了注解能在哪里使用
@Retention	可以理解为保留时间（生命周期）
@Inherited	表示修饰的自定义注解可以被子类继承
@Documented	表示该自定义注解，会出现在API文档里面

@target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
//指定注解是用的位置，成员变量，类，方法
@Retention(RetentionPolicy.RUNTIME)
//指定该注解的存活时间
@Inherited
//指定该注解可以被继承