自定义注释和反射

注释

注释是给读代码的人看的，注解是给编译器“看”的

元注解

public class Test02 extends Object{
    //Override  重写的注释
    @Override
    public String toString(){
        return super.toString();
    }
    //Deprecated 不推荐程序员使用，但可以使用，或者存在更好的方式
    @Deprecated
    public static void  test(){
        System.out.println("Deprecated");
    }
    //镇压警告
    @SuppressWarnings("all")
    public void mm(){
        ArrayList list = new ArrayList();
    }
    public static void main(String[] args) {
        test();
    }
}

//Target  表示我们的注解可以用在哪个地方   可以用在方法上 或者其他位置，继续加就是
@Target(value =ElementType.METHOD,...); 
//Retention 描述注解的生命周期 （Retention >class >Source）
@Retention 
//Document 表示是否将我们的注解生成在JAVAdoc中
@Document
//Inherited 子类可以继承父类的注解
@Inherited

自定义注解

public class test01 {
    //注解可以显示赋值，如果没有默认值，我们就必须给注解赋值
    @Myannotation1(age = 6,school = {"one","two"})
    @Myannotation2("mmm")
    public void test(){
    }
}
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotation1{
    //注解的参数：参数类型+参数名（）
    String name() default ""; //取默认值
    int age() default 0;
    int id() default -1;  //如果设置成默认值-1，表示不存在 相当于indexof:如果找不到就返回-1
    String[] school();
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface Myannotation2{
    String value();   //如果只有一个参数，这里就直接写成value
}

反射

反射简介：

主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。

https://www.kuangstudy.com/bbs/1375299928716247042

获得Class文件的方式

//方法1 _通过对象获得
Class c1 = person.getClass();
//方法2 _通过forname
Class c2 = Class.forname("com.kuang.reflection.Student");
//方法3 _通过类名.class
Class c3 = Student.class;
//通过父类也能获得
Class c4 = c1.getSuperclass();

成员内部类

需要注意的是不是static 静态变量，需要如下定义
其次注意在类里面函数与类有无（static），调用是不一样的

StringDemo.Inner inner=StringDemo.new Inner();

枚举enum

public class Test
{
    enum Color
    {
        RED, GREEN, BLUE;
    }
 
    // 执行输出结果
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
    }
}

迭代枚举元素

enum Color
{
    RED, GREEN, BLUE;
}
public class MyClass {
  public static void main(String[] args) {
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  }
}

打印枚举类型

enum Color
{
    RED, GREEN, BLUE;
 
    // 构造函数
    private Color()
    {
        System.out.println("Constructor called for : " + this.toString());
    }
 
    public void colorInfo()
    {
        System.out.println("Universal Color");
    }
}
 
public class Test
{    
    // 输出
    public static void main(String[] args)
    {
        Color c1 = Color.RED;
        System.out.println(c1);
        c1.colorInfo();
    }
}

枚举类中的抽象方法实现

enum Color{
    RED{
        public String getColor(){//枚举对象实现抽象方法
            return "红色";
        }
    },
    GREEN{
        public String getColor(){//枚举对象实现抽象方法
            return "绿色";
        }
    },
    BLUE{
        public String getColor(){//枚举对象实现抽象方法
            return "蓝色";
        }
    };
    public abstract String getColor();//定义抽象方法
}

public class Test{
    public static void main(String[] args) {
        for (Color c:Color.values()){
            System.out.print(c.getColor() + "、");
        }
    }
}

初始化块的执行

只有大于1的代码块才会被 执行

public class HelloNative
{   public void init()
    // 下面定义一个初始化块
    {
        int a = 6;
        if (a > 4)
        {
            System.out.println("Appliction初始化块：局部变量a的值大于4");
        }
        System.out.println("Appliction的初始化块");
    }
    // 定义第二个初始化块
    {
        System.out.println("Appliction的第二个初始化块");
    }

    // 定义第san个初始化块
    {
        System.out.println("Appliction的第san个初始化块");
    }
    // 定义无参数的构造器
    //public HelloNative()
    {
        System.out.println("Appliction类的无参数构造器");
    }
    public static void main(String[] args)
    {
        new HelloNative();
    }
}