GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型
TypeVariable：是各种类型变量的公共父接口
WildcardTyoe：代表一种通配符类型表达式，比如：?,? extends Number ,? super Inter
package com.lyy.test;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;
import com.lyy.test.bean.User;
/**
-
通过反射获取泛型信息
-
@author lyy
*/
public class Demo4 {
public void test01(Map<String,User> map,List list){
System.out.println(“Demo04.test01()”);
}
public Map<Integer,User> test02(){
System.out.println(“Demo04.test02()”);
return null;
}
public static void main(String[] args) {
try {
//获得指定方法参数泛型信息
Method m = Demo4.class.getMethod(“test01”, Map.class,List.class);
Type[] t = m.getGenericParameterTypes();//获取泛型信息
for (Type paramType : t) {
System.out.println(“#”+paramType);
if(paramType instanceof ParameterizedType){
Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
for (Type genericType : genericTypes) {
System.out.println(“泛型类型：”+genericType);
}
}
}
//获取指定方法返回值泛型信息
Method m2 = Demo4.class.getMethod(“test02”, null);
Type returnType = m2.getGenericReturnType();
if(returnType instanceof ParameterizedType){
Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();
for (Type genericType : genericTypes) {
System.out.println(“返回值，泛型类型”+genericType);
}
}
} 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();
}
}
1.6 反射操作注解（annotation）
1.6.1):可以通过反射API:getAnnotations、getAnnotation获取相关的注解信息
package com.lyy.test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import com.lyy.test.annotation.SxtField;
import com.lyy.test.annotation.SxtTable;
/**
*通过反射获取注解信息
-
@authorlyy
*/
public class Demo5 {
public static void main(String[] args) {
try {
Class clazz = Class.forName(“com.lyy.test.annotation.SxtStudent”);
//获取所有类的所有有效注解
Annotation[] annotations=clazz.getAnnotations();
for (Annotation a : annotations) {
System.out.println(a);
}
//获取类的指定的注解
SxtTable st = (SxtTable) clazz.getAnnotation(SxtTable.class);
System.out.println(st.value());
//获得类的属性的注解
Field f = clazz.getDeclaredField(“studentName”);
SxtField sxtField = f.getAnnotation(SxtField.class);
System.out.println(sxtField.columnName()+“–”+sxtField.type()+“–”+sxtField.length());
//根据获取的表名、字段的信息、拼出DDL语句、然后，使用JDBC执行这个SQL，在数据库中生成相关的表
} catch (Exception e) {
e.printStackTrace();
}
}
}
package com.lyy.test.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(value={ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtTable {
String value();
}
package com.lyy.test.annotation;
@SxtTable(“tb_student”)
public class SxtStudent {
@SxtField(columnName=“id”,type=“int”,length=10)
private int id;
@SxtField(columnName=“sname”,type=“varchar”,length=10)
private String studentName;
@SxtField(columnName=“age”,type=“int”,length=3)
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.lyy.test.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(value={ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface SxtField {
String columnName();
String type();
int length();
}
反射的核心是class ，反射降低了运行效率，但是提高了开发效率
2、动态编译
2.1):JAVA 6.0 引入了动态编译机制
2.1.2):动态编译的应用场景：
2.1.2.1):可以做一个浏览器端编写Java代码，上传服务器编译和运行的在线评测系统
2.1.2.2):服务器动态加载某些类进行进行编译
2.1.3)：动态编译的两种做法：
2.1.3.1):通过Rruntime调用javac,启动新的进程去操作
Runtime tun = Runtime.getRuntime();
Process process = run.exec(“java -cp g:/myjava/ HelloWorld.java”);
2.2):通过JavaCompiler动态编译
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
int result = compiler.run(null, null, null, “E:/myjava/HelloWorld.java”);
System.out.println(result==0?“编译成功！”:“编译失败！”);
第一个参数：为Java编译器提供参数
第二个参数：得到java编译器的输出信息
第三个参数：接收编译器的错误信息
第四个参数：可变参数（是一个String数组）能传入一个或多个Java源文件
返回值：0表示编译成功，非0表示编译失败
package com.lyy.test;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
public class Demo1 {
public static void main(String[] args) throws Exception {
//通过IO操作，将字符串存储成一个临时文件(Hi.java)，然后调用动态编译方法！
String str = “public class Hi{public static void main(String[] args){”
- “System.out.println(“haha lyy”);}}”;
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
int result = compiler.run(null, null, null, “E:/myjava/HelloWorld.java”);
System.out.println(result==0?“编译成功！”:“编译失败！”);
//通过Runtime调用执行类
// Runtime run = Runtime.getRuntime();
// Process pro = run.exec(“java -cp E:/myjava HelloWorld”);
//
// InputStream in = pro.getInputStream();
// BufferedReader reader = new BufferedReader(new InputStreamReader(in));
// String info = “”;
// while((info=reader.readLine()) != null){
// System.out.println(info);
// }
URL[] urls = new URL[]{new URL(“file:/”+“E:/myjava/”)};
URLClassLoader loader = new URLClassLoader(urls);
Class c = loader.loadClass(“HelloWorld”);
//调用加载类的main方法
Method method = c.getMethod(“main”,String[].class);
method.invoke(null,(Object)new String[]{“aa”,“bb”});
//由于可变参数是5.0之后才有 method.invoke(null,“aa”,“bb”) 会发生参数个数不匹配的问题
//因此，必须要加上(Object)转型，避免这个问题
//public static void main(String[] a,String[] b)
}
}
3、动态执行javassript代码
3.1):JAVA脚本引擎是从JDK6.0之后添加的新功能
3.2):脚本引擎介绍：
使得java应用程序可以通过一套固定的接口与各种脚本引擎交互，从而达到在Java平台上调用各种脚本语言的目的。
java脚本API是连通java平台和脚本语言的桥梁。
可以把一些复杂异变的业务逻辑交给脚本语言处理，这又大大提高了开发效率
3.3):获取脚本引擎对象
//获得脚本引擎对应
ScriptEngineManager sem = new ScriptEngineManager();
ScriptEngine engine = sem.getEngineByName(“javascript”);
3.4):java脚本API为开发者提供了如些功能：
获取本程序输入，通过脚本引擎运行脚本并返回运行结果，这是最核心的接口。
注意是：接口 。java可以使用各种不同的实现，从而通用的调用js、groovy、python等脚本
Rhino 是一种使用Java语言编写的javaScript的开源实现，原先由Mozilla开发，现在被集成进入JDK 6.0
通过脚本引擎的运行上下文在脚本和Java平台间交换数据
通过Java应用程序调用脚本函数
package com.lyy.test;
import java.io.FileReader;
import java.net.URL;
import java.util.List;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
/**
-
测试脚本引擎执行javascript代码
-
@author lyy
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
//相当于Java和Js脚本语言的一个中介
//获得脚本引擎对应
ScriptEngineManager sem = new ScriptEngineManager();
ScriptEngine engine = sem.getEngineByName(“javascript”);
//定义变量 存储到引擎的上下文中
engine.put(“msg”, “lyy is good man!”);
String str = “var user = {name:‘lyy’,age:18,schools:[‘清华大学’,‘湖北大学’]};”;
str +=“println(user.age)”;
//执行脚本
engine.eval(str);
engine.eval(“msg=‘lyy is goods !!!’”);
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 obj=jsInvoke.invokeFunction(“add”, new Object[]{13,20});
System.out.println(obj);
//导入其他的Java包，使用其他包中的java类,如果需要了解，可以详细学习了解Rhino的语法
String jsCode = “importPackage(java.util); var list = Arrays.asList([“清华大学”,“湖北工程学院”,“湖北职业技术学院”]);”;
engine.eval(jsCode);
List list2 = (List)engine.get(“list”);
for (String temp :list2) {
System.out.println(temp);
}
//执行一个js文件
URL url = Demo1.class.getClassLoader().getResource(“in.js”);
FileReader fr = new FileReader(url.getPath());
engine.eval(fr);
fr.close();
}
}
in.js
//定义test方法
function test(){
var a = 3;
var b = 4;
println(“invoke js file:”+(a+b));
}
//执行test方法
test();
**4、动态字节码操作
**
4.1):java动态性的两种常见实现方式：
4.1.1):字节码操作
4.2.1):反射
4.2):运行时操作字节码可以让我们实现如下功能：
4.2.1):动态生成新的类
4.2.2):动态改变某个类的结构（添加/删除/修改 新的属性/方法）
4.3):优势：
4.3.1):比反射开销小，性能高
4.3.2):JAVAssist性能高于反射，低于ASM
4.4):JAVAssist库的API详解
4.4.1):javassist的最外层的API和JAVA的反射包中的API颇为类型。
4.4.2):它主要由CtClass、CtMethod、以及CtField几个类组成。用以执行和JDK反射API中 java.lang.Class，java.lang.reflect.Method ，java.lang.reflect.Method.Field相同的操作
package com.lyy.test;
import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.NotFoundException;
/**
-
测试使用Javasost生成一个新的类
-
@author lyy
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass(“com.lyy.test.Emp1”);
//创建属性
CtField f1 = CtField.make(“private int empno;”, cc);
CtField f2 = CtField.make(“private String ename;”, cc);
cc.addField(f1);
cc.addField(f2);
//创建方法
CtMethod c1 = CtMethod.make(“public int getEmpno(){return empno;}”, cc);
CtMethod c2 =CtMethod.make(“public void setEmpno(int empno){this.empno=empno;}”, cc);
cc.addMethod(c1);
cc.addMethod(c2);
// 6228480799439345478
//添加构造器
CtConstructor constu = new CtConstructor(new CtClass[]{CtClass.intType,pool.get(“java.lang.String”)}, cc);
constu.setBody(“{this.empno=empno;this.ename=ename;}”);
cc.addConstructor(constu);
cc.writeFile(“E:/myjava”);//将上面构造好的类写入到e:/myjava下
System.out.println(“sucess！”);
}
}
package com.lyy.test;
@Author(name=“lyy”, year=2016)
public class Emp {
private int empno;
private String ename;
public void sayHello(int a){
System.out.println(“sayHello，”+a);
}
public int getEmpno() {
return empno;
}
public void setEmpno(int empno) {
this.empno = empno;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
面试结束复盘查漏补缺
每次面试都是检验自己知识与技术实力的一次机会，面试结束后建议大家及时总结复盘，查漏补缺，然后有针对性地进行学习，既能提高下一场面试的成功概率，还能增加自己的技术知识栈储备，可谓是一举两得。
以下最新总结的阿里P6资深Java必考题范围和答案，包含最全MySQL、Redis、Java并发编程等等面试题和答案，用于参考~
重要的事说三遍，关注+关注+关注！
更多笔记分享
pno){this.empno=empno;}", cc);
cc.addMethod(c1);
cc.addMethod(c2);
// 6228480799439345478
//添加构造器
CtConstructor constu = new CtConstructor(new CtClass[]{CtClass.intType,pool.get(“java.lang.String”)}, cc);
constu.setBody(“{this.empno=empno;this.ename=ename;}”);
cc.addConstructor(constu);
cc.writeFile(“E:/myjava”);//将上面构造好的类写入到e:/myjava下
System.out.println(“sucess！”);
}
}
package com.lyy.test;
@Author(name=“lyy”, year=2016)
public class Emp {
private int empno;
private String ename;
public void sayHello(int a){
System.out.println(“sayHello，”+a);
}
public int getEmpno() {
return empno;
}
public void setEmpno(int empno) {
this.empno = empno;
}
public String getEname() {
return ename;
}
public void setEname(String ename) {
面试结束复盘查漏补缺
每次面试都是检验自己知识与技术实力的一次机会，面试结束后建议大家及时总结复盘，查漏补缺，然后有针对性地进行学习，既能提高下一场面试的成功概率，还能增加自己的技术知识栈储备，可谓是一举两得。
以下最新总结的阿里P6资深Java必考题范围和答案，包含最全MySQL、Redis、Java并发编程等等面试题和答案，用于参考~
重要的事说三遍，关注+关注+关注！
[外链图片转存中…(img-ed8WJqDp-1710350628726)]
[外链图片转存中…(img-Eg12vm2W-1710350628727)]
更多笔记分享
[外链图片转存中…(img-qRAevtyC-1710350628728)]
6236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
