Download - Java interface
An interface is like a class. It has static constants and abstract methods.
Interfaces are declared using the interface keyword,
method signature
constant declarations (variable declarations that are declared to be
both static and final).
An interface never contains method implementations (ie function
"bodies").
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 – either public or not used.
Not used – default is an answer.
i/f is only available to other member of the package which it’s
declared.
Methods declared have no bodies and end with a semicolon after the
parameter list(abstract methods). Each class that includes an interface
must implement all of the methods.
Variables – declared implicitly final and static, meaning they cannot be
changed by the implementing class. They must also be initialized with
a constant value.
All methods and variables are implicitly public if the interface, itself, is
declared as public.
To implement an interface
– include the implements clause in a class definition
access class classname [extends superclass] [implements interface
[,interface...]]
{
constant declarations ;
abstract method declarations;
}
The methods that implement an interface must be declared public.
However, an interface is different from a class in several ways, including:
You cannot instantiate an interface.
An interface does not contain any constructors.
All of the methods in an interface are abstract.
An interface cannot contain instance fields. The only fields that can
appear in an interface must be declared both static and final.
An interface is not extended by a class; it is implemented by a class.
An interface can extend multiple interfaces.
interface shape{public String baseclass="shape";public void Draw();}class circle implements shape{public void Draw() {System.out.println("Drawing Circle here");}}public class inter {public static void main(String[] args) {circle s=new circle();// shape s=new circle();
s.Draw();} }
interface Printable{void print();}interface Showable{void show();}class A implements Printable,Showable{public void print(){System.out.println("Hello");}public void show(){System.out.println("Welcome");}public static void main(String args[]){A obj = new A();obj.print();obj.show(); }}
An interface can be declared as member of a class or another
interface – called nested interface.
How can we define i/f inside a class and how can we access it.
class A
{
interface Message()
{
void msg();
}
}
Class test implements A.Message{Public void msg(){S.o.p(“Hello”);}Public static void main(String args[]){A.Message message=new test();message.msg();}}
Interfaces Can Be Extended:
One interface can inherit another interface - extend.
The syntax is the same as for inheriting classes.
// One interface an extend another.
interface A
{
void meth1();
void meth2();
}
// B now includes meth1() and meth2() -- it adds meth3().
interface B extends A
{
void meth3();
}