Java反射以及工厂设计模式和单例模式

1、什么是类对象

类的对象：基于某个类new出来的对象，也成为实例对象
类对象：类加载的产物，封装了一个类的所有信息（类名、父类、接口、属性、方法、构造方法），每一个类加载到内存后都对应一个Class对象，每个类有且只有一个Class对象（模版类）
eclipse在run as中可以设置-verbose:class显示类的加载过程

2、获取类对象的方法

推荐使用第三种方式，通用性更好一点，可以编译通过，捕获异常，不用这个类就可以编译通过，前两种依赖性太强

2.1通过类的对象，获取类对象

 Person person = new Person();
 Class aClass = person.getClass();
 System.out.println(person.getClass());

2.2通过类名获取类对象

 Class aClass = person.class;

2.3通过静态方法获取类对象

 Class aClass = Class.forName("包名.类名");

 public static void commonMethod(){
        // 使用反射获取类的构造方法，创建对象
        try {
            Class<?> aClass = Class.forName("com.wchao.reflect.Person");
            Constructor<?>[] constructors = aClass.getConstructors();
            for (Constructor<?> constructor : constructors) {
                System.out.println(constructor.toString());
            }
            // 获取类中的无参构造
            Constructor<?> constructor = aClass.getConstructor();
            Person o = (Person) constructor.newInstance();
            System.out.println(o.toString());
            // 简便方法:这个只表示用类的无参构造创建对象
            Object o1 = aClass.newInstance();
            System.out.println(o1.toString());
            // 获取类中的带参构造方法
            Constructor<?> constructor1 = aClass.getConstructor(String.class);
            Object o2 = constructor1.newInstance("整数");
            System.out.println(o2);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

3、常见操作

   public static void commonUseMethod() throws Exception {
        // 使用反射获取类中的方法，并调用方法
        // 获得类对象
        Class<?> aClass = Class.forName("com.wchao.reflect.Person");
        Method[] methods = aClass.getMethods(); // getMethods只能获取公开的方法，包括从父类继承的方法
        for (Method method : methods) {
//            System.out.println(method.toString());
        }
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod); // 获取类中的所有方法，包括默认，私有，不包含继承的方法
        }
        // 获取单个方法
        Method method = aClass.getMethod("eat");
        // 调用方法
        Object o = aClass.newInstance();
        method.invoke(o);// 相当于之前写的zhangsan.eat();
        Method toString = aClass.getMethod("toString");
        Object invoke = toString.invoke(o);
        System.out.println(invoke);
        Method eat=aClass.getMethod("eat", String.class);
        eat.invoke(o,"鸡腿");
        // 获取私有的方法
        Method method1=aClass.getDeclaredMethod("privateMethod");
        // 调用私有方法的时候要设置访问权限无效，不然报错
        method1.setAccessible(true);
        method1.invoke(o);
        Method method2=aClass.getMethod("staticMethod");
        method2.invoke(null);
    }
}

使用反射实现一个可以调用任何对象方法的通用方法

 // 1.哪个对象 2.方法名称 3.方法参数类型 4.参数的数据值
    public static Object invokeAny(Object obj,String methodName,Class<?>[] types,Object...args) throws Exception{
        // 1. 获取类对象
        Class<?> aClass = obj.getClass();
        Method method = aClass.getMethod(methodName, types);
        return method.invoke(obj,args);
    }

使用反射获取类中的属性

// 使用反射获取类中的属性
    public static void reflectProperty() throws Exception{
        Class<?> aClass = Class.forName("com.wchao.reflect.Person");
        Field[] fields = aClass.getFields(); // 只能拿到公开的，父类继承的字段
        for (Field field : fields) {
            System.out.println(field);
        }
        Field[] declaredFields = aClass.getDeclaredFields();// 获取所有的属性，私有、默认，不包含继承的
        Object o = aClass.newInstance();
        Field name = aClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(o,"挖出"); //相当于zhangsan.name
        System.out.println(name.get(o));

    }

4、设计模式介绍

含义：一套被反复使用、多人知晓的、经过反类编目的、代码设计经验的总结，特定问题的固定解决方法
好处：使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、重用性
在Gof的《设计模式》中描述了23中设计模式

4.1、工厂设计模式

工厂设计模式主要负责对象创建的问题
开发中有着一个非常重要的原则，开闭原则，对拓展开放，对修改关闭
可通过反射进行工厂模式的设计，完成动态的对象创建
案例：设置有一个Usb接口，3个实现类，一个工厂类，一个使用类，使用类通过传入的type，使用多态来为创建的对象复制

4.2、单例设计模式

单例：只允许创建一个该类的对象
方式1：饿汉式（类加载时创建，天生线程安全），类一加载，类的对象就被创建出来了
1.首先创建一个常量
2.构造方法改成私有的，类外部不能创建对象
3.通过有个公开方法返回这个对象
生命周期太长浪费空间，线程安全

public class Singleton {
    private static final Singleton instance=new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return instance;
    }
}

方式2：懒汉式（使用时创建，线程不安全，加同步），饿汉式即使不使用也会创建，浪费空间，好处是线程安全，懒汉式是节省空间，要用的时候才会创建
1.首先创建一个对象赋值为null
2.构造方法改成私有的，类外部不能创建对象
3.通过一个公开的方法返回这个对象
生命周期短，节省空间，有线程安全问题
如果不加synchronized ，在多个线程运行的时候，就会创建不止一个对象

public class Singleton {
    private static Singleton instance=null;
    private Singleton2(){}
    public static synchronized Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}

使用同步代码块也可以实现多线程下安全单例，效率不是最高的，要判断锁能不能用，能用就进来，如果不能用就会一直等着

public class Singleton2 {
    private static Singleton2 instance=null;
    private Singleton2(){}
    public static  Singleton2 getInstance(){
        synchronized(Singleton2.class){
            if(instance==null){
                instance=new Singleton2();
            }
        }
        return instance;
    }
}

为了提高效率，如果instance为空才让他进入里面的判断，如果不为空，直接返回，不然每次进来都要判断，这个if判断是为了提高执行效率，只要有一个线程进来就不会有线程进来

public class Singleton2 {
    private static Singleton2 instance=null;
    private Singleton2(){}
    public static  Singleton2 getInstance(){
        if(instance==null){
            synchronized(Singleton2.class){
                if(instance==null){
                    instance=new Singleton2();
                }
            }
        }
        return instance;
    }
}

方式3：懒汉式（使用时创建，线程安全）

public class Singleton1 {
    private Singleton1(){}
    private static class Holder{
        static Singleton1 s=new Singleton1();
    }
    public static Singleton1 instance(){
        return Holder.s;
    }
}