女朋友说想要自己的注解，我又活下来了！！！

@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Autowired {
 /**
  * Declares whether the annotated dependency is required.
  * <p>Defaults to {@code true}.
  */
 boolean required() default true;
}

/**
 * Indicates that annotations with a type are to be documented by javadoc
 * and similar tools by default.  This type should be used to annotate the
 * declarations of types whose annotations affect the use of annotated
 * elements by their clients.  If a type declaration is annotated with
 * Documented, its annotations become part of the public API
 * of the annotated elements.
 *
 * @author  Joshua Bloch
 * @since 1.5
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Documented {
}

/**
 * Indicates how long annotations with the annotated type are to
 * be retained.  If no Retention annotation is present on
 * an annotation type declaration, the retention policy defaults to
 * {@code RetentionPolicy.CLASS}.
 *
 * <p>A Retention meta-annotation has effect only if the
 * meta-annotated type is used directly for annotation.  It has no
 * effect if the meta-annotated type is used as a member type in
 * another annotation type.
 *
 * @author  Joshua Bloch
 * @since 1.5
 * @jls 9.6.3.2 @Retention
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Retention {
    /**
     * Returns the retention policy.
     * @return the retention policy
     */
    RetentionPolicy value();
}

public enum RetentionPolicy {
    /**
     * Annotations are to be discarded by the compiler.关注公众号:moon聊技术，获取更多有趣文章
     */
    SOURCE,

    /**
     * Annotations are to be recorded in the class file by the compiler
     * but need not be retained by the VM at run time.  This is the default
     * behavior.
     */
    CLASS,

    /**
     * Annotations are to be recorded in the class file by the compiler and
     * retained by the VM at run time, so they may be read reflectively.
     *
     * @see java.lang.reflect.AnnotatedElement
     */
    RUNTIME
}

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.ANNOTATION_TYPE)
public @interface Target {
    /**
     * Returns an array of the kinds of elements an annotation type
     * can be applied to.
     * @return an array of the kinds of elements an annotation type
     * can be applied to
     */
    ElementType[] value();
}

public enum ElementType {
    /** Class, interface (including annotation type), or enum declaration 关注公众号:moon聊技术，获取更多有趣文章*/
    TYPE,

    /** Field declaration (includes enum constants) */
    FIELD,

    /** Method declaration */
    METHOD,

    /** Formal parameter declaration */
    PARAMETER,

    /** Constructor declaration */
    CONSTRUCTOR,

    /** Local variable declaration */
    LOCAL_VARIABLE,

    /** Annotation type declaration */
    ANNOTATION_TYPE,

    /** Package declaration */
    PACKAGE,

    /**
     * Type parameter declaration
     *
     * @since 1.8
     */
    TYPE_PARAMETER,

    /**
     * Use of a type
     *
     * @since 1.8
     */
    TYPE_USE
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyAnnotation {
    /**
     * 说我爱你(默认true)
     */
    boolean sayILoveYou() default true;
}

public class Me {
    @MyAnnotation
    public void sayLoveYou(){
        System.out.println("表达一下我的真心");
    }
}

public class Main {
    public static void main(String[] args) {
        try {
            //获取Me的Class对象
            Me me = new Me();
            Class clazz = me.getClass();
            //获取该对象sayLoveYou方法上Info类型的注解
            MyAnnotation myAnnotation = clazz.getMethod("sayLoveYou", null).getDeclaredAnnotation(MyAnnotation.class);
            if (myAnnotation.sayILoveYou()) {
                System.out.println("我爱你");
            } else {
                System.out.println("我不爱你");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Me {
    @MyAnnotation(sayILoveYou=false)
    public void sayLoveYou(){
        System.out.println("表达一下我的真心");
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target({Ele，mentType.METHOD,ElementType.TYPE})
@Inherited
public @interface MyAnnotation {
    /**
     * 说我爱你(默认true)
     */
    boolean sayILoveYou() default true;
}

@MyAnnotation
public class Me {
    public void sayLoveYou(){
        System.out.println("表达一下我的真心");
    }
}

public class Child extends Me{
}

public static void main(String[] args) {
   try {
       //获取child的Class对象
       Child child = new Child();
       Class clazz = child.getClass();
       //获取该对象sayLoveYou方法上Info类型的注解
       MyAnnotation myAnnotation = (MyAnnotation) clazz.getAnnotation(MyAnnotation.class);
       if (myAnnotation.sayILoveYou()) {
           System.out.println("我爱你");
       } else {
           System.out.println("我不爱你");
       }
   } catch (Exception e) {
       e.printStackTrace();
   }
}