黑马程序员-基础加强-反射

package heima;

public class ReflectionTest1{//获取对象的类型名称

    public static void main(String[] args){

        Foo f = new Foo();//创建一个Foo类实例对象

        System.out.println(f.getClass().getName());//通过   getClass方法获取对象的类名称     

    }

}

 

class Foo {//定义类Foo

    public void print() {

        System.out.println("abc");

    }

}

package heima;

 

import java.lang.reflect.Method;

 

public class ReflectionTest2 {

    public static void main(String[] args){

        Foo2 f = new Foo2();//创建一个Foo类实例对象

         Method method;

        try {//注意这个方法会有异常，要抛出异常

            method = f.getClass().getMethod("print", new Class<?>[0]);//判断f的类有没有print方法，有就返回方法

            method.invoke(f);//调用放回的print方法

        } catch (Exception e) {

            e.printStackTrace();

        }          

    }

}

 

class Foo2 {

    public void print() {

        System.out.println("abc");

    }

}

package heima;

 

public class ReflectionTest3 {

 public static void main(String[] args) {

    Class<?> c = null;

     try{//抛出异常

         c=Class.forName("heima.Foo3");//获取类Foo3的字节码

     }catch(Exception e){

         e.printStackTrace();

     }

 

     // 创建Foo实例

     Foo3 f = null;

 

     try {//抛出异常

         f = (Foo3) c.newInstance();//创建字节码是c的类的实例对象

     } catch (Exception e) {

         e.printStackTrace();

     }  

 

     f.print();//调用Foo3中的print方法

 

}

}

class Foo3 {

    public void print() {

        System.out.println("abc");

    }

}

package heima;

 

import java.lang.reflect.Constructor;

 

public class ReflectionTest4 {

    public static void main(String[] args){

        // 创建Class实例

        Class<?> c = null;

        try{

            c=Class.forName("heima.Foo4");//获取类Foo4的字节码

        }catch(Exception e){

            e.printStackTrace();


        }

 

        // 创建Foo4实例

        Foo4 f1 = null;

        Foo4 f2 = null;

 

      

        Constructor<?> cons[] = c.getConstructors(); // 获取所有的构造函数，

 

        try {

            f1 = (Foo4) cons[0].newInstance();//用无参构造函数fl实例并赋值

            f2 = (Foo4) cons[1].newInstance("abc");//用参数是String的构造函数创建f2实例并赋值

        } catch (Exception e) {

            e.printStackTrace();

        }  

 

        f1.print();

        f2.print();

    }

}

 

class Foo4 {

    String s;

 

    public Foo4(){}

 

    public Foo4(String s){

        this.s=s;

    }

 

    public void print() {

        System.out.println(s);

    }

}

package heima;

 

   import java.lang.reflect.Array;

    

   public class ReflectionTest5 {

       public static void main(String[] args) {

           int[] arr = { 1, 2, 3, 4, 5 };//创建数组

           int[] newArr = (int[]) changeArraySize(arr, 10);

           print(newArr);

           String[] atr2 = { "a", "b", "c", "d", "e" };

           String[] str1 = (String[]) changeArraySize(atr2, 10);

           print(str1);

       }

    

     

       public static Object changeArraySize(Object obj, int len) { // 修改数组的大小

           Class<?> arr = obj.getClass().getComponentType();//获取传入数组的类型，

           Object newArray = Array.newInstance(arr, len);//创建一个长度为len类型是arr的数组，用于保存改变后的数组

           int co = Array.getLength(obj);// 复制数组

           System.arraycopy(obj, 0, newArray, 0, co);

           return newArray;

       }

    

      

       public static void print(Object obj) {// 打印数组长度，并打印数组中的元素

           Class<?> c = obj.getClass();

           if (!c.isArray()) {//判断是否是数组类型

               return;

           }

    

           System.out.println(" 数组长度： " + Array.getLength(obj));

           for (int i = 0; i < Array.getLength(obj); i++) {//循环获取数组中的元素，注意这里的Array.toString方法起作用了，因为传入的参数是object类型，而不是arrag类型

               System.out.print(Array.get(obj, i) + " ");

           }

           System.out.println( );

 

       }

   }