注解和反射_1

p1-p9

1: 注解

1.1 注解的概念

 

注解：能给人看，也能给机器看 ，机器会用反射机制进行访问。

如@Override都是注解，注解具有检查和约束的作用.如把S小写，override就报错了。

 

 

 

 

1.2 内置注解

 

 

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

package annotation; import java.util.ArrayList; import java.util.List; /**  * author liulei  * data  5.21  * since 1.8  * version 1.0  * Description  内置注解演示  */ public class Demo01 {     //Override  重写的注释     @Override     public String toString(){         return super.toString();     }     //Deprecated 不推荐程序员使用，但是可以使用，或者存在更好的方式     @Deprecated     public static void test()     {         System.out.println("这是个不被推荐的方法");     }     @SuppressWarnings("all")     public void test02()     {         List list = new ArrayList();     }     public static void main(String[] args) {         test();     } }

 

1.3 元注解

 自定义的注解的类型都是@interface +名字的类型

 

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

package annotation;   import java.lang.annotation.*;   /**  * author liulei  * data  5.21  * since 1.8  * version 1.0  * Description  元注解演示  */ @Myannotation public class Demo02 {     @Myannotation     public void test()     {     }     @Myannotation2(age = 18,name = "liulei")     public void test1(){     }<br>//注解如果参数没有默认值，我们必须显示赋值     @Myannotation3(value = "ll")     public void test2(){     }   } //定义一个注解 //Target 表示注解可以用在哪些地方 //Retention 表示我们的注解在什么地方还有效，作用的范围 //runtime>class>source //Documented 表示是否将注解生成在Javadoc中 //Inherited  子类可以继承父类的注解 @Target(value = {ElementType.METHOD,ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @interface Myannotation{ } @interface Myannotation2{     //注解的参数：参数类型+参数名();     String name() default "";     int age();     int id() default -1;//如果默认为-1，代表不存在     String[] schools() default {"西部开源","清华大学"}; } @interface Myannotation3{     String value();//如果只有一个参数，则参数为value }

 

　　常用的四个注解就是下面四个，其中Retention表示注解的生命周期，绝大部分情况我们声明的注解都是运行时期间有效(RUNTIME)，尤其是自带的注解，所以我们自定义的一定要加上

?

1	Target 表示注解可以用在哪些地方，如ElementType.TYPE则表示这个注解只能用在类上，

 

 

 

2：反射

2.1 反射介绍

 

 

 

 

 

 

 

 

 

 

 

 

2.2 Class类

 

 

 

 

package Reflection;

/**
 * author liulei
 * data 5.21
 * since 1.8
 * version 1.0
 * Description  获取类对象的Class对象的几种方法
 */
public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p = new Student("abc");
        System.out.println("这个人是:"+p.name);
        //方式一：通过对象获得
        Class c1 = p.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;

    public Person(String name) {
        this.name = name;
    }
    public Person() {
    }

}
class Student extends Person
{
    public Student(String name) {
        this.name = name;
    }
}
class Teacher extends Person
{
    public Teacher() {
    }

    public Teacher(String name) {
        this.name = "老师";
    }
}

 

package Reflection;

import java.lang.annotation.ElementType;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description
 */
public class Test02 {
    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;//void
        Class c9 = Class.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());

    }
}

 2.3 类的加载

 

 

 

 

 

 

 

 先把class文件加载到内存，静态数据转换为运行时数据，获取对应的java.lang.Class，链接阶段，为类变量分配内存空间，并赋值默认初始值，初始化阶段则是调用cinit方法合并静态变量和静态代码块并赋值初始值。父类没初始化也要初始化父类，cinit方法保证了枷锁和同步。

 

package Reflection;

/**
 * author liulei
 * data
 * since 1.8
 * version 1.0
 * Description
 */
public class Test03 {
    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{
    static {
        System.out.println("A类静态代码块初始化");
        m = 300;
    }
    static int m = 100;

    public A() {
        System.out.println("A类的无参构造初始化");
    }
}

 

 

 

 

 通过数组定义类引用，只是创建了一些空间，空间的名字叫son而已。常量在链接的解析阶段就加载到类对象里面，已经完成赋值，不属于类初始化。

过程