JAVA复习 Day26+Day27 反射+MYSQL（未写完）Day29(事务索引)

23反射

23.1反射机制

通过外部文件配置，在不修改源码情况下，来控制程序，也符合设计模式的OCP原则（开闭原则：不修改源码，开扩容功能）

23.1.1反射的快速入门

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

        Properties properties = new Properties();
        properties.load(new FileInputStream("src\\re.properties"));
        String classfullpath=properties.get("classfullpath").toString();
        String  methodname =properties.get("method").toString();
        System.out.println("classfullpath="+classfullpath);
        System.out.println("method="+methodname);

        //使用反射机制解决
        //加载类,返回一个Class类型的对象
        Class<?> cls = Class.forName(classfullpath);
        //通过这个对象，可以得到加载的类com.dan23.Cat的对象实例
        Cat o = (Cat) cls.newInstance();
        //通过cls得到你加载的类com.dan23.Cat的methodname"hi"的方法对象
        //即：在反射中，可以把方法视为对象（万物皆对象）
        Method method1 = cls.getMethod(methodname);
        //通过method1 调用方法：即通过方法对象来实现调用方法
        System.out.println("============");
        method1.invoke(o);
        //传统方法是对象.方法（），反射机制   方法.invoke(对象)
    }
}

23.1.2反射机制JAVA Reflection

反射机制允许程序在执行期间借助于REflectionAPI取得任何类的内部信息，并能操作对象的属性及方法，反射在设计模式和框架底层都会用到

加载完类之后，在堆中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象包含了类的完整结构信息，通过这个对象得到类的结构。

23.1.2.1JAVA反射机制原理图

23.1.2.2JAVA反射机制可以完成

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时得到任意一个类所具有的成员变量和方法
在运行时调用任意一个对象的成员变量和方法
生成动态代理

23.1.2.3反射相关的主要类（java.long.reflect）

java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象
java.long.reflect.Method:代表类的方法，它的对象表示某个类的方法
java.long.reflect.Field:代表类的成员变量，它的对象表示某个类的成员变量
java.long.reflect.Constructor:代表类的构造方法，它的对象表示构造器
java.long.reflect 的API
https://www.matools.com/api/java8

23.1.2.4反射机制的优点和缺点

优点：可以动态的创建和使用对象，使用灵活，没有反射机制，框架技术就是失去底层支撑
缺点：使用反射基本是解释执行，对执行速度有影响

23.1.2.5反射调用优化——关闭访问检查

Method和Field、Constructor对象都有setAccessible()方法
setAccessible作用是启动和禁用访问安全检查的开关
参数值为true表示反射的对象使用时取消访问检查，提高反射的效率，参数值为false则表示反射的对象执行访问检查

23.2Class类

23.2.1基本介绍

Class也是类，因此也继承Object类
Class类对象不是new出来的，而是系统创建的
对于某个类的Class类对象，在内存中只有一份，因此类只加载一次
每个类的实例都会记得自己是由那个Class实例所生成
通过Class可以完整地得到一个类的完整结构，通过一系列的API
Class对象是存放在堆的
类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据

23.2.2Class类的常用方法

方法演示

public class class01 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {

        String classallpath="com.class01.Car";
        //获取到Car类对应的Class对象
        //表示不确定的JAVA类型
        Class<?> cls = Class.forName(classallpath);

        //1输出cls
        System.out.println(cls);
        //显示cls对象，是哪一个类的Class对象

        System.out.println(cls.getClass());
        //2输出cls运行类型  java.lang.Class


        System.out.println(cls.getPackage().getName());
        //3得到包名

        System.out.println(cls.getName());
        //4得到类名

        Car o = (Car)cls.newInstance();
        System.out.println(o);
        //5通过cls创建对象实例

        Field brand = cls.getField("brand");
        System.out.println(brand.get(o));
        //6通过反射获取属性

        brand.set(o,"奔驰");
        System.out.println(brand.get(o));
        //7通过反射给属性赋值

        System.out.println("所有的字段属性：");
        Field[] fields = cls.getFields();
        for (Field i:fields){
            System.out.println(i.getName());
        }
        //8遍历得到所有的属性
        
    }
}

23.2.3获取Class对象六种方式

23.2.3.1第一种

当已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取
        可能抛出ClassNotFoundException
        实例：Class cls1=Class.forName("java.lang.Cat");
        应用场景：多用于配置文件，读取类全路径，加载类

        String  path ="com.class01.Car";
        //这里往往是通过配置文件进行读取的
        //此为编译阶段
        Class<?> aClass = Class.forName(path);
        System.out.println(aClass);

23.2.3.2第二种

当已知具体的类，通过类的class获取，该方式最为安全可靠
        程序性能最高实例：Class cls2= Cat.class
        应用场景：多用于参数传递，比如通过反射得到对应构造器对象
        此为加载阶段

System.out.println(Car.class);

23.2.3.3第三种

  已知某个类的实例，调用该实例的getClass()方法获取Class对象
        实例：Class clazz=对象.getClass();运行类型
        应用场景：通过创建好的对象，获取Class对象
        此为运行阶段

        Car car = new Car();
        Class cls = car.getClass();
        System.out.println(cls);

23.2.3.4第四种

//通过类加载器【4种】来获取到类的Class对象
        //1先得到类加载器car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //2通过类加载器得到Class对象
        Class cls1 = classLoader.loadClass(path);
        System.out.println(cls1);

23.2.3.5第五种

基本类型(int ,char,boolean,float,double,byte,long,short)
      按照如下的方式得到Class类对象

  //Class cls=基本数据类型.class
    Class<Integer> integerClass = int.class;
    Class<Character> characterClass = char.class;
    System.out.println(integerClass);//自动装箱和自动拆箱的过程

23.2.3.6第六种

基本数据类型对应的包装类，可以通过.type得到Class对象
        Class cls=包装类.TYPE

 Class<Integer> type = Integer.TYPE;
        Class<Character> type1 = Character.TYPE;
        System.out.println(type);
        System.out.println(type1);

23.2.4JAVA那些类型有Class对象

外部类，成员内部类，静态内部类，局部内部类，匿名内部类
接口
数组
枚举enum
注释annotation
基本数据类型
void

23.3类加载

反射机制是JAVA实现动态语言的关键，也就是通过反射实现类动态加载
静态加载：编译时加载相关的类，如果没有则报错，依赖性太强
动态加载：运行时加载需要的类，如果运行时不用该类，则不报错，降低了依赖性

23.3.1类的加载时机

当创建对象时
当子类被调用时
调用类中的静态成员时
通过反射

23.3.2类加载流程图

23.4反射获取类的结构信息

23.4.1java.lang.Class类

  public  void api01() throws ClassNotFoundException, NoSuchMethodException {
        Class<?> cls = Class.forName("com.information.Person");

        //getName()得到全类名
        System.out.println(cls.getName());

        //getSimpleName()获取简单类名
        System.out.println(cls.getSimpleName());

        //getFields()获取所有public修饰的属性，包含本类以及父类的
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            System.out.println("本类以及父类的属性="+field.getName());
        }


        //getDeclaredFields()获取本类中的所有属性
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中的所有属性"+declaredField.getName());
        }

        //getMethods()获取所有public修饰的方法，包含本类以及父类的
        Method[] methods = cls.getMethods();
        for (Method method : methods) {
            System.out.println("本类以及（不限于直接父类）父类中的属性="+method.getName());

        }

        //getDeclaredMethods()获取本类中的所有方法
        Method[] declaredMethods = cls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中的所有方法"+declaredMethod.getName());
        }

        //getConstructors获取所有public修饰的构造器
        Constructor<?>[] constructors = cls.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类的public构造器"+constructor.getName());
        }

        //getDeclaredConstructors()获取本类的所有构造器
       Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
        for (Constructor<?> eclaredconstructor : declaredConstructors) {
            System.out.println("本类的所有构造器"+eclaredconstructor.getName());
        }

        //getPackage()以Package形式返回包信息
        System.out.println(cls.getPackage());

        //getSuperclass()以Class形式返回父类信息
        Class<?> superclass = cls.getSuperclass();
        System.out.println("得到父类的Class对象"+superclass);

        //getInterfaces()以Class[]形式返回接口信息
        Class<?>[] interfaces = cls.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息="+anInterface.getName());

        }

        //以Annotation[]形式返回注解信息
        Annotation[] annotations = cls.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息"+annotation);
        }


    }

class  A{
    public  String  hobby;
    public  void  hi(){

    }

    public A() {

    }
}
interface  IA{

}
interface  IB{

}
@Deprecated
class  Person extends A implements  IA,IB{
    public Person(){

    }
    public Person( String name) {

    }

    private Person(String  name,int age){}
    public   String  name;
    protected  int age;
    String  job;
    private  double sal;
    public  void m1(){

    }
    protected  void m2(){

    }
    void  m3(){

    }
    private  void m4(){

    }

}

23.4.2java.lang.reflect.Field类

 public  void  api02() throws ClassNotFoundException {
        Class<?> cls = Class.forName("com.information.Person");
        //getDeclaredFields()获取本类中的所有属性
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            //getModifiers:以int形式返回修饰符，【默认修饰符是0，public是1，private是2，
            //protected是4，static是8，final是16, public(1)+static(8)=9】
            System.out.println("本类中的所有属性"+declaredField.getName()
            +"该属性的修饰符值="+declaredField.getModifiers()+"该属性的类型"
            +declaredField.getType());
        }
        
        
    }

23.4.3java.lang.reflect.Method类

 @Test
    public  void  api03() throws ClassNotFoundException {
        Class<?> cls = Class.forName("com.information.Person");
        //getDeclaredMethods()获取本类中的所有方法
        Method[] declaredMethods = cls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类中的所有方法"+declaredMethod.getName()
            +"该方法的访问修饰值="+declaredMethod.getModifiers()
            +"该方法的返回类型="+declaredMethod.getReturnType());
        }

    }

23.4.4java.lang.reflect.Constructor类

 @Test
    public  void  api04() throws ClassNotFoundException {
        Class<?> cls = Class.forName("com.information.Person");
        //getDeclaredConstructors()获取本类的所有构造器
        //getDeclaredConstructors()获取本类的所有构造器
        Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
        for (Constructor<?> eclaredconstructor : declaredConstructors) {
            System.out.println("本类的所有构造器"+eclaredconstructor.getName());

            Class<?>[] parameterTypes = eclaredconstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该构造器的形参类型="+parameterType);
            }
            System.out.println("=========");
        }

    }

23.5通过反射创建对象

23.5.1调用类中的public修饰的无参构造器

23.5.2调用类中的指定构造器

23.5.3Class类相关方法

newInstance:调用类中的无参构造器，获取对应类的对象
getConstructor（Class …clazz）:根据参数列表，获取对应的public构造器对象
getDecalaredConstructor(Class… clazz):根据参数列表，获取对应的构造器对象

23.5.4Constructor类相关方法

setAccessible:爆破
newInstance(Obkect…obj):调用构造器

23.5.5演示通过反射机制创建实例

public class act03 {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        //1、先获取到User类的Class对象
        Class<?> aClass = Class.forName("com.information.User");
        //2、通过public的无参构造器创建实例
        Object o = aClass.newInstance();
        System.out.println(o);
        //3、通过public的有参构造器创建实例
        Constructor<?> constructor = aClass.getConstructor(String.class);
        Object jack = constructor.newInstance("jack");
        System.out.println("小明="+jack);
        //4、通过非public的有参构造器创建实例
        //此时的 constructor1是私有的
        Constructor<?> constructor1 = aClass.getDeclaredConstructor(int.class, String.class);
        constructor1.setAccessible(true);//爆破
        //使用反射可以使用反射访问private构造器
        Object zsd = constructor1.newInstance(100, "张三非");


    }
}

class User{
    private  int age=10;
    private String  name="小明";

    public User(String name) {
        this.name = name;
    }
    public User(){

    }

    private User(int age,String  name){
        this.age=age;
        this.name=name;
    }

    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

}

23.6通过反射访问类中的成员