Annotation是从JDK5.0开始引入的新技术
Annotation的作用:
Annotation的格式:
Annotation在哪里使用?
@Override:定义在java.lang.Override中,此注释只适用于修辞方法,表示一个方法声明打算重写超类中的另一个方法声明。
@Deprecated:定义在java.lang.Deprecated中,此注释可以用于修辞方法,属,类,表示不鼓励程序员使用这样的元素,通常是因为它很危险或者存在更好的选择。
@Suppresswarnings:定义在java.lang.Suppresswarningsl中,用来抑制编译时的警告信息。
元注解的作用就是负责注解其他注解,Java定义了4个标准的 meta-annotation类型,他们被用来提供对其他annotation类型作说明。
这些类型和它们所支持的类在java.lang. annotation包中可以找到.(@Target,@Retention,@Documented,@Inherited)
例子:
@MyAnnotation() public class Test01 { @MyAnnotation() public void test() { } } //定义一个注解 @Target(value = {ElementType.METHOD,ElementType.TYPE}) @Retention(value = RetentionPolicy.RUNTIME) @Documented @Inherited @interface MyAnnotation { }
使用@interface自定义注解时,自动继承了java.lang.annotation.Annotation接口。
分析:
例子:
@MyAnnotation1(name = "yt") public class Test02 { /** * 注解可以显示赋值,如果没有默认值,我们就必须给注解赋值 */ @MyAnnotation1(name = "yt",age = 18) public void test() { } @MyAnnotation2("yt") public void test2(){ } } /** * @author yt */ //定义一个注解 @Target(value = {ElementType.METHOD,ElementType.TYPE}) @Retention(value = RetentionPolicy.RUNTIME) @interface MyAnnotation1 { //注解的参数:参数类型 + 参数名 (); String name() default ""; int age() default 0; //如果默认值为-1,代表不存在,比如:indexOf ,如果找不到就返回-1 int id() default -1; String[] schools() default {"清华大学","北京大学"}; } /** * @author yt */ @Target(value = {ElementType.METHOD,ElementType.TYPE}) @Retention(value = RetentionPolicy.RUNTIME) @interface MyAnnotation2{ String value(); }
动态语言
静态语言
与动态语言相对应的,运行时结构不可变的语言就是静态语言。如Java、C、C++
Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时侯更加灵活!
Reflection(反射)是Java被视为动态语言的关鍵,反射机制允许程序在执行期借助于 Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
Class c= Class.forName("java. lang String")
加载完类之后,在堆内存的方法区中就产生了ー个Class类型的对象(一个类只有一个 Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以我们形象的称之为:反射
优点:
可以实现动态创建对象和编译,体现出很大的灵活性。
缺点:
对性能有影响。使用反射基本上是一种解释操作,我们可以告诉JVM,我们希望做什么并且它满足我们的要求。这类操作总是慢于直接执行相同的操作。
例子:
public class Test1 { public static void main(String[] args) throws ClassNotFoundException { //通过反射获取类的class对象 Class<?> c1 = Class.forName("com.company.reflection.User"); Class<?> c2 = Class.forName("com.company.reflection.User"); Class<?> c3 = Class.forName("com.company.reflection.User"); Class<?> c4 = Class.forName("com.company.reflection.User"); Class<?> c5 = Class.forName("com.company.reflection.User"); System.out.println(c1); //一个类在内存中只有一个Class对象 //一个类被加载后,类的整个结构都会被封装在Class对象中 System.out.println(c2.hashCode()); System.out.println(c3.hashCode()); System.out.println(c4.hashCode()); System.out.println(c5.hashCode()); } } class User{ private String name; private int id; private int age; public User() { } public User(String name, int id, int age) { this.name = name; this.id = id; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } 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; } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", id=" + id + ", age=" + age + '}'; } }
输出结果:
class com.company.reflection.User 1468177767 1468177767 1468177767 1468177767
在Object类中定义了以下的方法,此方法将被所有子类继承。
public final Class getClass()
以上的方法返回值的类型是个 Class类,此类是Java反射的源头,实际上所谓反射从程序的运行结果来看也很好理
解,即:可以通过对象反射求出类的名称。
对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言,JRE都为其保留一个不变的Class类型的对象。一个 Class对象包含了特定某个结构( class/interface/enum/annotation/ primitive type/void/[])的有关信息。
方法名 | 功能说明 |
---|---|
static ClassforName(String name) | 返回指定类名name的Class对象 |
Object newInstance() | 调用缺省构造函数,返回Class对象的一个实例 |
getName() | 返回此Class对象所表示的实体(类,接口,数组类或void)的名称。 |
Class getSuperClass() | 返回当前Class对象的父类的Class对象 |
Class[] getInterfaces() | 获取当前Class对象的接口 |
ClassLoader getClassLoader() | 返回该类的类加载器 |
Constructor[] getConstructors() | 返回一个包含某些 Constructor对象的数组 |
Method getMothed( String name,Class.. T) | 返回一个 Method对象,此对象的形参类型为paramType |
Field[] getDeclaredFields() | 返回 Field对象的一个数组 |
若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高。
Class clazz=Person.class;
已知某个类的实例,调用该实例的getClass()方法获取Class对象。
Class clazz=Person.getClass();
已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法 forName()获取,可能抛出 ClassNotFounDexception异常。
Class clazz=Class.forName("Person");
内置基本数据类型可以直接用类名.Type。
还可以利用 ClassLoader。
例子:
public class Test2 { public static void main(String[] args) throws ClassNotFoundException { Person person = new Student(); Class c1 = person.getClass(); System.out.println(c1.hashCode()); Class c2 = Class.forName("com.company.reflection.Student"); System.out.println(c2.hashCode()); Class c3 = Student.class; System.out.println(c3.hashCode()); //内置基本数据类型可以直接用类名.Type Class c4 = Integer.TYPE; System.out.println(c4); //获得父类类型 Class c5 = c1.getSuperclass(); System.out.println(c5); } }
输出结果:
434091818 434091818 434091818 int class com.company.reflection.Person
例子:
public class Test3 { public static void main(String[] args) { //类 Class c1 = Object.class; //接口 Class c2 = Comparable.class; //一维数组 Class c3 = String[].class; //二维数组 Class c4 = int[][].class; //注解 Class c5 = Override.class; //枚举 Class c6 = ElementType.class; //基本数据类型 Class c7 = Integer.class; Class c8 = void.class; Class c9 = Class.class; System.out.println(c1); System.out.println(c2); System.out.println(c3); System.out.println(c4); System.out.println(c5); System.out.println(c6); System.out.println(c7); System.out.println(c8); System.out.println(c9); //只要元素类型与维度一样,就是同一个Class。 int[] a=new int[10]; int[] b=new int[100]; System.out.println(a.getClass().hashCode()); System.out.println(b.getClass().hashCode()); } }
输出结果:
class java.lang.Object interface java.lang.Comparable class [Ljava.lang.String; class [[I interface java.lang.Override class java.lang.annotation.ElementType class java.lang.Integer void class java.lang.Class 1468177767 1468177767
当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化。
例子:
public class Test4 { public static void main(String[] args) { A a = new A(); System.out.println(A.m); /* 1.加载到内存,会产生一个类对应Class对象 2.链接,链接结束后m=0 3.初始化 <clinit>(){ System.out.println("A类静态代码块初始化"); m = 300; m = 100; } m = 100; */ } } class A { static { System.out.println("A类静态代码块初始化"); m = 300; } static int m = 100; public A(){ System.out.println("A类的无参构造初始化"); } }
输出结果:
A类静态代码块初始化 A类的无参构造初始化 100
例子:
public class Test5 { static { System.out.println("Main类被加载"); } public static void main(String[] args) throws ClassNotFoundException { //1.主动引用 Son son = new Son(); //2.反射也会产生主动引用 Class.forName("com.company.reflection.Son"); //不会产生类的引用的方法 System.out.println(Son.b); Son[] sons = new Son[5]; System.out.println(Son.M); } } class Father { static int b = 2; static { System.out.println("父类被加载"); } } class Son extends Father { static { System.out.println("子类被加载"); m = 300; } static int m = 100; static final int M = 1; }
类加载的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口。
类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些 Class对象。
类加载器作用是用来把类(class)装载进内存的。JVM规范定义了如下类型的类的加载器。
例子:
public class Test6 { public static void main(String[] args) throws ClassNotFoundException { //获取系统类的加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); System.out.println(systemClassLoader); //获取系统类加载器的父类加载器-->扩展类加载器 ClassLoader parent = systemClassLoader.getParent(); System.out.println(parent); //获取扩展类加载器的父类加载器-->根加载器(C/C++) ClassLoader parent1 = parent.getParent(); System.out.println(parent1); //测试当前类是哪个加载器加载的 ClassLoader classLoader = Class.forName("com.company.reflection.Test6").getClassLoader(); System.out.println(classLoader); //测试JDK内置类是谁加载的 classLoader = Class.forName("java.lang.Object").getClassLoader(); System.out.println(classLoader); //如何获取系统类加载器可以加载的路径 System.out.println(System.getProperty("java.class.path")); /* E:\yt\git\java-learn\IDEA\out\production\IDEA; C:\Users\yt\.m2\repository\junit\junit\4.12\junit-4.12.jar; C:\Users\yt\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar; E:\yt\git\java-learn\IDEA\src\com\company\lib\commons-io-2.8.0.jar; E:\yt\git\java-learn\IDEA\lib\kotlin-stdlib.jar; E:\yt\git\java-learn\IDEA\lib\kotlin-reflect.jar; E:\yt\git\java-learn\IDEA\lib\kotlin-test.jar; E:\yt\git\java-learn\IDEA\lib\kotlin-stdlib-jdk7.jar; E:\yt\git\java-learn\IDEA\lib\kotlin-stdlib-jdk8.jar */ } }
输出结果:
jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc jdk.internal.loader.ClassLoaders$PlatformClassLoader@57829d67 null jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc null E:\yt\git\java-learn\IDEA\out\production\IDEA;C:\Users\yt\.m2\repository\junit\junit\4.12\junit-4.12.jar;C:\Users\yt\.m2\repository\org\hamcrest\hamcrest-core\1.3\hamcrest-core-1.3.jar;E:\yt\git\java-learn\IDEA\src\com\company\lib\commons-io-2.8.0.jar;E:\yt\git\java-learn\IDEA\lib\kotlin-stdlib.jar;E:\yt\git\java-learn\IDEA\lib\kotlin-reflect.jar;E:\yt\git\java-learn\IDEA\lib\kotlin-test.jar;E:\yt\git\java-learn\IDEA\lib\kotlin-stdlib-jdk7.jar;E:\yt\git\java-learn\IDEA\lib\kotlin-stdlib-jdk8.jar
通过反射获取运行时类的完整结构。
Field、 Method、 Constructor、 Superclass、 Interface、 Annotation
例子:
public class Test7 { public static void main(String[] args) throws ClassNotFoundException { Class c1 = Class.forName("com.company.reflection.User"); //获取类的名字 System.out.println(c1.getName()); System.out.println(c1.getSimpleName()); //获取类的属性 //只能找到public属性 Field[] fields = c1.getFields(); //找到全部的属性 fields=c1.getDeclaredFields(); for (Field field : fields) { System.out.println(field); } //获得方法 //获得本类及其父类的全部public方法 Method[] methods = c1.getMethods(); for (Method method : methods) { System.out.println("getMethods:"+method); } //获得本类的全部方法 Method[] declaredMethods = c1.getDeclaredMethods(); for (Method declaredMethod : declaredMethods) { System.out.println("getDeclaredMethods:"+declaredMethod); } //获得构造器 Constructor[] constructors = c1.getConstructors(); for (Constructor constructor : constructors) { System.out.println(constructor); } for (Constructor declaredConstructor : c1.getDeclaredConstructors()) { System.out.println(declaredConstructor); } } }
输出结果:
com.company.reflection.User User private java.lang.String com.company.reflection.User.name private int com.company.reflection.User.id private int com.company.reflection.User.age getMethods:public java.lang.String com.company.reflection.User.getName() getMethods:public java.lang.String com.company.reflection.User.toString() getMethods:public void com.company.reflection.User.setName(java.lang.String) getMethods:public int com.company.reflection.User.getId() getMethods:public void com.company.reflection.User.setId(int) getMethods:public int com.company.reflection.User.getAge() getMethods:public void com.company.reflection.User.setAge(int) getMethods:public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException getMethods:public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException getMethods:public final void java.lang.Object.wait() throws java.lang.InterruptedException getMethods:public boolean java.lang.Object.equals(java.lang.Object) getMethods:public native int java.lang.Object.hashCode() getMethods:public final native java.lang.Class java.lang.Object.getClass() getMethods:public final native void java.lang.Object.notify() getMethods:public final native void java.lang.Object.notifyAll() getDeclaredMethods:public java.lang.String com.company.reflection.User.getName() getDeclaredMethods:public java.lang.String com.company.reflection.User.toString() getDeclaredMethods:public void com.company.reflection.User.setName(java.lang.String) getDeclaredMethods:public int com.company.reflection.User.getId() getDeclaredMethods:public void com.company.reflection.User.setId(int) getDeclaredMethods:public int com.company.reflection.User.getAge() getDeclaredMethods:public void com.company.reflection.User.setAge(int) public com.company.reflection.User() public com.company.reflection.User(java.lang.String,int,int) public com.company.reflection.User() public com.company.reflection.User(java.lang.String,int,int)
创建类的对象:调用Class对象的newInstance()方法。
思考?难道没有无参的构造器就不能创建对象了吗?只要在操作的时候明确的调用类中的构造器,并将参数传递进去之后,才可以实例化操作。
步骤如下:
调用指定的方法
通过反射,调用类中的方法,通过 Method类完成。
Object invoke( Object obj, Object[] args)
setAccessible
例子:
public class Test8 { public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException { Class c1 = Class.forName("com.company.reflection.User"); //构造对象 //调用无参构造器 User user =(User) c1.newInstance(); System.out.println(user); //通过构造器创建对象 Constructor constructor = c1.getDeclaredConstructor(String.class, int.class, int.class); User user2 =(User) constructor.newInstance("yt", 1, 18); System.out.println(user2); //通过反射调用普通方法 User user3 =(User) c1.newInstance(); //通过反射获取一个方法 Method setName = c1.getDeclaredMethod("setName", String.class); //invoke: 激活的意思(对象,"方法的值") setName.invoke(user3,"yt"); System.out.println(user3.getName()); //通过反射操作属性 User user4 =(User) c1.newInstance(); Field name = c1.getDeclaredField("name"); //不能直接操作私有属性,我需要关闭程序的安全检测,属性或者方法的setAccessible(true) name.setAccessible(true); name.set(user4,"yt2"); System.out.println(user4.getName()); } }
输出结果:
User{name='null', id=0, age=0} User{name='yt', id=1, age=18} yt yt2
例子:
public class Test9 { /** * 普通方式调用 */ public static void test01() { User user = new User(); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1000000000; i++) { user.getName(); } long endTime = System.currentTimeMillis(); System.out.println("普通方式执行10亿次:"+(endTime - startTime)+"ms"); } /** * 反射方式调用 */ public static void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class c1 = user.getClass(); Method getName = c1.getDeclaredMethod("getName", null); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1000000000; i++) { getName.invoke(user,null); } long endTime = System.currentTimeMillis(); System.out.println("反射方式执行10亿次:"+(endTime - startTime)+"ms"); } /** * 反射方式调用 关闭检测 */ public static void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { User user = new User(); Class c1 = user.getClass(); Method getName = c1.getDeclaredMethod("getName", null); getName.setAccessible(true); long startTime = System.currentTimeMillis(); for (int i = 0; i < 1000000000; i++) { getName.invoke(user,null); } long endTime = System.currentTimeMillis(); System.out.println("反射方式关闭检测后执行10亿次:"+(endTime - startTime)+"ms"); } public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException { test01(); test02(); test03(); } }
输出结果:
普通方式执行10亿次:5ms 反射方式执行10亿次:1710ms 反射方式关闭检测后执行10亿次:1326ms
Java采用泛型擦除的机制来引入泛型,Java中的泛型仅仅是给编译器javac使用的确保数据的安全性和免去强制类型转换问题,但是,一旦编译完成,所有和泛型有关的类型全部擦除。
为了通过反射操作这些类型,Java新增了 ParameterizedType, GenericarrayType,TypeVariable和 WildcardType几种类型来代表不能被归一到Class类中的类型但是又和原始类型齐名的类型。
例子:
public class Test10 { public void test01(Map<String, User> map, List<User> list) { System.out.println("test01"); } public Map<String, User> test02() { System.out.println("test02"); return null; } public static void main(String[] args) throws NoSuchMethodException { Method test01 = Test10.class.getMethod("test01", Map.class, List.class); Type[] genericParameterTypes = test01.getGenericParameterTypes(); for (Type genericParameterType : genericParameterTypes) { System.out.println(genericParameterType); if (genericParameterType instanceof ParameterizedType) { Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments(); for (Type actualTypeArgument : actualTypeArguments) { System.out.println(actualTypeArgument); } } } Method test02 = Test10.class.getMethod("test02", null); Type genericReturnType = test02.getGenericReturnType(); if (genericReturnType instanceof ParameterizedType) { Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments(); for (Type actualTypeArgument : actualTypeArguments) { System.out.println(actualTypeArgument); } } } }
输出结果:
java.util.Map<java.lang.String, com.company.reflection.User> class java.lang.String class com.company.reflection.User java.util.List<com.company.reflection.User> class com.company.reflection.User class java.lang.String class com.company.reflection.User
例子:
public class Test11 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException { Class c1 = Class.forName("com.company.reflection.Student2"); //通过反射获得注解 Annotation[] annotations = c1.getAnnotations(); for (Annotation annotation : annotations) { System.out.println(annotation); } //获得注解的value值 TableYt tableYt = (TableYt) c1.getAnnotation(TableYt.class); String value = tableYt.value(); System.out.println(value); //获得类的指定注解 Field name = c1.getDeclaredField("name"); FiledYt annotation = name.getAnnotation(FiledYt.class); System.out.println(annotation.columnName()); System.out.println(annotation.type()); System.out.println(annotation.length()); } } @TableYt("db_student") class Student2 { @FiledYt(columnName = "db_id", type = "int", length = 10) private int id; @FiledYt(columnName = "db_age", type = "int", length = 10) private int age; @FiledYt(columnName = "db_name", type = "varchar", length = 3) private String name; public Student2(int id, int age, String name) { this.id = id; this.age = age; this.name = name; } public Student2() { } 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 getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "Student2{" + "id=" + id + ", age=" + age + ", name='" + name + '\'' + '}'; } } /** * 类名注解 * * @author yt */ @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @interface TableYt { String value(); } /** * 属性注解 * * @author yt */ @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @interface FiledYt { String columnName(); String type(); int length(); }
输出结果:
@com.company.reflection.TableYt(value="db_student") db_student db_name varchar 3