20200807（反射机制和XML，正则表达式，懒汉和饿汉模式）

一.反射机制

1.定义

是指在运行状态中，动态获取信息以及动态调用对象方法的功能

2.反射的3个动态性质

1.运行时生成对象实例
2.运行时调用方法
3.运行时更改属性

3.通过反射实现的功能

1.在运行时判断任意一个对象所属的类
2.在运行构造任意一个类的对象
3.在运行时判断任意一个类具有的方法和属性
4.在运行时调用任意一个对象的方法

4.java反射常用API

1.Class类：可以获取累的属性，方法等内容信息
2.Field类：表示类的属性，可以获取和设置类中属性的值
3.Method类：表示类的方法，可以获取类中方法的信息或执行方法
4.Constructor类:表示类的构造方法

5.反射的应用

1.获取类的信息

• 获取Class对象Student p=new Student（）
  （1）.调用对象的getClass（）方法：Class cla=p.getClass();
  (2).调用class属性：Class cla=Student.class;
  (3).使用Class类中的forName（）静态方法：Class cla=Class.forName（“com.pb.jabv.reflection.Studdent”）

• 从Class对象获取信息
  （1）.Constructor getDeclaredConstructors():返回类的构造方法
  （2）.Method get的elaredMethod（）：返回Class对象所包含类的指定方法
  （3）.Field getDelaredField（）：返回Class对象所包含类的指定属性
  2.创建对象
  使用Class对象的newInstance（）方法创建给Class对象对应类的实例
  3.访问类的属性
  void setAccessible（）：对获取到的属性设置访问权限
  4.访问类的方法
  Object invoke（Object obj，Objec args）：met1.invoke（p，“jack”）
  5.使用Array类动态创建和访问数组

/**
 * @author Oldhu
 * @date @Date 2020/8/6
 * @des
 */
public class Student {
    public int stuId;
    private String stuName;
    String gender;

    private Student() {
    }

    private Student(int stuId, String stuName, String gender) {
        this.stuId = stuId;
        this.stuName = stuName;
        this.gender = gender;
    }

    private int getStuId() {
        return stuId;
    }

    private void setStuId(int stuId) {
        this.stuId = stuId;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuId=" + stuId +
                ", stuName='" + stuName + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author Oldhu
 * @date @Date 2020/8/6
 * @des
 */
public class TestConstructor {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Student> c=Student.class;
        Constructor<Student>sClass=
                c.getDeclaredConstructor(int.class,String.class,String.class);
        sClass.setAccessible(true);

        Student s=sClass.newInstance(2,"马云","男");
        System.out.println(s);

    }

}

import java.io.FileOutputStream;
import java.lang.reflect.Field;

/**
 * @author Oldhu
 * @date @Date 2020/8/6
 * @des
 */
public class TestField {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        Student s= TestStudent.getStudent();
        Class<Student> c=Student.class;
        Field stuId=c.getField("stuId");
        stuId.set(s,11);
        Field stuName=c.getDeclaredField("stuName");
         stuName.setAccessible(true);
         stuName.set(s,"跑跑");
       Field[]fields=c.getDeclaredFields();
       for(Field field:fields){
           field.setAccessible(true);
           System.out.println(field.get(s));
       }
        System.out.println(s.toString());
    }
}

import sun.reflect.misc.ConstructorUtil;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author Oldhu
 * @date @Date 2020/8/6
 * @des
 */
public class TestStudent<T> {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException {
       /* TestStudent s=new TestStudent();
        //第二种获取类对象的另一种方法
        Class<?extends TestStudent> sC=s.getClass();
        //第三种获取类对象
        Class stu=Class.forName("Student");

        //1.获取类对象
        //Class<Student> stu=Student.class;
        //2.通过类对象获取构造方法
        Constructor<Student> con=stu.getDeclaredConstructor();
        con.setAccessible(true);
        //3.通过构造方法创建对象
        Student student=con.newInstance();*/

       //Student student=getStudent();
        TestStudent ts=new TestStudent();
        //String  student=ts.getStudent(Student);
        Student student= (Student) ts.getObject(Student.class);
        student.stuId=1;
        student.gender="nan";
        student.setStuName("wangsicong");
        System.out.println(student);

    }
    //public T getObject(Class<Student> classPath) throws ClassNotFoundException
    public T getObject(Class<T> tClass){
        T t=null;
        try {

            //Class<T> tClass= (Class<T>) Class.forName(classPath);
            Constructor<T> c=tClass.getDeclaredConstructor();
            c.setAccessible(true);
            t=c.newInstance();


        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return t;
    }
    public static Student getStudent(){
        //
        Class<Student> s=Student.class;
        Student stu=null;
        try {
            Constructor<Student> c = s.getDeclaredConstructor();
            c.setAccessible(true);
            stu = c.newInstance();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return stu;
    }

}

二.XML

XML(EXtensible Markup Language）：可扩展标记语言

1.特点

1.XML与操作系统、编程语言的开发平台无关XML与操作系统、编程语言的开发平台无关
2.实现不同系统之间的数据交换

2.作用

数据交互
配置应用程序和网站
Ajax基石
Java的各种企业级框架都是用XML作为其配置文件的文档格式

3.XML文档结构

1.XML声明：<?xml version="1.0" encoding="GB2312" standalone="no"?>
2.标签：
3.根元素：有且仅有一个：
4.元素：由开始标签，元素内容和结束标签组成
5.属性：<元素名 属性名=“属性值”>
6.XML中的注释：

4.XML编写注意事项

• 所有XML元素都必须有结束标签
• XML标签对大小写敏感
• XML必须正确的嵌套
• 同级标签以缩进对齐
• 元素名称可以包含字母、数字或其他的字符
• 元素名称不能以数字或者标点符号开始
• 元素名称中不能含空格

5.使用DOM解析XML

读取XML配置文件信息
1.Document对象：代表整个XML文档，主要方法有：getElementByTagName（String）：返回一个NodeList对象，包含所有指定标签名称的标签
getDocumentElement（）：返回一个代表这个DOM树的根节点的Element对象
2.NodeList对象：包含一个或者多个节点的列表。
getLength（）：返回列表的长度
item（int index：返回指定位置的Node对象）
3.Node对象：代表文档树中的一个抽象节点；
getChildNodes：此节点包含的所有子节点的NodeList
getFirstChild（）：如果节点存在子节点，则返回第一个子节点
getLastChild（）：如果节点存在子节点，则返回最后一个子节点
4.Element对象：代表XML文档的标签元素，继承Node
getAttribute（String sttributename）：返回标签中指定属性名称的属性的值
getElementByTagName（String name ）：返回具有指定标记名称的所有后代Elements的NodeList

<?xml version="1.0" encoding="GB2312" standalone="no"?>
<phoneInfo>
    <brand name="华为">
        <type name="U8650"/>
        <type name="HW123"/>
        <type name="HW321"/>
    </brand>
    <brand name="苹果">
        <Type name="iPhone4"/>
    </brand>
<brand name="三星">
<type name="note20"/>
</brand>
</phoneInfo>

 //得到DOM解析器的工厂实例
        DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
        //从DOM工厂获得DOM解析器
        DocumentBuilder db=dbf.newDocumentBuilder();
        //解析XML文档，得到一个Document对象，即DOM树
        Document doc= (Document) db.parse("C:\\Users\\86157\\Desktop\\1\\收藏信息.xml");
        //得到所有Brand节点列表信息
        NodeList brandList=((org.w3c.dom.Document) doc).getElementsByTagName("Brand");

import org.w3c.dom.*;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author Oldhu
 * @date @Date 2020/8/7
 * @des
 */
public class TestXML {
    Document document;

    public void setDocument(String xmlPath) {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {
            DocumentBuilder builder = factory.newDocumentBuilder();
            document = builder.parse(xmlPath);
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) throws Exception {
        //得到DOM解析器的工厂实例,
        /*Document document;
        DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();//抽象类
        DocumentBuilder builder=factory.newDocumentBuilder();

        document=builder.parse("phone_info.xml");
        NodeList brands= document.getElementsByTagName("brand");
        Node item=brands.item(0);

        *//*Element e= (Element) item;
        System.out.println(e.getAttribute("name"));*//*
        for (int i = 0; i < brands.getLength() ; i++) {
            Node n=brands.item(i);
            if(n instanceof Element){
                Element e=(Element) n;
                System.out.println(e.getAttribute("name"));
            }

        }*/
        TestXML xml = new TestXML();
        xml.setDocument("phone_info.xml");
        //根节点
        NodeList brands = xml.document.getElementsByTagName("brand");
        //每一个节点
        Node item = brands.item(0);
        Node item2 = brands.item(1);

        //元素节点
        Element e = (Element) item;
        Element e2 = (Element) item2;

        //文本节点
        NodeList hwTypes = e.getChildNodes();
        NodeList pgTypes = e2.getChildNodes();
        //添加手机信息
        //获取根节点
        Node root=xml.document.getElementsByTagName("phoneInfo").item(0);

        Element sx=xml.document.createElement("brand");
        sx.setAttribute("name","三星");

        Element sxType=xml.document.createElement("type");
        sxType.setAttribute("name","note20");
        //建立标签中间的关系
        sx.appendChild(sxType);
        root.appendChild(sx);
        //建好节点信息
        //保存更改，需要转换器 Transformer
        TransformerFactory tf=TransformerFactory.newInstance();
        Transformer t= tf.newTransformer();

        //设置字符编码
        t.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
        //设置缩进
        //tf.setAttribute("indent-number",4);
        t.setOutputProperty(OutputKeys.INDENT,"yes");

        DOMSource source=new DOMSource(xml.document);
        //输出路径
        FileOutputStream fos=new FileOutputStream("phone_info.xml");
        StreamResult sr=new StreamResult(fos);
        t.transform(source,sr);
        /*进行遍历
        System.out.println(e.getAttribute("name"));
        for (int i = 0; i < hwTypes.getLength(); i++) {
            Node n = hwTypes.item(i);
            if (n instanceof Element) {
                Element type = (Element) n;
                //System.out.println(type.getTextContent());
                //Node firstChid=type.getFirstChild();
                System.out.println(type.getAttribute("name"));
            *//*if(firstChid instanceof  Text){
                Text t= (Text) firstChid;
                System.out.println(t.getWholeText().trim());
            }*//*
            }
        }
        System.out.println(e2.getAttribute("name"));
        for (int i = 0; i < pgTypes.getLength(); i++) {
            Node n = pgTypes.item(i);
            if (n instanceof Element) {
                Element type = (Element) n;
                System.out.println(type.getAttribute("name"));
            }
            System.out.println();
        }*/
    }
}

三.正则表达式

import com.sun.org.apache.xerces.internal.impl.xpath.regex.Match;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Oldhu
 * @date @Date 2020/8/7
 * @des 正则表达式
 */
public class TestRegex {
    public static void main(String[] args) {
        String s="13036951256";//匹配130开头的手机号
        Pattern p=Pattern.compile("^1(3|8)(?<a>\\d{9})");//匹配规则
        Matcher m=p.matcher(s);
        if(m.matches()){
            System.out.println(m.group("a"));
        }
    }
}

四 .懒汉模式和饿汉模式

/**
 * @author Oldhu
 * @date @Date 2020/8/6
 * @des  单例模式：一个系统中，只允许存在该类的一个对象
 */
public class Teacher {

    private static Teacher t=null;//本类的私有对象
    private Teacher(){
        //不允许随意创建对象,懒汉模式

    }
    /*//懒汉模式
    public synchronized static Teacher getInstance(){
        if(t==null){
            t=new Teacher();
        }
        return t;
    }*/
    //饿汉模式
    static {
        t=new Teacher();
    }
    public static Teacher getInstance(){
        return t;
    }
}