目录
注解
一、注解入门
作用
-
不是程序本身,可以对程序作出解释
-
可以被其它程序(编译器)读取
-
有检查和约束作用
格式:@注释名(参数可加)
使用在package class method field上,相当于给他们添加了额外的辅助信息
我们可以通过反射机制编程实现对这些元数据的访问
二、内置注解
-
@Override:定义在java.lang.Override中,此注释只用于修辞方法,表示一个方法声明打算重写超类的另一个方法声明
-
@Deprecated:定义在java.lang.Deprecated,可用于修辞方法、属性、类,表示不鼓励程序员使用这样的元素,通常是因为它很危险或者存在更好的选择
-
@SuppressWarnings:定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息,需加参数
public class Test01 extends Object{ @Override public String toString(){ return super.toString(); } @Deprecated public static void test(){ System.out.println("Deprecated"); } @SuppressWarnings("all") public void test02(){ List list=new ArrayList(); } public static void main(String[] args) { test(); } }
三、元注解
作用:负责注解其他注解,对其它annotation类型进行说明
在java.long.annotation中@Target @Retention @Documented @Inherited
//定义一个注解 //Target 表示我们的注解使用范围 可以用在方法上 或者其他位置,继续加就是 @Target(value =ElementType.METHOD,...); //Retention 表示需要什么级别保存该注释信息,描述注解的生命周期 (Retention >class >Source) @Retention //Document 表示是否将我们的注解生成在JAVAdoc中 @Document //Inherited 说明子类可以继承父类的注解 @Inherited
四、自定义注解
格式:public @interface A{...}
pubic class Test01{ //注解可以显示赋值 如果没有赋值,我们就必须给注解赋值 @MyAnnotation(name = "MakerLu",age = 18) //自定义注解参数名字没顺序 随便你怎么写 publice void test(){} } @interface MyAnnotation{ //用interface来定义注解 //注解的参数:参数类型 + 变量名(); String name() default ""; //default这里可以不用加 表示的是 不写注解名字的话 默认为什么什么... int age() default 0; int id() default -1; //如果默认值为-1 则表示不存在 String[] schools() default {"武汉大学"};
反射
一、反射概述
静态语言:运行不可以改变结构 c,c++,java(反射可赋予其动态性)
动态:运行时结构可变,如JavaScript
function f(){ var x="var a=3;var b=5;alert(a+b)"; eval(x);//运行时改变了x }
反射实际上就是java视为动态语言的关键,借助反射,我们可以在代码执行期间,通过Class类去操纵任何类的内部信息,比如内部属性或方法,甚至可以去操作私有属性!(可读取private)
(但是对性能有影响!)
加载完类之后,在堆内存的方法区就产生了一个class类型的对象(一个类只有一个class对象),这个对象就包含了完整的结构信息,我们可以通过这个对象看到类的结构。
-
正常方式:引入需要的包——通过new实例化——获取实例化对象
-
反射方式:实例化对象——getClass()方法——得到完整的“包类”名称
Class类 的概念下面讲!
Java反射机制提供的功能:
-
在运行时判断任意一个对象所属的类
-
在运行时构造任意一个类的对象
-
在运行时判断任意一个类所具有的成员变量和方法
-
在运行时调用任意一个对象的成员变量和方法
-
在运行时获取泛型信息
-
在运行时处理注解
-
生成动态代理
二、Class 类
注意Class 的首字母大写,代表一种类!(小写class 有其它作用)
首先呢,本身也是一个对象!由系统创建,在加载器将你写的代码定义的类加载到堆内存中的时候,就创建了这个对象。而它呢,是用来描述你写的代码中类的结构的 (比如:属性,构造器,方法,接口,枚举,注解….),你写的类不论创建(new)多少对象,这些对象都只拥有一个Class 对象!而我们呢,就可以通过对象的反射指向这个Class对象,得到这个Class对象,从而在执行期间去改变或者去获取关于你写的这个类的信息
-
Class类对应一个 JVM中的一个Class实例
-
一个Class对象对应的是一个加载到JVM中的一个.class文件
三、获取Class类的实例
public class A {...} A a = new A()
-
Class c1 = A.class;//已知具体类,通过类的class属性
-
Class c2 = a.getClass();//已知类的某个实例,调用getClass获得class对象
-
Classs c3 = Class.forName(“xxx.xx.A”);//已知一个类的全类名,在该类路径下,通过forname,注意抛出异常
-
基础类型的 Class c4 = Integer.TYPE;
-
通过ClassLoader获得
public class Test03 { public static void main(String[] args) throws ClassNotFoundException{ Person person=new Student(); System.out.println("是"+person.name); //通过对象获得 Class c1=person.getClass(); System.out.println(c1.hashCode()); //forname获得 Class c2=Class.forName("com.ic.reflection.Student"); System.out.println(c2.hashCode()); //通过类名.class获得 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); } }
四、所有类型的class对象
只要元素类型与维度一样,就是同一个class
五、类加载内存分析
主要分为三个:
-
栈内存 : 存放基本变量类型 ,以及对象的指针
-
堆内存: 主要存放new的对象和数组,可以被所有线程共享
-
方法区: 包含了所有class和static变量的数据结构,可以被所有进程共享
1、关于一个类的加载过程
主要分三步:
加载阶段
-
这个阶段主要由加载器来工作,也就是ClassLoader, 加载器的概念等下再说!
-
完成的工作:
-
1、将class文件的字节码存到内存当中去,把静态数据变成方法区的运行时数据结构,如上图方法区的样子
-
2、在堆内存中生成java.lang.Class对象
-
链接阶段
-
将java类的二进制代码合并到JVM的运行状态之中的过程
-
完成的工作:
-
1、为类变量(static) 分配内存以及赋予上默认初始值!比如 static int a = 0; static String b = “”;这样子。
-
2、为类的常量值进行赋值 先这么理解吧,也就是说,在这个阶段,常量值是可以使用的!
-
初始化阶段
-
这个阶段调用类构造器<clinit>,完成的工作,好比上图
-
1、将类变量进行真正的赋值,也就是你写的代码这个变量到底等于多少!
-
2、将静态代码块中的语句进行合并!
-
3、初始一个类的时候,父类没初始化,则先触发父类的初始化
-
public class Test04 { public static void main(String[] args) { A a=new A(); System.out.println(A.m); /* 1.加载到内存,产生一个类对应class对象 2.链接,结束后m=0 3.初始化 <clinit>(){ sout(""); 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类的无参构造初始化"); } }
2、首先来说加载器的概念
类加载器的作用:也就是在上面加载阶段所完成的事
类缓存:一旦类被加载到内存中,则会存在一段时间,然后再被回收!
加载器分为三种:
// 获取系统类加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); System.out.println(systemClassLoader); // 获取系统类加载器的父类加载器>>扩展加载器 ClassLoader sysParent = systemClassLoader.getParent(); System.out.println(sysParent); //获取扩展类加载器的父类加载器>>根加载器 但是获取的值为null ClassLoader extParent = sysParent.getParent(); System.out.println(extParent); //测试当前类是哪个加载器加载的 ClassLoader classLoader=Class.forName("com.ic.reflection.Test06").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"));
双亲委派机制:会从更高级选,根加载器优先
-
系统加载器 : 你写的用户自定义类的加载器,也是我们用的最多的加载器,父加载器是扩展加载器,可以获得引用
-
// 获取系统类加载器 ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
-
-
扩展加载器: 存放在 jre/lib/ext目录下jar包里面类的加载器,父加载器就是根加载器,可以获得引用
-
// 获取系统类加载器的父类加载器>>扩展加载器 ClassLoader sysParent = systemClassLoader.getParent();
-
-
根加载器 : Java的核心类,是通过这个加载器获得,我们并能获取它的引用, 为null
-
//获取扩展类加载器的父类加载器>>根加载器 但是获取的值为null ClassLoader extParent = sysParent.getParent();
-
3、再来说下初始化阶段的发生阶段
-
类的主动引用(一定会发生类的初始化)
-
虚拟机启动,执行main方法所在的类 ,这个类会到初始化阶段
-
new A() 也会发生初始化
-
调用类的静态方法和静态属性(除了final 常量)
-
使用java.lang.reflect包的方法,也就是获取Class的方法,也会将该类进行初始化
-
初始化子类的时候,父类如果没有初始化,则会先初始化父类
-
-
类的被动引用 (不会发生类的初始化)
-
子类引用父类的静态变量,子类不会初始化
-
数组定义分配空间,也不会引起该类的初始化
Son[] son1 = new Son[5]
-
引用常量也不会触发此类的初始化,因为再类加载的过程的第二阶段链接阶段,常量就已经可以用了
-
public class Test05 { static { System.out.println("main类被加载"); } public static void main(String[] args)throws ClassNotFoundException { //1.主动调用 Son son=new Son(); //2.反射也会产生主动引用 Class.forName("com.ic.reflection.Son"); //不会产生类的引用方法 System.out.println(Son.b); //不加载类,只是一个数组空间 Son[] array=new Son[5]; } } 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类,然后执行Class类的方法,就可以获得运行时你自己写的类的完整的数据结构了,包括:接口、所继承的父类、全部构造器、全部方法、全部属性、注解….
public class Test07 { public static void main(String[] args)throws ClassNotFoundException,NoSuchFieldException ,NoSuchMethodException{ Class c1=Class.forName("com.ic.reflection.User"); /* User user=new User(); c1=user.getClass(); */ 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); } //获得指定属性值 Field name=c1.getDeclaredField("name"); System.out.println(name); //获得本类及父类public方法 Method[] methods=c1.getMethods(); for(Method method:methods){ System.out.println(method); } //获得本类所有方法 methods=c1.getDeclaredMethods(); for(Method method:methods){ System.out.println(method); } //获得指定构造器 Constructor[] constructors=c1.getDeclaredConstructors(); for(Constructor constructor:constructors){ System.out.println(constructor); } Constructor declaredConstor=c1.getDeclaredConstructor(String.class,int.class); System.out.println(declaredConstor); } }
七、动态创建对象执行方法
通过反射,调用类中的方法,通过Method类完成
创建类的对象,也就是实例,平常我们通过new A()的方式创建的实例,我们现在可以通过反射创建
-
// 利用 Class类的newInstance()方法,调用了无参构造器创建实例 Class aClass=Class.forName("com.ClassLoader.Demo.User"); User user1=(User) aClass.newInstance();
-
// 非只能用无参构造器创建对象,用有参构造器也可以 // 先通过Class类的getDeclaredConstructor(对应的参数)方法获得有参构造器 // 然后调用有参构造器的newInstance()方法,就可以创建实例了 Constructor constructor=aClass.getDeclaredConstructor(String.class,int.class,double.class); User user2=(User) constructor.newInstance("xxx",xx,xx);//参数数量要一致否则出现异常
通过反射,去操作实例的方法和属性
-
// 通过反射调用普通方法 User user= (User) aClass.newInstance(); // 通过反射获取一个方法 Method setName=aClass.getDeclaredMethod("setName", String.class); // inoke激活,将实例作为第一个参数传入,修改的数据作为第二个参数 setName.invoke(user,"xxx"); System.out.println(user.getName());
-
// 通过反射操作属性,不能直接操作私有属性,可以通过关闭程序的安全检测关掉 User user4=(User) aClass.newInstance(); Field name=aClass.getDeclaredField("name"); name.setAccessible(true); //可通过的意思。private修饰的变量有安全保护机制, name.set(user4,"xxx"); System.out.println(user4.getName()); }
//通过反射,动态创建对象 public class Test08 { public static void main(String[] args)throwsClassNotFoundException,InstantiationException,IllegalAccessException,NoSuchMethodException, InvocationTargetException,NoSuchFieldException{ Class c1 = Class.forName("com.ic.reflection.User"); //本质调用了无参构造器 //User user=(User) c1.newInstance(); //通过构造器创建对象,可以没有无参构造器 Constructor constructor=c1.getDeclaredConstructor(String.class,int.class); User user2=(User)constructor.newInstance("ic",18); System.out.println(user2); //通过反射调用普通方法 User user3=(User) c1.newInstance(); //1、通过反射获取一个方法 Method setName=c1.getDeclaredMethod("setName",String.class); //2、invoke激活,(对象,"方法的值")调用 setName.invoke(user3,"ic"); System.out.println(user3.getName()); //通过反射操作属性 User user4=(User) c1.newInstance(); Field name=c1.getDeclaredField("name"); name.setAccessible(true);//不能直接操作私有属性,需要关掉安全检测,属性和方法setAccessible(true) name.set(user4,"ic"); System.out.println(user4.getName()); } }
反射调用关闭检测可以提高效率
八、反射操作泛型
java采用泛型擦除机制引入泛型,给编译器javac使用,确保数据的安全性和免去强制类型转换问题,编译✅会擦除
public class Test09 { public void test01(Map<String,User>map, List<User>list){ } public Map<String,User> test02(){ System.out.println("t02"); return null; } public static void main(String[] args)throws NoSuchMethodException{ Method method=Test09.class.getMethod("test01", Map.class, List.class); Type[] genericParameterTypes=method.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); } } } } }
九、反射获取注解信息
public class Test10 { public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException { Class c1=Class.forName("com.ic.reflection.Student1"); // 通过反射获得注解 Annotation[] annotations=c1.getAnnotations(); for (Annotation annotation : annotations) { System.out.println(annotation); } // 获得类的注解value参数的值 TableIc tableY=(TableIc)c1.getAnnotation(TableIc.class); String value=tableY.value(); System.out.println(value); // 获得类具体指定属性的注解 Field field=c1.getDeclaredField("name"); FieldIc annotation=field.getAnnotation(FieldIc.class); System.out.println(annotation.columnName()); System.out.println(annotation.type()); System.out.println(annotation.length()); } } @TableIc("db_student") class Student1{ @FieldIc(columnName = "db_id",type="int",length = 10) private int id; @FieldIc(columnName = "db_name",type="varchar",length = 10) private String name; @FieldIc(columnName = "db_age",type="int",length = 10) private int age; public Student1(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } //类名的注解 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @interface TableIc{ String value(); } //属性的注解 @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) @interface FieldIc{ String columnName(); String type(); int length(); }