标签：Java -- class System day05 clazz println Class out

反射

• 反射机制：通过一个抽象的类名能在自己记忆（加载类的内存）中找到匹配的类的具体信息。

//理解class类并实例化Class类对象
Person p = new Person();
//实例化Class类对象的四种方法
Class c = Person.class;//通过类的class属性获取，最为安全可靠，程序性能最高
Class c1 = p.getClass();//通过某个类的实例获取
try {
    Class c2 = Class.forName("day13.Person");//通过Class的静态方法forname来获取一个类的class实例，常用方法
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}
//        ClassLoader cl =  this.getClass().getClassLoader();
//        try {
//            Class c3 = cl.loadClass("day13.Person");
//        } catch (ClassNotFoundException e) {
//            e.printStackTrace();
//        }
//运行时创建对象并获取类的完整结构：
//获得父类
  Class superclass = c.getSuperclass();
  System.out.println("父类:"+superclass.getName());

//获得接口
  Class[] interfaces = c.getInterfaces();
  for (Class c1 : interfaces) {
      System.out.println("接口"+c1.getName());
  }

//获得构造器
  Class c = Class.forName("day13.Person");
  Constructor[] con = c.getConstructors();//获取公有的构造器
  for (Constructor con1 :con){
      System.out.println("构造方法名"+con1.getName());
      System.out.println("构造方法修饰符为"+con1.getModifiers());

      Class[] c2 = con1.getParameterTypes();
      for(Class clazz :c2){
          System.out.println(clazz);
      }
      System.out.println("--------------");
  }
  Constructor[] con2 = c.getDeclaredConstructors();//获取所有构造器
  for (Constructor con3 :con2){
      System.out.println("构造方法名"+con3.getName());
      System.out.println("构造方法修饰符为"+con3.getModifiers());

      Class[] c3 = con3.getParameterTypes();
      for(Class clazz1 :c3){
          System.out.println(clazz1);
      }
      System.out.println("--------------");
  }

  } catch (ClassNotFoundException e) {
  e.printStackTrace();
  }

//创建对象
  Class clazz = Class.forName("day13.Student");
  Object obj = clazz.newInstance();//相当于调用无参构造
  Student s = (Student) obj;
  System.out.println(s.school);

  Constructor c = clazz.getConstructor(String.class);//调用一个参数的构造
  Student stu = (Student)c.newInstance("张三");
  System.out.println(stu.name);

  Constructor c = clazz.getDeclaredConstructor(String.class,String.class);//调用两个参数的构造
  c.setAccessible(true);//解除私有的封装，下面就可以对这个私有方法强制使用
  Student stu = (Student) c.newInstance("李四","希望小学");
  System.out.println(stu.name+stu.school);

//获得方法
  Method[] ms = clazz.getDeclaredMethods();//获取类的所有方法
  for(Method m : ms){
  System.out.println("方法的名称"+m.getName());
  System.out.println("方法的修饰符"+m.getModifiers());
  System.out.println("返回值的类型"+m.getReturnType());

  Class[] cl = m.getParameterTypes();
  if(cl != null && cl.length > 0){
      for(Class c : cl){
          System.out.println("参数类型"+c.getName());
      }
  }
  System.out.println("------------");
  }

//获得属性
  //Field[] f= clazz.getFields();//获得公有的
  Field[] f= clazz.getDeclaredFields();//获得所有的
  for (Field f1 : f) {
      System.out.println("属性的名称"+f1.getName());
      System.out.println("属性的修饰符"+f1.getModifiers());
      System.out.println("属性的类型"+f1.getType());
      System.out.println("---------");
  }

//获得包名
  Package p = clazz.getPackage();
  System.out.println(p.getName());
  
//通过反射调用类的指定方法、指定属性
//指定方法
Constructor c = clazz.getConstructor(String.class);
Object obj = c.newInstance("张三");
Method m = clazz.getMethod("setInfo", String.class, String.class);
m.invoke(obj,"张三","希望小学");
Method m1 = clazz.getDeclaredMethod("test",String.class);
m1.setAccessible(true);//解除私有封装，下面可以调用
m1.invoke(obj,"张三");
//调用有返回值的方法
Method m2 = clazz.getMethod("getSchool");
String s = (String)m2.invoke(obj);
System.out.println(s);

//指定属性
Constructor con = clazz.getConstructor(String.class);
Student s = (Student) con.newInstance("沙城一小");

Field f = clazz.getField("school");
f.set(s,"希望小学");
System.out.println(f.get(s));

Field f1 = clazz.getDeclaredField("privateField");//访问私有
f1.setAccessible(true);
f1.set(s,"1");
System.out.println(f1.get(s));

• 动态代理

//1.创建一个实现接口的InvocationHandel的类，它必须实现invoke方法，以完成代理的具体操作。
public class ProxyDemo implements InvocationHandler {
	Object obj;
	 public ProxyDemo(Object obj){
        this.obj =obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      System.out.println(method.getName()+"方法开始执行");

      Object result = method.invoke(this.obj,args);//执行的是指定的代理对象的指定的方法

      System.out.println(method.getName()+"方法执行完毕");
      return result;
    }
}
//2.创建被代理的类以及接口
public class TestDemoImp1 implements ITestDemo{
    @Override
    public void test1() {
        System.out.println("执行test1");
    }

    @Override
    public void test2() {
        System.out.println("执行test2");
    }

    @Override
    public void test3() {
        System.out.println("执行test3");
    }
}

public interface ITestDemo {
    void test1();
    void test2();
    void test3();
}

//3.通过Proxy的静态方法newProxyInstance(ClassLoader Loader,Class[] interfaces,InvocationHandler h)创建一个Subject接口代理。
  ITestDemo t = new TestDemoImp1();
  InvocationHandler handler = new ProxyDemo(t);
  /**
    * 第一个参数是代理对象的类加载器
    * 第二个参数是代理对象的接口
    * 第三个参数是代理对象
    * 返回的值是成功被代理后对象，返回的是Object类型
    */
	ITestDemo t1 =(ITestDemo)Proxy.newProxyInstance(handler.getClass().getClassLoader(),t.getClass().getInterfaces(),handler);
  /**
    * 如果一个代理类想要被 Proxy.newProxyInstance方式代理那么这个对象的类一定要有对应的接口
    * 就像本例中的接口ITestDemo和实现类TestDemoImp1一样
    */

//4.通过Subject代理调用RealSubject实现类的方法。
  t1.test1();
  t1.test2();
  t1.test3();

标签：Java,--,class,System,day05,clazz,println,Class,out
来源： https://blog.csdn.net/m0_60404046/article/details/120421316

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。