Presentation is loading. Please wait.

Presentation is loading. Please wait.

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)

Similar presentations


Presentation on theme: "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)"— Presentation transcript:

1 Interfaces

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

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.LinkedListjava.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 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 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 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 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() Circle draw() resize() Rectangle draw() resize() implements

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 GeneratorGenerator

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; public void area { System.out.println(“Area is “ + (side*side));} }


Download ppt "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)"

Similar presentations


Ads by Google