java反射reflect

概述

• 作用
• 示例

作用

• 在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

示例

• 【案例1】通过一个对象获得完整的包名和类名
  

• package learn;
   
  /**
   * 通过一个对象获得完整的包名和类名
   * */
  class Demo{
      //other codes...
  }
   
  class hello{
      public static void main(String[] args) {
          Demo demo=new Demo();
          System.out.println(demo.getClass().getName());
      }
  }

• 【运行结果】：Reflect.Demo
  
• 添加一句：所有类的对象其实都是Class的实例。
  
• 【案例2】实例化Class类对象
  

• package learn;
  class Demo{
      //other codes...
  }
   
  class hello{
      public static void main(String[] args) {
          Class<?> demo1=null;
          Class<?> demo2=null;
          Class<?> demo3=null;
          try{
              //一般尽量采用这种形式
              demo1=Class.forName("Reflect.Demo");
          }catch(Exception e){
              e.printStackTrace();
          }
          demo2=new Demo().getClass();
          demo3=Demo.class;
           
          System.out.println("类名称   "+demo1.getName());
          System.out.println("类名称   "+demo2.getName());
          System.out.println("类名称   "+demo3.getName());
           
      }
  }

• 【运行结果】：
  
  类名称   learn.Demo
  
  类名称   learn.Demo
  
  类名称   learn.Demo

• 【案例3】通过Class实例化其他类的对象
  
  • 【案例】通过无参构造实例化对象
    

  • class hello{
        public static void main(String[] args) {
            Class<?> demo=null;
            try{
                demo=Class.forName("Reflect.Person");
            }catch (Exception e) {
                e.printStackTrace();
            }
            Person per=null;
            try {
                per=(Person)demo.newInstance();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            per.setName("Rollen");
            per.setAge(20);
            System.out.println(per);
        }
    }

  • 【运行结果】：
    
    [Rollen  20]

  • 但是注意一下，当我们把Person中的默认的无参构造函数取消的时候，比如自己定义只定义一个有参数的构造函数之后，会出现错误：
  • 比如我定义了一个构造函数：

  • public Person(String name, int age) {
            this.age=age;
            this.name=name;
    }

  • 然后继续运行上面的程序，会出现：
    

  • java.lang.InstantiationException: learn.Person
    	at java.lang.Class.newInstance0(Class.java:340)
    	at java.lang.Class.newInstance(Class.java:308)
    	at learn.hello.main(hello.java:12)
    Exception in thread "main" java.lang.NullPointerException
    	at learn.hello.main(hello.java:20)

  • 所以大家以后再编写使用Class实例化其他类的对象的时候，一定要自己定义无参的构造函数

• 【案例】通过Class调用其他类中的构造函数 （也可以通过这种方式通过Class创建其他类的对象）

• package learn;
  class Person {
  	private String name;
  	private int age;
  	public Person() {}
      public Person(String name){
          this.name=name;
      }
      public Person(int age){
          this.age=age;
      }
      public Person(String name, int age) {
          this.age=age;
          this.name=name;
      }
  	public String getName() {
  		return name;
  	}
  	public void setName(String name) {
  		this.name = name;
  	}
  	public int getAge() {
  		return age;
  	}
  	public void setAge(int age) {
  		this.age = age;
  	}
  	@Override
  	public String toString() {
  		return "[" + this.name + "  " + this.age + "]";
  	}
  }
  
  package learn;
  import java.lang.reflect.Constructor;
  public class hello {
  	public static void main(String[] args) {
          Class<?> demo=null;
          try{
              demo=Class.forName("learn.Person");
          }catch (Exception e) {
              e.printStackTrace();
          }
          Person per1=null;
          Person per2=null;
          Person per3=null;
          Person per4=null;
          //取得全部的构造函数
          Constructor<?> cons[]=demo.getConstructors();
          try{
              per1=(Person)cons[0].newInstance();
              per2=(Person)cons[1].newInstance("Rollen");
              per3=(Person)cons[2].newInstance(20);
              per4=(Person)cons[3].newInstance("Rollen",20);
          }catch(Exception e){
              e.printStackTrace();
          }
          System.out.println(per1);
          System.out.println(per2);
          System.out.println(per3);
          System.out.println(per4);
      }
  }

• 【运行结果】：
  [null  0]
  [Rollen  0]
  [null  20]
  [Rollen  20]

• 【案例】 返回一个类实现的接口：

• package learn;
  public interface China {
  	public static final String name = "yxj";
  	public static int age = 20;
  	public void sayChina();
  	public void sayHello(String name, int age);
  }
  package learn;
  class Person implements China{
  	private String sex;
  	public Person() {}
      public Person(String sex){
          this.sex=sex;
      }
      public String getSex() {
          return sex;
      }
      public void setSex(String sex) {
          this.sex = sex;
      }
      @Override
      public void sayChina(){
          System.out.println("hello ,china");
      }
      @Override
      public void sayHello(String name, int age){
          System.out.println(name+"  "+age);
      }
  }
  
  package learn;
  public class hello {
  	public static void main(String[] args) {
  		Class<?>demo=null;
  		try {
  			demo=Class.forName("learn.Person");
  		} catch (Exception e) {
  			e.printStackTrace();
  		}
  		Class<?>intes[]=demo.getInterfaces();
  		for (int i = 0; i < intes.length; i++) {
  			System.out.println("实现的接口   "+intes[i].getName());
  		}
  	}
  }
  

• 【运行结果】
  

• 实现的接口   learn.China

•