黑马程序员——反射

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

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

总结：就是把java类中各种成分映射成相应的java类

1、class 是关键字，用在类上,例如：class A{ } 
2、Class 是一个类，java程序中的类的类型就是Class（就像int是一个整数类型一样） 
3、Class 获取的是类上的属性和方法，不会获取类上属性的值， 
4、Class 不是对应用这个类声明的某一个对象，而是对应这个类

获取Class的方法：

    publicstatic void getClassDemo() throws ClassNotFoundException {

       String s = "abcdefg";

       "//通过对象的getClass()方法获取字类型的字节码文件"

       Class c1 = s.getClass();

       "//通过类型获取字节码文件"

       Class c2 = String.class;

       "/*通过Class.forName()获取字节码文件，若字节码没有加载进内存，就把文件加载进内存，若已经在内存中

       则直接取出字节码文件使用，内部是字符串，并且类所在的包也要写上*/"

       Class c3 = Class.forName("java.lang.String");

       System.out.println(c1 == c2);"//true"

       System.out.println(c1 == c3);"//true"

       System.out.println(c3 == c2);"//true"

       System.out.println(c1.getName());"获取类的名称，包括包名"

       System.out.println(c1.getSuperclass());"直接获取到Object的类，不论它上面有其他什么父类"

       System.out.println(c1.getModifiers());"最后修改时间"

       System.out.println(c1.getPackage());"获取包名"

       System.out.println(c1.getMethods());"获取所有方法，返回Methods[],不包括私有方法"

       System.out.println(c1.getMethod("charAt", int.class));"获取其中一个方法，指定方法名称，指定方法中参数类型的字节码文件"

       System.out.println(c1.getFields());"获取所有属性，返回Filed[]"

       System.out.println(c1.getField("name"));"获取指定属性，并返回Field"

       System.out.println(c1.isPrimitive());"判断是不是基本数据类型"

       System.out.println(int.class == Integer.class);"false"

       System.out.println(int.class == Integer.TYPE);"true"

       System.out.println(c1.isArray());"判断是不是数组类型"

    }

 

有9个预定义的Class对象： 
byte ,short,int,long,boolean,char,float,double,void

通过反射获取构造方法，并创建对象：

    publicstatic void getConstruct() throws ClassNotFoundException,

           InstantiationException, IllegalAccessException, NoSuchMethodException,

           SecurityException, IllegalArgumentException, InvocationTargetException {

       "//一般创建空参数的对象和有参数的对象"

       String str = "abc";

       String str2 = new String(new StringBuffer("abc"));

       "/**

        * 反射创建对象

        */

       // 获取没有参数的构造方法，并创建对象，然后对对象进行强转"

       Class c1 = Class.forName("java.lang.String");

       String s = (String) c1.newInstance();

 

       "// 获取有参数的构造方法，并创建对象"

       Class c2 = Class.forName("java.lang.String");

       "// 指定构造方法参数的字节码文件,可以通过参数的不同获取不同的构造方法"

       Constructor<String> con =c2.getConstructor(StringBuffer.class);

       "// 创建对象，并传入参数"

       StringBuffer sb = new StringBuffer("abc");

       String s1 = (String) con.newInstance(sb);

       System.out.println(s.getClass() == s1.getClass());"// true是同一个字节码文件"

       System.out.println(s == s1);"// false不是一个对象"

    }

 

通过反射获取类中属性： 
对应的类：Field Field[]

    publicstatic void getField() throws ClassNotFoundException, NoSuchFieldException,

           SecurityException,IllegalArgumentException, IllegalAccessException {

 

       Persion p = new Persion(10, "lisi");

       Class c = Class.forName("Persion.Persion");

       "// 获取的是Persion中num这个属性,不会获取他的值"

       Field f1 = c.getField("num");

        "/**

        * 这里获取的是这个Persion类中num属性，而不是Persion对应的具体的某个对象中的num

        * 不同对象他们对应的值不同，所以获取值的时候要传入对象，表示要获取那个对象这个属性的值

        */"

       System.out.println(f1.getInt(p));

       "// 修改某一个对象这个属性的值"

       f1.setInt(p, 30);

       System.out.println(f1.getInt(p));

 

       "// 获取所有的非私有属性，并返回Fiel[]"

       Field[] f2 = c.getFields();

       for (Field f : f2) {

           System.out.println(f.getName());

       }

       "/**

        * 获取所有属性，包括私有属性,并返回Fiel[]

        * c.getDeclaredFields();只是获取所有属性，但是并不能对私有属性进行操作

        */"

       Field[] f3 = c.getDeclaredFields();

       for (Field f : f3) {

           "//f.setAccessible(true);允许对某一个私有属性进行操作，"

           f.setAccessible(true);

           "//获取属性名称"

           System.out.println(f.getName());

       }

    }

 

用反射获取类中的方法： 
Method Methos[]

public static void getMethos() throwsClassNotFoundException, NoSuchMethodException,

            SecurityException,IllegalAccessException, IllegalArgumentException,

           InvocationTargetException {

       Persion p = new Persion(30, "lisi");

       Class c = Class.forName("Persion.Persion");

 

       "// 获取方法，传入要获取的方法名，方法中要传入的参数类型 的字节码文件"

       Method m1 = c.getMethod("setName", String.class);

       "// p这个对象调用SetName这个方法，传入的参数是“张三”"

       m1.invoke(p, new Object[] { "zhangsan" });"// =p.setName("zhangsan");"

       "// p这个对象调用getName这个方法，传入的参数是null，不需要参数"

       Method m2 = c.getMethod("getName", null);

       System.out.println(m2.invoke(p, null));"// = p.getName();"

       "//当一个方法是静态方法的时候使用m.invoke(null,'a'),不许要传入对象，因为静态方法不需要对象就能直接调用"

 

       "/**

        * 获取所有的方法，除了私有方法

        */"

       Method[] m3 = c.getMethods();

       for (Method m : m3) {

           System.out.println(m.getName());

       }

       "/**

        * 获取所有的方法，包括获取私有方法

        * c.getDeclaredMethods();获取但不能操作

        * m.setAccessible(true);允许操作

        */"

       Method[] m4 = c.getDeclaredMethods();

       for (Method m : m4) {

           m.setAccessible(true);

           System.out.println(m.getName());

       }

 

       "/**

        * 当方法中要传入的参数是数组时，如何传入参数

        * 参数类型是数组时候，一般我们会传入：m5.invoke(p,new String[] { "1", "2", "3","4" });

        * java 1.5之前传入的参数是数组类型，也就是把多个参数都封装到一个数组中传入，数组类型是Object[]类型

        * 所以new String[]数组Java虚拟机会直接看成new Object[]，这样他会进行对数组进行拆开，然后把里面的元素作为参数传入

        * 而java1.5之后可以直接书写多参数，不用封装成new Object[]，但是为了兼容1.5之前的版本，当传入的参数是数组类型的时候,会转换成Object[]类型(基本数据类型不能转换成Object[]类型)，然后对数组进行拆开，然后把里面的元素当做参数传入，造成错误

        * 解决方式：

        * 1、 (Object) new String[] { "1", "2", "3","4" }强转

        * 2、new Object[] { new String[] { "1", "2", "3","4" } }

         * 把new String[]作为参数传入，这样就算拆开数组也不会有问题

        * 参数是String[] 要传入String[].class，不能传String

        * 参数是String 要传入String.class

        */"

 

       Method m5 = c.getMethod("shuzu", String[].class);

       m5.invoke(p, new Object[] { new String[] { "1", "2","3", "4" } });

    }

    "/**

        * 数组的反射

        * 具有相同的维度和元素类型相同的数组就是同一种类型，他们的字节码文件相同，Class对象相同

        */"

       int[] a1 = new int[] { 1 };

       int[] a2 = new int[2];

       int[][] a3 = new int[1][];

       String[] a4 = new String[] { "1", "2", "3","4" };

       System.out.println(a1.getClass() == a2.getClass());"// true"

       System.out.println(a1.getClass()==a3.getClass());"//false"

       System.out.println(a1.getClass() == a4.getClass());"//false"

       Object obj1 = a1;

       Object obj2 = a3;

       Object obj3 = a4;

       "// Object[] obj4 = a1;//基本数据类型数据不能用Object[]表示"

       Object[] obj5 = a3;

       Object[] obj6 = a4;

 

       "/**

        * 实例：

        * Arrays.aList();

        * 在java1.5之前参数是new Object[]

        * 在java1.5之后参数是T...a

        */"

       System.out.println(Arrays.asList(a1));"// [[I@1acd47]"

    "//在反射中，当获取的对象是一个数组时候，可以使用Array（不是Arrays），来操作数组"

       Class cla = a4.getClass();

       if (cla.isArray()) {

            int len = Array.getLength(a4);

           System.out.println(Array.get(a4, 2));

       }

 

内存泄露： 
当一个对象没有被继续使用，但是也无法被回收，造成内存浪费，就是内存泄露 
实例：

    "/**

    * HashSet中是根据元素的hashCode()和equals()方法来判断元素是否相同

    * add()contains()和remove()方法要判断元素是否相同

     *在这里重写了Persion的hashCode()方法，根据num的值来判断

    * 当元素的值被修改后，他的hashco()的值不一样，hashset认为他们不是一个元素

    * 不进行删除，但是这个对象还存在集合中无法被使用，此时占用内存

    * 当这样的数据非常多以后就会造成内存问题

    */"

    publicstatic void memoryDemo() {

       HashSet<Persion> set = new HashSet<Persion>();

       Persion p = new Persion(10, "lisi", 100);

       set.add(p);

       System.out.println(set.size());"//1"

       "//修改num的值，导致hashcode()的值不相同"

       p.num = 0;

       set.remove(p);

       System.out.println(set.size());"//1"

    }

    publicclass Persion {

    privateint age = 3;

    privateString name;

    publicint num = 4;

    publicPersion(int age, String name, int num) {

       super();

       this.age = age;

       this.name = name;

       this.num = num;

    }

 

    @Override

    publicint hashCode() {

       "//使用num的值来判断是不是同一个元素"

       return num;

    }

}

 

"  /**

    * 反射实例

    */"

    publicstatic void demo() {

       "// 创建Properties 对象"

       Properties p = new Properties();

       "// 声明FileInputStream对象"

       FileInputStream fis = null;

       try {

           "//读取properties文件"

           fis = new FileInputStream("c://demo//a.txt");

           "//加载数据"

           p.load(fis);

           System.out.println(p.getProperty("demo") + "   " + p.getProperty("http"));

           "//获取demo多对应的值，然后创建他类的对象"

           Class c1 = Class.forName(p.getProperty("demo"));

           System.out.println(c1.getName());

           "//创建这个类的对象，这里使用的接口的类，因为传入的类实现了这个接口，就是这个接口的子类，多态的应用，提高扩展性"

           Rule r = (Rule) c1.newInstance();

           "//获取指定的方法，传入参数类型的字节码文件"

           Method m = c1.getMethod("down", String[].class, int.class);

           "//调用类中方法"

           m.invoke(r, new Object[] { new String[] { p.getProperty("http")}, 1 });

 

       } catch (Exception e) {

           e.printStackTrace();

       } finally {

           if (fis != null) {

                try {

                    fis.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

           }

       }

 

    }

"//定义接口，其他类实现这个接口"

package Persion;

 

public interface Rule {

    publicabstract void down(String[] s, int a);

}

 

"自定义类实现Rule 这个接口，利用传入的参数进行操作，可以利用传入的参数做任何操作，这里通过传入的参数获取网络资源，然后复制到指定位置"

 

public class Down implements Rule {

 

    @Override

    publicvoid down(String[] s, int a) {

       FileOutputStream fos = null;

       HttpURLConnection conn = null;

       try {

 

           URL url = new URL(s[0]);

           conn = (HttpURLConnection) url.openConnection();

           conn.setRequestMethod("GET");

           conn.setReadTimeout(3000);

           conn.connect();

           "把.之后的数据截取出来"

           String regex = "\\.\\w+";

           "//创建pattern对象，关联正则表达式"

           Pattern p = Pattern.compile(regex);

           "//通过pattern对象和要匹配的字符串关联，返回匹配引擎"

           Matcher m = p.matcher(s[0]);

           String name = null;

           "//不断循环找数据"

           while (m.find()) {

                name = m.group();

           }

           fos = new FileOutputStream("c://demo//a" + name);

           InputStream in = conn.getInputStream();

           int len = 0;

           byte[] by = new byte[1024];

           while ((len = in.read(by)) != -1){

                fos.write(by, 0, len);

                fos.flush();

           }

           System.out.println("OK");

 

       } catch (MalformedURLException e) {

           e.printStackTrace();

       } catch (IOException e) {

           e.printStackTrace();

       } finally {

 

           if (fos != null) {

 

                try {

                    fos.close();

                } catch (IOException e) {

                    e.printStackTrace();

                }

           }

           if (conn != null) {

                conn.disconnect();

           }

       }

    }

}

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-