注解Annotation
格式:注解是以“@注释名”在代码中存在的,还可以添加一些参数值
作用:
-
不是程序本身,可以对程序作出解释
-
可以被其他程序(比如编译器)读取
内置注解
@Override:定义在java.lang.Override中,此注释只适用于修辞方法,表示一个方法声明打算重写超类中的另一个方法声明
@Deprecated:定义在java.lang.Deprecated中,此注释可以用于修辞方法,属性,类。(不推荐使用,通常很危险或存在更好的选择)
@SuppressWarning:定义在java.lang.SuppressWarnings中,用来抑制编译时的警告信息(需要添加参数才能使用)如@SuppressWarnings(“all”)、@SuppressWarnings(“unchecked”)、@SuppressWarnings(value={“unchecked”,“deprecation”})
元注解
元注解的作用注解其他注解,Java中定义了4个标准的meta-annotation类型,他们被用来提供对其他annotation类型作说明
分别是@Target、@Retention、@Document、@Inherited
@Target:用于描述注解的使用范围(即:被描述的注解可以用在什么地方)
@Retention:用于表示需要在什么级别保存该注释信息,用于描述注解的生命周期(SOURCE<CLASS<RUNTIME)
@Document:说明该注解将被包含在javadoc中
@Inherited:说明子类可以继承父类中的该注释
package Annotation;
import java.lang.annotation.*;
//@MyAnnotation,需要@Target()中有ElementType.TYPE才可以使用,否则会报错
public class TestAnnotation {
@MyAnnotation//因为有在@Target的括号中有ElementType.METHOD所以可以在方法上注释
public void test(){
//自定义的方法
}
}
//定义一个注释
//@Target中的括号表示注释可用在哪些地方
@Target(value ={ ElementType.METHOD,ElementType.TYPE})
//Retention表示我们的代码在什么地方还有效
//runtime>class>source
@Retention(value = RetentionPolicy.RUNTIME)
//Documented表示是否将注解生成在Javadoc中
@Documented
//Inherited子类可以继承父类的注解
@Inherited
@interface MyAnnotation{}
自定义注解
格式@interface 自定义名称
自定义注解可以定义一些参数,如果参数没有默认值,则在主程序或方法中标准的时候必须赋值,否则会报错
package Annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
public class Test {
@MyAnnotation2(name = "spl3",age = 18)//没有默认值,则我们必须赋值,否则会报错
public void method(){
}
}
@Target({ElementType.METHOD,ElementType.TYPE})
@interface MyAnnotation2{
//注解的参数是:参数类型+自定义参数名称+括号()
String name();
int age();
int id() default -1;//如果默认值是-1,则表示不存在
String[] Array() default {"spl","spl2"};
}
反射
正常方式:引入需要的“包类”名称->通过new实例化->取得实例化对象
反射方法:实例化对象->getClass()方法->得到完整的“包类”名称
Class c = Class.forName(“java.lang.String”)
package reflection;
//反射
public class TestDemo01 {
public static void main(String[] args) throws ClassNotFoundException {
//通过类名返回一个对象
Class c1 = Class.forName("reflection.User");
System.out.println(c1);
System.out.println(c1.hashCode());
//一个类在内存中只有一个Class对象
//一个类被加载后,类的整个结构都会被封装在Class对象中
Class c2 = Class.forName("reflection.User");
Class c3 = Class.forName("reflection.User");
Class c4 = Class.forName("reflection.User");
System.out.println(c2.hashCode());
System.out.println(c3.hashCode());
System.out.println(c4.hashCode());
}
}
//实体类pojo , entity
class User{
private String name;
private int age;
private int id;
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
public User() {
}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public User(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
}
Class类
常用方法:
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对象的一个数组
package reflection;
//测试Class类的创建方式有哪些
public class TestDemo02 {
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("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 Person{
public String name;
@Override
public String toString() {
return "person{" +
"name='" + name + '\'' +
'}';
}
public Person(String name) {
this.name = name;
}
public Person() {
}
}
class Student extends Person{
public Student() {
this.name="学生";
}
}
所有类型的Class对象
class:外部类,成员(成员内部类、静态内部类),局部内部类,匿名内部类
interface:接口
[]:数组
enum:枚举
annotation:注解@interface
primitive type:基本数据类型
void
类加载内存分析
package reflection;
public class TestDemo03 {
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;
}
*/
}
}
class A{
public A() {
System.out.println("A类无参构造初始化");
}
static {
System.out.println("A类静态代码块初始化");
m=300;
}
static int m=100;
}
类的初始化
什么时候会发生类初始化?
1.类的主动引用(一定会发生类的初始化)
-
当虚拟机启动,先初始化main方法所在的类
-
new一个类的对象
-
调用类的静态成员(除了final常量)和静态方法
-
使用java.lang.reflect包的方法对类进行反射调用
-
当初始化一个类,如果其父类没有被初始化,则会先初始化它的父类
2.类的被动引用(不会发生类的初始化)
- 当访问一个静态域时,只有真正声明这个域的类才会被初始化。如:当通过子类引用父类的静态变量,不会导致子类初始化
- 通过数组定义类引用,不会触发此类的初始化
- 引用常量不会触发此类的初始化
package reflection;
public class TestDemo04 {
static {
System.out.println("main类被加载");
}
public static void main(String[] args) throws ClassNotFoundException {
//主动引用
//Son son = new Son();
//反射也会产生主动引用
//Class s =Class.forName("reflection.Son");
//不会产生类的引用的方法
//System.out.println(Son.b);
//常量引用不会引起初始化
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;//常量
}
类加载器
package reflection;
public class TestDemo05 {
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("reflection.TestDemo05").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"));
}
}
获取类运行时的结构
package reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class TestDemo06 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
Class c = Class.forName("reflection.User");
//读取类的名字
System.out.println(c.getName());
System.out.println(c.getSimpleName());
//分割线
System.out.println("======================================");
//分割线
//读取类的属性Field
Field[] fields = c.getFields();//只能找到public属性
fields= c.getDeclaredFields();//能找到全部属性
for (Field field:fields){
System.out.println(field);
}
//分割线
System.out.println("======================================");
//分割线
//获得指定属性的值
Field name = c.getDeclaredField("name");
System.out.println(name);
//分割线
System.out.println("======================================");
//分割线
//获得类的方法
Method[] methods = c.getMethods();//获得本类及其父类的全部public方法
for (Method method : methods) {
System.out.println("getMethods:"+method);
}
//分割线
System.out.println("======================================");
//分割线
methods = c.getDeclaredMethods();//获得本类的全部方法
for (Method method : methods) {
System.out.println("getDeclaredMethods:"+method);
}
//获取指定方法
Method getNamename = c.getMethod("getName", null);//parameter用于防止重载
Method setName = c.getMethod("setName", String.class);
System.out.println(getNamename);
System.out.println(setName);
System.out.println("=======================");
//获取构造器
Constructor[] constructors = c.getConstructors();//获得public构造器
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
constructors = c.getDeclaredConstructors();//获得全部构造器
//获得指定构造器同理
}
}
动态创建对象执行方法
创建类的对象:调用Class对象的newInstance()方法
- 类必须有一个无参数的构造器
- 类的构造器的访问权限需要足够
无参构造器创建对象,只要在操作的时候明确的调用类中的构造器,并将参数传递进去后,才可以进行实例化操作,步骤如下:
1.通过Class类getDeclaredConstrctor(Class…parameterTypes)取得本类的指定形参类型的构造器
2.向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数
3.通过Constructor实例化对象
调用指定方法:通过反射,调用类中的方法,通过Method类完成
1.通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象,并设置此方法操作时所需要的参数类型。
2.之后使用Object invoke(Object obj,Object[] args)进行调用,并向方法中传递要设置的obj对象的参数信息
setAccessible:
- Method和Field、Constructor对象都有setAccessible()方法
- setAccessible作用是启动和禁用访问安全检查的开关
- 参数值为true则指示反射的对象在使用时应该取消java语音访问检查
- 参数值为false则指示反射的对象应该实施java语音访问检查(默认)
package reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestDemo07 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//获得class对象
Class c = Class.forName("reflection.User");
//构造一个对象
User user = (User) c.newInstance();//本质是调用了类的无参构造器
System.out.println(user);
//构造器创建对象
Constructor constructor = c.getDeclaredConstructor(String.class, int.class, int.class);
User user2 = (User) constructor.newInstance("name",21,114514);
System.out.println(user2);
//通过反射调用普通方法
User user3 =(User) c.newInstance();
//通过反射获取一个方法
Method setName = c.getMethod("setName", String.class);
//invoke:激活
//(对象,“方法的值”)
setName.invoke(user3,"spl");
System.out.println(user3.getName());
//通过反射调用属性
User user4 = (User) c.newInstance();
Field name = c.getDeclaredField("name");
//通过name.setAccessible(true);获取private变量
name.setAccessible(true);
name.set(user4,"spl2");
System.out.println(user4.getName());
}
}
性能分析
package reflection;
import com.scanner.Demo1;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
//性能测试
public class TestDemo08 {
//普通方法调用
public static void Demo1(){
User user = new User();
long starttime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
user.getName();
}
long endtime = System.currentTimeMillis();
System.out.println("普通模式下执行一亿次消耗的时间"+(endtime-starttime)+"ms");
}
//反射方法调用
public static void Demo2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c = user.getClass();
Method getName = c.getDeclaredMethod("getName", null);
long starttime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
getName.invoke(user,null);
}
long endtime = System.currentTimeMillis();
System.out.println("反射方式下执行一亿次消耗的时间"+(endtime-starttime)+"ms");
}
//反射方法不开启检测 调用
public static void Demo3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
User user = new User();
Class c = user.getClass();
Method getName = c.getDeclaredMethod("getName", null);
getName.setAccessible(true);
long starttime = System.currentTimeMillis();
for (int i = 0; i < 100000000; i++) {
getName.invoke(user,null);
}
long endtime = System.currentTimeMillis();
System.out.println("反射方式下关闭检测执行一亿次消耗的时间"+(endtime-starttime)+"ms");
}
public static void main(String[] args) throws Exception{
Demo1();
Demo2();
Demo3();
}
/*
普通模式下执行一亿次消耗的时间4ms
反射方式下执行一亿次消耗的时间305ms
反射方式下关闭检测执行一亿次消耗的时间154ms
*/
}
关闭检测时间更短效率更高