java反射

Java反射

在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法

Java反射机制主要提供了以下功能：

• 1.在运行时判断任意一个对象所属的类。

• 2.在运行时构造任意一个类的对象。

• 3.在运行时判断任意一个类所具有的成员变量和方法。

• 4.在运行时调用任意一个对象的方法。

Reflectio

Reflection是Java被视为动态（或准动态）语言的一个关键性质。　　这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息。

包括其modifiers（诸如public、static等）、 superclass（例如Object）、实现了的 interfaces （例如Serializable）、也包括其fields和methods的所有信息，并可于运行时改变fields内容或调用methods。

换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。

这种“看透”class的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

Java Reflection API简介：

在JDK中，主要由以下类来实现Java反射机制，这些类（除了第一个）都位于java.lang.reflect包中

Class类：代表一个类，位于java.lang包下。

Field类：代表类的成员变量（成员变量也称为类的属性）。　　Method类：代表类的方法。

Constructor类：代表类的构造方法。

Array类：提供了动态创建数组，以及访问数组的元素的静态方法

Class对象

要想使用反射，首先需要获得待操作的类所对应的Class对象。　　Java中，无论生成某个类的多少个对象，这些对象都会对应于同一个Class对象。

这个Class对象是由JVM生成的，通过它能够获悉整个类的结构。　　常用的获取Class对象的3种方式：

1.使用Class类的静态方法。例如:　　Class.forName(“java.lang.String”);

2.使用类的.class语法。如:String.class;

3.使用对象的getClass()方法。如：Student stu = new Student(); stu.getClass()

反射初步操作

package com.hp.demo;
import java.util.Date; 	// 导入所需要的类
public class TestDemo {  
    public static void main(String[]args) throws Exception {   
        Date date = new Date();				// 产生实例化对象   
        System.out.println(date.getClass());		// 直接反射输出，返回Class类型的对象     
        System.out.println(Date.class);  
    }}

利用反射实例化对象

package com.hp.demo;
class Book {
    public Book() {
        System.out.println("********** Book类的无参构造方法 ***********");
    }
    @Override
    public String toString() {
        return "《名师讲坛——Java开发实战经典》";
    }
}
public class TestDemo {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("com.hp.demo.Book");		// 设置要操作对象的类名称
        // 反射实例化后的对象返回的结果都是Object类型
        Object obj = cls.newInstance(); 						// 相当于使用new调用无参构造
        Book book = (Book) obj;								// 向下转型
        System.out.println(book);

利用反射实现工厂设计模式

设计模式就是一种编程思想 ，都是为了便利开发的。

一般会将 工厂设置为 接口类（Java提倡面向接口编程，有利于实现多态）

package com.hp.test;
interface Fruit {
    public void eat() ;
}
class Apple implements Fruit {
    @Override
    public void eat() {
        System.out.println("** 吃苹果！");
    }
}
class Orange implements Fruit {
    @Override
    public void eat() {
        System.out.println("** 吃橘子！");
    }
}
class Factory {  //不要被名字混淆，类名可以随意
    public static Fruit getInstance(String className) {
        Fruit f = null;
        try {	// 反射实例化，子类对象可以使用Fruit接收
            f = (Fruit) Class.forName(className).newInstance();
        } catch (Exception e) {}		// 此处为了方便不处理异常
        return f;
    }
}
public class TestFactory {
    public static void main(String[] args) {	// 直接传递类名称
        Fruit fa = Factory.getInstance("com.hp.test.Apple") ;
        Fruit fb = Factory.getInstance("com.hp.test.Orange") ;
        fa.eat();
        fb.eat();
    }
}

错误的反射实例化操作(笔试题)

package com.hp.demo;
class Book {
    private String title ;
    private double price ;
    public Book(String title, double price) {
        this.title = title ;
        this.price = price ;
    }
    @Override
    public String toString() {
        return "图书名称：" + this.title + "，价格：" + this.price ;
    }
}
public class TestDemo {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("com.hp.demo.Book") ;
        Object obj = cls.newInstance() ;		// 相当于使用new调用无参构造实例化
        System.out.println(obj);
    }
}

明确调用类中的有参构造

package com.hp.demo;
import java.lang.reflect.Constructor;
class Book {
    private String title ;
    private double price ;
    public Book(String title, double price) {
        this.title = title ;
        this.price = price ;
    }
    @Override
    public String toString() {
        return "图书名称：" + this.title + "，价格：" + this.price ;
    }
}
public class TestDemo {
    public static void main(String[] args) throws Exception {
        Class<?> cls = Class.forName("com.hp.demo.Book") ;
        // 明确地找到Book类中两个参数的构造，第一个参数类型是String，第二个是double
        Constructor<?> con = cls.getConstructor(String.class,double.class) ;
        Object obj = con.newInstance("Java开发实战经典",79.8) ;		// 实例化对象，传递参数内容
        System.out.println(obj);
    }
}

使用反射操作简单Java类的属性

package com.hp.demo;
import java.lang.reflect.Method;
class Book {
private String title ;

    public void setTitle(String title) {
        this.title = title;
    }
    public String getTitle() {
        return title;
    }
}
public class TestDemo {
通过反射代替上面的getxx() 和 setxx()方法的功能
    public static void main(String[] args) throws Exception {
        String fieldName = "title" ;						// 要操作的成员名称
        Class<?> cls = Class.forName("com.hp.demo.Book") ;	// 取得要操作类的反射对象
        Object obj = cls.newInstance() ;					// 必须实例化对象
        // 取得类中的setTitle()方法，由于title需要首字母大写，所以调用init()处理，参数类型为String
        Method setMet = cls.getMethod("set" + initcap(fieldName), String.class) ;
        // 取得类中的getTitle()方法，本方法不接收参数并且没有返回值类型声明
                Method getMet = cls.getMethod("get" + initcap(fieldName)) ;
        setMet.invoke(obj, "Java开发实战经典") ; 	// 等价于：Book类对象.setTitle("Java开发实战经典")
        System.out.println(getMet.invoke(obj));		// 等价于：Book类对象.getTitle()
    }
    public static String initcap(String str) {			// 首字母大写操作
        return str.substring(0, 1).toUpperCase() + str.substring(1) ;
    }
}