What's the difference between interface and @interface in java?

Question

I haven't touched Java since using JBuilder in the late 90's while at University, so I'm a little out of touch - at any rate I've been working on a small Java project this week, and using Intellij IDEA as my IDE, for a change of pace from my regular .Net development.

I notice it has support for adding interfaces and @interfaces, what is an @interface, and how does it differ from a normal interface?

public interface Test {
}

vs.

public @interface Test {
}

I've done a bit of searching, but couldn't find a great deal of useful info referring to @interface.

Answer 1

The interface keyword indicates that you are declaring a traditional interface class in Java.
The @interface keyword is used to declare a new annotation type.

See docs.oracle tutorial on annotations for a description of the syntax.
See the JLS if you really want to get into the details of what @interface means.

Answer 2

With @interface you're defining annotations, with interface you're defining interfaces.

From Oracle docs: "Annotations do not directly affect program semantics, but they do affect the way programs are treated by tools and libraries, which can in turn affect the semantics of the running program. Annotations can be read from source files, class files, or reflectively at run time."

Annotations usually have 2 major uses: They help to define programming contracts (like @Nonnull annotation), which means they actually do nothing, but serve to programmers and IDES to detect potential error codes, and there are runtime annotations, which are usually used by frameworks for configuration (like the @Service annotation in spring): The core detects clases in yous scope with specific annotations and applies logic to them (any example you can think of, like defining Java Servlers, creating singletons, etc)

Generally speaking, a junior programmer doing some normal basic stuff, will rarely need to define Annotations, but the definitioon and using of interfaces is something basic any new developer should learn if their lenguaje allows it: Good practices USUALLY recommend the usage of interfaces in your code for maintainability.

In my personal experience, I've been defining and using Java interfaces almost since the day I learned Java, but I didn't need to DEFINE an annotation (tagging things with existing annotations is another story) until my 5th-6th year working proffesionally with Java, and it was a very specific project, a code autro-generator, something like Lombok but much more specific for a client.

I guess it depends on the nature of your work, but to day, I can't count how many interfaces I've defined, but annotations could be counted with the fingers of both hands. I beet there are good chances that a Java developer can start and end their entire career without defining a single interface (unless you use swagger's annotation based documentation generation xD)

Answer 3

interface in the Java programming language is an abstract type that is used to specify a behavior that classes must implement. They are similar to protocols. Interfaces are declared using the interface keyword

@interface is used to create your own (custom) Java annotations. Annotations are defined in their own file, just like a Java class or interface. Here is custom Java annotation example:

@interface MyAnnotation {

    String   value();

    String   name();
    int      age();
    String[] newNames();

}

This example defines an annotation called MyAnnotation which has four elements. Notice the @interface keyword. This signals to the Java compiler that this is a Java annotation definition.

Notice that each element is defined similarly to a method definition in an interface. It has a data type and a name. You can use all primitive data types as element data types. You can also use arrays as data type. You cannot use complex objects as data type.

To use the above annotation, you could use code like this:

@MyAnnotation(
    value="123",
    name="Jakob",
    age=37,
    newNames={"Jenkov", "Peterson"}
)
public class MyClass {


}

Reference - http://tutorials.jenkov.com/java/annotations.html

Answer 4

interface: defines the contract for a class which implements it

@interface: defines the contract for an annotation

Answer 5

interface:

In general, an interface exposes a contract without exposing the underlying implementation details. In Object Oriented Programming, interfaces define abstract types that expose behavior, but contain no logic. Implementation is defined by the class or type that implements the interface.

@interface : (Annotation type)

Take the below example, which has a lot of comments:

public class Generation3List extends Generation2List {

   // Author: John Doe
   // Date: 3/17/2002
   // Current revision: 6
   // Last modified: 4/12/2004
   // By: Jane Doe
   // Reviewers: Alice, Bill, Cindy

   // class code goes here

}

Instead of this, you can declare an annotation type

 @interface ClassPreamble {
   String author();
   String date();
   int currentRevision() default 1;
   String lastModified() default "N/A";
   String lastModifiedBy() default "N/A";
   // Note use of array
   String[] reviewers();
}

which can then annotate a class as follows:

@ClassPreamble (
   author = "John Doe",
   date = "3/17/2002",
   currentRevision = 6,
   lastModified = "4/12/2004",
   lastModifiedBy = "Jane Doe",
   // Note array notation
   reviewers = {"Alice", "Bob", "Cindy"}
)
public class Generation3List extends Generation2List {

// class code goes here

}

PS: Many annotations replace comments in code.

Reference: http://docs.oracle.com/javase/tutorial/java/annotations/declaring.html

Answer 6

The @ symbol denotes an annotation type definition.

That means it is not really an interface, but rather a new annotation type -- to be used as a function modifier, such as @override.

See this javadocs entry on the subject.