1 / 15

Java Interfaces

Java Interfaces. the public interface of a class the interface reference type examples (Note: not graphical user interface). How should we design classes? (from a previous lecture). obtain a statement of the problem sketch a sample scenario work out what objects are involved

rbarry
Download Presentation

Java Interfaces

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Java Interfaces • the public interface of a class • the interface reference type • examples • (Note: not graphical user interface)

  2. How should we design classes?(from a previous lecture) • obtain a statement of the problem • sketch a sample scenario • work out what objects are involved (do the following one class at a time:) • work out how those objects are meant to behave • design the interface for the class • define the variables • implement the methods • test the class • the interface only shows the public methods and data • it does not show private data or methods • it does not state how the class is implemented

  3. Determining the interface • before writing a class definition, determine the interface • the set of services we offer to clients • similarly, if defining data structures, we should first determine the interface • stacks support a constructor, push, pop, size, isEmpty, and top • queues offer a constructor, enqueue, dequeue, size, isEmpty and front • data structures people refer to the interface as the abstract data type

  4. 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 }

  5. states that this is an interface, not a class note no bodies for the methods Java Interfaces • Java allows us to take this one stage further, by formally recording the interface as a Java interface • 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(); }

  6. 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

  7. 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

  8. promises that we will provide bodies for all the MyStack methods Example • import java.util.ArrayList; • public class ALStack<E> implements MyStack { • private ArrayList<E> al; • public ALStack() { • al = new ArrayList<E>(); • } • public int size() { return al.size(); } • //and versions of isEmpty, push, pop and top, as • //in the previous lecture • }

  9. Example (cont) • public class ArrayStack implements MyStack { • private int capacity; • private Object[] s; • private int top = -1; • public ArrayStack(int reqdCapacity) { • capacity = reqdCapacity; • s = new Object[capacity]; • } • public int size() { return top+1; } • //and versions of isEmpty, push, pop and top ... • }

  10. More Polymorphism • Polymorphism: • a variable of a superclass type may refer to objects of that class or of its subclasses • a variable of Java interface type may refer to objects of any class that implements the interface MyStack s; s = new ArrayStack(20); s = new ALStack<Book>(); • Dynamic method binding: decide at run-time which method to run, based on the referenced object s.push(new Book());

  11. What's the point? • using Java interfaces polymorphically gives you client code that is much easier to modify • how much effort would be involved to change from an ArrayStack to an ALStack if we hadn't used an interface? • In program design and development, you will probably frequently change the data structures a program uses, so interfaces gives a significant improvement in maintainability

  12. Example: client not using interface • public void method1() { • ArrayStack s = new ArrayStack(10); • s.push(new Cow()); • method2(s); • method3(s); • } • public void method2(ArrayStack st) { • System.out.println(st.top()); • } • public void method3(ArrayStack st) { • st.push(new Pig()); • }

  13. only 1 thing to change Example: client using interface • public void method1() { • MyStack s = new ArrayStack(10); • s.push(new Cow()); • method2(s); • method3(s); • } • public void method2(MyStack st) { • System.out.println(st.top()); • } • public void method3(MyStack st) { • st.push(new Pig()); • }

  14. 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

  15. Next lecture ... • … Java Collections Framework

More Related