1、反射机制
2、动态编译
3、动态执行javassript代码
4、动态字节码操作
动态语言
程序运行时，可以改变程序结构或变量类型。典型的语言：
1):Python、ruby、javascript等。
2):如下javascript代码:
funtion test(){ var s ="var a=3;var b=5;alert(a+b);"; eval(s); }
3):C，C++，JAVA不是动态语言，JAVA可以称之为“准动态语言”。但是JAVA有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性
4):JAVA的动态性让编程更加灵活！
1、反射机制
1):指的是可以于运行时加载、探知、使用编译期间完全未知的类。
2):程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性
<strong><span style="font-size:18px;">Class c = Class.forName("com.lyy.test.User");</span></strong>
3):加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只有一个Class对象）这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的机构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
1.1 Class类介绍
java.lang.Class类十分特殊，用来表示Java中类型（class/interface/enum/annotation/primitive type/void）本身
1.1.1):Class类的对象包含了某个被加载类的机构，一个被加载的类对应一个Class对象
1.1.2):当一个class被加载，或当加载器（class loader）的definaClass()被JVM调用，JVM便自动产生一个Class对象
1.1.3):Class类是Reflection的根源
针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
1.2 反射机制的常见作用
1.2.1):动态加载类、动态获取类的信息（属性、方法、构造器）
1.2.2):动态构造对象
1.2.3):动态调用类和对象的任意方法、构造器
1.2.4):动态调用和处理属性
1.2.5):获取泛型信息
1.2.6):处理注解
1.3 Class类的对象如何获取？
1.3.1):运用 getClass()
1.3.2):运用Class.forName()(最常被使用)
1.3.3):运用 .class语法
测试各种类型（class、interface、enum、annotaion,primitive type void void） 测试java.lang.Class对应的获取方式
package com.lyy.test; /** * 测试各种类型（class、interface、enum、annotaion,primitive type void void） 测试java.lang.Class对应的获取方式 * @author lyy * */ @SuppressWarnings("all") public class Demo1 { public static void main(String[] args) { try { String path = "com.lyy.test.bean.User"; Class<?> cls = Class.forName(path); //对象用来表示或封装一些数据 一个类加载后，JVM会创建一个对应该类的class对象，类的机构信息会放到对应的class对象中 //class对象就像一面镜子一样，通过这面镜子可以看到对应的全部信息 Class<?> clss = Class.forName(path); System.out.println(cls.hashCode());//一个类只对应一个Class对象 System.out.println(clss.hashCode()); Class strcls = String.class; Class strclass = path.getClass(); System.out.println(strcls.equals(strclass)); Class incls = int.class; int[] arr1 = new int[10]; int[][] arr2 = new int[30][3]; int[] arr3 = new int[30]; double[] arr4 = new double[10]; System.out.println(arr1.getClass().hashCode()); System.out.println(arr2.getClass().hashCode()); System.out.println(arr3.getClass().hashCode()); System.out.println(arr4.getClass().hashCode()); } catch (Exception e) { e.printStackTrace(); } } }
package com.lyy.test.bean; public class User { private int id; private int age; private String uname; public int getId() { return id; } public void setId(int id) { this.id = id; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getUname() { return uname; } public void setUname(String uname) { this.uname = uname; } public void setUname() { this.uname = "lyy"; } public User(int id, int age, String uname) { super(); this.id = id; this.age = age; this.uname = uname; } //javabean必须要有无参构造方法 public User() { super(); } }
应用反射API，获取类的信息（类的名字、属性、方法、构造器等）
package com.lyy.test; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; /** * 应用反射API，获取类的信息（类的名字、属性、方法、构造器等） * @author lyy * */ public class Demo2 { public static void main(String[] args) { String path = "com.lyy.test.bean.User"; try { Class<?> cls = Class.forName(path); //获取类的名字 System.out.println(cls.getName());//获得包名+类名 System.out.println(cls.getSimpleName());// 类名 User //获取属性信息 // Field[] field = cls.getFields(); //只能获取public下的field Field[] field = cls.getDeclaredFields();//获取所有的field Field f = cls.getDeclaredField("uname"); System.out.println(field.length); for (Field temp : field) { System.out.println("属性："+temp); } //获取方法信息 Method[] method = cls.getDeclaredMethods(); Method method1= cls.getDeclaredMethod("getUname",null); //如果方法有参数，则必须传递参数类型对应的Class对象 Method method2= cls.getDeclaredMethod("setUname",String.class); for(Method m:method){ System.out.println("方法："+m); } //获取构造信息 Constructor[] con = cls.getDeclaredConstructors(); Constructor c =cls.getDeclaredConstructor(int.class,int.class,String.class); System.out.println("获取构造器："+c); for(Constructor m:con){ System.out.println("构造器："+m); } } catch (Exception e) { e.printStackTrace(); } } }
通过反射动态的操作 构造器、方法、属性
package com.lyy.test; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import com.lyy.test.bean.User; /** * 通过反射动态的操作 构造器、方法、属性 * @author lyy * */ @SuppressWarnings("all") public class Demo3 { public static void main(String[] args) { String path = "com.lyy.test.bean.User"; try { Class<User> cls = (Class<User>) Class.forName(path); //通过反射API动态调用构造方法，构造对象 User u = cls.newInstance(); //其实是调用了User的无参构造方法 System.out.println(u); Constructor<User> c = cls.getDeclaredConstructor(int.class,int.class,String.class); User u1 = c.newInstance(1001,18,"lyy666"); System.out.println(u1.getUname()); //通过反射API 调用普通方法 User u2 = cls.newInstance(); Method method = cls.getDeclaredMethod("setUname",String.class); method.invoke(u2, "lyy而");//u2.setUname("lyy3"); System.out.println(u2.getUname()); //通过反射API操作属性 User u4 = cls.newInstance(); Field f = cls.getDeclaredField("uname"); f.setAccessible(true);//这个属性不需要安全检查了，可以直接访问 f.set(u4, "lyy4");//通过反射直接写属性 System.out.println(u4.getUname());//通过反射直接读属性的值 System.out.println(f.get(u4)); } catch (Exception e) { e.printStackTrace(); } } }
