0% found this document useful (0 votes)
45 views24 pages

Lecture 09 - Interfaces

This document discusses interfaces in Java. It defines an interface as fully abstracting a class's interface from its implementation by specifying what a class must do but not how. Interfaces declare methods without bodies and cannot declare instance variables. A class implements an interface by providing method bodies for the interface's methods. Variables can be declared in interfaces as public, static, and final. Interfaces can extend other interfaces, requiring implementing classes to provide implementations for all inherited methods.

Uploaded by

Muhammad Tayyab
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
45 views24 pages

Lecture 09 - Interfaces

This document discusses interfaces in Java. It defines an interface as fully abstracting a class's interface from its implementation by specifying what a class must do but not how. Interfaces declare methods without bodies and cannot declare instance variables. A class implements an interface by providing method bodies for the interface's methods. Variables can be declared in interfaces as public, static, and final. Interfaces can extend other interfaces, requiring implementing classes to provide implementations for all inherited methods.

Uploaded by

Muhammad Tayyab
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 24

CSE205: Object Oriented

Programming
Lecture # 09: Interfaces

Muhammad Imran
(Based on Java, The Complete Reference)
http://www.secscourses.tk

1
Outline

• Interfaces

• Implementing Interfaces

• Accessing Implementations through Interface References

• Partial Implementations

• Variables in Interfaces

• Interfaces can be Extended

2
Interfaces
• Using the keyword interface, we can fully abstract a class’
interface from its implementation.
• That is, using interface, we 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.

3
Interfaces
• An interface is defined much like a class. This is the general
form of an interface:

access-specifier interface InterfaceName {


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;
}
4
Interfaces
• access-specifier for interface is either public or not used.
• Notice that the methods which are declared have no bodies.
 They are, essentially, abstract methods;
• Variables declared inside an interface
 Are implicitly final and static, meaning they cannot be changed by the
implementing class.
 Must also be initialized with a constant value.
• All methods and variables are implicitly public if the interface, itself,
is declared as public.

5
Interfaces
• Once it is defined, any number of classes can implement an
interface.
• Also, one class can implement any number of interfaces.
• To implement an interface, a class must create the complete set of
methods defined by the interface.
• Interfaces are designed to support dynamic method resolution at
run time.
• Interfaces have a different hierarchy from classes, thus, it is possible
for classes that are unrelated in terms of the class hierarchy to
implement the same interface.
• This is where the real power of interfaces is realized.

6
Interfaces
• Here is an example of an interface definition.

• It declares a simple interface which contains one method called


callback( ) that takes a single integer parameter.

interface Callback {

void callback(int param);

7
Implementing Interfaces
• Once an interface has been defined, one or more classes can
implement that interface.
• To implement an interface, include the implements clause in a class
definition, and then create the methods defined by the interface.
• The general form of a class that includes the implements clause
looks like this:

access-specifier class classname [extends superclass]


[implements interface [,interface...]] {
// class-body
}

8
Implementing Interfaces
• access-specifier is either public or not used.

• If a class implements more than one interface, the interface names


are separated with a comma.

• If a class implements two interfaces that declare the same method,


then the same method will be used by clients of either interface.

• The methods that implement an interface must be declared public.

9
Implementing Interfaces
• Here is a small example class that implements the Callback interface
shown earlier.

class Client implements Callback {


// Implement Callback's interface
public void callback(int p) {
System.out.println("callback called with " + p);
}
}

When we implement an interface method, it must be declared


as public.
10
Implementing Interfaces
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.");
}
}
11
Accessing Implementations through Interface
References
• We can declare variables as object references that use an interface

rather than a class type.

• Any instance of any class that implements the declared interface can

be referred to by such a variable.

• When we call a method through one of these references, the

correct version will be called based on the actual instance of the

interface being referred to.

12
Accessing Implementations through Interface
References
• The following example calls the callback( ) method via an interface
reference variable:

class TestIface {
public static void main(String args[]) {
Callback c = new Client();
c.callback(42);
}
}
callback called with 42
13
Accessing Implementations through Interface
References
// Another implementation of Callback.

class AnotherClient implements Callback {


// Implement Callback's interface
public void callback(int p) {
System.out.println("Another version of callback");
System.out.println("p squared is " + (p*p));
}
}

14
Accessing Implementations through Interface
References
class TestIface2 {
public static void main(String args[]) {
Callback c = new Client();
AnotherClient ob = new AnotherClient();
c.callback(42);
c = ob; // c now refers to AnotherClient object
c.callback(42);
}
}
callback called with 42
Another version of callback
p squared is 1764
15
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.

abstract class Incomplete implements Callback {


int a, b;
void show() {
System.out.println(a + " " + b);
}
// ...
}

16
Variables in Interfaces
• We can use interfaces to import shared constants into multiple
classes by simply declaring an interface that contains variables
which are initialized to the desired values.
• When we include that interface in a class (that is, when we
“implement” the interface), all of those variable names will be in
scope as constants.
• If an interface contains no methods, then any class that includes
such an interface doesn’t actually implement anything.

17
Variables in Interfaces
import java.util.Random;

interface SharedConstants {
int NO = 0;
int YES = 1;
int MAYBE = 2;
int LATER = 3;
int SOON = 4;
int NEVER = 5;
}

class Question implements SharedConstants {


Random rand = new Random();
int ask() {
int prob = (int) (100 * rand.nextDouble());
if (prob < 30)
return NO; // 30%
18
Variables in Interfaces
else if (prob < 60)
return YES; // 30%
else if (prob < 75)
return LATER; // 15%
else if (prob < 98)
return SOON; // 13%
else
return NEVER; // 2%
}
}

class AskMe implements SharedConstants {


static void answer(int result) {
switch(result) {
case NO:
System.out.println("No");
break;
19
Variables in Interfaces
case YES: public static void main(String
System.out.println("Yes");
break; args[]) {
case MAYBE: Question q = new Question();
System.out.println("Maybe");
answer(q.ask());
break;
case LATER: answer(q.ask());
System.out.println("Later");
answer(q.ask());
break;
case SOON: answer(q.ask());
System.out.println("Soon");
}
break;
case NEVER: }
System.out.println("Never");
break;
}
}

20
Interfaces can be Extended
• One interface can inherit another by use of the keyword extends.

• The syntax is the same as for inheriting classes.

• When a class implements an interface that inherits another


interface, it must provide implementations for all methods defined
within the interface inheritance chain.

21
Interfaces can be Extended
// One interface can extend another.
interface A {
void meth1();
void meth2();
}
interface B extends A {
void meth3();
}
class MyClass implements B {
public void meth1() {
System.out.println("Implement meth1().");
}
public void meth2() {
System.out.println("Implement meth2().");
}
22
Interfaces can be Extended
public void meth3() {
System.out.println("Implement meth3().");
}
}

class IFExtend {
public static void main(String arg[]) {
MyClass ob = new MyClass();
ob.meth1();
ob.meth2();
ob.meth3();
}
}

23
Recommended Readings
• Page # 196 to 207, Chapter # 9: Packages and Interfaces
from Herbert Schildt, Java: The Complete Reference,
J2SETM 9th Edition

24

You might also like