Java反射

java通常是先有类再有对象，有对象我就可以调用方法或者属性。反射其实是通过Class对象来调用类里面的方法。通过反射可以调用私有方法和私有属性。大部分框架都是运用反射原理

一、Class类的使用

１．在面向对象的世界中，完事万物都是对象
２．java语言中静态成员和普通数据类型不是对象
３．类也是对象，是java.lang.Class的实例对象

• 任何一个类都是Class的实例对象，有三种表示方式：
  Class c1 = myClass.class;
  Class c2 = myObject.getClass();
  Class c3 = Class.forName("com.myClass");

class Foo{
    public void print()
    {
        System.out.println("it is Foo");
    }
}
public class ClassDemo1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //Foo类的实例对象
        Foo foo1 = new Foo(); //foo1表示Foo类的实例对象

        /*
         * Foo这个类本身也是一个实例对象，就是Class（java.lang.Class）类的实例对象
         * /任何一个类都是Class类的实例对象, 该实例对象有三种表示方法
         */
        //第一种 --> 任何一个类都有一个隐含的静态成员变量class
        Class c1 = Foo.class; //c1表示Class类的实例对象

        //第二种，已知该类的对象, 通过该类对象的getClass方法表示
        Class c2 = foo1.getClass(); //c2表示Class类的实例对象

        /*
         * 以上c1,c2都表示Class类的实例对象，但是这个实例对象又是说Foo这个类
         * c1,c2表示Foo类的类类型 ( class type ), 因为Foo类可以理解为Class类的实例对象
         * 也就是世界万物皆对象，类也是对象，是Class类的实例对象
         * 这个对象我们称为该类的类类型
         */

        //不管c1 or c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象, 所以c1=c2
        System.out.println(c1==c2);//输出: true

        //第三种
        Class c3 = null;
        try {
            c3 = Class.forName("com.lxf.reflect.Foo");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println(c3==c2); //输出：true

        //我们可以通过类的类类型创建该类的实例--->通过c1 or c2 or c3创建Foo的实例
        try {
            Foo foo2 = (Foo)c2.newInstance(); //需要有无参数的构造方法
            foo2.print();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

二．静态加载

• 在编译java源文件的时候的加载类叫做静态加载,比如:Test.java文件如下

class Test{
  public static void main(String[] args) {
      People p = new People();
      p.eat();
  }
}

编译Test.java

javac Test.java
这时候People.class字节码文件并没有，所以在编译的时候会报错

创建People.java

class People
{
  public void eat()
  {
        System.out.println("我喜欢美食");
  }
}

此时在编译

先编译People.java
javac People.java //编译后会产生People.class字节码文件
javac Test.java     //编译后会产生Test.class字节码文件

执行Test

java Test  //会输出：我喜欢美食

三、动态加载

通过Class a=Class.forName(arg[0]);此时为动态加载，因为编译时不知道使用哪个类，因此编译没有加载任何类，通过编译。运行时，根据 Javac office.java word （word为arg[0]，也是类类型）,去确定a是哪个类。这就是动态加载。
实际问题举例：

class offic
{
   public static void main(String[] args)
   {
     if("Word".equals(args[0]))
     {
       Word w=new Word();
       w.start();
     }
     if("Excel".equals(args[0])
     {
       Excel e=new Excel();
       e.start();
     }
   }    
}

编译无法通过，Word类、Excel类和start()方法不存在。

class Word 
{
    public static void start(){
        System.out.println("Word.....start");
    }
}

创建Word类后，进行编译，仍会报错，Excel类不存在。如果我们只想用已经存在的Word类，此类方法也是无法实现的。因为new创建的对象是静态加载类，在编译时刻需要加载所有可能使用的类，不管你是否会用到。

class OfficeBetter 
{
    public static void main(String[] args) 
    {
        
        try
        {
            //动态加载类
            Class c=Class.forName(args[0]);
            //通过类类型创建该类对象
            OfficeAble oa=(OfficeAble)c.newInstance();
            oa.start();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

通过动态加载，编译过程中不会报错。编写借口OfficeAble直接创建对象，Word类和Excel类通过继承方式，实现不同方法。

interface OfficeAble
{
    public void start();
}

class Word implements OfficeAble
{
    public void start(){
        System.out.println("Word.....start");
    }
}

• 基本数据类型，void关键字都存在类类型

四、获取信息

• 1、获取方法信息
  Method类，方法对象，一个成员方法就是一个Method对象
  getMethods()方法获取的是所有public函数，包括父类继承而来的
  getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限

/**
     * 打印类的信息，包括类的成员函数、成员变量(只获取成员函数)
     * @param obj 该对象所属类的信息
     */
public static void printClassMethodMessage(Object obj){
        //要获取类的信息  首先要获取类的类类型
        Class c = obj.getClass();//传递的是哪个子类的对象  c就是该子类的类类型
        //获取类的名称
        System.out.println("类的名称是:"+c.getName());
        /*
         * Method类，方法对象
         * 一个成员方法就是一个Method对象
         * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
         * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
         */
        Method[] ms = c.getMethods();//c.getDeclaredMethods()
        for(int i = 0; i < ms.length;i++){
            //得到方法的返回值类型的类类型
            Class returnType = ms[i].getReturnType();
            System.out.print(returnType.getName()+" ");
            //得到方法的名称
            System.out.print(ms[i].getName()+"(");
            //获取参数类型--->得到的是参数列表的类型的类类型
            Class[] paramTypes = ms[i].getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }
    }

• 2、获取成员变量信息
  成员变量是java.lang.reflect.Field的对象
  1、Field类封装了关于成员变量的操作
  2、Field[] fs = c.getFields()方法获取所有public的成员变量Field[]信息
  3、c.getDeclaredFields获取的是该类自己声明的成员变量信息
  4、field.getType()获得成员类型的类类型
  5、field.getName()获得成员的名称

  /**
     * 获取成员变量的信息
     * @param obj
     */
    public static void printFieldMessage(Object obj) {
        Class c = obj.getClass();
        /*
         * 成员变量也是对象
         * java.lang.reflect.Field
         * Field类封装了关于成员变量的操作
         * getFields()方法获取的是所有的public的成员变量的信息
         * getDeclaredFields获取的是该类自己声明的成员变量的信息
         */
        //Field[] fs = c.getFields();
        Field[] fs = c.getDeclaredFields();
        for (Field field : fs) {
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName+" "+fieldName);
        }
    }

• 3、获取构造方法信息
  构造函数是java.lang.Constructor类的对象
  1、通过Class.getConstructor()获得Constructor[]所有公有构造方法信息
  2、建议getDeclaredConstructors()获取自己声明的构造方法
  3、Constructor.getName():String
  4、Constructor.getParameterTypes():Class[]

/**
     * 打印对象的构造函数的信息
     * @param obj
     */
    public static void printConMessage(Object obj){
        Class c = obj.getClass();
        /*
         * 构造函数也是对象
         * java.lang. Constructor中封装了构造函数的信息
         * getConstructors获取所有的public的构造函数
         * getDeclaredConstructors得到所有的构造函数
         */
        //Constructor[] cs = c.getConstructors();
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName()+"(");
            //获取构造函数的参数列表--->得到的是参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }
    }

JAVA中extends 与implements有啥区别？

1. 在类的声明中，通过关键字extends来创建一个类的子类。一个类通过关键字implements声明自己使用一个或者多个接口。
   extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用
   2.extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口 来实现，这样就要用到implements，继承只能继承一个类，但implements可以实现多个接口，用逗号分开就行了

五、方法的反射

1、获得类类型 A a1 = new A(); Class c= a1.getclass;
2、获得方法对象 Method getMet=c.getMethod("print",String.class,String.class);//忘了加引号 其中可以用new Class[]{}数组作为参数
3、反射，m.invoke(调用方法的对象，参数); 参数可以 new Object[]{}
4、反射结果和直接对象调用结果一样，本例都是 打印输出

六、Java反射机制

——通过反射了解集合泛型的本质
1：反射的操作都是编译之后的操作；就是运行阶段
2：java中集合的泛型是防止错误输入的；只在编译阶段有效，只要绕过编译就无效啦
1：注解是一个什么东西——一种技术，使用特定语法，能过比较简单的实现一些比较牛逼的功能
2：注解的功能什么？也就是都有什么类型的注解？注解都能干什么？还是说什么都能干？
3：有些注解是人家提供的，如果想自己编写注解，该怎么玩？然后就是什么情况下自己编写注解比较好？怎么才能又快又好的编写自己的注解？
4：想了解一下，框架中注解是怎么使用的比如：Spring框架

七、Java自带的常用注解：

• @Overrid （覆盖）覆盖了父类的方法
• @Deprecated（弃用）过时了的方法，不能删掉，有可能导致错误，所以注解成过时。
• @Suppvisewarnings（忽略）调用deprecated方法会导致警告，使用@Suppvisewarning("deprecation")注解会忽略掉这个警告

常见第三方注解

Spring:@Autowired @Service @Repository

• @Autowired：可以对成员变量、方法和构造函数进行标注，来完成自动装配的工作
  用法：

public class UserManagerImpl implements UserManager {
   @Autowired 
   private UserDao userDao;
}

• @Service：定义某个类为一个bean，则在这个类的类名前一行使用@Service("XXX"),就相当于讲这个类定义为一个bean，bean名称为XXX。而无需去xml文件内去配置。

Paste_Image.png

• 源码注解：只存在于源代码中，编译后就没有了。
• 编译时注解：存在源代码和.class文件中
• 注解的分类：
  按照运行机制分类：源码注解；编译时注解；运行时注解。
  按照来源分类：来自JDK（如override）；来自第三方（如spring的autowired）；自定义注解。
• 元注解：给注解的注解。
• 自定义注解的语法
  （1）使用@interface关键字定义注解
  （2）无参无异常声明成员
  （3）可用default为成员指定一个默认值
  （4）合法成员类型，包括：原始、String、Class、Annotation和Enumeration
  （5）如只有一个成员，则成员名必须为value(),且使用时可忽略"成员名="
  （6）无成员的注解称为标识注解
• 元注解：注解自定义注解的注解
  @Target（作用范围）：使用ElementType增加范围
  Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）
  1.CONSTRUCTOR:用于描述构造器
  　　　　2.FIELD:用于描述域
  　　　　3.LOCAL_VARIABLE:用于描述局部变量
  　　　　4.METHOD:用于描述方法
  　　　　5.PACKAGE:用于描述包
  　　　　6.PARAMETER:用于描述参数
  　　　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明
  @Rentention（作用时长）：使用RetentionPolicy限制
  1.SOURCE:在源文件中有效（即源文件保留）
  　　　　2.CLASS:在class文件中有效（即class保留）
  　　　　3.RUNTIME:在运行时有效（即运行时保留）
  @Inherited（可继承性）：允许子类继承
  如果继承的是借口，注释无法被继承；如果继承的时类，则只有类上的注释可以被继承，方法上的注释无法被继承。
  @Documented（生成文档）:可生成在JavaDoc文档

Paste_Image.png

Paste_Image.png

如果注解只有一个成员，则成员名必须取名为value(),在使用时可以忽略成员名和赋值号（=），这是一个约定俗成的规则，不这样使用也可以编译通过。
解析注解：

Paste_Image.png

Paste_Image.png