Java凝视Override、Deprecated、SuppressWarnings具体解释

            
class ParentClass1
            {
            public void myMethod1() {...}

            }

            

            class Class1 extends ParentClass1
            {
            public void myMethod2() {...}

            } 
            

            
ParentClass1 c1 = new Class1();
            c1.myMethod1();
            
            

            
class Class1 extends ParentClass1
            {
             @Override // 编译器产生一个错误

            public void myMethod2()
            {...}

            }
            
            

            
class Class1 extends ParentClass1
            {
            @Override
            public void myMethod1() {...}

            }
            

    这个凝视是一个标记凝视。所谓标记凝视，就是在源程序中添?这个标记后，并不影响程序的编译，但有时编译器会显示一些警告信息。
   
    那么Deprecated凝视是什么意思呢？假设你常常使用eclipse等IDE编写java程序时，可能会常常在属性或方法提示中看到这个词。假设某个类成员的提示中出现了个词，就表示这个并不建议使用这个类成员。由于这个类成员在未来的JDK版本号中可能被删除。之所以在如今还保留，是由于给那些已经使用了这些类成员的程序一个缓冲期。假设如今就去了，那么这些程序就无法在新的编译器中编译了。

    讲到这，可能你已经猜出来了。Deprecated凝视一定和这些类成员有关。说得对！使用Deprecated标注一个类成员后，这个类成员在显示上就会有一些变化。在eclipse中很明显。让我们看看图1有哪些变化。


图1 加上@Deprecated后的类成员在eclipse中的变化

    从上图能够看出，有三个地方发生的变化。红色框里面的是变化的部分。
    1. 方法定义处
    2. 方法引用处
    3. 显示的成员列表中

    发生这些变化并不会影响编译，仅仅是提醒一下程序猿，这种方法以后是要被删除的，最好别用。

    Deprecated凝视另一个作用。就是假设一个类从另外一个类继承，而且override被继承类的Deprecated方法，在编译时将会出现一个警告。如test.java的内容例如以下：

            
class Class1
            {
            @Deprecated
            public void myMethod(){}

            }

            

            class Class2 extends Class1
            {
            public void myMethod(){}

            } 

            
            

            
public void myMethod()
            {
            List wordList = new ArrayList();
            wordList.add("foo");
            }
            

            
public @interface MyAnnotation
            {
            }
            

            
public @interface MyAnnotation
            {
              String value();
            }
            

            
@MyAnnotation("abc")
            public void myMethod()
            {
            }
            

            
public @interface MyAnnotation
            {
              public String myMethod(){} default “xyz”;
            }
            

            
@MyAnnotation // 使用默认值xyz

            public void myMethod()
            {
            }
            

            
@MyAnnotation(myMethod=”abc”)
            public void myMethod()
            {
            }
            

            
public @interface MyAnnotation
            {
            public enum MyEnum{A, B, C}

            public MyEnum.value1() {}

            public String value2() {}

            }

            

            @MyAnnotation(value1=MyAnnotation.MyEnum.A, value2 = “xyz”)
            public void myMethod()
            {
            }
            

            
@Target(ElementType.METHOD)
            @interface MyAnnotation {}

            

            @MyAnnotation // 错误的使用

            public class Class1
            {
            @MyAnnotation // 正确的使用

            public void myMethod1() {}

            }
            

            
@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
            @interface MyAnnotation {}

            
            

            
@Retention(RetentionPolicy.SOURCE)
            @interface MyAnnotation1 { }

            

            @Retention(RetentionPolicy.CLASS)
            @interface MyAnnotation2 {}

            

            @Retention(RetentionPolicy.RUNTIME)
            @interface MyAnnotation3 {}
            

            
@interface MyAnnotation{ }

            @MyAnnotation
            class Class1
            {
            public void myMethod() { }

            }
            

            
class Class1extends java.lang.Object
            而假设这样定义MyAnnotation将会出现还有一个结果。
            @Documented
            @interface MyAnnotation {}

            

            生成的文档：
            @MyAnnotation // 这行是在加上@Documented后被加上的

            class Class1extends java.lang.Object
            
            

            
@Inherited
            @interface MyAnnotation { }

            

            @MyAnnotation
            public class ParentClass {}

            public class ChildClass extends ParentClass { }

            

            在以上代码中ChildClass和ParentClass一样都已被MyAnnotation凝视了。 
            

            
Method method = TestAnnotation.class.getMethod("myMethod", null);
            Annotation annotation = method.getAnnotation(MyAnnotation.class);
            注：要想使用反射得到凝视信息，这个凝视必须使用
            @Retention(RetentionPolicy.RUNTIME)进行凝视。