COMP 121

1. COMP 121 Week 2: Interfaces and Polymorphism

2. Objectives • To learn about interfaces • To be able to convert between class and interface references • To understand the concept of polymorphism

3. What is an Interface? • In general, an interface is something that facilitates interaction between two things • Examples: • The buttons on a TV remote • The controls in a car • The keypad, microphone, and speaker in a phone • The USB interface on a computer

4. Java Interface Type • Declares a set of methods and their signatures • Methods are used to communicate with an object • Methods form the object's interface with the outside world • Interface is similar to a class but contains only methods and constants • Cannot contain instance variables • Specifies the methods that must be supported by any class that implements the interface • Cannot be instantiated • Methods are implicitly defined as public and abstract • The body of the method is not filled in • The body or implementation of the method is in the classes that implement the interface Horstmann, C. (2008). Big Java (3rd ed.). New York: John Wiley & Sons.

5. Interface is like a Contract • Allows a class to be more formal about the behavior it promises to provide • Forms a contract between the class and the outside world • Contract is enforced by the compiler

6. Classes that Implement an Interface • Use the implements keyword to indicate they implement the interface type • Must include all methods defined by the interface • Interface methods being implemented must be declared as public methods Horstmann, C. (2008). Big Java (3rd ed.). New York: John Wiley & Sons.

7. Why Use an Interface? • Makes code more general and reusable • Reduces coupling between classes • Insures all classes that implement the interface will have a certain behaviors because interface methods must be implemented Horstmann, C. (2008). Big Java (3rd ed.). New York: John Wiley & Sons.

8. Defining an Interface public interface InterfaceName { // Method signatures }

9. Implementing an Interface public class ClassName implements InterfaceName, InterfaceName,… { // Implementation goes here }

10. Example: Predator Interface public interface Predator { public boolean pursuesPrey(Prey p); public void devoursPrey(Prey p); }

11. Example: Prey Interface public interface Prey { public boolean fleesPredator(Predator p); }

12. Example: Lion Class public class Lion implements Predator { public boolean pursuesPrey(Prey p) { // Implementation of method goes here } public void devoursPrey(Prey p) { // Implementation of method goes here } public void roars( ) { // Implementation of method goes here } }

13. Example: Frog Class public class Frog implements Predator, Prey { public boolean pursuesPrey(Prey p) { // Implementation of method goes here } public void devoursPrey(Prey p) { // Implementation of method goes here } public boolean fleesPredator(Predator p) { // Implementation of method goes here } }

14. Example: LargeCorp Class public class LargeCorp implements Predator { public boolean pursuesPrey(Prey p) { // Implementation of method goes here } public void devoursPrey(Prey p) { // Implementation of method goes here } public double maximizeProfits( ) { // Implementation of method goes here } }

15. UML “is-a” Relationship

16. Converting Between Class and Interface Types • You can convert from a class type to an interface type, provided the class implements the interface • Interface type  Class type • Variables whose type is an interface must be cast when assigned to a variable whose type is a class that implements the interface • Class type  Interface type • Variables whose type is a class that implements the interface do not have to be cast when assigned to a variable whose type is the interface Horstmann, C. (2008). Big Java (3rd ed.). New York: John Wiley & Sons.

17. To Cast or Not to Cast? Lion simba = new Lion( ); Frog kermit = new Frog( ); Lion cat; Predator attacker = simba; // no need to cast cat = (Lion)attacker; // need to cast attacker = kermit; // no need to cast cat = (Lion)attacker; // what will happen?

18. Example: Using Interfaces public class ZooKeeper { public boolean areHostile(Predator pred, Prey prey) { if ((pred.pursuesPrey(prey)) || (prey.fleesPredator(pred))) { return true; // are hostile } else { return false; // are not hostile } } }

19. Polymorphism • The principle that behavior can vary depending on the actual type of an object • Method selection takes place at runtime (late binding) Predator x = new Lion( ); x.devoursPrey(y); x = new Frog( ); x.devoursPrey(z); Horstmann, C. (2008). Big Java (3rd ed.). New York: John Wiley & Sons.

20. Summary • Use interface types to make code more reusable • A Java interface type declares a set of methods and their signatures • An interface type has no implementation • The implements keyword indicates that a class implements an interface • Interfaces reduce coupling between classes • You can convert from a class type to an interface type as long as the class implements the interface • A cast is needed to convert from an interface type to a class type • Polymorphism is the principle that behavior can vary depending on the actual type of an object Horstmann, C. (2008). Big Java (3rd ed.). New York: John Wiley & Sons.

21. Any Questions?