Java基础反射reflect学习

Class类对象实例化(三种实例化方式)

package com.cvicse.reflect.demo;
/**
 * Class类对象实例化(三种实例化方式)
 * @author 13169
 *
 */
public class ClassDemo {

	public static void main(String[] args) throws ClassNotFoundException {
		/**
		 * 	使用关键字new实例化对象以及使用反射实例化对象有什么区别？
		 *	1.如果现在只是一个单纯的类进行对象的实例化，那么两者的区别不大，但相对而言，使用反射实例化对象，它的灵活度更高，
		 *	因为只需要传入“包.类”名称的字符串就可以取得实例化对象，比严谨性的new要宽松很多。
		 *	2.如果说现在是一个子类需要与父接口进行对象实例化，那么如果使用了关键字new,会造成接口对象耦合性增加的问题，
		 *	因为一个接口在使用就与固定的一个子类进行绑定了，而最早的解耦合的方式是利用工厂设计模式，但是为了让一个工厂类
		 *	可以使用所有接口子类的扩展要求，则可以利用反射完成。
		 */
		
		//1.第一种Class类实例化对象的方式
		//Date date = new Date();
		//Class<? extends Date> cls = date.getClass();
		//2.第二种Class类实例化对象的方式
		//Class<?> cls = java.util.Date.class;
		//3.第三种Class类实例化对象的方式
		//可能发生类找不到的情况，所以抛出ClassNotFoundException异常
		Class<?> cls = Class.forName("java.util.Date");
		System.out.println(cls);
	}

}

利用反射实例化对象

package com.cvicse.reflect.po;
//普通java类
public class Book {
	private String title ;
	private double price ;
	public Book() {
		System.out.println("Book 类的无参构造方法");
	}
	public Book(String title, double price) {
		this.title = title;
		this.price = price;
	}
	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public double getPrice() {
		return price;
	}

	public void setPrice(double price) {
		this.price = price;
	}

	@Override
	public String toString() {
		return "Book [title=" + title + ", price=" + price + "]";
	}
}

package com.cvicse.reflect.demo;
/**
 *	利用反射实例化对象
 * @author 13169
 */
public class InstanceDemo {

	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class<?> cls = Class.forName("com.cvicse.reflect.po.Book");
		//newInstance 实例化对象是调用的无参构造方法
		Object obj = cls.newInstance();
		System.out.println(obj);
	}

}

工厂设计模式（反射）解耦合，可扩展性很强

package com.cvicse.reflect.demo;
/**
 * 工厂设计模式（反射）解耦合，可扩展性很强
 * @author 13169
 *
 */
interface Fruit{
	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) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Class<?> cls = Class.forName(className);
		return (Fruit) cls.newInstance();
	}
}
public class FactoryDemo {

	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
		Fruit f = Factory.getInstance("com.cvicse.reflect.demo.Apple");
		//Fruit f=Factory.getInstance("com.cvicse.reflect.demo.Orange");
		f.eat();
	}

}

** 利用反射调用有参数构造方法（建议在普通Java类中有一个无参构造） **

package com.cvicse.reflect.demo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 利用反射调用有参数构造方法  （建议在普通Java类中有一个无参构造）
 * @author 13169
 *
 */
public class ConstructorDemo {

	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException {
		Class<?> cls = Class.forName("com.cvicse.reflect.po.Book");
		Constructor<?> con = cls.getConstructor(String.class,double.class);
		Object obj = con.newInstance("JAVA编程思想",102.3);
		System.out.println(obj);
		
	}

}

利用反射调用类中的方法

package com.cvicse.reflect.demo;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 	利用反射调用类中的方法
 * @author 13169
 *
 */
public class MethodDemo {

	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
		String fieldName="title"; //要操作的成员
		Class<?> cls = Class.forName("com.cvicse.reflect.po.Book");
		Object obj = cls.newInstance();
		Method setMet = cls.getMethod("set"+initcap(fieldName),String.class);
		Method getMet = cls.getMethod("get"+initcap(fieldName));
		setMet.invoke(obj, "Java编程思想");
		System.out.println(getMet.invoke(obj));
	}
	public static String initcap(String str) {
		return str.substring(0,1).toUpperCase()+str.substring(1);
	}

}

利用反射调用类中的（私有）属性

package com.cvicse.reflect.demo;

import java.lang.reflect.Field;

/**
 * 	利用反射调用类中的（私有）属性
 * @author 13169
 *
 */
public class FieldDemo {

	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, SecurityException {
		Class<?> cls = Class.forName("com.cvicse.reflect.po.Book");
		Object obj = cls.newInstance();
		Field field = cls.getDeclaredField("title"); 
		field.setAccessible(true);//取消封装 private关键字不起作用了，构造方法与普通方法也可以使用此方法取消封装
		field.set(obj, "Java编程思想");//相当于Book对象.title = "Java编程思想";
		System.out.println(field.get(obj));
		
	}

}