- 100% abstract data structure.
- It can contain only constant variables, abstract methods, classes and other interfaces.
- An interface cannot contain non-abstract functions and variables.
- We cannot create objects of an interface.
- On compilation, an interface generates a .class extension file.
TestInterface1.java
interface Shapes {
int i = 10; // implicit conversion to public static final int i = 10;
void drawCircle(); // public abstract void drawCircle();
}
class DrawShape1 implements Shapes { //directly implementing Shapes
public void drawCircle() { //Interface methods are implicitly public abstract
System.out.println(
"drawCircle() - implemented in DrawShape1.");
}
public void function1() {
System.out.println(
"function1()- implemented in DrawShape1.");
}
}
class SomeClass extends DrawShape1 {
//indirectly implementing Shapes via DrawShape1
}
class DrawShape2 implements Shapes { //directly implementing Shapes
public void drawCircle() {
System.out.println(
"drawCircle() - implemented in DrawShape2.");
}
public void function1() {
System.out.println(
"function1()- implemented in DrawShape2.");
}
}
class TestInterface1 {
public static void main(String args[]) {
/*DrawShape1 ds1 = new DrawShape1();
ds1.drawCircle();
ds1.function1();
DrawShape2 ds2 = new DrawShape2();
ds2.drawCircle();
ds2.function1(); */
Shapes s = new Shapes(); /*Shapes is abstract and cannot be instantiated*/
Shapes s = new DrawShape2();
s.drawCircle();
s.function1(); /*cannot find symbol function1() in interface Shapes since function1() is invisible to Shape (reference variable s)*/
}
}
TestInterface3.java
interface Circle {
void drawCircle();
}
interface Square {
void drawCircle(int radius);
void drawSquare();
}
class DrawShape implements Circle, Square {
public void drawCircle(int r) {
System.out.println("This is a circle with a radius of " + r);
}
public void drawCircle() {
System.out.println("This is a circle.");
}
public void drawSquare() {
System.out.println("This is a square.");
}
}
class TestInterface3 {
public static void main(String args[]) {
DrawShape ds1 = new DrawShape();
ds1.drawCircle();
ds1.drawCircle(10);
ds1.drawSquare();
}
}
TestInterface4.java
interface Circle {
void drawCircle();
}
interface Square {
void drawSquare();
}
class Triangle {
public void drawCircle() {
System.out.println(
"This is a circle - in Triangle.");
}
public void drawTriangle() {
System.out.println(
"This is a triangle - in Triangle.");
}
}
class DrawShape extends Triangle implements Circle, Square {
public void drawCircle() {
System.out.println(
"This is a circle - in DrawShape.");
}
public void drawSquare() {
System.out.println(
"This is a square - in DrawShape.");
}
}
class TestInterface4 {
public static void main(String args[]) {
DrawShape ds = new DrawShape();
ds.drawCircle();
ds.drawSquare();
ds.drawTriangle();
}
}
TestInterface5.java
interface Circle {
void drawCircle();
}
interface Square extends Circle {
void drawSquare();
}
interface CircleSquareTriangle extends
Circle, Square {
void drawTriangle();
}
class DrawShape implements CircleSquareTriangle {
public void drawCircle() {
System.out.println("This is a circle.");
}
public void drawSquare() {
System.out.println("This is a square.");
}
public void drawTriangle() {
System.out.println("This is a triangle.");
}
}
class TestInterface5 {
public static void main(String args[]) {
DrawShape ds1 = new DrawShape();
ds1.drawCircle();
ds1.drawTriangle();
ds1.drawSquare();
}
}
TestInterface6.java
interface Circle {
void drawCircle();
}
interface Square {
void drawSquare();
}
interface Triangle {
void drawTriangle();
}
interface CircleSquareTriangle extends Circle, Square, Triangle { // Extending multiple interfaces
}
class DrawShape implements CircleSquareTriangle {
public void drawCircle() {
System.out.println("This is a circle.");
}
public void drawSquare() {
System.out.println("This is a square.");
}
public void drawTriangle() {
System.out.println("This is a triangle.");
}
}
class TestInterface6 {
public static void main(String args[]) {
DrawShape ds1 = new DrawShape();
ds1.drawCircle();
ds1.drawTriangle();
ds1.drawSquare();
}
}
-
The modifier
final
with a method prevents it from being overridden. A final method cannot be overridden. -
The modifier final with a class prevents it from being inherited. A final class cannot be inherited.
-
Return type of functions is not considered in overloading.
-
If the return type is non-primitive then we can use sub-type while overloading the method.
public Rectangle doSomething() { } public Container doSomething() { //overriding }
-
While overriding a function the access modifier can only be broadened, widened, or strengthened.
-
While overriding a function if the data type of an identifier is changed in the overridden function, it becomes overloading.
-
Modifier abstract cannot be used in combination with final, private or static.
abstract + final
-> abstraction is resolved by overriding the functions, but final prevents the function from being overridden.abstract + private
-> abstraction is resolved by overriding the functions in the sub-class, but private members are not inherited.abstract + static
-> static methods can be referred to by qualifying using class-name. Abstract methods are not definitive and hence make no sense. -
implements
- has a relationship. -
extends
- is a relationship. -
An interface can extend one or more interfaces.
-
A class can extend only one class.
-
A class can implement one or more interfaces.
-
An interface cannot extend a class, since nothing can be non-abstract in an interface.
-
In Java, multiple inheritance can be attained only with the involvement of interface(s).
-
Where ever an interface is expected, we can pass the instance of a class that directly or indirectly implements the interface.