in java what does the @ symbol mean?

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)

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.

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

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.

The @ symbol denotes Annotations. They provide information about a class, its field or method (above which they appear). They cannot perform operations. The compilers or special annotation processors use this information to make writing code less verbose.

In Java Persistence API you use them to map a Java class with database tables.

For example @Table() Used to map the particular Java class to the date base table.

@Entity Represents that the class is an entity class.

Similarly you can use many annotations to map individual columns, generate ids, generate version, relationships etc.

As some other suggests, it is Java's annotation. It helps the compiler to validate your code and to notify the programmer as well.

Very simple code example:

public class SomeClass {

    @Override
    public String toString() {
        return "SomeClass";
    }

    @Deprecated
    public void doSomeOperation() {
        // some operation...
    }
}

The annotation from SomeClass#toString which is @Override helps the compiler to determine that it is an overridden function from the implicit inheritance to the class Object.

While the annotation from SomeClass#doSomeOperation will warn the programmer that the function itself is deprecated already and should be avoided to use.

The annotations are for the reader or compiler, not executable code.