java程序中各个java类属于同一类事物,描述这类事物的java类名就是Class
比如说,很多人,用java来表示就用Person类,很多类,就用Class,Person类的实例对象比如张三、李四代表着一个个具体的人,而Class类就代表着各个类在内存中的字节码
一个类被类加载器加载进内存,会占用一片存储空间,这个空间的内容就是类的字节码,不同的类的字节码不同,所以他们在内存中的内容是不同,这些空间分别用一个一个对象来表示,这些对象具有相同的类型,这个类型就是Class
面试题:Class.forName("java.lang.String"),forName()的作用:
返回字节码,返回的方式有两种:1.这份字节码曾经被加载过,已经存在jvm中,那么就可以直接返回。2.jvm中没有,用类加载器去加载,加载后,字节码缓存到jvm中,以后再这份字节码就不需要加载了。
得到一个类的字节码有三种方法:
1.String.class
2.Person p = new Person(); p.getClass();对象.class
3.Class.forName("java.lang.String");
了解:一共有9个预定义Class对象,8个基本类型+void.class
数组类型的class实例对象,int[].class.isArray();int数组的字节码是数组
总之:只要是在源程序中出现的类型都有各自的class实例对象,int[]、void
演示:
<span style="white-space:pre"> </span>public static void main(String[] args)throws Exception {
String str1 = "abc";
Class class1 = str1.getClass();
Class class2 = String.class;
Class class3 = Class.forName("java.lang.String");
System.out.println(class1==class2);
System.out.println(class2==class3);
System.out.println(class1.isPrimitive());//是否是原始类型,false,它是类
System.out.println(int.class.isPrimitive());//true
System.out.println(int.class==Integer.class);//false
System.out.println(int.class==Integer.TYPE);//true
System.out.println(int[].class.isArray());//true
}
一位大牛总结的一句经典:反射就是把Java类中的各种成分映射成相应的Java类。
一个java类中用一个Class类的对象来表示,一个类的组成成分:构造函数,方法,成员变量,包等也同java类来表示,车本身是一个类,它的轮胎、发动机等等也是一个个类。java的Class类提供一系列方法来获得构造函数、方法、成员变量等信息,这些信息就是相应类的实例对象,Field、Method、Contructor、Package等。
一个类中的每个成员都有可以用相应的反射API类的一个实例对象来表示
System.exit(0);
System.gc();
System是一个类
exit、gc也是一个类
Method method1 代表exit()
method2 代表gc()
他们都属于Method类
这也就可以很好的理解java的核心思想:万物皆对象。不论是什么,都是对象
三、反射的应用
1.构造方法
Constructor类代表某个类中的一个构造方法
得到类的所有构造方法: Constructor[] constructors = Class.forName("java.lang.String").getConstructors();
得到类的一个构造方法: Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);
也可以是:Constructor constructor = String.class.getConstructor(StringBuffer.class);
在获得实例对象的时候要注意,指定实例对象的类型,因为编译器只知道是个对象,但是不知道是什么类型的对象String str = (String) constructor.newInstance(new StringBuffer("abc"));
2.成员变量
Field类代表某个类中的一个成员变量
注意fiedx代表的是x的定义,而不是具体的x变量,要想得到x的变量,就必须从对象上获取
public class Reflection {
private int x;
public int y;
public Reflection(int x, int y) {
super();
this.x = x;
this.y = y;
}
}
import java.lang.reflect.Field;
public class LreanReflect {
public static void main(String[] args)throws Exception{
Reflection re = new Reflection(3, 4);
Field fieldy = re.getClass().getField("y");
//fieldy是多少?4?错,fieldy不是对象身上的变量,而是类上,要用它取某个对象上的值
int st = (Integer)fieldy.get(re);
System.out.println(st);
//x是私有的
Field fieldx = re.getClass().getDeclaredField("x");//允许你看见,但是不让你用
fieldx.setAccessible(true);//暴力反射,不管它同不同意,我都要用
st = (Integer)fieldx.get(re);
System.out.println(st);
}
}
3.获取父类、带泛型的父类、父类的泛型、接口、包、注解 (重要***)
import static org.junit.Assert.*;
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import org.junit.Test;
import cn.cil.dao.DAO;
import cn.cil.dao.impl.Daoimpl;
import cn.cil.domain.Person;
public class DAO<T> {
public void save(){}
}
public class Daoimpl extends DAO<Person> {
}
public class Person {
<span style="white-space:pre"> </span>
<span style="white-space:pre"> </span>private String name;
<span style="white-space:pre"> </span>public void setName(String name) {
<span style="white-space:pre"> </span>this.name = name;
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>public String getName() {
<span style="white-space:pre"> </span>return name;
<span style="white-space:pre"> </span>}
<span style="white-space:pre"> </span>public static void get(){}
<span style="white-space:pre"> </span>
}
public class test {
private Daoimpl daoimp = new Daoimpl();
@Test
public void test1() {
// 获取 父类
Class clazz = daoimp.getClass().getSuperclass();
System.out.println(clazz.getName());
}
@Test
public void test2(){
/*获取父类的泛型 */
//获取父类
Class clazz = daoimp.getClass();
//获取带泛型的父类
Type type = clazz.getGenericSuperclass();
System.out.println(type.getTypeName());
}
@Test
public void test3(){
/* 获取 父类 的 泛型 */
//获取父类
Class clazz = daoimp.getClass();
//获取带泛型的父类
Type type = clazz.getGenericSuperclass();
//强转为其子类 -> 参数化
ParameterizedType params = (ParameterizedType)type;
//获取泛型数组
Type[] types = params.getActualTypeArguments();
System.out.println(((Class)types[0]).getName());
}
@Test
public void test4(){
/* 获取实现的接口 */
Class clazz = Person.class;
Class[] interfaces = clazz.getInterfaces();
}
@Test
public void test5(){
/* 获取 所在的 包 */
Class clazz = Person.class;
Package packge = clazz.getPackage();
}
@Test
public void test6(){
/* 获取 注解 */
Class clazz = Person.class;
//注意 注解的值 只有被声明为runtime的才可以被获取
Annotation[] annotations = clazz.getAnnotations();
}
}
将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"
import java.lang.reflect.Field;
public class LreanReflect {
public static void main(String[] args) throws Exception {
Reflection reflection = new Reflection(3, 4);
ChangeStringValue(reflection);
System.out.println(reflection);
}
private static void ChangeStringValue(Object obj) throws Exception{
Field[] fields = obj.getClass().getFields();
for(Field f : fields){
//if(f.getType().equals(String.class))//因为只有一份String的字节码
if(f.getType()==String.class){
String str = (String)f.get(obj);
//String value = str.replaceAll("b", "a");
String value = str.replace('b', 'a');
f.set(obj,value);//将更改后的值更新给Reflection
}
}
}
}
package ReflectLearn;
public class Reflection {
private int x;
public int y;
public String str1 = "ball";
public String str2 = "basketball";
public String str3 = "mail";
public Reflection(int x, int y) {
super();
this.x = x;
this.y = y;
}
@Override
public String toString(){
return str1+":"+str2+":"+str3;
}
}
3.成员方法
(1)调用方法
Method method = String.class.getMethod("charAt", int.class);
String str1 = "abc";
System.out.println(method.invoke(str1, 1));//invoke,调用
//如果xxx.invoke(null,1)第一参数是null,那么这个方法肯定是静态的,因为不需要对象
调用指定的属性
@Test
public void test7()throws Exception{
Class clazz = Person.class;
clazz.getModifiers();//获取属性的权限修饰符
//获取指定的属性(private ) ,getField()是获取public类型
Field name = clazz.getDeclaredField("name");
Person pser = (Person) clazz.newInstance();
name.setAccessible(true);//暴力访问
System.out.println(pser);
name.set(pser, "1"); // 把 pser 对象的 name 设置为 1
}
调用运行时类的指定的方法
@Test
public void test8()throws Exception{
Class clazz = Person.class;
Method m = clazz.getMethod("save");//public
Person p = (Person) clazz.newInstance();
m.invoke(p);// invoke 的返回值是 被调用的方法的返回值
Method m1 = clazz.getMethod("get");//static 方法
m1.invoke(Person.class);
Method m2 = clazz.getDeclaredMethod("update",String.class);//private 方法
m2.setAccessible(true);
m2.invoke(p, "123"); // p : 方法所在的对象
}
调用指定构造器
@Test
public void test9()throws Exception{
String className = "cn.cil.domain.Person";
Class clazz = Class.forName(className);
Constructor con = clazz.getDeclaredConstructor(String.class,int.class);
con.setAccessible(true);
Person p = (Person) con.newInstance("大卫",20);//创建 对应 的对象
System.out.println(p.getName());
}
(2)对接收数组参数的成员方法进行反射
写一个程序,这个程序能够根据用户提供的类名,取执行该类中的main方法
import java.lang.reflect.Method;
public class LreanReflect {
public static void main(String[] args) throws Exception {
//MyMain.main(new String[]{"11","22","33"});
String startingClassName = args[0];//这里需要设置一下main参数,因为我不知道要运行那个main方法
//run as ->run Configurations->Arguments(ReflectLearn.MyMain)
System.out.println(startingClassName);
Method mainMethod = Class.forName(startingClassName).getMethod("main", String[].class);
mainMethod.invoke(null, new Object[]{new String[]{"11","22","33"}});//打包
//mainMethod.invoke(null, (Object)new String[]{"11","22","33"});
//为什么要打包?main方法接受一个参数(字符串数组),我们传递给它一个字符串数组
//在JDK1.5一个数组就是对应一个参数,但是在JDK1.4,数组中的每一个元素对应一个参数
//我们传递一个String[],也就是一个Object数组,一打开,其中的每个元素都是一个参数,它就会认为收到3各参数
//所以,用Object数组,再打一个包,这样,我给你一包东西,打开后,是一个数组,这样就OK了
//正式因为,要拆开,所以我提前就给你打一个包
}
}
class MyMain{
public static void main(String[] args){
for(String s : args){
System.out.println(s);
}
}
}
(3)数组的反射
一个数组也是一个Object,每一个相同元素类型,以及相同维度的数组,都是同一个class
import java.lang.reflect.Array;
import java.util.Arrays;
public class LreanReflect {
public static void main(String[] args) throws Exception {
int[] arr1 = new int[3];
int[] arr2 = new int[4];
int[][] arr3 = new int[3][4];
String[] arr4 = new String[]{"a","b","c"};
System.out.println(arr1.getClass() == arr2.getClass());
System.out.println(arr1.getClass().getName());
System.out.println(arr1.getClass().getSuperclass().getName());
Object obj1 = arr1;
//Object[] obj2 = arr2;这样不行
Object[] obj3 = arr3;
Object obj4 = arr4;
Object[] obj5 = arr4;
System.out.println(Arrays.asList(arr1));
System.out.println(Arrays.asList(arr4));//字符串可以
printElement(arr1);
}
private static void printElement(Object arr1) {
Class c = arr1.getClass();
if(c.isArray()){
int len = Array.getLength(arr1);
for(int i = 0;i<len;i++){
System.out.println(Array.get(arr1,i));
}
}else{
System.out.println(arr1);
}
}
}
延伸:关于hashCode
当一个对象被存储进HashSet集合中,就不能修改这个对象中那些参与计算哈希值的字段了,否则,对象修改后的哈希值与最初存储进HasgSet集合中时的哈希值不同,这就导致了使用当前集合对象的contains取检查修改后的对象,发生检索失败的现象,从而导致了无法从HashSet集合中删除这个修改前的对象,进而致使内存泄露
public class Reflection {
private int x;
public int y;
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + x;
result = prime * result + y;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Reflection other = (Reflection) obj;
if (x != other.x)
return false;
if (y != other.y)
return false;
return true;
}
public Reflection(int x, int y) {
super();
this.x = x;
this.y = y;
}
}
public class ReflectTest2 {
public static void main(String[] args) {
Collection conCollection = new HashSet();
Reflection[] rs = new Reflection[]{
new Reflection(3, 3),new Reflection(4, 4),new Reflection(3, 3)
};
for(Reflection r : rs)
conCollection.add(r);
//rs[0].y = 1;
System.out.println(conCollection.contains(rs[0]));
boolean b = conCollection.remove(rs[0]);
System.out.println(b);
System.out.println(conCollection.size());
}
}
true
true
1
把注释打开
false
false
2
所以说,如果我们往集合中存对象,又改对象,再删对象,对象并没有被删除,以此日积月累,内存泄露。所以存进集中的对象,就不要
修改了
四、框架的概念及用反射技术开发框架的原理
反射的作用->实现框架
模拟一个超小型框架
config.properties
className=java.util.ArrayList
public class Reflection {
private int x;
public int y;
public Reflection(int x, int y) {
super();
this.x = x;
this.y = y;
}
}
public class ReflectTest2 {
public static void main(String[] args) throws Exception {
InputStream in = new FileInputStream("D:/JavaSourue/config.properties");
Properties pro = new Properties();//从配置文件中,得到是什么类
pro.load(in);
in.close();
String className = pro.getProperty("className");
Collection conCollection = (Collection)Class.forName(className).newInstance();
Reflection[] rs = new Reflection[]{
new Reflection(3, 3),new Reflection(4, 4),new Reflection(3, 3)
};
for(Reflection r : rs)
conCollection.add(r);
System.out.println(conCollection.size());
}
}
框架:
一个毛坯房就是一个框架,而用户自己装修门、窗等,用户使用的是框架,门和窗插入到框架中
框架和工具类的区别就是:工具类被用户所调用,而框架调用用户所提供的类
框架解决的问题:
房地产商在盖房子时(做框架),可能用户还没有买房,自然也就不会想到装修,那么框架怎么调用用户以后写的类?
因为在写框架时,无处得知以后要调用什么类,也就无法new对象,所以就必须用反射来解决这个问题
五、反射高级应用之动态代理
静态代理:特征是代理类和目标对象的类都是在编译期间就确定下来了,不利于程序的扩展,且每一个代理类只能为一个接口服务,这样在一个程序就必须产生过多的代理
动态代理:通过一个类完成全部的代理功能,指客户通过代理类调用其他对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理使用场合:
1.调试
2.远程方法调用
代理设计模式原理:
使用一个代理将对象包装起来,然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理类,代理对象决定是否以及何时将方法调用转到原始对象上。
静态代理的缺点:
interface GoodFactory {
public void productCloth();
}
class Nike implements GoodFactory{
@Override
public void productCloth() {
System.out.println("Nike 生成衣服...");
}
}
class ProxyFactory implements GoodFactory{
Nike n ;
ProxyFactory(Nike n){
this.n = n;
}
@Override
public void productCloth() {
n.productCloth();
}
}
public class GoodsFactory{
public static void main(String[] args){
Nike n = new Nike(); //被代理的类
ProxyFactory p = new ProxyFactory(n); // 代理类
p.productCloth(); // 对原始对象的调用 都要通过代理类 决定 是否或何时 调用
/*
* 缺点:
* 如果再出现一个 LiNing 被代理类,就必须再创建一个 新的 代理类
* */
}
}
动态代理
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
interface ClothFactory{
public void product();
}
class NikeClothFactory implements ClothFactory{
@Override
public void product() {
System.out.println("Nike生产衣服");
}
}
// 动态 代理类 需要实现 InvocationHandler 接口
class MyInvocationHandler implements InvocationHandler{
Object obj ; //实现了接口的 被代理类对象的 声明
public Object binld(Object obj){
this.obj = obj; //被代理的对象实例化
//返回一个代理类 参数:
// 被代理类的 getClassLoader() 类加载器 , 被代理类实现的接口 , 以及 代理类实现的 InvocationHandler
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(), this);
}
//当通过 代理类 对 被代理的 重写方法时候,都会转为调用 如下的 invoke()
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
method.invoke(obj, args);
return null;
}
}
public class TestProxy {
public static void main(String[] args){
NikeClothFactory n = new NikeClothFactory();
MyInvocationHandler handler = new MyInvocationHandler();
Object obj = (Object)handler.binld(n);
ClothFactory clothFactory = (ClothFactory) obj; //转型
clothFactory.product();
//这样,就可以实现 一个 代理类 完成众多的代理功能
}
}
总结:反射是动态语言的关键
代理模式的好处是:在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。为其他对象提供一种代理以控制对这个对象的访问。