注解与反射

注解

  一些内置注解

@Override 注解重写  添加到方法上
@Deprecated  过时注解，不推荐  添加到方法上
@SuppressWarnings() 抑制编译时的警告信息  添加到方法上

元注解

元注解  主要用于注解其他的注解
@Target        用于描述注解的使用范围
@Retention     描述注解的生命周期   （source<class<tuntime）优先级
@Documented    说明该注解将被包含在javadoc中
@Inherited     说明子类可以继承父类中的该注解

定义一个注解

@Target(value = {ElementType.METHOD,ElementType.TYPE})//注解在方法上,注解在类上
@Retention(value = RetentionPolicy.RUNTIME)//注解在运行时有效
@interface MyAnn{

}

注解的属性值

@Target(value = {ElementType.METHOD,ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@interface MyAnnotation{
    //注解的参数：参数类型+参数名（）
    String name();
    int age() default 0;
    int id() default -1;//如果值为-1代表不存在
    String[] schools();
}

@interface MyAnnotation2{
    String value();//如果注解只有一个属性，并且属性名为value，则可以省略不写value
}

具体使用

//注解可以显示赋值，如果没有默认值，我们必须给注解赋值
    @MyAnnotation(name = "五月",schools = {"江南大学","清华大学"})
    @MyAnnotation2("傻逼")
    public void test(){}

 

反射

静态和动态语言

动态语言

➢是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以被 引进，已有的函数可以被删除或是其他结构.上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
➢主要动态语言: Object-C、 C#、 JavaScript. PHP、Python等。
静态语言
➢与动态语言相对应的,运行时结构不可变的语言就是静态语言。如Java、 C、C++.
➢Java不是动态语言，但Java可以称之为"准动态语言”。即Java有一定的动态性,我们可以利用反射机制获得类似动态语言的特性。Java的动态性让编程的时候更加灵活!

java反射的优缺点

优点：

可以实现动态创建对象和编译，体现很多的灵活性

缺点：

对性能有影响

通过反射获取Class对象的几种方式

Class类

对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个 Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/D)的有关信息。
➢Class本身也是一个类
➢Class 对象只能由系统建立对象
➢一个加载的类在JVM中只会有一一个Class实例
➢一个Class对象对应的是一个加载到JVM中的一 个.class文件
➢每个类的实例都会记得自己是由哪个Class实例所生成
➢通过Class可以完整地得到一 -个类中的所有被加载的结构
➢Class类 是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

 

 

 

Person person=new Student();

//方式一
Class<? extends Person> al1 = person.getClass();
System.out.println(al1.hashCode());
//方式二
Class<?> al2 = Class.forName("com.jn.Student");//可能抛出异常
System.out.println(al2.hashCode());
//方式三
Class<Student> al3 = Student.class;
System.out.println(al3.hashCode());
//方式四：基于内置类型的包装类都有一个TYPE属性
Class<Integer> al4 = Integer.TYPE;
System.out.println(al4.hashCode());

//获得父类类型
Class<?> superclass = al1.getSuperclass();
System.out.println(superclass);

只要元素类型与维度一样，获取到的Class都是一个对象，例如：int[] a=new int[10]与int[] a=new int[100]是一样的

 

java内存分析

 

 

 

 

获取类的运行时结构

Class cl1=User.class;
        //获取类的名字
        System.out.println(cl1.getName());//com.jn.User 包名+类名
        System.out.println(cl1.getSimpleName());//User  类名
        
        //获取类的属性
        Field[] fields = cl1.getFields();//只能找到public属性
        Field[] declaredFields = cl1.getDeclaredFields();//获取所有属性
        Field name1 = cl1.getField("name");//获取指定public属性
        Field age = cl1.getDeclaredField("age");//获取指定属性
        
        //获得类的方法
        Method[] methods = cl1.getMethods();//获得本类及其父类的所有方法
        Method[] declaredMethods = cl1.getDeclaredMethods();//获得本类方法
        Method setName1 = cl1.getMethod("setName", String.class);//获得指定方法，参数1：方法名称，参数2：方法参数的Class
        
        //获得构造器
        Constructor[] constructors = cl1.getConstructors();//获得本类及其父类的所有所有构造器
        Constructor[] declaredConstructors = cl1.getDeclaredConstructors();//获得本类构造器
        Constructor constructor1 = cl1.getConstructor(String.class, int.class, int.class);//获得指定构造器

 

动态创建对象执行方法

//构造一个对象
        User user=(User) cl1.newInstance();//本质是通过类的无参构造器实现
        System.out.println(user.toString());

        //通过构造器创建对象
        Constructor constructor=cl1.getConstructor(String.class,int.class,int.class);
        User user2=(User) constructor.newInstance("五月",20,100);
        System.out.println(user2);

        //通过反射调用普通方法
        User user3=(User) cl1.newInstance();
        Method setName = cl1.getDeclaredMethod("setName", String.class);
        setName.invoke(user3,"傻逼");
        System.out.println(user3.getName());

        //通过反射操作属性：不能直接操作私有属性要关闭关闭程序安全检测
        User user4=(User) cl1.newInstance();
        Field name = cl1.getDeclaredField("name");//发现没有权限
        name.setAccessible(true);//赋予权限
        name.set(user4,"250");
        System.out.println(user4);