java笔录---反射机制(1)

引言

  为了方便记忆java的反射机制，在这里仔细的总结了一下。主要是怕以后忘记了，这样也方便回忆。因为最近利用空余时间深入的了解spring和Mybatis框架，

  像spring中核心模块IOC底层实现的原理就是反射机制，mybatis也是利用java的反射机制来获取和设置对象的值的。由此看来java反射机制还是很强大的，其实也蛮有趣的。

  Java语言允许通过程序化的方式间接对Class的对象实例操作，Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：构造函数、属性和方法等。Java允许用户借由这个Class相关的元信息对象间接调用Class对象的功能.

反射定义:

  JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。注意是在运行状态中。

  “程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。Java不是动态语言。但是Java有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

理解反射

看了定义有点稍微的明白了，

反射之中包含了一个“反”的概念，要解释反射就必须先从“正”开始解释，一般而言，要产生实例化对象一定要有类。如下：

import java.util.Date;//先导入类
public class ReflectionDemo {
    public static void main(String[] args) {     
        Date date = new Date();//再产对象       
        System.out.println(date);    
    }
}

而所谓的“反”，是通过对象找到类。在Object类里面提供有一个方法：

public final Class<!--?--> getClass()

通过getClass方法我们可以获取到这个对象对应的反射类

注：反射之中的所有泛型都定义为?，返回值都是Object。

import java.util.Date;//先导入类
public class ReflectionDemo {
    public static void main(String[] args) {     
        Date date = new Date();//再产对象 
        Class<?> c =date.getClass();
        System.out.println(c);
    }
}
输出为：class java.util.Date 

我们发现，调用getClass()后，得到了类的完整名称。也就找到了对象的出处

Class类对象实例化

  java.lang.Class是一个类，它和一般类一样继承自Objec。这个类是反射操作的源头，即所有的反射都要从此类开始进行，如何获取一个对象对应的反射类Class，在Java中我们有三种方法可以获取一个对象的反射类：

1.调用Object类的getClass()方法（很少用到）

即上述例子，此处略过。

2.调用Class类提供的一个静态方法forName：

//import java.util.Date;//先导入类
public class ReflectionDemo {
    public static void main(String[] args) throws Exception  {     
        Class<?> c = Class.forName("java.util.Date");
        System.out.println(c);
    }
}
输出：class java.util.Date

注意：此时，无需使用import语句导入一个明确的类，而类名称是采用字符串的形式进行描述的。

3.使用“类.class”取得：

import java.util.Date;//先导入类
public class ReflectionDemo {
    public static void main(String[] args){     
        Class<?> c = Date.class;
        System.out.println(c);
    }
}

反射实例化对象

一般情况下，对象的实例化操作需要依靠构造方法和关键字new完成。可是有了Class类对象之后，可以利用反射来实现对象的实例化。

Class<?> c = Class.forName("com.putao.Person");
    Person p = (Person)c.newInstance();//相当于使用new调用无参构造实例化对象
    p.setName("张三");
    System.out.println(p.getName());
输出：张三

  注意：newInstance只能调用默认的无参构造方法,若类中不提供无参构造方法，只能明确的调用有参构造方法。（一般创建类的时候尽量保留有无参构造）
Class类中有取得构造的方法

public Constructor<t> getConstructor(Class<!--?-->... parameterTypes)


Class<?> c = Class.forName("com.putao.Person");
//      Person p = (Person)c.newInstance();
//      p.setName("张三");
    Constructor<?> con = c.getConstructor(String.class,int.class);
    Object obj = con.newInstance("李四",22);//实例化对象
    Person p2 = (Person) obj;
    System.out.println(p2.toString());
输出：Person [name=李四, age=22]

工厂模式的实现

  程序的开发尽量降低耦合。而降低耦合的最好做法是使用接口，但是就算使用了接口也逃不出关键字new，所以实际上new是造成耦合的关键元凶。反射机制实例化对象的时候实际上只需要“包.类”就可以

    package com.putao;
    interface Fruit{
        public void eat();
    }
     
    class Apple implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat apple");
        }
    }
    class Grape implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat grape");
        }
    }
    class Orange implements Fruit{
        @Override
        public void eat(){
            System.out.println("eat orange");
        }
    }
     
    class Factory{
        public static Fruit getInstance(String className){
            /*if("apple".equals(className)){
                return new Apple();
            }else if("orange".equals(className)){
                return new Orange();
            }
            return null;*/
            Fruit f = null;
            try {
                f = (Fruit)Class.forName(className).newInstance();
     
            } catch (Exception e) {
                e.printStackTrace();
            }
            return f;
     
        }
    }
     
    public class FactoryDemo{
        public static void main(String[] args){
            /*Fruit f = Factory.getInstance("apple");
            f.eat();
     
            Fruit f1 = Factory.getInstance("orange");
            f1.eat();*/
     
            Fruit f1= Factory.getInstance("com.putao.Apple");
            f1.eat();
     
            Fruit f2 = Factory.getInstance("com.putao.Orange");
            f2.eat();
            Fruit f3 = Factory.getInstance("com.putao.Grape");
            f3.eat();
     
        }
    }
    输出：eat apple
    eat orange
    eat grape

即使后来增加了接口的子类，工厂类照样可以完成对象的实例化操作，这样的工厂类，可以应对于所有的变化。这就完成了解耦合的目的，而且扩展性非常强。

通过反射调用方法、成员

Class类中有

取得一个类中的全部方法：
public Method[] getMethods() throws SecurityException
取得指定方法：
public Method getMethod(String name, Class<?>... parameterTypes) throws
NoSuchMethodException, SecurityException
取得全部成员：
public Field[] getDeclaredFields() throws SecurityException
取得指定成员：
public Field getDeclaredField(String name) throws NoSuchFieldException, SecurityException

例：获取方法

Class<?> c = Class.forName("com.putao.Person");
    Object obj =c.newInstance();
    Method setMet = c.getMethod("setName", String.class);
    setMet.invoke(obj, "张三");//等价于调用person类的setName("张三")
    Method getMet = c.getMethod("getName");
    System.out.println(getMet.invoke(obj));//等价于调用person类的getName()方法
    输出：张三

例：获取属性

Class<?> c = Class.forName("com.putao.Person");
    Object obj =c.newInstance();    
    Field titleField = c.getDeclaredField("name");
    titleField.setAccessible(true);//解除封装
    titleField.set(obj, "张三");//相当于Person类对象.name = "张三"
    System.out.println(titleField.get(obj));//相当于Person类对象。name

转载于:https://www.cnblogs.com/favour/p/7282889.html