反射和枚举

/**
     * 类的加载概述：
     *       当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化
     * 加载
     *   就是指将class文件读入内存，并为之创建一个class对象，任何类被使用时系统都会建立一个class对象
     * 连接
     *      验证：是否有正确的内部结构，并和其他类协调一致
     *     准备： 负责为类的静态成员分配内存，并设置默认初始化值
     *     解析： 将类的二进制数据中的符号引用替换为直接引用
     * 初始化
     *      就是初始化步骤
     * 
     * 加载时机
     *      创建类的实例
     *     访问类的静态变量，或者为静态变量赋值
     *     调用类的静态方法
     *  使用反射方法来强制创建某个类或接口对应的java.lang.class对象
     *  初始化某个类的子类
     *  直接使用java.exe命令来运行某个主类
     */

/**
     * 类加载器概述：负责将.class文件加载到内存中，并为之生成对应的Class对象
     * 反射概述：java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法
     *           对于任意一个对象，都能够调用它的任意一个方法和属性
     *          这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制
     *     想要解剖一个类，必须先要获取到该类的字节码文件对象
     *     而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象
     * 
     * 三种方法：
     *     Object类的getClass()方法，判断两个对象是否是一个字节码文件
     *     静态属性class，锁对象
     *     Class类中静态方法forName()，读取配置文件
     */

/**
     * 通过反射获取带参的构造方法
     * 
     * Class类的newInstance()方法是使用该类的无参的构造函数创建对象，如果一个类没无参的构造函数
     * 就不能这样创建，可以调用Class类的getConstructor
     * (String.class,int.class)方法获取一个指定的构造函数然后在调用Construction类的newInstance
     * ("张三",20)方法创建对象
     * @param args
     */
    public static void main(String[] args) throws Exception{
        Class clazz = Class.forName("day27.Person");    //加载class对象
        //Person p = (Person) clazz.newInstance();    //通过无参构造创建对象
        //System.out.println(p);
        
        Constructor c = clazz.getConstructor(String.class,int.class);    //获取有参构造
        Person p = (Person) c.newInstance("张三",20);            //通过有参构造创建对象
        System.out.println(p);
        
    }

/**通过反射获取成员变量并使用
     * 
     * Class.getFiled(String)方法可以获取类中的指定字段（可见的）
     * 如果是私有的可以用getDeclaedFiled("name")方法获取，通过set(obj,"李四")方法可以设置指定对象上该字段的值
     * 如果是私有的需要调用setAccessible(true)设置访问权限，用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值
     */
    public static void main(String[] args) throws Exception{
        Class clazz = Class.forName("day27.Person");     //加载class对象
        Constructor c = clazz.getConstructor(String.class,int.class);    //获取有参构造
        Person p = (Person) c.newInstance("张三",20);            //通过有参构造创建对象
        
        //Field f = clazz.getField("name");        //获取姓名字段
        //f.set(p, "李四");                            //修改姓名值
        
        Field f = clazz.getDeclaredField("name"); //暴力反射获取字段
        f.setAccessible(true);        //去除私有权限
        f.set(p, "李四");
        
        System.out.println(p);
    }

/**
     * 通过反射获取方法并使用
     * 
     * Class.getMethod(String,Class...)和getDeclaredMethod(String,Class..)方法可以获取
     * 类中的指定方法，调用invoke(Objct,Object...)可以调用该方法，Class.getMethod("eat") invoke(obj)
     * Class.getMethod("eat",int.class) invoke(obj,10)
     */
    public static void main(String[] args) throws Exception{
        Class clazz = Class.forName("day27.Person");     //加载class对象
        Constructor c = clazz.getConstructor(String.class,int.class);    //获取有参构造
        Person p = (Person) c.newInstance("张三",20);            //通过有参构造创建对象
        
        Method m = clazz.getMethod("eat");                //获取Person类中的eat方法
        m.invoke(p);
        
        Method m2 = clazz.getMethod("eat", int.class);    //获取有参的eat方法
        m2.invoke(p, 2);
    }

/**
     * 通过反射越过泛型检查
     * 
     * ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据
     * 泛型只在编译期有效，在运行期会被擦除掉
     */
    public static void main(String[] args) throws Exception{
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(22);
        Class clazz = Class.forName("java.util.ArrayList"); //获取字节码对象
        Method m = clazz.getMethod("add", Object.class);    //获取add方法
        m.invoke(list, "zhangsna");
        
        System.out.println(list);
    }

public class Tool {
    /**
     * 此方法可将obj对象中名为propertyName的属性值设置为value
     */
    public void setProperty(Object obj,String propertyName,Object value) throws Exception{
        Class clazz = obj.getClass();    //获取字节码对象
        Field f = clazz.getDeclaredField(propertyName);    //暴力反射获取字段
        f.setAccessible(true);    //去除权限
        f.set(obj, value);
    }

}
------------------------------------------------------------
    /**
     * public void setProperty(Object obj,String propertyName,Object value){},
     * 此方法可将obj对象中名为propertyName的属性值设置为value
     */
    public static void main(String[] args) throws Exception {
        Student s = new Student("张三", 23);    
        System.out.println(s);    //Student [name=张三, age=23]
        
        Tool t = new Tool();
        t.setProperty(s, "name", "李四");
        System.out.println(s);    //Student [name=李四, age=23]
    }

/**
     * 已知一个DemoClass类
     * 写一个Properties格式的配置文件，配置类的完整名称
     * 读取这个Properties配置文件，获取类的完整名称并加载这个类，用反射的方式运行run方法
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new FileReader("config.Properties"));
        Class clazz = Class.forName(br.readLine());
        
        DemoClass dc = (DemoClass) clazz.newInstance();
        dc.run();
    }

动态代理

public interface User {
    public void add();
    public void delete();
}
----------------------------------------------
public class Userimp implements User {

    @Override
    public void add() {
        System.out.println("新增方法");
    }

    @Override
    public void delete() {
        System.out.println("删除方法");
    }

}
----------------------------------------------------------

public class MyInvocatioHandler implements InvocationHandler {
    private Object target;
    
    public MyInvocatioHandler(Object target){
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("权限校验");
        method.invoke(target, args);        //执行被代理target对象的方法
        System.out.println("日志校验");
        return null;
    }

}

--------------------------------------------

/**
     * @param args
     */
    public static void main(String[] args) {
        Userimp ui = new Userimp();
        ui.add();
        ui.delete();
        System.out.println("------------------");
        //现在想在add和delete方法中加入权限校验和日志记录，不修改Userimp里的方法
        MyInvocatioHandler m = new MyInvocatioHandler(ui);
        User u = (User)Proxy.newProxyInstance(ui.getClass().getClassLoader(), 
                ui.getClass().getInterfaces(), m);
        u.add();
        u.delete();
        
    }

public class Demo_Template {

    /**
     * 模板设计模式
     *     定义一个算法的骨架，而将具体的算法延迟到子类中来实现
     *     优点：再定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
     *     缺点：如果算法骨架有修改的话，则需要修改抽象类
     */
    public static void main(String[] args) {
        Demo d = new Demo();
        System.out.println(d.getTime());

    }

}

abstract class GetTime{
    public final long getTime(){    //final 不让子类重写
        long start = System.currentTimeMillis();
        //需要测试的代码
        code();
        long end = System.currentTimeMillis();
        return end-start;
    }
    public abstract void code(); //定义为abstract方法，目的让子类重写
}

class Demo extends GetTime{

    @Override
    public void code() {
        //这样测试的代码可以自己任意书写
        int i=0;
        while(i<10000){
            System.out.println("#");
            i++;
        }
    }
    
}

 枚举

public class Demo_Enum {

    /**
     * 枚举
     *     指将变量的值一一列出来，变量的值只限于列举出来的值的范围内（如：一周只有7天，一年只有12个月）
     */
    public static void main(String[] args) {
        //demo();
        //demo2();
        
        //有抽象方法
        Week3 mon = Week3.MON;
        mon.show();
        
    }
    
    /**
     * 无参
     */
    public static void demo(){
        Week mon = Week.MON;
        Week tue = Week.TUE;
        Week wed = Week.WED;
    }
    /**、
     * 有参
     */
    public static void demo2(){
        Week2 mon = Week2.MON;
        System.out.println(mon.getName());
    }

}
------------------------------------------------------------------
public class Week {

    public static final Week MON = new Week();
    public static final Week TUE = new Week();
    public static final Week WED = new Week();
    
    private Week(){}        //私有构造，不让其他类创造本类对象

}
--------------------------------------------------------------------------
public class Week2 {
    public static final Week2 MON = new Week2("星期一");
    public static final Week2 TUE = new Week2("星期二");
    public static final Week2 WED = new Week2("星期三");
    
    private String name;
    private Week2(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
    
}
--------------------------------------------------------------------------
public abstract class Week3 {
    public static final Week3 MON = new Week3("星期一"){
        public void show(){
            System.out.println("星期一");
        }
    };
    public static final Week3 TUE = new Week3("星期二"){
        public void show(){
            System.out.println("星期二");
        }
    };
    public static final Week3 WED = new Week3("星期三"){
        public void show(){
            System.out.println("星期三");
        }
    };
    
    private String name;
    private Week3(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }    
    public abstract void show();
    
}

Enum

    /**
     * Enum
     */
    public static void main(String[] args) {
        //demo1();
        //demo2();
        Week3 mon = Week3.MON;
        mon.show();    //星期一
        
        
    }
    public static void demo1(){
        Week mon = Week.MON;
        System.out.println(mon);//MON
    }
    public static void demo2(){
        Week2 mon = Week2.MON;
        System.out.println(mon.getName());//星期一
    }
---------------------------------------------------------------------
public enum Week {
    MON,TUE,WED;
}
---------------------------------------------------------------------
public enum Week2 {
    MON("星期一"),TUE("星期二"),WED("星期三");
    private String name;
    private Week2(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
    
}

---------------------------------------------------------------------
public enum Week3 {
    MON("星期一"){
        public void show(){
            System.out.println("星期一");
        }
    },TUE("星期二"){
        public void show(){
            System.out.println("星期二");
        }
    },WED("星期三"){
        public void show(){
            System.out.println("星期三");
        }
    };
    private String name;
    private Week3(String name){
        this.name = name;
    }
    public String getName() {
        return name;
    }
    
    public abstract void show();
    
}

/**
     * 枚举的一些方法
     */
    public static void main(String[] args) {
        
        //demo();
        Week2 mon = Week2.valueOf(Week2.class,"MON"); // 星期一 通过字节码对象获取枚举项

        Week2[] arr = Week2.values();
        for(Week2 week2: arr){
            System.out.println(week2);
        }
    }
    
    public static void demo(){
        Week2 mon = Week2.MON;
        Week2 tue = Week2.TUE;
        
        System.out.println(mon.ordinal());    //0 在枚举中的编号
        System.out.println(tue.ordinal());    //1 在枚举中的编号
        
        System.out.println(mon.compareTo(tue));  //比较编号
        
        System.out.println(mon.name()); // MON 获取实列名称
        System.out.println(mon.toString());
    }