15-基础加强2-xml(约束)&枚举&注解

<student>

<student> </student>
前边的是开始标签，后边的是结束标签

<address/>

<student id="1"> </student>

这是正确的: <student id="1"> <name>张三</name> </student>
这是错误的: <student id="1"><name>张三</student></name>

< < 小于
> > 大于
& & 和号
' ' 单引号
" " 引号

<?xml version="1.0" encoding="UTF-8" ?>
<!--文档声明必须第一行第一列 上面连空格 空行都不能有-->

<students> <!--根标签 有且只能有一个-->

    <!--学生1 通过id区分是哪个学生-->
    <student id="1">
        <name>张三</name>
        <age>23</age>
        <info>张三信息[特殊字符:小于:< 大于:">> 且:& 单引号:' 双引号:"]</info>
        <message><![CDATA[直接用CDATA域: 这里的所有东西都当做简简单单的文本，不会被转义 < > & ' "]]></message>
    </student>

    <!--学生2 id=2-->
    <student id="2">
        <name>李四</name>
        <age>24</age>
    </student>


</students>

<?xml version="1.0" encoding="UTF-8" ?>
<students> 
    <!--学生1 通过id区分是哪个学生-->
    <student id="1">
        <name>张三</name>
        <age>23</age>
    </student>

    <!--学生2 id=2-->
    <student id="2">
        <name>李四</name>
        <age>24</age>
    </student>
</students>

public class Student {
    private String id;
    private String name;
    private int age;
    
	//全参构造，无参构造，set/get, toString\
}

/**
 * 利用dom4j解析xml文件
 */
public class XmlParse {

    public static void main(String[] args) throws Exception {
        //1.获取Document对象
        //1.1先得获取一个解析器对象(SAXReader)
        SAXReader saxReader = new SAXReader();
        //1.2利用解析器把xml文件加载到内存中,并返回一个文档对象(Document对象)
        Document document = saxReader.read(new File("myxml/xml/student.xml"));

        //2.逐步获取标签对象
        //2.1 获取根标签
        Element rootElement = document.getRootElement();
        //2.2 通过根标签获取Student标签
        //方法1：elements(),返回调用者所有子标签,放在一个List中
        /*List list = rootElement.elements();
        System.out.println(list.size());//3  不仅<student>,连<aaa>也都获取到了*/
        //方法2：★ elements("标签名"),返回调用者所有指定名称子标签,放在一个List中
        /*List list = rootElement.elements("student");
        System.out.println(list.size());//2 只有所有<student>了*/
        List<Element> studentElements = rootElement.elements("student");

        //用来装学生对象
        ArrayList<Student> list = new ArrayList<>();

        //2.3 遍历集合得每一个student标签
        for (Element studentElement : studentElements) {
            // 2.4 继续读取每一个student子标签以及属性
            //2.4.1 获取id属性，以及其值
            Attribute attribute = studentElement.attribute("id");//获取id属性
            String id = attribute.getValue();//获取id属性值
            //2.4.2 获取各个子标签 以及其值(标签体内容)
            //element("标签名"): 获取调用者指定子标签(单个)
            Element nameElement = studentElement.element("name");//name标签
            String name = nameElement.getText();//name标签体内容(需要的值)
            Element ageElement = studentElement.element("age");
            String age = ageElement.getText();

            //3. 最后根据获取到的值 封装对象了
            //System.out.println(id+" "+name+" "+age);
            Student stu = new Student(id, name, Integer.parseInt(age));
            list.add(stu);
        }
        
        System.out.println(list);

    }

}

<!ELEMENT persons (person)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons SYSTEM 'persondtd.dtd'>
<!--persons根标签  SYSTEM表示引入本地约束-->

<!--引入之后再编写也有提示了-->
<persons>
    <person>
        <name>张三</name>
        <age>18</age>
    </person>
</persons>

<!DOCTYPE 根元素名称 SYSTEM ‘DTD文件的路径'>

<!DOCTYPE 根元素名称 [ dtd文件内容 ]>

<!DOCTYPE 根元素的名称 PUBLIC "DTD文件名称" "DTD文档的URL">

<!DOCTYPE 根元素名称 SYSTEM ‘DTD文件的路径'>

<!ELEMENT persons (person)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons SYSTEM 'persondtd.dtd'>
<!--方法1：引入本地约束-->

<persons>
    <person>
        <name>张三</name>
        <age>18</age>
    </person>
</persons>

<!DOCTYPE 根元素名称 [ dtd文件内容 ]>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons [
        <!ELEMENT persons (person)>
        <!ELEMENT person (name,age)>
        <!ELEMENT name (#PCDATA)>
        <!ELEMENT age (#PCDATA)>
        ]>
<!--方法2：xml文件内部引入约束-->

<persons>
    <person>
        <name>张三</name>
        <age>18</age>
    </person>
</persons>

<!DOCTYPE 根元素的名称 PUBLIC "DTD文件名称" "DTD文档的URL">

<!ELEMENT persons (person+)>
<!--person+ 1个或多个   person 只能写一个-->
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ATTLIST person id CDATA #REQUIRED>
<!ATTLIST name id CDATA #FIXED "p1"> <!-- 属性值定死为name了 -->

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons SYSTEM 'persondtd.dtd'>

<persons>
    <person id="001">
        <name>张三</name>
        <age>23</age>
    </person>

    <person id = "002">
        <name>张三</name>
        <age>23</age>
    </person>

</persons>

<?xml version="1.0" encoding="UTF-8" ?>
<!--根标签有三个固定属性-->
<schema
    xmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.whu.cn/javase"
    elementFormDefault="qualified"
>
    <!--定义persons复杂元素-->
    <element name="persons">
        <complexType>
            <!--sequence表示子标签必须按顺序来-->
            <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>

<?xml version="1.0" encoding="UTF-8" ?>

<persons
    xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
    xmlns = "http://www.whu.cn/javase"
    xsi:schemaLocation = "http://www.whu.cn/javase person.xsd"

>
    <person>
        <name>张三</name>
        <age>18</age>
    </person>
</persons>

<!--此处定义person的属性约束-->
<attribute name="id" type="string" use="required"></attribute>
<!--表示person标签必须有一个string类型的id属性-->

public enum s {   
	枚举项1,枚举项2,枚举项3;
}
注意: 定义枚举类要用关键字enum

// 定义一个枚举类，用来表示春，夏，秋，冬这四个固定值
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

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

public static void main(String[] args) {
        //1.所有枚举类都是Enum的子类
        /*不必演示了*/

        //2.我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
        System.out.println(Season.SPRING); // SPRING
        System.out.println(Season.AUTUMN); // AUTUMN
        System.out.println(Season.SUMMER); // SUMMER
        System.out.println(Season.WINTER); // WINTER

        //3.每一个枚举项其实就是该枚举的一个对象
        Season spring = Season.SPRING;//看类型 竟然就是Season枚举类型

        //4.枚举也是一个类，也可以去定义成员变量
        //sea = new Season();//报错 枚举类不可以被实例化
        Season.SPRING.name = "张三";
        System.out.println(Season.SPRING.name);//张三

        //5.枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
        /*将public String name;放在四个枚举项之前定义 会报错*/

        //6.枚举类可以有构造器，但必须是private的，它默认的也是private的。
        // 枚举项的用法比较特殊：枚举(“”);
        /*空参构造最为方便，没有也行*/
        System.out.println(Season.WINTER);//WINTER
        System.out.println(Season.WINTER.name);//冬

        //7.枚举类也可以有抽象方法，但是枚举项必须重写该方法
    }

package cn.whu.demo01;

public enum Season {
    SPRING("春"){},
    SUMMER("夏"){},
    AUTUMN("秋"),//大括号都可写可不写
    WINTER("冬");

    public String name;

    Season(String name) {
        this.name = name;
    }
}

//6.枚举类可以有构造器，但必须是private的，它默认的也是private的。
/*空参构造最为方便，没有也行*/
System.out.println(Season.WINTER);//WINTER
System.out.println(Season.WINTER.name);//冬

package cn.whu.demo01;

public enum Season {

    //核心，每一个枚举项其实就是该枚举类的一个对象
    SPRING("春"){
        //如果枚举类中有抽象方法，那么在枚举项中必须全部重写
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },
    SUMMER("夏"){
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },
    AUTUMN("秋") {
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },//大括号都可写可不写
    WINTER("冬") {
        @Override
        public void show() {
            System.out.println(this.name);
        }
    };

    public String name;

    Season(String name) {
        this.name = name;
    }

    public abstract void show();
}

//7.枚举类也可以有抽象方法，但是枚举项必须重写该方法
Season.WINTER.show();//冬

public static void main(String[
        //String name()	获取枚举项的名称   
        String name = Season.SPRING
        System.out.println(name); 
    }

SPRING

//int ordinal()	返回枚举项在枚举类中的索引值    
/*枚举的好处 自动有0 1 2 3... 索引值*/       
int index1 = Season.SPRING.ordinal
int index2 = Season.SUMMER.ordinal
int index3 = Season.AUTUMN.ordinal
int index4 = Season.WINTER.ordinal
System.out.println(index1);//【0】  
System.out.println(index2);//【1】  
System.out.println(index3);//【2】  
System.out.println(index4);//【3】

//int compareTo(E o)	比较两个枚举项，返回的是索引值的差值
int result = Season.SPRING.compareTo(Season.WINTER); //0-3
System.out.println(result);//-3 
result = Season.SPRING.compareTo(Season.SPRING);
System.out.println(result);//0

//String toString()	返回枚举常量的名称
String s = Season.SPRING.toString();
System.out.println(s);//SPRING 
/*一般用name方法就行了，toString()方法一般不直接用二十打印类对象时自动调用的
也就是说，我们打印枚举项时，打印的不是地址值，而是变量名称*/

System.out.println(Season.SPRING);//SPRING
System.out.println(Season.SPRING.toString());//SPRING

//static T valueOf(Class type,String name)	获取指定枚举类中的指定名称的枚举值
Season spring = Enum.valueOf(Season.class, "SPRING");//有点反射的意思了(可以动态获取了)
System.out.println(spring);//SPRING
System.out.println(spring == Season.SPRING);//true

//values()	获得所有的枚举项(名称)
Season[] values = Season.values();
for (Season value : values) {
    System.out.println(value);
}

package cn.whu.myanno1;


@SuppressWarnings(value = "all") //压制(忽略)类中所有的警告
public class Zi extends Fu {


    @Override //此注解告诉我们的编译器这个方法是重写了父类中的show方法 那么我们在进行方法定义的时候，就需要按照重写方法的要求进行方法定义
    //改名字(父类没有此名方法)  改参数   就都会报错了
    public void show() {
        super.show();
    }


    @Deprecated //表示这是一个过时的方法
    public void method() {
        System.out.println("method");
    }

    @SuppressWarnings(value = "all") //压制(忽略)本方法中所有警告 (eg: 变量未被使用过的警告)  写在类上面就压制了类中所有的警告
    public void function() {
        int a = 10;
        int b = 20;
        /*System.out.println(a);
        System.out.println(b);*/
    }


    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

public @interface 注解名称 {

  		public 属性类型 属性名() default 默认值 ;

  }

package cn.whu.myanno1;


//创建一个注解类
public @interface Anno1 {
    //可以给注解类定义各种属性
    //属性访问修饰符只能是public,可以省略不写

    //定义一个基本类型的属性
    int a() default 23; //public省略不写

    //定义一个String类型的属性
    public String name();//不给默认值

    //定义一个Class类型的属性
    public Class clazz() default Anno2.class;

    //定义一个注解类型的属性
    public Anno2 anno() default @Anno2;

    //定义一个枚举类型的属性
    public Season season() default Season.SPRING;

    //以上类型的一维数组
    //eg: int[]
    public int[] arr() default {1,2,3,4,5};
    //eg: 枚举数组
    public Season[] seasons() default {Season.SPRING,Season.SUMMER,Season.AUTUMN,Season.WINTER};
}

package cn.whu.myanno1;

public @interface Anno2 {
}

//使用我们自定义的注解Anno1
//发现报错，原来注解内有属性没有给出默认值，我们使用注解时就得手动给出默认值
@Anno1(name="whu")  //执行不会出错 编译器出bug可能瞎报
public class AnnoDemo {

}

public @interface Anno1 {

    public String name() default "whu";//不给默认值

    public String value();
    //仅仅value属性没有初始值,也就表示使用注解时也只用给value提供一个值就行了

}

//@Anno1(value = "abc")
@Anno1("abc") //只用给名为value的属性赋值时，可以简写
public class AnnoDemo {

}

package cn.whu.demo1;

public class UseTest {

    //只执行用@Test注解了的2个方法  不执行第一个没@Test注解的方法


    public void show(){
        System.out.println("UseTest....show....");
    }

    @Test
    public void method(){
        System.out.println("UseTest....method....");
    }

    @Test
    public void function(){
        System.out.println("UseTest....function....");
    }

}

package cn.whu.demo1;


import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

//表示Test注解的存活时间
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Test {
}

package cn.whu.demo1;

import java.lang.reflect.Method;

public class ReflectRun {

    public static void main(String[] args) throws Exception {
        //1.通过反射获取UserTest类的字节码文件对象 (也就是Class对象)
        Class clazz = Class.forName("cn.whu.demo1.UseTest");

        //2.通过反射获取这个类里面的所有方法
        Method[] methods = clazz.getDeclaredMethods();

        //3.下面要执行方法，就先创建一个对象
        UseTest useTest = (UseTest) clazz.newInstance();//空参构造 简写形式 跳过了获取空参构造的那步

        //4.遍历方法
        for (Method method : methods) {
            //4.1判断方法有无@Test注解
            /*isAnnotationPresent(Class<? extends Annotation> annotationClass)
              判断当前方法上是否有指定的注解。
              参数：注解的字节码文件对象
              返回值：布尔结果。  true 存在  false 不存在*/
            boolean b = method.isAnnotationPresent(Test.class);
            if(b) method.invoke(useTest);
        }
    }

}

import java.lang.annotation.*;

// @Target(位置1,位置2,位置3) 指定注解可以使用的位置
// ElementType.FIELD: 成员变量
// ElementType.TYPE: 类
// ElementType.METHOD: 方法
@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})
// @Retention(生存周期)
// 不写,默认仅仅能在.java文件中存在 .class文件中不存在, 编译好后就消失了
// RetentionPolicy.RUNTIME 运行时存在(.class文件中存在)
@Retention(RetentionPolicy.RUNTIME)
//@Inherited 指定该注解可以被继承
@Inherited
public @interface Anno {

}

@Anno
public class Person {
}

public class Student extends Person{
    public void show(){
        System.out.println("Student........show.........");
    }
}

public class Demo {
    public static void main(String[] args) throws Exception {
        //获得到Student类的字节码文件对象
        Class clazz = Class.forName("cn.whu.myanno3.Student");

        //获取注解
        boolean b = clazz.isAnnotationPresent(Anno.class);//有没有Anno注解
        System.out.println(b);//true Student确实继承了父类Person的注解 [也可以反向推出注解Anno肯定被@Inherited标注了]
    }
}