Java interface

• using interface, you can specify what a class
must do, but not how it does it.
• Interfaces are syntactically similar to classes,
but they lack instance variables, and their
methods are declared without any body.
• Through the use of the interface keyword,
Java allows you to fully abstract the interface
from its implementation.

Interface
• Using interface, you can specify a set of
method which can be implemented by one or
more classes.
• The interface, itself, does not actually define
any implementation.
• A class can implement more than one
interface.
• A class can only inherit a single superclass.

Defining an Interface
• The general form :
access interface name {
return-type method-name1(parameter-list);
return-type method-name2(parameter-list);
type final-varname1 = value;
type final-varname2 = value;
// ...
return-type method-nameN(parameter-list);
type final-varnameN = value;
}

• access is either public or not used.
• When no access specifier is included, then
default access results, and the interface is only
available to other members of the package in
which it is declared.
• When it is declared as public, the interface
can be used by any other code.
• All methods and variables are implicitly public
if the interface, itself, is declared as public.

• Variables can be declared inside of interface
declarations.
• They are implicitly final and static, meaning
they cannot be changed by the implementing
class.

Sample
interface Callback {
void callback(int param);
}

Implementing Interfaces
• To implement an interface, include the
implements clause in a class definition, and
then create the methods defined by the
interface.
• The general form:
access class classname [extends superclass]
[implements interface [,interface...]] {
// class-body
}

Sample
class Client implements Callback {
// Implement Callback's interface
public void callback(int p) {
System.out.println("callback called with " + p);
}
void nonIfaceMeth() {
System.out.println("Classes that implement interfaces "
+
"may also define other members, too.");
} }

Partial Implementations
• If a class includes an interface but does not
fully implement the methods defined by that
interface, then that class must be declared as
abstract.

Interface sample
// Define an integer stack interface.
interface IntStack {
void push(int item); // store an item
int pop(); // retrieve an item
}
class FixedStack implements IntStack {
private int stck[];
private int tos;
FixedStack(int size) {
stck = new int[size];
tos = -1;
}

public void push(int item) {
if(tos==stck.length-1) // use length member
System.out.println("Stack is full.");
else
stck[++tos] = item;
}
// Pop an item from the stack
public int pop() {
if(tos < 0) {
System.out.println("Stack underflow.");
return 0;
}
else
return stck[tos--];
} }

class IFTest {
public static void main(String args[]) {
FixedStack mystack1 = new FixedStack(5);
FixedStack mystack2 = new FixedStack(8);
// push some numbers onto the stack
for(int i=0; i<5; i++) mystack1.push(i);
for(int i=0; i<8; i++) mystack2.push(i);
// pop those numbers off the stack
System.out.println("Stack in mystack1:");
for(int i=0; i<5; i++)
System.out.println(mystack1.pop());
System.out.println("Stack in mystack2:");
for(int i=0; i<8; i++)
System.out.println(mystack2.pop());
}

Variables in Interfaces
• To import shared constants into multiple
classes by simply declaring an interface that
contains variables which are initialized to the
desired values.

Sample
import java.util.Random;
interface SharedConstants {
int NO = 0;
int YES = 1;
int MAYBE = 2;
}

class Question implements SharedConstants {
Random rand = new Random();
int ask() {
int prob = (int) (100 * rand.nextDouble());
if (prob < 50)
return NO;
else if (prob < 80)
return YES;
else
return NEVER;
}
}

class AskMe implements SharedConstants {
static void answer(int result) {
switch(result) {
case NO:
System.out.println("No");
break;
case YES:
System.out.println("Yes"); break;
case MAYBE:
System.out.println("Maybe");
break;
} }
public static void main(String args[]) {
Question q = new Question();
answer(q.ask());
answer(q.ask());
answer(q.ask());
answer(q.ask());
} }

Interfaces Can Be Extended
• One interface can inherit another by use of the
keyword extends.
interface A {
void meth1();
void meth2();
}
// B now includes meth1() and meth2() -- it adds
meth3().
interface B extends A {
void meth3(); }

Java interface

More Related Content

What's hot (20)

Similar to Java interface (20)

More from GaneshKumarKanthiah (11)

Recently uploaded (20)

Java interface