开始时间:2018年8月15日08:58:57 | 2018年8月15日17:02:11| 2018年8月15日22:19:35
结束时间:2018年8月15日12:08:07 | 2018年8月15日18:02:19| 2018年8月15日23:29:27
累计时间:5小时
知乎推荐 https://www.zhihu.com/question/24304289/answer/147529485
再补充一下泛型知识点,下面会涉及 https://blog.csdn.net/s10461/article/details/53941091/
溯源-------理解class类
获取方式:
其中方式3为动态效果
还有一种方式 通过类加载器调用 (了解即可)
类加载器和双亲委派模式有关 ,暂时还不太会用:https://blog.csdn.net/javazejian/article/details/73413292这个大神写的很好
具体例子如下:
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;
import org.junit.Test;
public class TestReflection {
//关于类的加载器:ClassLoader
@Test
public void test5() throws Exception{
ClassLoader loader1 = ClassLoader.getSystemClassLoader();
System.out.println(loader1);
ClassLoader loader2 = loader1.getParent();
System.out.println(loader2);
ClassLoader loader3 = loader2.getParent();
System.out.println(loader3);
Class clazz1 = Person.class;
ClassLoader loader4 = clazz1.getClassLoader();
System.out.println(loader4);
String className = "java.lang.String";
Class clazz2 = Class.forName(className);
ClassLoader loader5 = clazz2.getClassLoader();
System.out.println(loader5);
//掌握如下
//法一:
ClassLoader loader = this.getClass().getClassLoader();
InputStream is = loader.getResourceAsStream("com\\atguigu\\java\\jdbc.properties");
//法二:
// FileInputStream is = new FileInputStream(new File("jdbc1.properties"));
Properties pros = new Properties();
pros.load(is);
String name = pros.getProperty("user");
System.out.println(name);
String password = pros.getProperty("password");
System.out.println(password);
}
//如何获取Class的实例(3种)
@Test
public void test4() throws ClassNotFoundException{
//1.调用运行时类本身的.class属性
Class clazz1 = Person.class;
System.out.println(clazz1.getName());
Class clazz2 = String.class;
System.out.println(clazz2.getName());
//2.通过运行时类的对象获取
Person p = new Person();
Class clazz3 = p.getClass();
System.out.println(clazz3.getName());
//3.通过Class的静态方法获取.通过此方式,体会一下,反射的动态性。
String className = "com.atguigu.java.Person";
Class clazz4 = Class.forName(className);
// clazz4.newInstance();
System.out.println(clazz4.getName());
//4.(了解)通过类的加载器
ClassLoader classLoader = this.getClass().getClassLoader();
Class clazz5 = classLoader.loadClass(className);
System.out.println(clazz5.getName());
System.out.println(clazz1 == clazz3);//true
System.out.println(clazz1 == clazz4);//true
System.out.println(clazz1 == clazz5);//true
}
/*
* java.lang.Class:是反射的源头。
* 我们创建了一个类,通过编译(javac.exe),生成对应的.class文件。之后我们使用java.exe加载(JVM的类加载器完成的)
* 此.class文件,此.class文件加载到内存以后,就是一个运行时类,存在在缓存区。那么这个运行时类本身就是一个Class的实例!
* 1.每一个运行时类只加载一次!
* 2.有了Class的实例以后,我们才可以进行如下的操作:
* 1)*创建对应的运行时类的对象
* 2)获取对应的运行时类的完整结构(属性、方法、构造器、内部类、父类、所在的包、异常、注解、...)
* 3)*调用对应的运行时类的指定的结构(属性、方法、构造器)
* 4)反射的应用:动态代理
*/
@Test
public void test3(){
Person p = new Person();
Class clazz = p.getClass();//通过运行时类的对象,调用其getClass(),返回其运行时类。
System.out.println(clazz);
}
//有了反射,可以通过反射创建一个类的对象,并调用其中的结构
@Test
public void test2() throws Exception{
Class clazz = Person.class;
// Class clazz1 = String.class;
//1.创建clazz对应的运行时类Person类的对象
Person p = (Person)clazz.newInstance();
System.out.println(p);
//2.通过反射调用运行时类的指定的属性
//2.1
Field f1 = clazz.getField("name");
f1.set(p,"LiuDeHua");
System.out.println(p);
//2.2
Field f2 = clazz.getDeclaredField("age");
f2.setAccessible(true);
f2.set(p, 20);
System.out.println(p);
//3.通过反射调用运行时类的指定的方法
Method m1 = clazz.getMethod("show");
m1.invoke(p);
Method m2 = clazz.getMethod("display",String.class);
m2.invoke(p,"CHN");
}
//在有反射以前,如何创建一个类的对象,并调用其中的方法、属性
@Test
public void test1(){
Person p = new Person();
// Person p1 = new Person();
p.setAge(10);
p.setName("TangWei");
System.out.println(p);
p.show();
// p.display("HK");
}
}
/*
* java.lang.Class:是反射的源头。
* 我们创建了一个类,通过编译(javac.exe),生成对应的.class文件。之后我们使用java.exe加载(JVM的类加载器完成的)
* 此.class文件,此.class文件加载到内存以后,就是一个运行时类,存在在缓存区。那么这个运行时类本身就是一个Class的实例!
* 1.每一个运行时类只加载一次!
* 2.有了Class的实例以后,我们才可以进行如下的操作:
* 1)*创建对应的运行时类的对象
* 2)获取对应的运行时类的完整结构(属性、方法、构造器、内部类、父类、所在的包、异常、注解、...)
* 3)*调用对应的运行时类的指定的结构(属性、方法、构造器)
* 4)反射的应用:动态代理
*/
创建运行时类的对象
创建类时候 最好有一个空参构造器,以方便调用class的newinstance方法。
其他类可以看做是class类的实例化。
例子:
import java.lang.reflect.Constructor;
import org.junit.Test;
public class TestConstructor {
@Test
public void test1() throws Exception{
String className = "com.atguigu.java.Person";
Class clazz = Class.forName(className);
//创建对应的运行时类的对象。使用newInstance(),实际上就是调用了运行时类的空参的构造器。
//要想能够创建成功:①要求对应的运行时类要有空参的构造器。②构造器的权限修饰符的权限要足够。
Object obj = clazz.newInstance();
Person p = (Person)obj;
System.out.println(p);
}
@Test
public void test2() throws ClassNotFoundException{
String className = "com.atguigu.java.Person";
Class clazz = Class.forName(className);
Constructor[] cons = clazz.getDeclaredConstructors();
for(Constructor c : cons){
System.out.println(c);
}
}
//调用指定的构造器,创建运行时类的对象
@Test
public void test3() throws Exception{
String className = "com.atguigu.java.Person";
Class clazz = Class.forName(className);
Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
cons.setAccessible(true);
Person p = (Person)cons.newInstance("罗伟",20);
System.out.println(p);
}
}
通过反射调用完整的结构
下面两个方法获取运行时类的对象。
//调用指定的构造器创建运行时类的对象
@Test
public void test2() throws Exception{
Class clazz = Animal.class;
Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
cons.setAccessible(true);
Animal a = (Animal)cons.newInstance("Tom",10);
System.out.println(a);
}
//获取运行时类的对象:方法一
@Test
public void test1() throws Exception{
Class clazz = Class.forName("com.atguigu.review.Animal");
Object obj = clazz.newInstance();
Animal a = (Animal)obj;
System.out.println(a);
}
Animal.java
public class Animal {
private String name;
public int age;
static String desc = "我是一个动物";
public Animal() {
super();
System.out.println("!!!");
}
private Animal(String name, int age) {
super();
this.name = name;
this.age = age;
}
public static void info(){
System.out.println("动物");
}
public void show(String desc){
System.out.println("我是一个:" + desc);
}
private int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static String getDesc() {
return desc;
}
public static void setDesc(String desc) {
Animal.desc = desc;
}
@Override
public String toString() {
return "Animal [name=" + name + ", age=" + age + "]";
}
}
可以获取属性权限修饰符,属性名,属性类型(具体看API),了解即可。
其他的可以获取权限修饰符 返回值类型 方法名 形参列表 异常
获取通过反射类的属性和方法
获取属性:
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import org.junit.Test;
public class TestField {
//获取对应的运行时类的属性
@Test
public void test1(){
Class clazz = Person.class;
//1.getFields():只能获取到运行时类中及其父类中声明为public的属性
Field[] fields = clazz.getFields();
for(int i = 0;i < fields.length;i++){
System.out.println(fields[i]);
}
System.out.println();
//2.getDeclaredFields():获取运行时类本身声明的所有的属性
Field[] fields1 = clazz.getDeclaredFields();
for(Field f : fields1){
System.out.println(f.getName());
}
}
//权限修饰符 变量类型 变量名
//获取属性的各个部分的内容
@Test
public void test2(){
Class clazz = Person.class;
Field[] fields1 = clazz.getDeclaredFields();
for(Field f : fields1){
//1.获取每个属性的权限修饰符
int i = f.getModifiers();
String str1 = Modifier.toString(i);
System.out.print(str1 + " ");
//2.获取属性的类型
Class type = f.getType();
System.out.print(type.getName() + " ");
//3.获取属性名
System.out.print(f.getName());
System.out.println();
}
}
//调用运行时类中指定的属性
@Test
public void test3() throws Exception{
Class clazz = Person.class;
//1.获取指定的属性
//getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
Field name = clazz.getField("name");
//2.创建运行时类的对象
Person p = (Person)clazz.newInstance();
System.out.println(p);
//3.将运行时类的指定的属性赋值
name.set(p,"Jerry");
System.out.println(p);
System.out.println("%"+name.get(p));
System.out.println();
//getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性
Field age = clazz.getDeclaredField("age");
//由于属性权限修饰符的限制,为了保证可以给属性赋值,需要在操作前使得此属性可被操作。
age.setAccessible(true);
age.set(p,10);
System.out.println(p);
// Field id = clazz.getField("id");
}
}
获取方法:
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import org.junit.Test;
public class TestMethod {
//1.获取运行时类的方法
@Test
public void test1(){
Class clazz = Person.class;
//1.getMethods():获取运行时类及其父类中所有的声明为public的方法
Method[] m1 = clazz.getMethods();
for(Method m : m1){
System.out.println(m);
}
System.out.println();
//2.getDeclaredMethods():获取运行时类本身声明的所有的方法
Method[] m2 = clazz.getDeclaredMethods();
for(Method m : m2){
System.out.println(m);
}
}
//注解 权限修饰符 返回值类型 方法名 形参列表 异常
@Test
public void test2(){
Class clazz = Person.class;
Method[] m2 = clazz.getDeclaredMethods();
for(Method m : m2){
//1.注解
Annotation[] ann = m.getAnnotations();
for(Annotation a : ann){
System.out.println(a);
}
//2.权限修饰符
String str = Modifier.toString(m.getModifiers());
System.out.print(str + " ");
//3.返回值类型
Class returnType = m.getReturnType();
System.out.print(returnType.getName() + " ");
//4.方法名
System.out.print(m.getName() + " ");
//5.形参列表
System.out.print("(");
Class[] params = m.getParameterTypes();
for(int i = 0;i < params.length;i++){
System.out.print(params[i].getName() + " args-" + i + " ");
}
System.out.print(")");
//6.异常类型
Class[] exps = m.getExceptionTypes();
if(exps.length != 0){
System.out.print("throws ");
}
for(int i = 0;i < exps.length;i++){
System.out.print(exps[i].getName() + " ");
}
System.out.println();
}
}
//调用运行时类中指定的方法
@Test
public void test3() throws Exception{
Class clazz = Person.class;
//getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法
Method m1 = clazz.getMethod("show");
Person p = (Person)clazz.newInstance();
//调用指定的方法:Object invoke(Object obj,Object ... obj)
Object returnVal = m1.invoke(p);//我是一个人
System.out.println(returnVal);//null
Method m2 = clazz.getMethod("toString");
Object returnVal1 = m2.invoke(p);
System.out.println(returnVal1);//Person [name=null, age=0]
//对于运行时类中静态方法的调用
Method m3 = clazz.getMethod("info");
m3.invoke(Person.class);
//getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法
Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);
m4.setAccessible(true);
Object value = m4.invoke(p,"CHN",10);//我的国籍是:CHN
System.out.println(value);//10
}
}
获取构造器和其他
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import org.junit.Test;
public class TestOthers {
//6.获取注解
@Test
public void test6(){
Class clazz = Person.class;
Annotation[] anns = clazz.getAnnotations();
for(Annotation a : anns){
System.out.println(a);
}
}
//5.获取所在的包
@Test
public void test5(){
Class clazz = Person.class;
Package pack = clazz.getPackage();
System.out.println(pack);
}
//4.获取实现的接口
@Test
public void test4(){
Class clazz = Person.class;
Class[] interfaces = clazz.getInterfaces();
for(Class i : interfaces){
System.out.println(i);
}
}
//3*.获取父类的泛型
@Test
public void test3(){
Class clazz = Person.class;
Type type1 = clazz.getGenericSuperclass();
ParameterizedType param = (ParameterizedType)type1;
Type[] ars = param.getActualTypeArguments();
System.out.println(((Class)ars[0]).getName());
}
//2.获取带泛型的父类
@Test
public void test2(){
Class clazz = Person.class;
Type type1 = clazz.getGenericSuperclass();
System.out.println(type1);
}
//1.获取运行时类的父类
@Test
public void test1(){
Class clazz = Person.class;
Class superClass = clazz.getSuperclass();
System.out.println(superClass);
}
}
基本上全了吧~ 应用的话在动态代理部分。
2018年8月15日23:27:48于易动 整理了一下,运行结果太多就来不及截图了,自行车轮胎还炸了,真无奈。
要是年薪百万了多好,买个跑车好哈哈哈哈哈哈哈哈哈,然后嘛 ~~~wxy我喜欢你。