CMSC 132: Object-Oriented Programming II. Interface

Transcription

1 CMSC 132: Object-Oriented Programming II Interface 1

2 Java Interfaces An interface defines a protocol of behavior that can be implemented by any class anywhere in the class hierarchy. Interfaces are Java's way of providing much of the power of multiple inheritance without the potential confusion of multiple bases classes having conflicts between method names.. 2

3 Java Interfaces Is defined by the keyword interface (rather than class) Has only static constants and abstract methods All abstract, default, and static methods in an interface are implicitly public, so you can omit the public modifier. Notice that an interface is not a class. You cannot create an instance of an interface. 3

4 Defining an Interface public interface Set<E> { public void insert(e e); public void clear(); public boolean contains(e o); public boolean isempty(); public boolean remove(e o); public int size(); No matter how it is implemented, a Set must have insert, clear, contains, isempty, remove, and size methods 4

5 Implementing an Interface A class is said to implement an interface if it provides definitions for these methods public class BagSet<E> implements Set<E>{ Now, we may use a BagSet any place that an object of type Set is expected A class implementing an interface can implement additional methods A class can implement several interfaces 5

6 Interface Example public interface Speaker { public void speak(); class Philosopher extends Human implements Speaker { public void speak(){ public void pontificate() { class Dog extends Animal implements Speaker { public void speak(){ Speaker guest; guest = new Philosopher(); guest.speak(); guest = new Dog(); guest.speak(); 6

7 Interface Example public interface Rentable{ public int rent(); class House implements Rentable{ public int rent(){ class Car extends Vehicle implements Rentable{ public int rent(){ Rentable r1 = new Car(); Rentable r2 = new House(); 7

8 Comparable Interfaces The Comparable interface specifies a method called compareto that takes an object as a parameter and returns a negative integer, zero, or a positive integer as the current object is less than, equal to, or greater than the specified object public interface Comparable<T>{ public int compareto(t o); 8

9 Comparable Interfaces Have we seen classes implementing this interface? Yes! All primitive wrapper classes (String, Integer, Double) implement Comparable By using interfaces a function like Collections.sort() can sort an ArrayList of objects that implement the Comparable interface. For example, an ArrayList of Integers, of Strings, etc. ArrayList<Integer> a = new ArrayList<>(); a.add(10); a.add(5); a.add(20); Collections.sort(a); for(integer i: a){ System.out.print(i+, ); // Output: 5,10,20 9

10 Comparable Interfaces Can Collections.sort() sort an ArrayList of your own objects (e.g., ArrayList of Students?) Yes! Just make the Students class implement the Comparable interface public interface Comparable<T>{ public int compareto(t o); // Compare students by gpa public class Student implements Comparable<Student>{ public int comparateto(student s2){ return gpa == s2.gpa? 0: gpa> s2.gpa? 1: -1; Can t sort Students if Student is Comparable 10

11 Multiple Inheritance There are many situations where a simple class hierarchy is not adequate to describe a class structure Example: Suppose that we have our class hierarchy of university people and we also develop a class hierarchy of athletic people: Person AthleticPerson Student Faculty Athlete Coach AthleticDirector HeadCoach AssistantCoach StudentAthlete StudentAthlete: Suppose we want to create an object that inherits all the elements of a Student (admission year, GPA) as well as all the elements of an Athlete (sport, amateur-status) 11

12 Multiple Inheritance Can we define a StudentAthlete by inheriting all the elements from both Student and Athlete? public class StudentAthlete extends Student, extends Athlete { Alas, no. At least not in Java Nice try! But not allowed in Java Multiple Inheritance: Building a class by extending multiple base classes is called multiple inheritance It is a very powerful programming construct, but it has many subtleties and pitfalls. (E.g., If Athlete and Student both have a name instance variable and a tostring( ) method, which one do we inherit?) Java does not support multiple inheritance. (Although C++ does.) In Java a class can be extended from only one base class However, a class can implement any number of interfaces. 12

13 Multiple Inheritance with Interfaces Java lacks multiple inheritance, but there is an alternative What public methods do we require of an Athlete object? String getsport( ): Return the athlete s sport boolean isamateur( ): Does this athlete have amateur status? We can define an interface Athlete that contains these methods: public interface Athlete { public String getsport( ); public boolean isamateur( ); Now, we can define a StudentAthlete that extends Student and implements Athlete 13

14 Multiple Inheritance with Interfaces StudentAthlete extends Student and implements Athlete:public class StudentAthlete extends Student implements Athlete { private String mysport; private boolean amateur; // other things omitted public String getsport( ) { return mysport; public boolean isamateur( ) { return amateur; StudentAthlete can be used: Anywhere that a Student object is expected (because it is derived from Student) Anywhere that an Athlete object is expected (because it implements the public interface of Athlete) So, we have effectively achieved some of the goals of multiple inheritance, by using Java single inheritance mechanism 14

15 Common Uses of Interfaces Interfaces are flexible things and can be used for many purposes in Java: A work-around for Java s lack of multiple inheritance. (We have just seen this.) Specifying minimal functional requirements for classes (This is its principal purpose.) For defining groups of related symbolic constants. (This is a somewhat unexpected use, but is not uncommon.) 15

16 Using Interfaces for Symbolic Constants In addition to containing method declarations, interfaces can contain constants, that is, variables that are public final static. interface OlympicMedal { static final String GOLD = "Gold"; static final String SILVER = "Silver"; static final String BRONZE = "Bronze"; Considered bad practice. 16

17 Default Methods Java 8 introduces Default Method, a new feature Add new methods to the interfaces without breaking the existing implementation of these interface. public interface A { public void m1(); default public void m2 { println("default m2 ; public class B implements A { public void m1() { B b = new B(); b.m2(); // print default m2 17

18 Abstract classes versus interfaces After introducing Default Method, it seems that interfaces and abstract classes are same. However, they are still different concept in Java 8. Abstract class can define constructor. They can have a state associated with them. default method can be implemented only in the terms of invoking other interface methods, with no reference to a particular implementation's state. Both use for different purposes and choosing between two really depends on the scenario context. 18

19 Multiple Inheritance Ambiguity Problems Since java class can implement multiple interfaces and each interface can define default method with same method signature, therefore, the inherited methods can conflict with each other. public interface A { default int m1(){ return 1; public interface B { default int m1(){ Return 2; public class C implements A, B { A:m1 C:m1 B:m1 This code will fail to compile 19

20 Interface Hierarchies Inheritance applies to interfaces, just as it does to classes. When an interface is extended, it inherits all the previous methods 20

21 Quiz 1: True /False An interface can contain following type of members: public, static, final fields (i.e., constants) default and static methods with bodies A. True B. False 21

22 Quiz 1: True /False An interface can contain following type of members: public, static, final fields (i.e., constants) default and static methods with bodies A. True B. False 22

23 Quiz 2: True /False A class can implement multiple interfaces and many classes can implement the same interface. A. True B. False 23

24 Quiz 2: True /False A class can implement multiple interfaces and many classes can implement the same interface. A. True B. False 24

25 Quiz 3: What is the output? abstract class Demo{ public int a; public Demo(){ a = 10; abstract public void set(); abstract final public void get(); class Test extends Demo{ public void set(int a){this.a = a; final public void get(){ System.out.println("a = " + a); public static void main(string[] args){ Test obj = new Test(); obj.set(20); obj.get(); A. a = 10 B. a = 20 C. Compile error 25

26 Quiz 3: What is the output? abstract class Demo{ public int a; public Demo(){ a = 10; abstract public void set(); abstract final public void get(); class Test extends Demo{ public void set(int a){this.a = a; final public void get(){ System.out.println("a = " + a); public static void main(string[] args){ Test obj = new Test(); obj.set(20); obj.get(); Final method can t be overridden. Thus, an abstract function can t be final. A. a = 10 B. a = 20 C. Compile error 26

27 Quiz 4: Can an interface extend another interface? A. No. Only classes can be extended. B. No. Interfaces can not be part of a hierarchy. C. Yes. Since all interfaces automatically extend Object. D. Yes. 27

28 Quiz 4: Can an interface extend another interface? A. No. Only classes can be extended. B. No. Interfaces can not be part of a hierarchy. C. Yes. Since all interfaces automatically extend Object. D. Yes. 28

29 Quiz 5: Can an interface be given the private access modifier? A. No. Then the interface could never be used. B. No. Since only private classes could use the interface. C. Yes. This would make all of its methods and constants private. D. Yes. This would mean that only classes in the same file could use the interface. 29

30 Quiz 5: Can an interface be given the private access modifier? A. No. Then the interface could never be used. B. No. Since only private classes could use the interface. C. Yes. This would make all of its methods and constants private. D. Yes. This would mean that only classes in the same file could use the interface. 30