单例模式与反射

反射

Class类的获取三种

　　　　//第一种获取class对象
　　　　ReflectTarget reflectTarget = new ReflectTarget();
　　　　Class aClass1 = reflectTarget.getClass();//第二种方式
　　　　Class aClass2 = ReflectTarget.class;//第三种凡是来获取对象
　　　　Class aClass3 = Class.forName("demo.reflect.ReflectTarget");

访问构造器

　　　　Class clazz = Class.forName("demo.reflect.ReflectTarget");

　　　　//1.获得公有的构造方法
　　　　Constructor[] constructors = clazz.getConstructors();
　　　　for (Constructor constructor : constructors) {
    　　　　System.out.println(constructor);
　　　　}

　　　　//2.获得所有的构造方法
　　　　constructors = clazz.getDeclaredConstructors();
　　　　for (Constructor constructor : constructors) {
  　　  　　System.out.println(constructor);
　　　　}

　　　　//获取公有、带两个参数的构造方法
　　　　Constructor con1 = clazz.getConstructor(String.class, int.class);
　　　　System.out.println("获取公有、带两个参数的构造方法 con1 = "+con1);

　　　　//获取单个私有的构造方法
　　　　Constructor con2 = clazz.getDeclaredConstructor(int.class);
　　　　System.out.println("获取公有、带一个参数的构造方法 con2 = "+con2);
　　　　System.out.println("##############调用私有方法创建实例###############");
　　　　//暴力访问，忽略修饰符
　　　　con2.setAccessible(true);
　　　　ReflectTarget reflectTarget = (ReflectTarget)con2.newInstance(1);

 访问字段

        //获取Class对象
        Class clazz = Class.forName("demo.reflect.ReflectTarget");

        //1.获取所有公有的字段
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        //2.获取所有的字段
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            System.out.println(field);
        }

        //3.获取单个特定公有的field
        Field name = clazz.getField("name");
        ReflectTarget reflectTarget = (ReflectTarget)clazz.getConstructor().newInstance();
        name.set(reflectTarget,"带反射一号");
        System.out.println("反射设置的公有field字变量：" + reflectTarget.name);
        //4.获取获取单个特定私有的field并调用
        Field targetInfo = clazz.getDeclaredField("targetInfo");
        System.out.println(targetInfo);
        targetInfo.setAccessible(true);
        targetInfo.set(reflectTarget,"13858492323");
        System.out.println("反射设置的私有feild变量 : "+reflectTarget);

 访问方法

        //获取class对象
        Class clazz = Class.forName("demo.reflect.ReflectTarget");
        //获取所有公有方法，包括父类的方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        //3.获取所有的该类的所有方法，包括私有
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        //4.获取单个公有的方法
        Method show1 = clazz.getMethod("show1", String.class);
        System.out.println(show1);
        ReflectTarget reflectTarget = (ReflectTarget) clazz.getConstructor().newInstance();
        show1.invoke(reflectTarget,"带反射方法一号");

        //5.获取私有的成员方法
        System.out.println("******************获取私有的show4方法***************");
        Method show4 = clazz.getDeclaredMethod("show4", int.class);
        System.out.println(show4);
        show4.setAccessible(true);
        String result = (String) show4.invoke(reflectTarget, 20);
        System.out.println("返回值 ： "+result);

单例模式

饿汉模式：类被加载的时候就立即初始化并创建唯一实例

public class StaringSingleton {
    private static final StaringSingleton staringSingleton = new StaringSingleton();
    private StaringSingleton(){};
    public static StaringSingleton getInstance() {
        return staringSingleton;
    }
}

懒汉模式：

public class LazyDoubleCheckSingleton {

    private volatile static LazyDoubleCheckSingleton instance;
    private LazyDoubleCheckSingleton(){}
    public static LazyDoubleCheckSingleton getInstance() {
        //第一次检测
        if (instance == null) {
            //同步
            synchronized (LazyDoubleCheckSingleton.class) {
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }

}

枚举+饥饿模式：防止反射创建实例

public class EnumStarvingSingleton {
    private EnumStarvingSingleton(){}
    public static EnumStarvingSingleton getInstance(){
        return ContainerHolder.HOLDER.instance;
    }
    private enum ContainerHolder{
        HOLDER;
        private EnumStarvingSingleton instance;
        ContainerHolder(){
            instance = new EnumStarvingSingleton();
        }
    }

}