标签：
——- android培训、java培训、期待与您交流！ ———-
A:类的加载概述
连接
初始化 就是我们以前讲过的初始化步骤
A:反射概述
B:三种方式
public class ReflectTest
{
public static void main(String[] args) throws Exception
{
String str = "abc";
Class cls1 = str.getClass();
Class cls2 = String.class;
Class cls3 = Class.forName("java.lang.String");
//说明他们是同一份字节码
System.out.println(cls1==cls2);//true
System.out.println(cls1==cls3);//true
System.out.println(cls1.isPrimitive());//false
System.out.println(int.class.isPrimitive());//true
System.out.println(int.class == Integer.class);//false
System.out.println(Integer.class.isPrimitive());//false
System.out.println(int.class == Integer.TYPE);//true
System.out.println(int[].class.isPrimitive());//false
System.out.println(int[].class.isArray());//true运行结果：
注意：
数组类型的Class实例对象
Class.isArray();
/*
榨汁机(Juicer)榨汁的按例
分别有水果(Fruit) 苹果 香蕉 橘子 榨汁
注: 本例为了突出核心代码,没有进行异常处理
*/
import java.io.*;
public class ReflectDemo
{
public static void main(String[] args) throws Exception
{
//没有用反射 只有多态
// Juicer j = new Juicer();//买榨汁机
// j.run(new Apple());//往榨汁机里面扔苹果
// j.run(new Orange());
//利用反射和配置文件
//创建流对象,关联配置文件
BufferedReader br = new BufferedReader(new FileReader("d:\\config.properties"));
//,获取该类的字节码对象, 读取配置文件一行内容
Class clazz = Class.forName(br.readLine());
//通过字节码对象创建对象实例
Fruit f = (Fruit)clazz.newInstance();//父类引用指向子类对象 水果的引用指向了苹果对象
Juicer j = new Juicer();//创建一个榨汁机对象
j.run(f);
}
}
interface Fruit
{
public void squeeze();
}
class Apple implements Fruit
{
public void squeeze()
{
System.out.println("榨苹果汁");
}
}
class Orange implements Fruit
{
public void squeeze()
{
System.out.println("榨橘子汁");
}
}
class Juicer
{
public void run(Fruit f)
{
f.squeeze();
}
}运行结果:
总结:
通过反射,大大简化了代码的应用场景.在本例中,要改变程序的功能只需要修改相应的配置文件即可,而不用大费周折的修改源码.
从另一方面看, 大大增强了程序的安全性和健壮性.
/*
注意: 为了程序简便.本例没有加上Person类.
*/
import java.lang.reflect.*;
class ReflectDemo2
{
public static void main(String[] args) throws Exception
{
Class clazz = Class.forName("Person");
// Person p = (Person)clazz.newInstance();//通过无参构造对象
// System.out.println(p);
//获取有参数构造
Constructor c = clazz.getConstructor(String.class,int.class);
//通过有参构造创建对象
Person p = (Person)c.newInstance("张三",22);
System.out.println(p);
}
}运行结果:
代码实现如下:
import java.lang.reflect.*;
class ReflectDemo3
{
public static void main(String[] args) throws Exception
{
Class clazz = Class.forName("Person");
Constructor c = clazz.getConstructor(String.class,int.class);
Person p = (Person)c.newInstance("张三",22);
//因为姓名字段是private的 因此获取不到
//Field f = clazz.getField("name");//获取姓名字段
//f.set(p,"李四");//修改姓名
//通过暴力反射获取字段
Field f = clazz.getDeclaredField("name");
f.setAccessible(true);//取出权限
f.set(p,"李四");
System.out.println(p);
}
}运行结果:
示例代码:
import java.lang.reflect.*;
class ReflectDemo4
{
public static void main(String[] args) throws Exception
{
Class clazz = Class.forName("Person");
Constructor c = clazz.getConstructor(String.class,int.class);
Person p = (Person)c.newInstance("张三",22);
Method m = clazz.getMethod("eat"); //获取Method方法
m.invoke(p);
Method m2 = clazz.getMethod("eat",int.class);//获取有参的方法
m2.invoke(p,10);//运行放法
}
}运行结果:
/*
* A:案例演示 泛型擦除 泛型反射
* ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？
泛型只在编译期有效,在运行期会被擦除掉
*/
import java.util.*;
import java.lang.reflect.*;
class ReflectTest1
{
public static void main(String[] args) throws Exception
{
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(111);
list.add(222);
//获取字节码对象
Class clazz = Class.forName("java.util.ArrayList");
//获取add方法
Method m = clazz.getMethod("add",Object.class);
m.invoke(list,"abc");//运行方法
System.out.println(list);
}
}运行结果:
总结:
泛型只在编译期有效,在运行期会被擦除掉
import java.lang.reflect.*;
class ReflectTest2
{
public static void main(String[] args) throws Exception
{
//创建Student实例
Student s = new Student("张三",23);
System.out.println("修改前的信息: "+s);
Tool t = new Tool();//创建工具类实例
t.setProperty(s,"name","李四");
System.out.println("修改后的信息: "+s);
}
}
//工具类
class Tool
{
//此方法可将obj对象中名为propertyName的属性的值设置为value
public void setProperty(Object obj, String propertyName, Object value)throws Exception
{
Class clazz = obj.getClass();//获取字节码对象
Field f = clazz.getDeclaredField(propertyName);//暴力反射获取字段
f.setAccessible(true);//取出权限
f.set(obj,value);
}
}
class Student
{
private String name;
private int age;
public Student()//无参构造方法
{
}
public Student(String name,int age)//有参构造方法
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public void setName(String name)
{
this.name = name;
}
public void setAge(int age)
{
this.age = age;
}
public String toString()
{
return "name= "+name+", "+"age="+age;
}
}运行结果:
import java.io.*;
import java.lang.reflect.*;
class ReflectTest3
{
public static void main(String[] args) throws Exception
{
//创建输入流 关联配置文件
BufferedReader br = new BufferedReader(new FileReader("D:\\xxx.txt"));
Class clazz = Class.forName(br.readLine());//读取配置文件中的类名 获取字节码对象
DemoClass dc = (DemoClass)clazz.newInstance();//通过字节码对象创建对象
dc.run();
}
}
class DemoClass
{
public void run()
{
System.out.println("Welcome to heima");
}
}运行结果:
A:动态代理概述
动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
标签：
原文地址：http://blog.csdn.net/u010247281/article/details/50486931
