1. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Chapter 13 Inheritance and Polymorphism

2. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Chapter 13 Objectives After you have read and studied this chapter, you should be able to Write programs that are easily extensible and modifiable by applying polymorphism in program design. Polymorphism comes from the Greek word meaning “many forms.” Define reusable classes based on inheritance and abstract classes and abstract methods. Define methods, using the protected modifier. Parse strings, using a String Tokenizer object.

3. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.1 A superclass Student and its subclasses GraduateStudent and UndergraduateStudent.

4. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Inheritance and Polymorphism Two importance and powerful features in object-oriented programming are: Inheritance and Polymorphism 1.Inheritance is the mechanism to design two or more entities that are different but share many common features Java interface and inheritance both model an IS-A relationship (strong relationship): 2. Polymorphism comes from the Greek word meaning “many forms.” The principle is that the actual type of the object determines the method called. In Java, all instance methods are polymorphic.

5. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance To explain the concept of inheritance, we will consider an example of a class roster. The class roster should contain both undergraduate and graduate students.

6. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance Each student’s record will contain his or her name, three test scores, and the final course grade. The formula for determining the course grade is different for graduate students than for undergraduate students.

7. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance The formula for determining the course grade is different for graduate students than for undergraduate students. Type of Students Grading Scheme Undergraduate Pass if (Test1 + Test2 + test3)/3 >= 70 Graduate Pass if (Test1 + Test2 + test3)/3 >= 80

8. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance There are two broad ways to design the classes to model undergraduate and graduate students. We can define two unrelated classes, one for undergraduates and one for graduates. We can model the two kinds of students by using classes that are related in an inheritance hierarchy. Two classes are unrelated if they are not connected in an inheritance relationship.

9. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance If two objects are expected to share common behaviors and data, it is better to design their classes using inheritance. Using unrelated classes in such an instance will result in duplicating code common to both classes.

10. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance You can create a subclass from a superclass by adding new fields and methods. You can override the methods in the superclass. The keyword this is used to reference the subclass. The keyword super is used to reference the superclass.

11. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance For this example, we will design three classes: Student (superClass) UndergraduateStudent (subclass) GraduateStudent (subclass) The Student class will incorporate behavior and data common to both UndergraduateStudent and GraduateStudent objects.

12. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance The UndergraduateStudent class and the GraduateStudent class will each contain behaviors (methods) and data specific to their respective objects.

13. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance /* File: Student.java superclass */ class Student { protected final static int NUM_OF_TESTS = 3; protected String name; protected int[] test; protected String courseGrade; public Student( ) { //default constructor this("No Name"); } //non-default constructor public Student(String studentName) { name = studentName; test = new int[NUM_OF_TESTS]; courseGrade = "****"; }

14. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance public String getCourseGrade( ) { return courseGrade; } public String getName( ) { return name; } public int getTestScore(int testNumber) { return test[testNumber-1]; } public void setName(String newName) { name = newName; } public void setTestScore(int testNumber, int testScore) { test[testNumber-1] = testScore; }

15. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance The visibility modifier protected makes a data member or method visible and accessible to only the instances of the class and the descendant(subclass) classes. Public data members and methods are accessible to everyone. Private data members and methods are accessible only to instances of the class.

16. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance The UndergraduateStudent and GraduateStudent classes are descendants of the Student class. A subclass extends its superclass.A subclass is a specialization of its superclass. Following are the class definitions for the UndergraduateStudent and GraduateStudent classes. A subclass cannot have multiple inheritance (more than one parent)- can only extend one superclass. Can implement many interfaces to achieve multiple inheritance

17. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance to achieve multiple inheritance Syntax to declare multiple inheritance using interfaces: Public class Newclass extends Baseclass implements Interface1, Interface2…N { } Syntax to declare an interface: modifier interface InterfaceName { // constants declarations // method signatures }

18. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance /* File: UndergraduateStudent.java subclass */ class UndergraduateStudent extends Student { public void computeCourseGrade() { int total = 0; for (int i = 0; i < NUM_OF_TESTS; i++) { total += test[i]; } if (total / NUM_OF_TESTS >= 70) { courseGrade = "Pass"; } else { courseGrade = "No Pass"; }

19. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.1 Defining Classes with Inheritance /* File: GraduateStudent.java subclass */ class GraduateStudent extends Student { public void computeCourseGrade() { int total = 0; for (int i = 0; i < NUM_OF_TESTS; i++) { total += test[i]; } if (total / NUM_OF_TESTS >= 80) { courseGrade = "Pass"; } else { courseGrade = "No Pass"; }

20. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism Polymorphism allows a single variable to refer to objects from different classes. Since GraduateStudents and Undergraduate Student are enrolled in a class. Should we declare two arrays? No. Arrays must contain elements of the same data type when we store integers and real numbers. Not so, when the elements of an array are objects the objects may be different. Student[] roster = new Student [40];

21. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.2 The roster array with elements referring to instances of GraduateStudent or UndergraduateStudent classes.

22. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism Polymorphism allows a single variable to refer to objects from different classes. Also, polymorphism denotes the principle that behavior (methods) can vary (be called) depending on the actual type of an object. The actual type of the object determines the method to be called.

23. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Polymorphism We can maintain our class roster using an array, combining objects from the Student, UndergraduateStudent, and GraduateStudent classes. Student roster [40]; roster[0] = new GraduateStudent(); roster[1] = new UndergraduateStudent(); roster[2] = new UndergraduateStudent(); and so on.

24. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism For example, if we declare Student student;//The Superclass We can say student = new Student(); but also student = new GraduateStudent(); or student = new UndergraduateStudent(); Note: An object of a subclass can refer to any object of its superclass.

25. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism A subclass is a specialization of its superclass, every instance of a subclass is an instance of its superclass, but not vice versa. For example: Every GraduateStudent is a Student, but every Student is not a GraduateStudent. Also, every UndergraduateStudent is a Student but every Student is not an underGradStudent. The following assignment statements are invalid: GraduateStudent grad1; UndergraduateStudent grad2; grad1 = new Student(); //superclass grad2 = new Student(); //superclass

26. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism We cannot make a variable of a subclass refer to an object from its sibling classes. Sibling classes are those that share the common ancestor class (superclass). The following assignment statements are invalid GraduateStudent grad1; UndergraduateStudent grad2; grad1 = new UndergraduateStudent(); //sibling class grad2 = new GraduateStudent(); //sibling class

27. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism To compute the course grade using the roster array, we execute for (int i=0; i<numberOfStudents; i++){ roster[i].computeCourseGrade(); }

28. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism If roster[i] refers to a GraduateStudent, then the computeCourseGrade method of the GraduateStudent class is executed. If roster[i] refers to an UndergraduateStudent, then the computeCourseGrade method of the UndergraduateStudent class is executed.

29. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism The computeCourseGrade method is called polymorphic because the message refers to methods from different classes depending on the object referenced by roster[i]. Benefits: Polymorphism allows us to maintain the class roster with one array instead of maintaining a separate array for each type of student. This simplifies the processing tremendously. Polymorphism, as you can see, permits the smooth and easy extension and modification of a program. We can add a third type of student to the array without rewriting existing code.

30. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism The instanceof operator can help us learn the class of an object. Student x = new UndergraduateStudent(); if(x instanceof UndergraduateStudent ){ System.out.println(“Mr. X is an undergraduate student”); }else{ System.out.println(“Mr. X is a graduate student”); }

31. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.2 Using Classes Effectively with Polymorphism The following code counts the number of undergraduate students in the roster array. int undergradCount= 0; for(int i = 0; i < numberOfStudents; i++) { if roster[i] instanceof UndergraduateStudent) { undergradCount++; } // end if statement }// end for statement

32. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility In addition to declaring members private and public, we can declare them protected. The protected modifier is meaningful only if used with inheritance.

33. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility class Super{ public int public_Super_Field; protected int protected_Super_Field; private int private_Super_Field; //default constructor public Super(){ public_Super_Field = 10; protected_Super_Field = 20; private_Super_Field = 30; }... } Note: super is a reserved word so don’t use it.

34. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility class Sub extends Super { public int public_Sub_Field; protected int protected_Sub_Field; private int private_Sub_Field; //default constructor public Sub(){ public_Sub_Field = 100; protected_Sub_Field = 200; private_Sub_Field = 300; }... }

35. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. The protected Modifier, cont. Note C4 is in a different package and it is not a subclass C1.

36. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Summary of Access Level for Members of a Class with respect to class inheritance Modifier |class |package|subclass|World ____________________________________________ |private |X |- | - |- |no modifier |X |X | - |- |protected |X |X |X |- |public |X |X |X |X No modifier is also known as package- private or package visibility.

37. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.3 A graphical representation of superclasses and subclasses with public, private, and protected members.

38. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility A public member is accessible to any method. A private member is accessible only to the methods that belong to the same class.

39. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility class Client { //Client is unrelated to // the classes Super and Sub public void test(){ Super mySuper = new Super(); Sub mySub = new Sub(); int i = mySuper.public_Super_Field; // inherited by mySub int j = mySub.public_Super_Field; int k = mySub.public_Sub_Field; } The above three statements are valid. Public members of a class, whether they are inherited or not, are accessible from any object or class

40. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility class Client { // an unrelated class public void test(){ Super mySuper = new Super(); Sub mySub = new Sub(); int l = mySuper.private_Super_Field; int m = mySub.private_Sub_Field; int n = mySub.private_Super_Field; } The above three statements are invalid. Private members of a class are never accessible from any outside object or class.

41. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility A protected member is accessible only to the methods that belong to the same class or to the descendant classes. It is inaccessible to the methods of an unrelated class.

42. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.3 Inheritance and Member Accessibility class Client { public void test(){ Super mySuper = new Super(); Sub mySub = new Sub(); int o = mySuper.protected_Super_Field; int p = mySub.protected_Sub_Field; int q = mySub.protected_Super_Field; } The statements above are invalid. This class is unrelated to the classes Super and Sub therefore Client cannot accessed their protected members.

43. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.4 The difference between public, private, and protected modifiers. Only public members are visible from outside.

44. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.5 Everything(public and protected) except the private members of the Super class is visible from a method of the Sub class.

45. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.6 Data members accessible from an instance (object) are also accessible from other instances (objects) of the same class.

46. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.4 Inheritance and Constructors Unlike members of a superclass, constructors of a superclass are not inherited by its subclasses. You must define a constructor for a class or use the default constructor added by the compiler.

47. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.4 Inheritance and Constructors A class definition such as Class Person { public void sayHello() { System.out.println(“Well, hello.”); } is equivalent to Class Person { public Person(){ super();//This statement calls the super //class constructor } public void sayHello() { System.out.println(“Well, hello.”); } Note: The compilier will provide a default constructor if you do not provide any constructor.

48. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.4 Inheritance and Constructors The statement super(); calls the superclass’s constructor. Every class has a super class. If the class declaration does not explicitly designate the superclass with the extends clause, then the class’s superclass is the Object class.

49. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.4 Inheritance and Constructors If you declare a constructor, then no default constructor is added to the class. If you define a class as class MyClass { public MyClass(int x){... } then a statement MyClass test = new MyClass(); is invalid because MyClass has no matching default constructor.

50. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.4 Inheritance and Constructors If the constructor you define does not contain an explicit call to a superclass constructor, then the compiler adds the statement super(); as the first statement of the constructor.

51. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Calling Superclass Constructors C3 C2 C1 See classes C1, c2, and c3 on the M: Drive in the Sample folder.

52. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.4 Inheritance and Constructors If a class has a superclass that is not the Object class, then a constructor of the class should make an explicit call to a constructor of the superclass. Always provide a constructor for every class you define. Don’t rely on default constructors. See class C1 on the M: Drive in the Sample folder.

53. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods Abstract classes are like regular classes with data and methods, but you cannot create instances (objects) of abstract classes using the new operator. An abstract method cannot be placed in a nonabstract class. If a subclass of an abstract superclass does not implement all the abstract methods, the subclass must be declared abstract..

54. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods A classes that contains abstract methods must be abstract. However, it is possible to declare an abstract class that contains no abstract methods. A subclass can be abstract even if its superclass is concrete..

55. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods When we define a superclass, we often do not need to create any instances of the superclass. Depending on whether we need to create instances (objects) of the superclass, we must define the class differently. We will study examples based on the Student superclass defined earlier.

56. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods Example Case 1: Student Must Be Undergraduate or Graduate If a student must be either an undergraduate or a graduate student, we only need instances (objects) of UndergraduateStudent or GraduateStudent. Therefore, we must define the Student class so that no instances (objects) may be created of it.

57. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods An abstract class is a class defined with the modifier abstract. No instances can be created from an abstract class.

58. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods abstract class Student { protected final static int NUM_OF_TESTS = 3; protected String name; protected int[] test; protected String courseGrade; public Student() { this(“No name”); } public Student(String studentName){ name = studentName; test = new int[NUM_OF_TESTS]; courseGrade = “******”; } abstract public void computeCourseGrade(); Note: If a subclass of this abstract superclass does not implement this abstract methods, the subclass must be declared abstract.

59. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods public String getCourseGrade(){ return courseGrade; } public String getName(){ return name; } public int getTestScore(int testNumber) { return test[testNumber-1]; } public void setName(String newName){ name = newName; } public void setTestScore(int testNumber, int testScore){ test[testNumber-1] = testScore; }

60. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods An abstract method is a method with the keyword abstract, and it ends with a semicolon instead of a method body. A class is abstract if the class contains an abstract method or does not provide an implementation of an inherited abstract method.

61. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods We say a method is implemented (concrete) if it has a method body. If a subclass has no abstract methods and no unimplemented inherited abstract methods, then the subclass is no longer abstract, and instances (objects) may be created of it. An abstract class must contain the keyword abstract in its definition.

62. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods In a program diagram, we represent an abstract class by using the keyword abstract.

63. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods Example Case 2: Student Does Not Have to Be Undergraduate or Graduate. In this case, we may design the Student class in one of two ways. 1.We can make the Student class instantiable (able to create an object). OR 2.We can leave the Student class abstract and add a third subclass, OtherStudent, to handle a student who does not fall into the UndergraduateStudent or GraduateStudent categories.

64. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods With the second approach, we delete the keyword abstract from the class and method definition. We provide a method body for computeCourseGrade. class Student {... public void computeCourseGrade(){ int total = 0; for (int i=0; i<NUM_OF_TESTS; i++){ total += test[i]; }

65. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods if (total/NUM_OF_TESTS >=50){ courseGrade = “Pass”; }else{ courseGrade = “No Pass”; }... } This design allows us to create an instance of Student to represent a nonregular student.

66. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods In the second approach, we leave the Student class abstract. We define a third subclass, OtherStudent (better approach): class OtherStudent extends Student { public void computeCourseGrade(){ int total = 0; for (int i=0; i<NUM_OF_TESTS; i++){ total += test[i]; } if (total/NUM_OF_TESTS >=50){ courseGrade = “Pass”; }else{ courseGrade = “No Pass”; }

67. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Fig. 13.7 A program diagram of the abstract superclass Student and its three subclasses.

68. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.5 Abstract Superclasses and Abstract Methods The best approach depends on the particular situation. When considering design options, we can ask ourselves which approach allows easier modification and extension. Not all methods can be declared abstract. Private methods and static methods can not be declared abstract.

69. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.6 Inheritance versus Interface Java interface and inheritance both model an IS-A relationship: class ButtonHandler implements ActionListener Class SavingsAccount extends Account We say “ButtonHandler is an ActionListener” and “SavingsAccount is an Account.”

70. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.6 Inheritance versus Interface However, their uses are very different. The Java interface is used to share common behavior (only method headers) among the instances of different classes. Inheritance is used to share common code (including both data members and methods) among the instances of related classes.

71. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.6 Inheritance versus Interface In your program designs, remember to use the Java interface to share common behavior. Use inheritance to share common code. If an entity A is a specialized form of another entity B, then model them by using inheritance. Declare A as a subclass of B.

72. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.6 Interface An interface is a classlike construct. It contains only constants and abstract methods. An interface is treated like a a special class in Java. Each interface is compiled into a separate bytecode file same as a regular class. You cannot create an instance (object) from an interface using the new operator. The java.lang.Comparable interface defines the compareTo method. Many classes in the Java library implement Comparable.

73. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.6 Define an Interface The data must be constants. Each method in an interface has only a signature without implementation. Syntax: public interface NewInterface { /** Constants declarations */ public static final int CONSTANT_J = 2; /** Method signatures*/ public abstract void AbstractMethod(); }

74. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. 13.6 Define an Interface Java allows only single inheritance for class extensions. Java allows multiple extensions for interfaces. public class SubClassName extends SuperClass implements Interface1, … InterfaceN { }

75. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Interface Comparable //Interface for comparing objects, defined in java.lang // The compareTo method determines the order of this // object with the specified/ object o, and returns a // negative integer, zero, or a positive integer if this // object is less than, equal to, or greater than the specified // object o package java.lang; public interface Comparable { public int compareTo(Object o); }

76. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Interface Comparable // Max.java: Find the maximum object of the //two objects. Note to use this method, you // must first implement the Comparable interface for // the class of these two objects. public class Max { /** Return the maximum between two objects */ public static Comparable max(Comparable o1, Comparable o2) { if (o1.compareTo(o2) > 0) return o1; else return o2; }

77. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. Programs to Use Programs are stored on the M: drive in the Sample folder : TestEdible Edible Animal Chicken Tiger Elephant Fruit Apple Orange Cherry

78. ©TheMcGraw-Hill Companies, Inc. Permission required for reproduction or display. TestEdible (Driver) Animal ElephantTigerChicken > Fruit AppleCherry Tiger