通过反射实例化对象

  • 获取Class，能干什么？ 
通过Class的newInstance()方法来实例化对象
注意：newInstance()内部实际上调用了无参数构造方法，必须保证无参数构造的存在

代码示例

public class ReflectTest01 {
    public static void main(String[] args) {

        //不适用反射机制创建对象
        User user = new User();
        System.out.println(user);

        //下面这段代码是以反射机制的方式创建对象
        try {
            //通过反射机制，获取Class，通过Class来实例化对象
            Class c = Class.forName("bean.User");//c代表User类型

            //newInstance()这个方法会调用User这个类的无参数构造方法，完成对对象的创建
            //重点是：newInstance()调用的是无参构造，必须保证无参构造是存在的
           Object obj =  c.newInstance();

            System.out.println(obj);//bean.User@16b98e56

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

User类：

public class User {
    public User(){System.out.println("无参数构造方法");}
    public User(String s){}
    }

运行结果：

无参数构造方法
bean.User@16b98e56
无参数构造方法
bean.User@7ef20235

一个对象没有构造方法时，会自动创建无参构造方法
【注意：当定义了有参构造方法时，必须创建无参构造方法，否则会报错java.lang.InstantiationException实例化异常】

两种创建方式的区别：

通过反射机制创建对象更加灵活

测试反射机制的灵活性

  • 验证反射机制的灵活性：
    Java代码写一遍，再不改变Java源代码的基础之上，可以做到不同对象的实例化
    非常之灵活（符合OCP开闭原则：对扩展开放，对修改关闭）
  • 为什么要学反射机制：
    后期要学高级框架，而在工作过程中，也都是使用高级框架
    包括：ssh ， ssm , spring ， springmvc 。。。
    这些高级框架底层实现原理，都采用了反射机制，所以反射机制还是重要的
    【学会了反射机制，有利于理解剖析框架底层的源代码】

代码示例：

public class ReflectTest02 {
    public static void main(String[] args) {

        //这种方式代码就写死了，只能创建一个User类型的对象
//        User user = new User();

        //一下代码是灵活的，代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例化对象
        FileReader reader = null ;
        try {
            //通过IO流读取classinfo.properties文件
            reader = new FileReader("classinfo.properties");
            //创建属性类对象Map
            Properties pro = new Properties();
            //加载
            pro.load(reader);
            //通过key获取value
            String className = pro.getProperty("className");
//            System.out.println(className);

            //通过反射机制实例化对象
            Class c = Class.forName(className);
            Object obj  = c.newInstance();
            System.out.println(obj);


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } finally{
            if (reader!=null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

classinfo.properties配置文件:

className=bean.User

运行结果：

无参数构造方法
bean.User@15aeb7ab

classinfo.properties配置文件：

className=java.util.Date

运行结果：

Tue Sep 27 09:27:53 CST 2022

只让静态代码块执行

研究一下：Class.forName()发生了什么？

代码示例：

public class TestReflect04 {
    public static void main(String[] args) {
        try {
             Class.forName("Day01.Myclass");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Myclass{

    //静态代码块在类加载时执行，并且只执行一次
    static{
        System.out.println("Myclass类的静态代码块执行了");
    }
}

运行结果：

Myclass类的静态代码块执行了

重点：如果你只希望一个类的静态代码块执行，其他代码一律不执行

你可以使用：**Class.forName("完整类名")；**
这个方法的执行会导致类加载，类加载时，静态代码块执行

提示：后面JDBC技术的时候我们还需要这段代码

获取类路径下文件的绝对路径

FileReader reader = new FileReader("bean.User");

这种方式的路径缺点是：移植性差，在IDEA中默认的当前路径是project的根
这个代码假设离开IDEA，换到其他位置，可能当前路径就不是project的根了，这时这个路径就无效了

通用获取路径的方式

通用路径，即使代码换位置了，这样编写仍然是通用的

【注意】：使用以下通用方式的前提是：这个文件不许在类路径下

【记住】什么是类路径下？方式在src下的都是类路径下
src是类的根路径

String path =Thread.currentThread().getContextClassLoader().getResource("classinfo02.properties").getPath();
System.out.println(path);

采用以上的代码可以拿到一个文件的绝对路径,这种方式获取文件绝对路径是通用的
解释：
**Thread.currentThread()😗*当前线程对象
getContextClassLoader(): 是线程对象的方法，可以获取当前线程的类加载器对象
getResource(): 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源
**getPtah() 😗*获取路径

【注意！！】以上讲解的方式是通用的，但前提需要在类路径下，才能用这种方式

以流的形式直接返回

代码示例：

public class IoPropertiesTest {
    public static void main(String[] args) {

//        FileReader reader = null ;
        try {
//            String path = Thread.currentThread().getContextClassLoader().getResource("classinfo02.properties").getPath();
//
//             reader = new FileReader(path);
            
            //直接以流的形式返回
            InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("classinfo02.properties");

            Properties pro = new Properties();

            pro.load(reader);

            String className = pro.getProperty("className");

            System.out.println(className);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
//        finally {
            if (reader!=null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

classinfo02.properties

className=bean.User

运行结果：

bean.User