15.从零开始学习Java-反射：通用编程

转载请标明原文地址，后续会持续更新《从零开始学习》系列，数据结构和算法，Mysql和ssm框架。
如果有问题可以私信或者直接在文章下评论，大概晚上会回。
如果零基础的同学没有学习的大概方向也可以私信问我，发给你一些学习路线和一些B站的学习视频地址。
希望能为世界带来些微价值，peace！

反射：通用编程

一、什么是类对象

• 类的对象：基于某个类new出来的对象，也称为实例对象。
• 类对象：类加载的产物，封装了一个类的所有信息（类名、父类、接口、属性、方法、构造方法）

二、获取类对象的方法

1、通过类的对象，获取类对象

Student s = new Student();//类的对象
Class c = s.getClass();//类对象  是类的对象的模板

2、通过类名获取类对象

Class c = 类名.class;

3、通过静态方法获取类对象

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

• • static 类<?>	forName(String className) 返回与给定字符串名称的类或接口相关联的 类对象。

三、常用方法

public String getName()
public Package getPackage()
public Class<? super T> getSuperclass()
public Class<?>[] getInterfaces()
public Field[] getFields()
public Method[] getMethod()
public Constructor<?>[] getConstructors()
public T newInstance()

• • T	newInstance() 创建由此 类对象表示的类的新实例。

四、invoke方法：

public class TestInvokeAnything {

	public static void main(String[] args) throws Exception {

		//invokeAny(new Student(), "exam" , new Class[]{ int.class, double.class} , 111 , 2.3 );
		
		Properties prop = new Properties();
		
		invokeAny(prop , "setProperty" , new Class[]{String.class , String.class} , "CN" , "中国");
		
		System.out.println(prop.getProperty("CN"));
	}

	//通用编程（调用任何一个方法）  lang3
	public static void invokeAny(Object obj , String methodName , Class[] types , Object... args) throws Exception{
		
		//获得类对象
		Class c = obj.getClass();
		
		//获得方法对象Method
		Method m = c.getDeclaredMethod( methodName , types);
		
		//执行方法
		m.invoke(obj, args);
	}
}

//通过invoke，让study实例方法执行起来，所需的对象，作为第一个参数，所需的方法调用实参，作为第二个参数
//method5.setAccessible(true);
//反射是一种Java的底层技术，可以突破封装
public class TestInvokeMethod {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //通过工厂创建了一个类（Teacher）的对象
        Object teac = factory("java0908.Teacher");
        //通过学生对象获得了所属的类对象（Class ---> invokes.Student）
        Class c = teac.getClass();
        //通过类对象获得了其中的一个方法（study方法、无参）
        Method method = c.getMethod("run", String.class);
        //通过invoke，让study实例方法执行起来，所需的对象，作为第一个参数，所需的方法调用实参，作为第二个参数
        method.invoke(teac,"xxx");

        Method method1 = c.getMethod("run",null);//获得公开的//getDeclaredMethod:获得私有的
        method1.invoke(teac,null);

        Method method2 = c.getMethod("run",String.class,int.class);
        method2.invoke(teac,"xxx",2);

        Method method3 = c.getMethod("run",double.class);//获得公开的
        method3.invoke(teac,2);

        Method method4 = c.getMethod("run",int.class,double.class);//获得公开的
        method4.invoke(teac,1,1);

        Method method5 = c.getDeclaredMethod("calc",null);
        //注意：反射是一种Java的底层技术，可以突破封装
        System.out.println(method5);
        method5.setAccessible(true);
        method5.invoke(teac,null);

    }
    //工厂
    public static Object factory(String className){
        Class c = null;
        try {
            c = Class.forName(className);
            return c.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}


class Teacher{
    String name;
    int numbs;
    private double dd;
    public void run(){
        System.out.println("...跑");
    }
    public void run(String name){
        System.out.println(name + "...跑");
    }
    public void run(String name,int numbs){
        System.out.println(numbs+"个"+name+"...跑");
    }
    public void run(double dd){
        System.out.println(dd + "...跑");
    }
    private void calc(){
        System.out.println("calc() Executed");
    }
    public void run(int numbs,double n){
        System.out.println(numbs+"xxx"+n);
        calc();
    }
}

五、设计模式介绍

六、单例设计模式

单例（Singleton）：只允许创建一个该类的对象。

方式1：饿汉式（类加载时创建，天生线程安全）

//饿汉式：天生线程安全、类加载时创建（不好，不用的时候也被迫创建，占用一点点资源）
class Singleton{
    private static final Singleton instance = new Singleton();//static方法保证类加载时创建，final保证不能被反射修改//2.
    private Singleton(){}//3.
    public static Singleton getInstance(){//1.
        return instance;
    }
}

方式2：懒汉式（使用时创建，线程不安全，加同步）

//懒汉式：使用时再创建、天生线程不安全（加锁）
class Singleton{
    private static Singleton instance = null;//2.
    private Singleton(){}//2.
    public static synchronized Singleton getInstance(){//1.
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

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

//使用静态内部类，使用的时候才创建
class Singleton{
    private Singleton(){}//保证构造方法外界无法访问
    private static class Holder{//2.调用实例方法
        static Singleton s = new Singleton();
    }
    public static Singleton getInstance(){//1.
        return Holder.s;
    }
}

七、工厂设计模式(开闭原则)

• 开发中有一个非常重要的原则“开闭原则”，对拓展开放、对修改关闭。
• 工厂模式主要负责对象创建的问题。
• 可通过反射进行工厂模式的设计，完成动态的对象创建。

public class TestFactory {
    public static void main(String[] args) throws Exception {
        Reader fileReader = new FileReader("E:\\Files\\bbb.txt");
        BufferedReader bufferedReader = new BufferedReader(fileReader);
        String className = bufferedReader.readLine();
        Object factory = factory(className);
        System.out.println(factory);

    }
    public static Object factory(String className){
        Class c = null;
        try {
            c = Class.forName(className);
            return c.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
class Student{
    String name;
    public void run(){
        System.out.println("跑");
    }
}

八、总结

• 类对象：
  • Class对象，封装了一个类的所有信息；程序运行中，可通过Class对象获取类的信息。
• 获取类对象的三种方式：
  • Class c = 对象.getClass();
  • Class c = 类名.class;
  • Class c= Class.forName(“包名.类名”);
• 工厂模式：
  • 主要用于创建对象，通过反射进行工厂模式的设计，完成动态的对象创建。
• 单例模式：
  • Singleton，只允许创建一个该类的对象。

九、扩展

为编译器加一个启动参数：

Arguments→VM arguments

-verbose;class

类加载器：classloader：里面一定有流

Method:

• • Object	invoke(Object obj, Object... args) 在具有指定参数的 方法对象上调用此 方法对象表示的底层方法。