All Downloads are FREE. Search and download functionalities are using the official Maven repository.

java.lang.annotation.Annotation Maven / Gradle / Ivy

There is a newer version: 1.2.9
Show newest version
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with this
 * work for additional information regarding copyright ownership. The ASF
 * licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package java.lang.annotation;

/**
 * Defines the interface implemented by all annotations. Note that the interface
 * itself is not an annotation, and neither is an interface that simply
 * extends this one. Only the compiler is able to create proper annotation
 * types.
 *
 * @since 1.5
 */
public interface Annotation {

    /**
     * Returns the type of this annotation.
     *
     * @return A {@code Class} instance representing the annotation type.
     */
    Class annotationType();

    /**
     * Determines whether or not this annotation is equivalent to the annotation
     * passed. This is determined according to the following rules:
     *
     * 
    *
  • * Two annotations {@code x} and {@code y} are equal if and only if * they are members of the same annotation type and all the member * values of {@code x} are equal to the corresponding member values * of {@code y}. *
  • *
  • * The equality of primitive member values {@code x} and {@code y} * is determined (in a way similar to) using the corresponding * wrapper classes. For example, * {@code Integer.valueOf(x).equals(Integer.valueOf(y)} is used for * {@code int} values. Note: The behavior is identical to the * {@code ==} operator for all but the floating point type, so the * implementation may as well use {@code ==} in these cases for * performance reasons. Only for the {@code float} and {@code double} * types the result will be slightly different: {@code NaN} is equal * to {@code NaN}, and {@code -0.0} is equal to {@code 0.0}, both of * which is normally not the case. *
  • *
  • * The equality of two array member values {@code x} and {@code y} * is determined using the corresponding {@code equals(x, y)} * helper function in {@link java.util.Arrays}. *
  • *
  • * The hash code for all other member values is determined by simply * calling their {@code equals()} method. *
  • *
* * @param obj * The object to compare to. * * @return {@code true} if {@code obj} is equal to this annotation, * {@code false} otherwise. */ boolean equals(Object obj); /** * Returns the hash code of this annotation. The hash code is determined * according to the following rules: * *
    *
  • * The hash code of an annotation is the sum of the hash codes of * its annotation members. *
  • *
  • * The hash code of an annotation member is calculated as {@code * (0x7f * n.hashCode()) ^ v.hashCode())}, where {@code n} is the * name of the member (as a {@code String}) and {@code v} its value. *
  • *
  • * The hash code for a primitive member value is determined using * the corresponding wrapper type. For example, {@code * Integer.valueOf(v).hashCode()} is used for an {@code int} value * {@code v}. *
  • *
  • * The hash code for an array member value {@code v} is determined * using the corresponding {@code hashCode(v)} helper function in * {@link java.util.Arrays}. *
  • *
  • * The hash code for all other member values is determined by simply * calling their {@code hashCode} method. *
  • *
* * @return the hash code. */ int hashCode(); /** * Returns a {@code String} representation of this annotation. It is not * strictly defined what the representation has to look like, but it usually * consists of the name of the annotation, preceded by a "@". If the * annotation contains field members, their names and values are also * included in the result. * * @return the {@code String} that represents this annotation. */ String toString(); }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy