【基础】-----反射的理解

创建某类A的类类型的三种方式：

1.A.class

2.A a= new A(); a.getClass();

3.Class.ForName("类的全称")；

根据类类型得到某类A的实例化

class.newInstance();

package com.wisdomtraffic.common;

public class ClassDemo {
  public static void main(String[] args) {
	Foo foo1=new Foo();
	//任何一个类都是Class类的实例对象，这个对象表示该类的类类型
	
	/*//第一种表示方式：*/	
	Class c1 =Foo.class; //表明任何一个类都有一个隐含的静态成员变量class
	
	/*//第二种表示方法：通过该类的实例对象创建该类的类类型*/
	Class c2=foo1.getClass();
	
	//c1,c2表示了Foo类的类类型
	
	System.out.println(c1==c2);  //true
	
	/*//第三种表示方式：Class.ForName()*/
	Class c3=null;
	try {
		c3= Class.forName("com.wisdomtraffic.common.Foo");
	} catch (ClassNotFoundException e) {
		e.printStackTrace();
	}
	System.out.println(c2==c3);  //true
	
	
	//可以通过类的类类型创建该类的对象
	try {
		Foo foo2 = (Foo)c1.newInstance();
	} catch (InstantiationException | IllegalAccessException e) {
		e.printStackTrace();
	}
  }

}
  
class Foo{}

动态加载类与静态加载类

编译时加载的类为静态加载类。运行时加载的类为动态加载类

new 创建的对象时静态加载类，编译时就加载。若有不存在的类，在编译时就出错

通过动态加载类Class.ForName("类的全称")可解决该问题

package com.wisdomtraffic.common;

public class Office {
	
	public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
	 //动态加载类，在运行时加载
		Class a=Class.forName(args[0]);
		//通过类类型，创建该类对象
		OfficeAble officeAble = (OfficeAble)a.newInstance();
		officeAble.start();
	}

}

package com.wisdomtraffic.common;

public interface OfficeAble {
	public void start();
}

package com.wisdomtraffic.common;

public class Word implements OfficeAble {
public void start(){
	System.out.println("word  /// ");
}
}

package com.wisdomtraffic.common;

public class Excel implements OfficeAble{

	@Override
	public void start() {
		System.out.println("Excel   ///");
		
	}

}

此时若Excel类不存在，使用Word类不会报错

基本的数据类型及void关键字都存在类类型

抽出部分代码重构方法：选中代码，右键-->rafactor-->ExtractMethod

根据反射操作类中的方法


package com.wisdomtraffic.common.MyTest;

import java.lang.reflect.Method;

public class ClassDemo2 {
   public static void main(String[] args) throws Exception{
	   A a1=new A();
	   Class c1 = a1.getClass();
	   Method method = c1.getMethod("print", int.class,int.class);
	   Object invoke = method.invoke(a1, 1,2);
}
}

class A{
	public void print(int a,int b){
		System.out.println(a+b);
	}
}

通过反射来认识泛型的本质

* 反射的操作都是编译之后的操作
   * c1==c2返回true，说明编译之后，集合的泛型是去泛型化的
   * java中集合的泛型是防止错误输入的，只在编译阶段有效，绕过编译后就失效了
   * 验证：通过反射来操作，绕过编译

 ArrayList a=new ArrayList();
	   ArrayList<String> a1=new ArrayList<String>();
	   a1.add("hello");
	   Class c1 = a.getClass();
	   Class c2 = a1.getClass();
	   System.out.println(c1==c2);  //true
	   /**
	    * 反射的操作都是编译之后的操作
	    * c1==c2返回true，说明编译之后，集合的泛型是去泛型化的
	    * java中集合的泛型是防止错误输入的，只在编译阶段有效，绕过编译后就失效了
	    * 验证：通过反射来操作，绕过编译
	    */
       Method m1 = c2.getMethod("add", Object.class);
       m1.invoke(a1, 20);
       System.out.println(a1.size());  //2

【基础】-----反射的理解

猜你喜欢