JavaSE基础篇：反射（二）-阿里云开发者社区

第一章：注解

一：注解引入

Annotation是从jdk5.0引入的技术，注解和反射是很多框架的实现的方式

二：注解作用

不是程序本身：可以对程序作出解释，这一点和注释没有任何区别。

可以被其他程序，例如编译器进行读取，作为一定的标志。

检查和约束，例如：不是正确的重写的方法，上边的@Override就会报错。

三：注解定义格式

@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldkuang{
    String column();
    String type();
    int length();
}

四：注解分类

1：元注解

元注解是解释其他注解的注解，Java当中只有四个元注解 TRDI

@Target：这个注解描述非元注解的使用的位置。这个注解用于描述被修饰注解的使用时放置的位置，非元注解值得就是内置注解和自定义注解，注解所在的包位于，java.lang.annotation包下

@Retention：这个注解描述的是被修饰的注解的生命周期，作用时间分别为source < class< runtime三种情况

@Document：注解表示被修饰的注解被包含在JavaDoc当中

@Inherited：说明子类可以继承父类中被此注解修饰的注解。

2：内置注解

内置注解就是java自带的注解。

@SuppressWarnings(“all”)抑制编译器警告

@Deprecated 表示：某个程序元素（类、方法等）已过时

@SafeVarargs (JDK1.7更新) 表示：专门为抑制“堆污染”警告提供的。

@FunctionalInterface注明这是函数式接口

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
    String[] value();
}

五：自定义注解

自定义注解时，自动继承了java.lang.annotation接口。

@interface用于声明注解，可以public，可以非public,注解中看似像方法的东西其实是一个个参数，方法名就是参数名的名称，获取时采用注解对象.参数名()进行获取，返回值类型的位置就是参数的类型（基本类型，Class,String,Enum,数组），可以通过default赋值，默认值一般为0或者“”，注解有默认值我们可以不用赋值，注解没有默认值使用的时候必须手动赋值，如果只有一个参数，我们经常叫做value,如果叫做value，赋值的时候可以value = 进行省略，注解可以通过反射机制进行元数据的访问，所以反射+注解的形式会被大量应用在框架中。

//定义一个注解：
//@Target(value = ElementType.METHOD)
//target表示我们的注解可以使用在什么位置
@Target(value = {ElementType.METHOD,ElementType.TYPE})
//retention表示我们的注解什么时候有效，retention默认是runtime
@Retention(value = RetentionPolicy.RUNTIME)
//表示是否将我们的注解保存奥Javadoc当中
@Documented
//表示是否子类是否可以集成父类中的该注解。
@Inherited
@interface MyAnnotation{
    String [] value() default {""};
}

第二章：反射

一：创建对象的四种方式

用new语句创建对象，这是最常用的创建对象的方式

运用反射手段，调用Java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法

调用对象的clone()方法

运用反序列化手段，调用java.io.ObjectInputStream对象的readObject()方法

二：反射机制

1：动态语言

动态语言是运行时可以改变其结构的语言，运行时代码可以根绝某些条件改变自身结构。

2：静态语言

静态语言是指运行时不能改变其代码的自身结构的语言。

反射允许程序在执行期间使用反射的api读取类中的内部信息，并能直接从操作任意对象的内部属性和内部方法。

三：反射可以提供的功能

在运行时判断任意一个对象所属的类，构造任意一个类的对象

运行时获取和调用任意一个类的属性和方法

运行时获取区类中任意位置的泛型信息和注解信息

生成动态代理

四：反射的优缺点

实现动态创建对象和编译，体现出很大的灵活性。

对性能有影响，反射基本上是一种解释性工作，性能较低。

五：反射主要的API

java.lang.Class:反射的核心类。
java.lang.reflect.Field：类的变量
java.lang.reflect.Method:类的方法
java.lang.reflect.Constructor：类的构造器
java.lang.reflect.ParameterizedType:类的泛型
java.lang.annotation.Annotation：类的注解

第三章：Class类和Class对象

一：Class类

Class类是反射中的核心类，这个类是java反射的源头。

二：Class对象

获取java中任何一个类都只有一个Class对象，获取这种Class对象共有五中，包含三种常规方法和两种特有的方法。

三：获取Class对象

1：类名.class

2：对象.getClass()此方法继承自Object

3：Class.forName(“com.yuming.mokuaiming.Name”)

4：内置基本类型数据可以直接用类名.Type

5：还可以使用ClassLoader类加载器

package reflaction;
/**
这个类用于说明，不同方式得到的Class对象是一个。
*/
public class Test02 extends Object {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class clazz1 = Class.forName("reflaction.User");
        System.out.println(clazz1);//class reflaction.User
        Class clazz2 = Class.forName("reflaction.User");
        Class clazz3 = Class.forName("reflaction.User");
        Class clazz4 = Class.forName("reflaction.User");
        System.out.println(clazz1.hashCode());
        System.out.println(clazz2.hashCode());
        System.out.println(clazz3.hashCode());
        System.out.println(clazz4.hashCode());
//        460141958
//        460141958
//        460141958   一个类在内存中只有一个Class对象，一个类被加载后，整个类的结构都会被封装在这个Class对象当中。
//        460141958   hashcode相同说明是一个类。
    }
}
//实体类，类中只有属性；pojo entity
class User{
    private int id;
    private int age;
    private String name;
    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }
    void show(){}
    public User() {
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

/**
创建Class对象的五中方式
*/
package reflaction;
public class Test03 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person.name);
        //方式一：通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());
        //方式二：forName方式获得；
        Class c2 = Class.forName("reflaction.Student");
        System.out.println(c2.hashCode());
        //方式三：通过类名.class可以直接获得。
        Class c3 = Student.class;
        System.out.println(c3.hashCode());
//        这个人是：学生
//        460141958
//        460141958
//        460141958
        //方式四：基本内置类型的包装类都有一个TYPE属性，
        Class c4 = Integer.TYPE;
        System.out.println(c4); //int
        Class c5 = c1.getSuperclass();
        System.out.println(c5);   //class reflaction.Person
    }
}

四：Class对象的细节补充

Class对象只能有系统进行建立

一个加载的类在JVM当中只能有一个Class对象，无论是采用哪种方式获得

一个Class对象对应的是加载到JVM当中的一个Class文件

每个类的实例都会记得自己是由哪个Class实例产生

通过Class对象可以完整的得到一个类中所有被加载的结构细节信息

Class类是反射的根源，动态加载、运行的类都必须获得响应的Class对象

1：JAVA动态加载类和静态加载类的区别

new创建对象的方式称作为静态加载，而使用Class.forName(“XXX”)称作为动态加载，它们俩本质的区别在于静态加载的类的源程序在编译时期加载（必须存在，必须导入类，并且new他的对象）而动态加载的类在编译时期可以缺席（源程序不必存在，写入类的路径就可以骗过编译器）

2：Class类的常用方法

##:3：都有哪些类可以有Class对象

共计七种：

Class：Class类本身、外部类、内部类：成员（成员内部类，静态内部类，局部内部类，匿名内部类）
interface 接口
数组（一维数组+二维数组）
枚举
注解
基本数据类型
Void

package reflaction;
import java.lang.annotation.ElementType;
//所有类型的class对象
public class Test04 {
    public static void main(String[] args) {
        Class c1 = Object.class;//类
        Class c2 = Comparable.class;//接口
        Class c3 = String[].class;//一维数组
        Class c4 = int[][].class;//二维数组
        Class c5 = Override.class;//注解
        Class c6 = ElementType.class;//枚举
        Class c7 = Integer.class;//基本数据类型
        Class c8 = void.class;//void
        Class c9 = Class.class;//Class
        //只要元素的类型和维度是一样的，Class就是一样的。
        int[] a = new int[10];
        int[] b = new int[20];
        System.out.println(a.getClass().hashCode() == b.getClass().hashCode());
//类             System.out.println(c1);      //class java.lang.Object
//接口           System.out.println(c2);      //interface java.lang.Comparable
//一维数组        System.out.println(c3);      //class [Ljava.lang.String;
//二维数组        System.out.println(c4);      //class [[I
//注解           System.out.println(c5);      //interface java.lang.Override
//枚举           System.out.println(c6);      //class java.lang.annotation.ElementType
//基本数据类型    System.out.println(c7);      //class java.lang.Integer
//void           System.out.println(c8);      //void
//Class          System.out.println(c9);      //class java.lang.Class
    }
}

4：反射获取类的运行时结构

创建运行时类的对象，首先需要获取运行时类的结构，这是两个不同的概念。

通过反射获取类运行时的完整的结构包括：

1、实现的全部的接口。

2、所继承的父类。

3、所有的构造器

4、所有的属性

5、所有的方法

6、所有的注解。

动态获取类的构造的对象。

package reflaction;
/**
 * 获取类的信息
 * */
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//获取类的信息
public class Test08 {//alt + shift + enter --方法上直接抛出异常信息。
    public static void main(String[] args) throws Exception{
        Class c1 = Class.forName("reflaction.User");
        //获取类的名字
        System.out.println(c1.getName());//reflaction.User 这个是全限定类名。
        System.out.println(c1.getSimpleName());//User 这个是单纯的类名。
        //获得类的属性
        //只能获取public修饰的属性
        System.out.println("====================================");
        Field[] fields = c1.getFields();
        //fields.for可以快速实现foreach。
        for (Field field : fields) {
            System.out.println(field);
        }
        //可以获取所有类型的属性
        System.out.println("====================================");
        Field[] fields1 = c1.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(fields);
//            [Ljava.lang.reflect.Field;@74a14482
//            [Ljava.lang.reflect.Field;@74a14482
//            [Ljava.lang.reflect.Field;@74a14482
        }
        //获取指定名称的属性--只能找到public类型的属性
//        Field field = c1.getField("name");因为找不到这个属性所以会抛出一个NoSuchFieldException,程序碰到异常之后就会停止。
//        System.out.println(field);
        //获取指定名称的属性--可以找到任何类型的属性
        Field field1 = c1.getDeclaredField("name");
        System.out.println(field1);//private java.lang.String reflaction.User.name
        //获取类的方法
        //1、获取所有类的方法--获取本类和父类所有的public修饰的方法
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(method);
//            public java.lang.String reflaction.User.toString()
//            public java.lang.String reflaction.User.getName()
//            public int reflaction.User.getId()
//            public void reflaction.User.setName(java.lang.String)
//            public void reflaction.User.setId(int)
//            public int reflaction.User.getAge()
//            public void reflaction.User.setAge(int)
//            public final void java.lang.Object.wait() throws java.lang.InterruptedException
//            public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
//            public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
//            public boolean java.lang.Object.equals(java.lang.Object)
//            public native int java.lang.Object.hashCode()
//            public final native java.lang.Class java.lang.Object.getClass()
//            public final native void java.lang.Object.notify()
//            public final native void java.lang.Object.notifyAll()
            //2、获取本类的所有的public和非public的方法
            System.out.println("=============================================");
            Method[] methods1 = c1.getDeclaredMethods();
            for (Method method1 : methods1) {
                System.out.println(method1);
//                public java.lang.String reflaction.User.toString()
//                public java.lang.String reflaction.User.getName()
//                public int reflaction.User.getId()
//                public void reflaction.User.setName(java.lang.String)
//                public void reflaction.User.setId(int)
//                void reflaction.User.show()
//                public void reflaction.User.setAge(int)
//                public int reflaction.User.getAge()
            }
            //3、获取指定方法
            Method method1 = c1.getMethod("getName",null);
            Method method2 = c1.getMethod("setName",String.class);
//            System.out.println(method1);public java.lang.String reflaction.User.getName()
//            System.out.println(method2);public void reflaction.User.setName(java.lang.String)
            //获取构造器
            //1、获取本类的所有的public的构造器
            System.out.println("==============================================");
            Constructor[] constructors = c1.getConstructors();
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
//                public reflaction.User(int,int,java.lang.String)
//                public reflaction.User()
            }
            //2、获取本类的所有的public和非public的构造器
            System.out.println("==============================================");
            Constructor[] constructor1 = c1.getDeclaredConstructors();
            for (Constructor constructor : constructor1) {
                System.out.println(constructor);
//                public reflaction.User(int,int,java.lang.String)
//                public reflaction.User()
            }
            //3、获取指定名称的构造器
            System.out.println("===============================================");
            Constructor constructor = c1.getConstructor(int.class,int.class,String.class);
            System.out.println(constructor);
            constructor = c1.getConstructor(Integer.TYPE,Integer.TYPE,"".getClass());
            System.out.println(constructor);
            constructor = c1.getConstructor(Integer.TYPE,Integer.TYPE,Class.forName("java.lang.String"));
            System.out.println(constructor);
            constructor = c1.getDeclaredConstructor(Integer.TYPE,Integer.TYPE,"".getClass());
            System.out.println(constructor);
            constructor = c1.getDeclaredConstructor(Integer.TYPE,Integer.TYPE,Class.forName("java.lang.String"));
            System.out.println(constructor);
//            public reflaction.User(int,int,java.lang.String)
//            public reflaction.User(int,int,java.lang.String)
//            public reflaction.User(int,int,java.lang.String)
//            public reflaction.User(int,int,java.lang.String)
//            public reflaction.User(int,int,java.lang.String)
        }
    }
}

package reflaction;
/**
 * 动态获取类运行时结构的对象
 * */
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//动态的创建类的运行时结构对象
public class Test09 {
    public static void main(String[] args) throws Exception {
        //获得User的Class对象
        Class c1 = Class.forName("reflaction.User");
        //创建一个User对象
        //本质上是调用了类的无参构造器。--如果没有无参构造器，就会报错。
//        User user = (User)c1.newInstance();
//        System.out.println(user);
        //通过构造器对象如何创建对象
//        Constructor constructor = c1.getConstructor(String.class, int.class, int.class);
        Constructor constructor = c1.getConstructor(int.class, int.class, String.class); //参数的个数、类型、顺序必须实际构造器保持一致。
        User user1 =(User)constructor.newInstance(001,10,"秦江");
        System.out.println(user1);
        //通过反射调用普通方法
        User user3 = (User)c1.newInstance();
        //获取指定名称的方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
        //激活方法执行方法--invoke（谁的方法，方法的参数） 返回值是原方法的返回值，原方法没有则返回null
        setName.invoke(user3, "kuangshen");
        System.out.println(user3);
        System.out.println(user3.getName());//kuangshen
        //通过方法调用属性
        User user4 = (User)c1.newInstance();
        Field field = c1.getDeclaredField("name");
        /**
         * 不能直接操作私有属性，我们需要关闭程序的安全检测，属性或者方法的setAccessble方法。
         * */
        field.setAccessible(true);//这样就不检查属性是否是private了。默认是FALSE
        field.set(user4,"狂神2"); //Class reflaction.Test09 can not access a member of class reflaction.User with modifiers "private"
        System.out.println(user4.getName());//狂神2
    }
}

4：关闭私有检查的效率问题

package reflaction;
import java.lang.reflect.Method;
//比较性能问题
public class Test10 {
    public static void main(String[] args) throws Exception {
        //普通方式
        test01();
        test02();
        test03();
//        普通方式执行10亿次：0ms
//        反射不关闭执行10亿次：2437ms
//        反射关闭私有检查执行10亿次：1109ms 关闭之后效率提升了两到三倍。
    }
    private static void test01(){
        User user = new User();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            user.getName();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式执行10亿次："+(endTime - startTime)+"ms");//普通方式执行10亿次：10ms
    }
    private static void test02() throws Exception {
        Class c1 = Class.forName("reflaction.User");
        User user = new User();
        Method method = c1.getMethod("getName",null);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(user);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射不关闭执行10亿次："+(endTime - startTime)+"ms");//普通方式执行10亿次：2347ms
    }
    private static void test03() throws Exception {
        Class c1 = Class.forName("reflaction.User");
        User user = new User();
        Method method = c1.getMethod("getName",null);
        method.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            method.invoke(user);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射关闭执行10亿次："+(endTime - startTime)+"ms");//普通方式执行10亿次：1206ms
    }
}

5：反射构建类运行时结构对象-泛型

package reflaction;
import sun.reflect.generics.tree.ReturnType;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
//通过反射获取泛型
public class Test11 {
    public void test01(Map<String,User> map, List<User> list){
        System.out.println("test01");
    }
    public Map<String,User> test02(){
        System.out.println("test02");
        return null;
    }
    public static void main(String[] args) throws Exception {
        Method method = Test11.class.getMethod("test01",Map.class,List.class);
        //获取带有泛型的参数类型
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        for (Type genericParameterType : genericParameterTypes) {
            System.out.println(genericParameterType);//例如：java.util.Map<java.lang.String, reflaction.User>
            if(genericParameterType instanceof ParameterizedType){
                //获取带有泛型的参数类型中的真实泛型类型
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument.getTypeName());//例如：java.lang.String，，reflaction.User
                }
            }
        }
//        java.util.Map<java.lang.String, reflaction.User>
//        java.lang.String
//        reflaction.User
//        java.util.List<reflaction.User>
//        reflaction.User
        System.out.println("===========================================================");
        Method test02 = Test11.class.getMethod("test02",null);
        Type genericReturnType = test02.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            System.out.println(genericReturnType.getTypeName());
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument.getTypeName());//例如：java.lang.String，，reflaction.User
            }
        }
    }
}

6：反射获取类运行时结构对象-注解

package reflaction;
//练习反射操作注解。
/*
 * 通过反射操作注解，我们以后用到的框架当中都是这样写的，
 * 他们在类中会有大量的注解，通过反射读取这个注解，进行
 * 响应的操作。
 */
import java.lang.annotation.*;
import java.lang.reflect.Field;
public class Test12 {
    public static void main(String[] args) throws Exception {
        Class c1 = Class.forName("reflaction.Student2");
        //通过反射获取注解
        Annotation[] annotations = c1.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation); //@reflaction.Tablekuang(value=db_student)
        }
        //获取注解value的值
        Tablekuang annotation = (Tablekuang)c1.getAnnotation(Tablekuang.class);
        String value  = annotation.value();
        System.out.println(value);//db_student
        //获得类指定的注解
        Field name = c1.getDeclaredField("name");
        Fieldkuang fieldkuang = name.getAnnotation(Fieldkuang.class);
        System.out.println(fieldkuang.column());    //        db_id
        System.out.println(fieldkuang.type());      //        varchar
        System.out.println(fieldkuang.length());    //        10
    }
}
@Tablekuang("db_student")
class Student2{
    @Fieldkuang(column = "db_id",type = "int",length = 10)
    private int id;
    @Fieldkuang(column = "db_id",type = "int",length = 10)
    private int age;
    @Fieldkuang(column = "db_id",type = "varchar",length = 10)
    private String name;
    public Student2(){
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student2{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
@SuppressWarnings("all")
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@interface Tablekuang{
    String value() ;
}
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldkuang{
    String column();
    String type();
    int length();
}

JavaSE基础篇：反射（二）

第一章：注解

一：注解引入

二：注解作用

三：注解定义格式

四：注解分类

1：元注解

2：内置注解

五：自定义注解

第二章：反射

一：创建对象的四种方式

二：反射机制

1：动态语言

2：静态语言

三：反射可以提供的功能

四：反射的优缺点

五：反射主要的API

第三章：Class类和Class对象

一：Class类

二：Class对象

三：获取Class对象

四：Class对象的细节补充

1：JAVA动态加载类和静态加载类的区别

2：Class类的常用方法

4：反射获取类的运行时结构

4：关闭私有检查的效率问题

5：反射构建类运行时结构对象-泛型

6：反射获取类运行时结构对象-注解

类加载和类加载器

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

JavaSE基础篇：反射（二）

第一章：注解

一：注解引入

二：注解作用

三：注解定义格式

四：注解分类

1：元注解

2：内置注解

五：自定义注解

第二章：反射

一：创建对象的四种方式

二：反射机制

1：动态语言

2：静态语言

三：反射可以提供的功能

四：反射的优缺点

五：反射主要的API

第三章：Class类和Class对象

一：Class类

二：Class对象

三：获取Class对象

四：Class对象的细节补充

1：JAVA动态加载类和静态加载类的区别

2：Class类的常用方法

4：反射获取类的运行时结构

4：关闭私有检查的效率问题

5：反射构建类运行时结构对象-泛型

6：反射获取类运行时结构对象-注解

类加载和类加载器

热门文章

最新文章

相关课程

相关电子书

相关实验场景