in java what does the @ symbol mean?

Question

I know what it means in a comment for documentation purposes, but outside of that what does it mean? (I would normally just google this but every non letter symbol shows up in results)

Answer 1

The @ symbol denotes a Java Annotation. What a Java annotation does, is that it adds a special attribute to the variable, method, class, interface, or other language elements. (This can be configured when you declare the annotation) When you add an annotation to something, other parts of the program can check whether something has an annotation or not. It then can use this information to do whatever stuff they need.

Let me give you some examples:

The @Override annotation

public class SuperClass {
    public void someInterestingMethod() {
        System.out.println("Superclass!");
    }
}

public class DerivedClass extends SuperClass {
    public void someInterestngMethod() {
        System.out.println("Derived class!");
    }
}

And when you do this:

SuperClass sc = new DerivedClass();
sc.someInterestingMethod();

The someInterestingMethod() call should be dynamically dispatched, and print "Derived class!", right? Well the derived class' method was actually misspelled, so DerivedClass got its own separate method called someInterestngMethod(), totally unrelated to the superclass' someInterestingMethod(). As such, someInterestingMethod() is no longer overridden, and the superclass' implementation is invoked.

The @Override keyword is intended to help with this. It signals your intent to the compiler, that you would like the annotated method to be an overload of one of the ancestor class' methods. If it's not (such as in this typo case, or if the SuperClass API changed and renamed the method), the will fail your compilation, to alert your attention to the broken override.

The @SuppressWarnings Annotation

Here is a method:

public void someMethod() {
    int i;
}

There will be a compiler warning saying that i is never used. So you can add the @SuppressWarnings to the method to suppress the warning:

@SuppressWarnings("unused")
public void someMethod() {
    int i;
}

Note that there is a parameter to the @SuppressWarnings annotation. Some annotations have parameters and you can look for the them in the javadoc. But for those that don't have parameters you don't need to add () like a method.

You can also declare your own annotations and use reflection to check for them. The above 2 annotations will be checked by the compiler.

Answer 2

The @ sign is used to specify Java Annotation.

https://en.wikipedia.org/wiki/Java_annotation

There are built-in Java Annotation and user defined Custom Annotation.

Annotations are used in various ways, such as suppress warning, associate method to URI (Servlet), associate variables to resource (JNDI) etc

Answer 3

The @ symbol is used for annotations. In my experience, the most common annotation is @Override, which indicates that a method is declared in a superclass. Other common annotations are @Deprecated, indicating that a method should no longer be used but still exists for backwards compatibility, and @SupressWarnings, to prevent warnings from showing up in the compiler.

Note that it's actually possible to get annotations which are not included in the core Java libraries and to declare your own annotations.