关于java反射机制的学习

package day05;

import day04.NioTest;

import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.Arrays;

class Reflect {

public Reflect(String s){
System.out.println("String construction"+s);
}
public Reflect(int i){
System.out.println("int construction"+i);
}
private int i;

private String string;

public int ii;

public String strings;

public int getI() {
return i;
}

public void setI(int i) {
this.i = i;
}

public void stringmethodstring(String s){
System.out.println("stringmethodstring"+"---"+s);
}

public void stringmethod(){
System.out.println("stringmethod");
}

private void privatemethod(){
System.out.println("privatemethod----");
}
}

interface Myinterface{
void dosth(String ss);
void doot();
}

public class reflectLearn{

public static void main(String[] args) {
Reflect reflect = new Reflect("s");

//        NioTest nioTest = new NioTest();
Class cla = Reflect.class;
Class cla1 = NioTest.class;
System.out.println(cla.getName());//获取带包名的类名
System.out.println(cla.getSimpleName());//获取不带包名的类名
System.out.println(cla1.getModifiers());//获取权限修饰符,枚举类型
System.out.println(Modifier.isPublic(cla1.getModifiers()));//判断修饰符
Package pa = cla.getPackage();//获取包信息
Class superclass = cla.getSuperclass();//获取父类
Class[] classes = cla.getInterfaces();//获取实现的接口
Annotation[] annotations = cla.getAnnotations();//获取注解
Constructor[] constructors = cla.getConstructors();//获取构造器

try{
Constructor constructor = cla.getConstructor(String.class);//获取指定参数（String）的构造器
Reflect reflect1 = (Reflect) constructor.newInstance("sth");//用构造函数实例化一个类

Field[] fields = cla.getFields();//获取变量
System.out.println("变量："+ Arrays.asList(fields));
Field field = cla.getField("ii");
System.out.println("获取指定变量："+field.getName()+"变量类型是："+field.getType().getName());
field.set(reflect,2);
System.out.println("field的set和get方法："+field.get(reflect));

Method[] methods = cla.getMethods();//获取方法
Method method = cla.getMethod("stringmethodstring", String.class);//获取指定方法
method.invoke(reflect,"sth");
method = cla.getDeclaredMethod("privatemethod");
method.setAccessible(true);//获取private和public和protected成员属性和方法
method.invoke(reflect);

Myinterface proxy = (Myinterface)Proxy.newProxyInstance(Myinterface.class.getClassLoader(),
new Class[]{Myinterface.class},new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                    System.out.println("--invoke--");
//                    method.invoke(proxy);
if(method.getName().equals("dosth")){
System.out.println("invoke----dosth"+args[0]);
}else {
System.out.println("invoke----doot");
}
return null;
}
});
proxy.dosth("?");
proxy.doot();
}catch (Exception e){
System.out.println("????");
}

}

}另外，动态代理和类加载不是很理解，以后再学习吧。