黑马程序员————java中类的加载、反射、动态代理、枚举

标签：类的加载   反射   动态代理   枚举   

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

类的加载、反射、动态代理、枚举

一.类的加载

1.加载：

2.连接：

3.初始化：

4.类的初始化时机

5.类的加载器：

二.反射

1.反射的概述

2.获取的Class对象的三种方式：

1).使用对象，调用getClass()；

2).静态的class属性；

3).Class类forName()方法；

三：通过反射获取和使用构造方法和类中成员变量即成员方法

1.获取构造方法：使用的都是class类中的方法

2.调用构造方法:使用Constructor中的方法

    3.获取成员属性：class类中的方法

4.获取、设置属性值：Field类中的方法

5.获取成员方法：class类中的方法

6.访问成员方法：Method类中方法

四.反射的重要应用：

1.通过反射运行配置文件的内容

public class Demo {
	public static void main(String[] args) throws Exception{
		
		/*
		//获取一个class类对象,使用三种方法中那一中，class类中静态方法
		Class aclass =Class.forName("cn.itcast.Test反射读取配置文件.line2");
		//由获得Class对象再得到一个该类的一个对象
		Object obj=aclass.getConstructor().newInstance();
		//得到的该类的一个成员方法
		Method m=aclass.getMethod("move", int.class);
		m.invoke(obj, 20);
		*/
		
		//定义一个class类对象
		Class aclass=Class.forName(getvalue("classname"));
		//通过反射，并调用构造方法，创建一个该类的对象
		Object obj=aclass.getConstructor(String.class).newInstance("好方法");
		//通过反射调用其成员方法
		aclass.getMethod(getvalue("methodname"), int.class).invoke(obj, 50);		
	}
	//通过定义一个方法来获取几种东西
	public static String getvalue(String str)throws IOException{
		//定义一个properties集合map集合，以便于读写文件
		Properties pro=new Properties();
		//定义一个输入流
		FileReader filein=new FileReader(new File("pro.properties"));
		//读取文件中内容到集合中
		pro.load(filein);
		//关闭资源
		filein.close();		
		return pro.getProperty(str);
	}
}
public class line2 {
	private String name;
	public line2(String name){
		this.name =name;
	}	
	public void move(int n){
		System.out.println("名字是："+name+"小伙的年龄是"+n);
	}
}

2.通过泛型越过泛型检查

public class Demo {
	public static void main(String[] args) throws Exception  {
		//定义一个集合
		ArrayList<Integer> list=new ArrayList<>();
		list.add(10);
		//使用反射创建此类的class对象,调用其方法
		Class aclass=ArrayList.class;//list.getclass();
		//获取其方法的对象，使用的参数为object.class,通用的类型
		Method m=aclass.getMethod("add", Object.class);
		m.invoke(list, "nihaoma ");
		System.out.println(list);
	}
}

3.通过泛型设置某个对象的某个属性为指定值

public class Demo {
	public static void main(String[] args) throws Exception {
		Cat c=new Cat();
		setValue(c,"name","bosimao");
		setValue(c, "age", 2);
		System.out.println("年龄："+c.getAge()+"名字："+c.getName());
	}


	private static void setValue(Object obj, String fieldName, Object value) throws Exception {
		Class aclass=obj.getClass();
		Field field=aclass.getDeclaredField(fieldName);
		//由于是私有属性，需要暴力访问
		field.setAccessible(true);
		field.set( obj, value);
	}	
}
public class Cat {
	private String name;
	private int age=0;
	
	public String getName(){
		return this.name;
	}
	public int getAge(){
		return this.age;
	}
}

五.动态代理

1.动态代理的概述

在程序运行过程中产生的这个对象，而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

2.代理模式：

public class Demo {//测试类
	public static void main(String[] args) {
		/*
		Student stu = new Student();
		stu.coding();
		*/
		//使用代理模式
		StudentProxy proxy = new StudentProxy();
		proxy.coding();
	}
}




public class StudentProxy {//代理类
	public void coding(){
		check();
		new Student().coding();
		zj();
	}
	//先期检查
	public void check(){
		System.out.println("先期检查......");
	}
	//后期总结
	public void zj(){
		System.out.println("后期总结.......");
	}
}




public class Student {//基础类
	public void coding(){
		System.out.println("做项目，写程序......");
	}
}

3.动态代理的步骤；

public class Demo {//测试类
	public static void main(String[] args) throws Exception {
		//多态的子类对象,使用proxy类中的方法newproxyInstace
		
		//Idao idaostu=(Idao) Proxy.newProxyInstance(Class.forName("cn.itcast.Test动态代理.Student").getClassLoader(), 
		//									Student.class.getInterfaces(),new MyInvocationhander(new Student()));
		
		Idao idaostu=(Idao) Proxy.newProxyInstance(Student.class.getClassLoader(), 
													Student.class.getInterfaces(),
													new MyInvocationhander(new Student()));
		idaostu.write();//需要使用的方法
	}
}




public class MyInvocationhander implements InvocationHandler {//实现接口，代理类
	
	private Object obj;//定义需要代理的对象
	public MyInvocationhander(Object obj) {
		this.obj=obj;
	}


	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object objmethod=method.invoke(obj);
		show();
		return objmethod;
	}


	private void show() {
		System.out.println("真是牛叉啊！！");
	}
}


public interface Idao {//自己定义接口
	public void write();
}


public class Student implements Idao {//自定义类，需要代理的类
		
	@Override
	public void write() {
		System.out.println("你好,动态代理！！");
	}
}

六.枚举

1.枚举概述

public abstract class MyColor3 {//抽象类也是可以定义多例模式
	public static final MyColor3 RED  = new MyColor3("红"){
		@Override
		void show() {
			System.out.println("我是红色的！");
		}};
	public static final MyColor3 GREEN = new MyColor3("绿"){
		@Override
		void show() {
			System.out.println("我是绿色的！");
		}};
	public static final MyColor3 BLUE = new MyColor3("蓝"){
		@Override
		void show() {
			System.out.println("我是蓝色的！");
		}};
	private String colorName;
	
	private MyColor3(String colorName){
		this.colorName = colorName;
	}
	
	public String toString(){
		return this.colorName;
	}
	
	abstract void show();
}

2.制作枚举步骤：

public enum MyColor3 {
	RED("红") {
		@Override
		void show() {
			System.out.println("我是红色的!");
		}
	},GREEN("绿") {
		@Override
		void show() {
			System.out.println("我是绿色的!");
		}
	},BLUE("蓝") {
		@Override
		void show() {
			System.out.println("我是蓝色的!");
		}
	};
	private String colorName;
	private MyColor3(String n){
		this.colorName = n;
	}
	
	public String getColorName(){
		return this.colorName;
	}
	
	abstract void show();
}

3.枚举类中常用方法，使用枚举对象调用

public class Demo {
	public static void main(String[] args) {
		MyColor3 c1 = MyColor3.RED;
		MyColor3 c2 = MyColor3.BLUE;
		
		System.out.println(c2.compareTo(c1));//索引值的减法
		System.out.println("name = " + c2.name());//BLUE
		//int ordinal()
		System.out.println("c2.ordinal() : " + c2.ordinal());
		System.out.println("c1.ordinal() : " + c1.ordinal());
		//String toString()
		System.out.println("c2.toString():" + c2.toString());
		//<T> T valueOf(Class<T> type,String name)
		MyColor3 c3 = c1.valueOf("RED");//将一个字符串转换为MyColor3对象
		MyColor3 c4 = MyColor3.valueOf(MyColor3.class,"BLUE");
		
		System.out.println(c3);
		System.out.println(c4);
		
		//values() 
		MyColor3[] result = c1.values();
		System.out.println("循环遍历：");
		for(MyColor3 c : result){
			System.out.println(c);
		}
	}
}

黑马程序员————java中类的加载、反射、动态代理、枚举

标签：类的加载   反射   动态代理   枚举   

原文地址：http://blog.csdn.net/lgplf/article/details/46565747