[Java笔记]常用核心类内部类枚举注解

public class Main {
    public static void main(String[] args) {
        Character c_1 = ('A');
        Character c_2 = ('$');
        Character c_3 = ('简');
        System.out.println(c_1.compareTo('D'));  // -3
        System.out.println(c_2.charValue());       // $
        System.out.println(c_3.isLetter('简'));  // true
    }
}

public class Main {
    public static void main(String[] args) {
        boolean b = false;
        Boolean b_1 = new Boolean(b);               // false
        Boolean b_2 = new Boolean("TruE");      // true , 这两个方法已经不支持, 将要移除
        System.out.println(b_1);
        System.out.println(b_2);
        System.out.println(b_1.booleanValue());  // false
        System.out.println(Boolean.parseBoolean("True"));     // true
        System.out.println(Boolean.valueOf(b).booleanValue());   // false
        System.out.println(Boolean.valueOf("OK")); // false
    }
}

public class Main {
    public static void main(String[] args) {
        Integer i = 300;   // auto boxing
        int i_1 = i;        // auto unboxing
        System.out.println(((Integer)i_1).toString()); // 强制转换
    }
}

public class Main {
    public static void main(String[] args) {
        String s = new String("123");
        System.out.println(Integer.parseInt(s));  // 字符串转基本类型
        System.out.println(Double.parseDouble(s));

        int i = 100;
        System.out.println(String.valueOf(i) instanceof  String); // 基本类型转字符串
        System.out.println(((Integer)i).toString());   // 或者通过包装类的toString()方法
    }
}

public class OuterClass {
    public class InnerClass {   // 内部类相当于成员, 可以访问外部内所有成员
        public int y = 1;
        public int add() {
            return x + y;
        }
    }
    private int x = 2;
    public static void main(String[] args) {
        OuterClass o = new OuterClass();
        OuterClass.InnerClass i = o.new InnerClass();   // 创建内部类

        OuterClass.InnerClass ii = new OuterClass().new InnerClass();  // 或者

        System.out.println(ii.add()); // 3
    }
}

public class OuterClass {
    private int x = 1;
    public void makeInner(int p) {
        String s = "local_variable";
        class InnerClass{
            public void seekOuter() {
                System.out.println(x);
                System.out.println(s);
                System.out.println(p);
            }
        }       // 此局部类只在这个函数中有效
        new InnerClass().seekOuter();       // 创建对象调用方法
    }

    public static void main(String[] args) {
        OuterClass o = new OuterClass();
        o.makeInner(2);
        //1
        //local_variable
        //2
    }
}

abstract class Person {
    public String name = "slacr";
    abstract public String work();
}
public class OuterClass {
    private int x = 1;

    public static void main(String[] args) {
        // 匿名对象继承 Person, 初始化同时定义
        Person hero = new Person(){
          @Override
           public String work() {
              return "punish evil-doers";
          }
        };
        System.out.println("Hero " + hero.name + ", I will " + hero.work());
        // Hero slacr, I will punish evil-doers
    }
}

public class OuterClass {
    private  static int x = 1;
    private static void outer() {
        System.out.println(new OuterClass().getClass().getSimpleName());
    }
    public  static  class InnerClass{
        private int y = 2;
        public void test() {
            outer();
            System.out.println(x);      // 可以访问外部静态成员方法和变量
            System.out.println(y);
        }
    }

    public static void main(String[] args) {
        OuterClass.InnerClass i = new OuterClass.InnerClass();
        // 不需要外层实例就可以直接创建一个静态内部实例
        i.test();
    }
}

public class Main {
    public static void main(String[] args) {
        Direction left = Direction.W;
        System.out.println(left);
        for ( Direction d : Direction.values()) {    // values() 是一个包含枚举常量的数组
            System.out.println(d.name() + " " + d.ordinal());
        }

        // enum 配合 Switch
        Direction d = Direction.values()[(int)(Math.random()*4)];
        switch (d) {
            case E -> System.out.println("EAST");
            case S -> System.out.println("SOUTH");
            case W -> System.out.println("WEST");
            case N -> System.out.println("NORTH");
            default -> System.out.println("error");
        }
    }
}

enum Color {
   R("RED", 1), G("GREEN", 2) , B("BLUE", 3);
   private String name;
   private int idx;
   private Color(String name, int idx) { // 构造方法只能 private, 通过枚举具体的类型创建
       this.name = name;
       this.idx = idx;
   }
   public static String getName(int idx) {  
       for (Color c : Color.values()){
           if(c.idx ==idx ) {
               return c.name;
           }
       }
       return null;
   }
   @Override
   public String toString() {
       return idx + " " + name;
   }
}
public class Main {
    public static void main(String[] args) {
        Color c = Color.G;    // 自动调用构造
        System.out.println(c.toString());
    }
}

@Target (value={TYPE,FIELD,METHOD,PARAMETER, CONSTRUCTOR,LOCAL_VARIABLE})
@Retention(value=SOURCE)
public @interface SuppressWarnings

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface MyAnnotation {
    String value();
}
 class MyClass1 {
    @MyAnnotation(value = "Hello, World!")
    public void myMethod() {
        // do something
    }
}

public class Main {
    
    public static void main(String[] args) throws NoSuchMethodException {
        MyClass1 obj = new MyClass1();
        Method method = obj.getClass().getMethod("myMethod");
        MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
        String value = annotation.value();
        System.out.println(value);
    }
}