注解和反射_1

p1-p9

1: 注解

1.1 注解的概念

 

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

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

 

 

 

 

1.2 内置注解

 

 

 

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 +名字的类型

 

 

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(){
    }
//注解如果参数没有默认值，我们必须显示赋值
    @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)，尤其是自带的注解，所以我们自定义的一定要加上

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而已。常量在链接的解析阶段就加载到类对象里面，已经完成赋值，不属于类初始化。

过程