JAVA Class25

学习内容：

1.反射

反射目的是在不修改代码的情况下，只需修改外部配置文件，实现调用不同类的不同方法。

（1）类的载入

当我们需要使用一个类时，我们要将这个类载入JVM，这里就要用到类载入的方法：

在我们实例化一个对象时，类会自动载入，另外，实例化一个子类对象会导致父类自动载入

public class Person {
    public String name;
    private int age;
    static {//注意这个静态代码块！
        System.out.println("静态代码块");
    }
    public Person() {
        super();
    }
    public Person(String name,int age) {
        super();
        this.name = name;
        this.age = age;
    }
} 

public class TestPerson {

    @SuppressWarnings({"rawtypes","unchecked"})//忽略多类型警告
    public static void main(String[] args) {
        try {
            Class c1 = Class.forName("edu.java.reflection.Person");//包名.类名
            Class c2 = new Person().getClass();
            //上述两种方式都会初始化静态属性，且只会执行一次！
            Class c3 = Person.class;//不会初始化静态属性
            //在一个JVM中，一种类，只会有一个类对象存在。所以以上三种方式取出来的类对象，都是一样的。
            //注： 准确的讲是一个ClassLoader下，一种类，只会有一个类对象存在。通常一个JVM下，只会有一个ClassLoader。
            System.out.println(c1==c2);//true
            System.out.println(c1.equals(c2));//true
            System.out.println(c1==c3);//true
            System.out.println(c1.equals(c3));//true
　　}
}

（2）构造器的获取与利用构造器实例化对象：

public class TestPerson {

    @SuppressWarnings({"rawtypes","unchecked"})
    public static void main(String[] args) {
        try {
            Class c1 = Class.forName("edu.java.reflection.Person");//包名.类名
            //获取造器数组
            Constructor[] con = c1.getConstructors();//获取所有公共的构造器
            for(Constructor s:con) {
                System.out.println(s);
            }
            //获取空参构造器
            Constructor con = c1.getConstructor();
            //空参构造器实例化对象
            Object obj = con.newInstance();
            Person p = (Person)obj;//newInstance()返回的是Object，向下强转Person
            //有参构造器
            Class[] v = {String.class,int.class};
            Constructor con = c1.getConstructor(v);
            Object obj = con.newInstance("张三",20);
            Person p = (Person)obj;
            System.out.println(p);
            Constructor[] all = c1.getDeclaredConstructors();//获取所有构造器，包括私有的
            for(Constructor con:all) {
                System.out.println(con);
            }
            Constructor con = c1.getDeclaredConstructor(String.class);//获取私有的有参构造器
            con.setAccessible(true);//取消变量权限检查，可以访问私有化变量
            Object obj = con.newInstance("李四");
            Person p = (Person)obj;
            System.out.println(p);
            //空参构造快速生成对象
            Object obj = c1.newInstance();
            Person p = (Person)obj;
　　}
}

（3）获取字段值

public class TestPerson {

    @SuppressWarnings({"rawtypes","unchecked"})
    public static void main(String[] args) {
        try {
            Class c1 = Class.forName("edu.java.reflection.Person");//包名.类名
            Field[] f = c1.getFields();//获取所有公共字段
            for(Field i:f) {
                System.out.println(i);
            }
            Constructor con = c1.getConstructor(String.class,int.class);
            Object obj = con.newInstance("张三",20);
            Person p = (Person)obj;
            Field f = p.getClass().getField("name");//获取对象的指定字段值
            f.set(p, "李四");
            System.out.println(p);
            Field age = p.getClass().getDeclaredField("age");//获取私有变量
            age.setAccessible(true);
            age.set(p, 30);
            System.out.println(p);
        } catch(Exception e) {
            e.printStackTrace();
        }
        
    }

}

（4）通过类获取方法

public class TestPerson {

    @SuppressWarnings({"rawtypes","unchecked"})
    public static void main(String[] args) {
        try {
            Class c1 = Class.forName("edu.java.reflection.Person");//包名.类名
            Constructor con = c1.getConstructor(String.class,int.class);
            Object obj = con.newInstance("张三",20);
            Person p = (Person)obj;
            Field f = p.getClass().getField("name");//获取对象的指定字段值
            f.set(p, "李四");
            System.out.println(p);
            Field age = p.getClass().getDeclaredField("age");//获取私有变量
            age.setAccessible(true);
            age.set(p, 30);
            System.out.println(p);*/
            //获取所有方法
            Method[] all = c1.getMethods();
            for(Method mm:all) {
                System.out.println(mm);
            }
            Method m1 = c1.getMethod("eat");
            m1.invoke(p);
            Method m2 = c1.getDeclaredMethod("sleep",String.class,int.class,double.class);//获取私有带参方法
            m2.setAccessible(true);
            m2.invoke(p,p.name,30,90);
        } catch(Exception e) {
            e.printStackTrace();
        }
        
    }

}

2.泛型擦除

JAVA的泛型是”假泛型“，不进class文件，所以利用反射，我们可以突破泛型限制添加数据

public class TestPerson {

    @SuppressWarnings({"rawtypes","unchecked"})
    public static void main(String[] args) {
        try {
            //泛型擦除
            ArrayList<String> list = new ArrayList<String>();
            list.add("abc");
            Class c = list.getClass();
            Method method = c.getMethod("add", Object.class);
            method.invoke(list, 1);
            System.out.println(list);//数字1被成功添加，JAVA的泛型是”假泛型“，不进class文件
            System.out.println(list.get(0));
            System.out.println(list.get(1));//但是获取会报类型转换失败错误
        } catch(Exception e) {
            e.printStackTrace();
        }
        
    }

}

3.泛型应用

public class Test {
     @SuppressWarnings({ "rawtypes", "unchecked" })//忽略多类型警告
    public static void main(String[] args) throws Exception {
        //从spring.txt中获取类名称和方法名称
        File sp = new File("e:/java/spring/spring.txt");
        Properties sc = new  Properties();
        sc.load(new FileInputStream(sp));
        String classname = (String)sc.get("class");
        //String methodname = (String)sc.get("method");
        String methodname = sc.getProperty("method");
        //根据类名称获取类对象
        Class cl = Class.forName(classname);
         //根据方法名称，获取方法对象
        Method m = cl.getMethod(methodname);
         //获取构造器
        Constructor c = cl.getConstructor();
        //根据构造器，实例化出对象
        Object service = c.newInstance();
        //调用对象的指定方法
        m.invoke(service);
        //如果要切换类及方法，只改变外部的txt文件内容即可，代码不用改
    }

}

 利用这一思想，我们可以对之前用过的DButil包做一下改动：

配置文件 DButil.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/Hero?characterEncoding=UTF-8
user=root
password=123456

做改动：

public class DButil {
    private DButil() {};
    public static Connection getConn() {
        try {
            Properties pro = new Properties();
            pro.load(new FileInputStream("properties/DButil.properties"));
            String driver = pro.getProperty("driver");
            String url = pro.getProperty("url");
            String user = pro.getProperty("user");
            String password = pro.getProperty("password");
            Class.forName(driver);
            Connection conn = DriverManager.getConnection(url, user, password);
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("连接数据库失败！"+e);
        }
    }
    /**
     * 用来连接数据库
     * 返回Connection对象
     * */
    public static void close(Statement sta,Connection conn) {
        if(sta!=null) {
            try {
                sta.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(conn!=null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 用来关闭Statement Connection
     * 接收一个Statement对象、一个Connection对象
     * */
    public static void close(ResultSet rs,Statement sta,Connection conn) {
        if(rs!=null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        close(sta,conn);
    }
    /**
     * 用来关闭ResultSet Statement Connection
     * 接收一个ResultSet对象、一个Statement对象、一个Connection对象
     * */
}