1. Interfaces

2. Interfaces
An interface in the Java programming language is an abstract type that is used to specify an interface (in the generic sense of the term) that classes must implement. Interfaces are declared using the interface keyword and may only contain method signatures and constant declarations (variable declarations which are declared to be both static and final).

3. Java Interfaces
a java interface is just a collection of abstract methods (i.e. we state the signatures, but not the bodies)
states that
this is an
interface,
not a class
note no
bodies for
the methods
public interface MyStack {
public int size();
public boolean isEmpty();
public Object top();
public void push(Object elt);
public Object pop(); }

4. Continued
As interfaces are implicitly abstract, they cannot be directly instantiated. Object references in Java may be specified to be of an interface type; in which case they must either be null, or be bound to an object which implements the interface.
The keyword implements is used to declare that a given class implements an interface. A class which implements an interface must either implement all methods in the interface, or be an abstract class

5. Advantages of Interfaces
Provide a standard set of methods for a group of classes.
This is Java’s implementation of an Abstract Data Type (ADT)
Objects of these classes can be accessed by the standard set of methods without considering about their location in class hierarchy.
Support selective multiple inheritance.
e.g. java.util.LinkedList

6. Benefit
One benefit of using interfaces is that they simulate multiple inheritance. All classes in Java (other than java.lang.Object, the root class of the Java type system) must have exactly one base class; multiple inheritance of classes is not allowed. However, a Java class/interface may implement/extend any number of interfaces.

7. Data Abstraction
if the interface remains the same, clients don't need to be changed, even if the implementation behind the interface changes
public class Time {
private int timeInSecs;
//public methods }
public class Time {
private int hours;
private int minutes
private int secs;
//same public methods
//but with different
//bodies }

8. Defining an interface Interfaces are defined with the following syntax
[visibility] interface InterfaceName [extends other interfaces]
{ constant declarations
member type declarations
abstract method declarations }

9. Abstract methods
The body of the interface contains abstract methods, but since all methods in an interface are, by definition, abstract, the abstract keyword is not required. Since the interface specifies a set of exposed behaviours, all methods are implicitly public.

10. Example public interface Predator { boolean chasePrey(Prey p);
void eatPrey(Prey p); }

11. Implements
Classes may implement an interface. For example

12. public class Cat implements Predator {
public boolean chasePrey(Prey p) { // programming to chase prey p (specifically for a cat) }
public void eatPrey (Prey p) { // programming to eat prey p (specifically for a cat) } }

13. Abstract
If a class implements an interface and does not implement all its methods, it must be marked as abstract.
If a class is abstract, one of its subclasses is expected to implement its unimplemented methods.

14. Multiple Interfaces Classes can implement multiple interfaces
public class Frog implements Predator, Prey { ... }

15. Example of when Interfaces apply
Games Console
Interface required for Button Press
This is supplied by Device Driver
Need to do Different things in response to button press from Game to Game

16. interfaces vs classes
a class definition can contain instance/class variables and instance/class methods, including both the signature and the body
a java interface contains only the signatures of public instance methods (and named constants)
a java interface acts like a specification
it says what it means to be e.g. a stack
to be a stack, an object must offer at least those methods in its public interface

17. using Java interfaces
Java allows us to tell the compiler that a class will implement an interface
regard it as a contract stating that you will meet the specification
any class that implements an interface must provide implementations of the public methods (or it must be abstract, and its subclasses provide them)
the compiler will check, and if the bodies are not provided, it won't compile

18. Summary
An interface is like an abstract class - it specifies what its methods should look like, but gives no body
if a class implements an interface, it is equivalent to signing a contract saying that it will provide a body for the specified method - Java will not compile the program unless we provide the method definition
we can refer to an object as though it were an object of the interface, and invoke the interface methods

19. Java Interfaces
Identify a common set of methods for a group of classes implementing the interface
Share constants (static and final) between classes.
See examples.

20. Interface Example - Shape
public interface Shape {
double PI = ; //static and final constant.
void draw();
void resize(); }
public class Circle implements Shape
public void draw() { /* draw a circle*/ }
public void resize() { /* resize a circle*/ }
public class Rectangle implements Shape
public void draw() { /* draw a rectangle*/ }
public void resize() { /* resize a rectangle*/ }
Shape
draw()
resize()
implements
Circle
draw()
resize()
Rectangle
draw()
resize()

21. Interface Example – Generator
Goal
Develop several implementations of an object, i.e. generator, that generate different sequence of integers, such as
constants - ConstantGenerator
random integers – RandomGenerator
primes – PrimeGenerator
Interface Generator

22. Simple Example Interface public interface IntExample1{
public void sayHello(); }
Class which implements it
public class JavaInterfaceExample implements IntExample1{
public void sayHello(){
System.out.println("Hello Visitor !"); }

23. Control Program public static void main(String args[]){
JavaInterfaceExample JavaIExample = new JavaInterfaceExample();
JavaIExample.sayHello(); }}

24. Simple Example Interface
public interface IntExample1{
public void sayHello(); }
Class which implements it 2
public class JavaInterfaceExample1 implements IntExample1{
public void sayHello(){
System.out.println("HI there Visitor !"); }

25. Control Program public static void main(String args[]){
JavaInterfaceExample1 JavaIExample = new JavaInterfaceExample1();
JavaIExample.sayHello(); }}

26. Exercise
Write a shape interface which has one method which calculates the area.
Write class definitions for a circle class and a square class which implement the shape interface

27. public interface Shape{
double PI = ; //static and final constant.
void area();}
public class Circle implements Shape
double radius;
public void area {
System.out.println(“Area is “ + (radius*radius*PI));} }
public class Rectangle implements Shape
double side;
System.out.println(“Area is “ + (side*side));}