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.

score 347 · Accepted Answer · answered May 27 '09 at 23:10

347

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.

answered May 27 '09 at 23:10

mrkishi

4,229
1
17
14

10

Great thanks, good to know. So what was the rationale for calling it @interface, rather then say @annotation I wonder.. seems like an unnecessarily overloaded term. – Bittercoder May 27 '09 at 23:46
6

The tutorial and the JLS allude to an annotation being a special kind of interface. There doesn't appear to be much discussion out there on the subject, but http://javarunner.blogspot.com/2005/01/annotations-in-java-15.html explains that annotations are an implicit extension of the Annotation interface and @ and interface are used to together differentiate from a regular interface. You may also want to read the JSR specification for annotations. – DavidValeri May 28 '09 at 11:41
2

@Bittercoder the docs do mention: "keyword interface is preceded by the at sign (@) (@ = AT, as in annotation type)". Thats all the rationale I can find w.r.t. naming. – Shaishav Sep 06 '17 at 03:41
Actually, Bittercoder's question is quite inevitable, and DavidValeri's link very nicely explains it. So, you can write like this: `@ interface`, not only `@interface`. – starriet Dec 11 '20 at 03:27

score 121 · Answer 2 · edited Jan 19 '17 at 18:26

121

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

edited Jan 19 '17 at 18:26

jsheeran

2,337
2
14
26

answered Feb 19 '14 at 07:47

mavis

2,630
3
19
31

3

That was actually useful. I didn't know Java could do this. – Jay Sidri Aug 29 '16 at 05:53
The previous answer included this link which is where this information came from. I found it useful to find more information about this topic. https://docs.oracle.com/javase/tutorial/java/annotations/declaring.html – PatS Nov 11 '18 at 01:50
1

One of the best and full answers (yet clear) I've been witnessing on stackoverflow. – Mr. D Feb 14 '20 at 15:03
I'm not sure why everyone loves this answer while it gives a very limited use case of the annotations. Annotation in java is used for so many more things than just a replacement for comments. The power of annotations lies in the fact that they can change the way how annotated elements behave or get processed in the runtime – Leonid Usov Aug 20 '20 at 15:33
This helped me a lot , good explanation, thank you! – Dax Feb 19 '21 at 10:29

score 34 · Answer 3 · edited May 19 '17 at 08:29

34

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.

edited May 19 '17 at 08:29

Dr.jacky

2,499
6
41
76

answered May 27 '09 at 23:16

DavidValeri

2,330
15
11

Emmanuel Osimosu · Answer 4 · 2017-09-05T08:24:23.513

20

interface: defines the contract for a class which implements it

@interface: defines the contract for an annotation

edited Sep 05 '17 at 08:24

answered Sep 05 '17 at 07:49

Emmanuel Osimosu

3,966
1
30
35

score 9 · Answer 5 · answered Feb 15 '19 at 11:27

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

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

5 Answers5

Linked