反射机制：java.lang.reflect

面向对象编程的基本特点：封装、继承和多态。因此下面的例子就用到了接口、抽象类和子类等。
Animal接口：
[java] view plaincopy
package com.taobao.demo;
public interface Animal {
void eat();
void say();
}
AbstractAnimal抽象类：
[java] view plaincopy
package com.taobao.demo;
public abstract class AbstractAnimal implements Animal {
public String name;
private Gender gender;
public AbstractAnimal() {}
public AbstractAnimal(String name, Gender gender) {
this.name = name;
this.gender = gender;
}
@Override
public void eat() {
System.out.println(“eat…”);
}
@Override
public void say() {
System.out.println(“say…”);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Gender getGender() {
return gender;
}
public void setGender(Gender gender) {
this.gender = gender;
}
public enum Gender {
MALE, FEMALE;
}
}
Cat类：
[java] view plaincopy
package com.taobao.demo;

public class Cat extends AbstractAnimal implements Animal {
//给猫添加一个私有属性
private Color eyeColor;
public Cat() {}
public Cat(String name, Gender gender, Color eyeColor) {
super(name, gender);
this.eyeColor = eyeColor;
}
@Override
public void eat() {
System.out.println(“I like to eat fish.”);
}
@Override
public void say() {
System.out.println(“miao…miao…miao…”);
}
public Color getEyeColor() {
return eyeColor;
}
public void setEyeColor(Color eyeColor) {
this.eyeColor = eyeColor;
}
public enum Color {
WHITE,BLUE,YELLOW,BLACK;
}
}
Dog类：
[java] view plaincopy
package com.taobao.demo;
public class Dog extends AbstractAnimal implements Animal {
//给狗添加一个私有属性
private int age;
public Dog() {}
public Dog(String name, Gender gender, int age) {
super(name, gender);
this.age = age;
}
@Override
public void eat() {
System.out.println(“I like to eat bone.”);
}
@Override
public void say() {
System.out.println(“wang…wang…wang…”);
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
}
上面这些类都是基础类，为了做实验用的基本类。也是为了实践而专门写的无意义的类。
AnimalFactory类：
[java] view plaincopy
package com.taobao.demo.factory;
import com.taobao.demo.Animal;
public class AnimalFactory {
public static Animal getInstance(String className)
throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return (Animal) Class.forName(className).newInstance();
}
}

测试反射实践：

[java] view plaincopy
package com.taobao.demo.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import com.taobao.demo.AbstractAnimal;
import com.taobao.demo.Animal;
import com.taobao.demo.Cat;
import com.taobao.demo.factory.AnimalFactory;

public class ReflectPractice {
public static void main(String[] args) throws Exception {
//所有类的对象都是Class的实例
Class<?> clazz1 = Class.forName(“com.taobao.demo.Cat”);
Class<?> clazz2 = new Cat().getClass();
Class<?> clazz3 = Cat.class;
//判断以上三个是不是同一个类
System.out.println(clazz1.equals(clazz2) && clazz1.equals(clazz3));
//输出类名
System.out.println(clazz1.getName());

//通过多种方式获得一个类的实例对象
Cat cat0 = (Cat) clazz1.newInstance();
Cat cat1 = new Cat();
//通过class调用Cat类的构造方法，默认获得的构造方法的顺序比较奇怪
Cat cat2 = (Cat) clazz1.getConstructors()[1].newInstance(“miaomiao”, AbstractAnimal.Gender.MALE, Cat.Color.YELLOW);
//通过指定参数类型来获取对应的构造器
Constructor<?> csr = clazz1.getConstructor(String.class, AbstractAnimal.Gender.class, Cat.Color.class);
//打印该构造器的方法定义，返回值、参数类型等
System.out.println(csr.toGenericString());
//通过该构造器构造出实例对象
Cat cat3 = (Cat) csr.newInstance(“miaomiao”, AbstractAnimal.Gender.MALE, Cat.Color.YELLOW);

//获取父类和接口信息
Class<?> superClass = clazz2.getSuperclass();
System.out.println(“父类名为：”+superClass.getName());

Class<?> clazz4 = Class.forName(clazz2.getSuperclass().getName());
System.out.println(clazz4.getName());

Class<?>[] interfaces = clazz3.getInterfaces();
for(Class<?> interf: interfaces) {
System.out.println(interf.getName());
}

//获取成员属性
Field[] fields = clazz3.getDeclaredFields();
for(Field field : fields) {
System.out.println(field.getName());
}
//获取父类的属性，private和protected类型的获取不到
Field[] fields2 = clazz3.getFields();
System.out.println(“父类属性”+fields2.length);
for(Field field : fields2) {
System.out.println(field);
}

//获取成员方法
Method[] meths = clazz3.getMethods();
for(Method method : meths) {
System.out.println(method);
}

//调用其它类的方法
Method method = clazz1.getMethod(“say”);
Cat catt = (Cat) clazz1.newInstance();
method.invoke(catt);
method = clazz1.getMethod(“setEyeColor”, Cat.Color.class);
method.invoke(catt, Cat.Color.YELLOW);
System.out.println(catt.getEyeColor());

//通过反射操作属性
Field field = clazz1.getField(“name”);
field.set(cat0, “xiaomao”);
System.out.println(field.get(cat0));

//测试工厂方法
Animal animal = AnimalFactory.getInstance(“com.taobao.demo.Cat”);
animal.getClass().newInstance().say();
}
}