java小结_018_反射Constructof_Method_field

反射机制的优点与缺点：  

        为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，  

       静态编译：在编译时确定类型，绑定对象,即通过。  

       动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。  

       一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性。

Class中得到构造方法Constructor、

 

常用方法：

Constructor类用于描述类中的构造方法：

Constructor<T>getConstructor(Class<?>... parameterTypes)

返回该Class对象表示类的指定的public构造方法;

Constructor<?>[] getConstructors()

返回该Class对象表示类的所有public构造方法;

Constructor<T>getDeclaredConstructor(Class<?>... parameterTypes)

返回该Class对象表示类的指定的构造方法,和访问权限无关;

Constructor<?>[]getDeclaredConstructors()

返回该Class对象表示类的所有构造方法,和访问权限无关;

 

<span style="font-size:18px;">import java.lang.*;
 
class Emp{
    private String name;
    private int age;
    private Emp() {
    }
    Emp(String name){
    }
    public Emp(String name,int age){
    }
}
 
public class ConstructorDemo4 {
    public static void main(String[] args) throws Exception {
       //得到所有的构造器（先得到类）
       Class<Emp> c = Emp.class;
       /**
        *Constructor<?>[] getConstructors()
              返回一个包含某些Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
        */
       Constructor[] con = c.getConstructors();//前面的修饰符必须是public才可以在这个方法下获取到
       for (Constructor cons :con) {
           System.out.println("c.getConstructors()"+cons);//如果上面的某构造器public去掉，则显示不出
          
       }
      
       //得到指定的构造器,也是必须public
       Constructor c1 = c.getConstructor(String.class,int.class);
       System.out.println(c1);                          
System.out.println("====================================");
    //现在想获得不受public影响的,getDeclaredConstructors(),暴力反射
      
       con = c.getDeclaredConstructors();
       for (Constructor cons :con) {
                       
System.out.println("c.getDeclaredConstructors()=="+cons);//此时不受修饰符的影响
          
       }
    }
}
 </span>

方法Method、字段Field

 

Method类用于描述类中的方法：

Method getMethod(String name,Class<?> ... parameterTypes)

返回该Class对象表示类和其父类的指定的public方法;

Method[] getMethods()： 

返回该Class对象表示类和其父类的所有public方法;

Method getDeclaredMethod(String name,Class<?>... parameterTypes)

返回该Class对象表示类的指定的方法。和访问权限无关，但不包括继承的方法;

Method[] getDeclaredMethods(): 获得类所有的方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法;

 

<span style="font-size:18px;">import java.lang.*;
 
class AB{
    protected String name;
    protected String id;
}
@Deprecated
public class MethodDemo5extends AB{
    void show(){}
    public void say(){}
    private int age;
    public char c;
    private boolean b;
    public static void main(String[] args) throws Exception {
       Class<MethodDemo5> c = MethodDemo5.class;
       //获取所有的（包含父类的方法）public修饰的方法
       Method[] m = c.getMethods();
       for (Method method : m) {
           System.out.println(method);
       }
             
       //获取指定的方法
       Method me = c.getMethod("main", String[].class);
       System.out.println("main "+me);   
       //访问所有方法，不受访问权限影响
       m = c.getDeclaredMethods();
       for (Method method : m) {
           System.out.println("不受访问权限影响："+method);
       }
      
       me = c.getDeclaredMethod("show");
       System.out.println(me);
       me = c.getMethod("toString");
       System.out.println(me);    
       /**
        * Method[]getDeclaredMethods()
                 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，
                 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法,只可以对当前类有效
        */
      
       //得到字段
       Field[] f = c.getFields();
       for (Field field : f) {//只得到了public的
           System.out.println("字段"+field);
       }
      
       //特定字段
       Field fi = c.getField("c");//""里面是名称
       System.out.println(fi);    
       //得到不受限定名限定的全部字段
       f = c.getDeclaredFields();
       for (Field field : f) {//得到不受修饰符限定的字段，但是只对当前类有效
           System.out.println("全部："+field);
          
       }
      
    }
}</span>