Java深入(JDK1.5版本新特性、枚举以及注解介绍)

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
/* 
 * 用普通类如何实现枚举功能，定义一个Weekday的类来模拟枚举功能。  
    1、私有的构造方法 
    2、每个元素分别用一个公有的静态成员变量表示 
    3、可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。 
 
*/  
  
package cn.itheima;  
  
public abstract class WeekDay {  
    private WeekDay(){}  
  
    public final static WeekDay SUN=new WeekDay(){  
        public WeekDay nextDay(){  
            return MON;  
        }  
    };  
      
    public final static WeekDay MON=new WeekDay(){  
        public WeekDay nextDay(){  
            return SUN;  
        }  
    };  
      
    public abstract WeekDay nextDay();  
  
    public String toString(){  
        return this==SUN?"SUM":"MON";  
    }  
} 

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
    package cn.itheima;  
      
    public class EnumDemo {  
        public static void main(String[] args) {  
            WeekDay weekDay=WeekDay.MON;  
            System.out.println(weekDay);//输出枚举常量名  
            System.out.println(weekDay.name());//输出对象名  
            System.out.println(weekDay.getClass());//输出对应类  
            System.out.println(weekDay.toString());//输出枚举对象名  
            System.out.println(weekDay.ordinal());//输出此对象在枚举常量的次序  
            System.out.println(WeekDay.valueOf("WED"));//将字符串转化为枚举常量  
            System.out.println(WeekDay.values().length);//获取所以的枚举元素，并打印其长度  
        }  
        //定义枚举内部类  
        public enum WeekDay{  
            SUN(1),MON,TUE,WED,THI,FRI,SAT;//分号可有可无，但如果下面还有方法或其他成员时，分号不能省。  
            //而且当有其他方法时，必须在这些枚举变量的下方。  
      
            //无参构造器  
            private WeekDay(){  
                System.out.println("First");  
            }  
            //带参数的构造器  
            private WeekDay(int day){  
                System.out.println("Second");  
            }  
        }  
    }  

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
    /* 
     * 抽象的枚举方法 
     * 此时枚举中的常量需要子类来实现，这是可以利用内部类的方式来定义枚举常量 
     * 带方法的枚举 
        1）定义枚举TrafficLamp 
        2）实现普通的next方法 
        3）实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类 
        4）用类似内部类的方式进行定义。 
        5）增加上表示时间的构造方法 
     * */  
      
    package cn.itheima;  
      
    public class EnumTest {  
        public enum TrafficLamp{  
            RED(30){  
                public TrafficLamp nextLamp(){  
                    return GREEN;  
                }  
            },  
            GREEN(30){  
                public TrafficLamp nextLamp(){  
                    return YELLOW;  
                }  
            },  
            YELLOW(5){  
                public TrafficLamp nextLamp(){  
                    return RED;  
                }  
            };  
            private int time;  
            //构造器  
            private TrafficLamp(int time){  
                this.time=time;}  
            //抽象方法  
            public abstract TrafficLamp nextLamp();  
        }         
    }  

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
package cn.itheima.Demo;  
  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
  
@Retention(RetentionPolicy.RUNTIME)//元注释  表明该注解是在运行阶段
//注解类  
public @interface MyAnnotation {  
}  
  
@MyAnnotation  
//应用类  
public class AnnotationDemo {  
    @SuppressWarnings("deprecation")//此注解用于抑制过时信息的提示  
    public static void main(String[] args) {  
          
        System.runFinalizersOnExit(true); //这是一个过时了的方法 ,如果没有注解就会有警告提示  
        //判断此类是否有MyAnnotation注解  
        if (AnnotationDemo.class.isAnnotationPresent(MyAnnotation.class)) {  
            //如果有，则获取该注解  
            MyAnnotation annotation =AnnotationDemo.class.getAnnotation(MyAnnotation.class);  
            System.out.println(annotation);  
        }  
    }  
} 

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
48
49
50
51
52
53
54
55
56
    package cn.itheima.demo;  
      
    import java.lang.annotation.ElementType;  
    import java.lang.annotation.Retention;  
    import java.lang.annotation.RetentionPolicy;  
    import java.lang.annotation.Target;  
      
    @Retention(RetentionPolicy.RUNTIME)//元注释  
    @Target({ElementType.METHOD,ElementType.TYPE})//元注解，指定使用范围  
    //注解类  
    public @interface MyAnnotation {  
        String color() default "red" ;  
        String value();  
        //数组  
        int[] arr() default {1,2,3};  
        //枚举  
        EnumTest.TrafficLamp lamp() default EnumTest.TrafficLamp.GREEN;  
        //注解类  
        MetaAnnotation annotation() default @MetaAnnotation("heima");  
        //Class类  
        Class clazz() default System.class;  
    }  
      
    import java.lang.reflect.Method;  
      
    //注解类的应用，给属性赋值或者重新赋值  
    @MyAnnotation(lamp=EnumTest.TrafficLamp.YELLOW,value="heima",  
                clazz=AnnotationDemo.class,annotation=@MetaAnnotation("itheima"))  
    //应用类  
    public class AnnotationDemo {  
        @SuppressWarnings("deprecation")//此注解用于抑制过时信息的提示  
        @MyAnnotation("Method")//自定义注解应用在方法上  
        public static void main(String[] args) throws NoSuchMethodException, SecurityException {  
              
            System.runFinalizersOnExit(true); //这是一个过时了的方法 ,如果没有注解就会有警告提示  
            //判断此类是否有MyAnnotation注解  
            if (AnnotationDemo.class.isAnnotationPresent(MyAnnotation.class)) {  
                //如果有，则获取该注解  
                MyAnnotation annotation =AnnotationDemo.class.getAnnotation(MyAnnotation.class);  
                System.out.println(annotation);//@cn.itheima.Demo.MyAnnotation()  
                System.out.println(annotation.color());//red  
                System.out.println(annotation.value());//heima  
                System.out.println(annotation.arr().length);//3  
                System.out.println(annotation.lamp());//YEllOW  
                System.out.println(annotation.annotation().value());//itheima  
                System.out.println(annotation.clazz());//class cn.itheima.demo.AnnotationDemo  
            }  
              
            //获取方法上的注解  
            Method mainMethod=AnnotationDemo.class.getMethod("main",String[].class);  
            MyAnnotation annotationMethod=(MyAnnotation) mainMethod.getAnnotation(MetaAnnotation.class);  
            SuppressWarnings sw=mainMethod.getAnnotation(SuppressWarnings.class);  
            System.out.println(sw);//null  
            System.out.println(annotationMethod);//null   
        }  
    }