动态语言:程序运行时仍可改变程序结构或变量类型
python/ruby/javascript
JAVA有一定的动态性,称为“准动态语言”(反射机制、字节码操作获得类似动态语言的特性)
反射机制
包名+类名
String path="Annotation.sxtStudent";//同样的类只会被加载一次,一个类只对应一个class对象
try {
Class clazz=Class.forName(path);
//对象是表示或封装一些数据,一个类被加载后,JVM会创建一个对应该类的class对象,类的整个结构信息放到对应的Class对象中
//这个class对象像镜子一样,可以看到对应的类的全部信息
System.out.println(clazz.hashCode());
Class strClazz=String.class;
Class strClazz2=path.getClass();
System.out.println(strClazz==strClazz2);//true
Class intClazz=int.class;
int[] arr01=new int[10];
int[] arr02=new int[30];//均为1维,class对象相同
System.out.println(arr01.getClass().hashCode());
System.out.println(arr02.getClass().hashCode());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
常见操作:
/*
* 应用反射API,获取类的信息(类名、方法、属性、构造器)
*
* */
public class Demo02 {
public static void main(String[] args) {
String path="Annotation.sxtStudent";//同样的类只会被加载一次,一个类只对应一个class对象
try {
Class clazz=Class.forName(path);
//类名
System.out.println(clazz.getName());//package+name
System.out.println(clazz.getSimpleName());//only name
//获得属性信息
Field[] field=clazz.getFields();//获得public field
Field[] fields=clazz.getDeclaredFields();//获得all field
Field f=clazz.getDeclaredField("id");
System.out.println(f);
System.out.println(fields.length);
for(Field temp:fields){
System.out.println("属性"+temp);
}
//获得方法信息
Method[] methods=clazz.getDeclaredMethods();
Method m=clazz.getDeclaredMethod("getId", null);
Method m01=clazz.getDeclaredMethod("setId", int.class);//参数名 参数的class对象
//获得构造器信息
Constructor[] constructors=clazz.getConstructors();
Constructor[] constructors01=clazz.getDeclaredConstructors();
for(Constructor temp:constructors){
System.out.println(temp);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/*
* 通过反射API动态操作:构造器、方法、属性
*
* */
public class Demo03 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String path="Annotation.sxtStudent";//同样的类只会被加载一次,一个类只对应一个class对象
try {
Class<sxtStudent> clazz=(Class<sxtStudent>)Class.forName(path);
//获得反射API调用构造方法构造对象
sxtStudent student=clazz.newInstance();//调用了sxtStudent的无参构造方法
Constructor<sxtStudent> c=clazz.getDeclaredConstructor(int.class,String.class,int.class);//调用了sxtStudent的有参构造方法
sxtStudent student01=c.newInstance(18,"hello",101);
System.out.println(student01.getAge());
//通过反射API调用普通方法
sxtStudent stu3=clazz.newInstance();
Method method=clazz.getDeclaredMethod("setId",int.class);
method.invoke(stu3, 101);
System.out.println(stu3.getId());
//通过反射API操作属性
sxtStudent stu4=clazz.newInstance();
Field f=clazz.getDeclaredField("id");
f.setAccessible(true);//告诉属性无需做安全检查,可以直接访问
f.set(stu4, 102);//通过反射直接写属性
System.out.println(stu4.getId());
System.out.println(f.get(stu4));//通过反射直接读属性
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
反射机制性能问题:
反射会降低程序性能分别为1:30:7
反射操作泛型
反射操作注解
//使用反射处理注解信息,模拟处理注解信息的流程
public class Demo03 {
public static void main(String[] args) {
try {
Class clazz=Class.forName("Annotation.sxtStudent");
Annotation[] annotation =clazz.getDeclaredAnnotations();//获取类的所有注解
for(Annotation a:annotation){
System.out.println(a);
}
//获得类指定注解
SxtTable st=(SxtTable)clazz.getAnnotation(SxtTable.class);
System.out.println(st.value());
//获得类的属性注解
Field sf=clazz.getDeclaredField("studentName");
sxtField sxtField=sf.getAnnotation(sxtField.class);
System.out.println(sxtField.columnName()+"--->"+sxtField.type()+"--->"+sxtField.length());
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
动态编译javaCompiler
动态执行javascript代码
脚本引擎java执行js代码 JDK6.0以后
java脚本api是连通java平台和脚本语言的桥梁
- 获得脚本引擎对象
- 通过脚本引擎运行脚本并返回运行结果,这是最核心的接口
注:java可以使用各种不同的实现,从而通用的调用js、groovy、python等脚本 --js使用了Rhino
- 通过脚本引擎的运行上下文在脚本和java平台间交换数据
//获得脚本引擎对象
ScriptEngineManager sem = new ScriptEngineManager();
ScriptEngine engine=sem.getEngineByName("javascript");
//定义变量 会存储到引擎的上下文中
engine.put("msg", "hello,huanxing test javascript");
String str= "var user={name:'zhaojr',age:18,school:['tsing','beijing']};";
str+="print(user.name);";
//执行脚本
engine.eval(str);
engine.eval("msg ='java is the best';");//修改
System.out.println(engine.get("msg"));
System.out.println("###############");
//定义函数
engine.eval("function add(a,b){var sum=a+b;return sum;}");
//取得调用接口
Invocable jsInvoke=(Invocable) engine;
//执行脚本中定义方法
Object result1=jsInvoke.invokeFunction("add", new Object[]{13,20});
System.out.println(result1);
//导入其他java包,使用其他包中的java类
String jsCode ="import Package(java.util); var list=Arrays.asList([\"hello\",\"tsinghua\",\"beijing\"]);";
engine.eval(jsCode);
List<String> list3=(List<String>)engine.get("list");
for(String temp:list3){
System.out.println(temp);
}
动态字节码操作
java动态性实现方式 字节码操作、反射
运行时操作字节码实现功能:动态生成新的类、动态改变类结构
字节码操作优势:比反射开销小,性能高
常见字节码操作类库:
ClassPool pool=ClassPool.getDefault();
CtClass cc = pool.makeClass("javaAssist.Emp");
//创建属性
CtField f1 = CtField.make("private int empno;", cc);
CtField f2 = CtField.make("private String ename;", cc);
cc.addField(f1);
cc.addField(f2);
//创建方法
CtMethod m=CtMethod.make("public void setEmpno(int empno){this.empno=empno;}", cc);
cc.addMethod(m);
//添加构造器
CtConstructor constructor=new CtConstructor(new CtClass[]{CtClass.intType,pool.get("java.lang.String")}, cc);
constructor.setBody("{this.empno=empno;this.ename=ename;}");
cc.addConstructor(constructor);
cc.writeFile("C:/testJava");//将构建好的类写入该目录下
System.out.println("yes");
//反编译工具 XJad下载