黑马程序员——反射

最新推荐文章于 2019-03-06 17:28:00 发布

原创最新推荐文章于 2019-03-06 17:28:00 发布 · 239 阅读

0 ·

CC 4.0 BY-SA版权

——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培训、期待与您交流！ ——-