1. 1 Object-Oriented Programming (Java), Unit 12 Kirk Scott

2. 2 Inheritance, Part I 12.1 What is Inheritance? 12.2 Writing the Code for Subclasses 12.3 Access to Instance Variables and Overriding Methods

3. 12.4 A Note on the Meaning of Inheritance 12.5 The Key Word super, Methods, and Construction 12.6 References to Classes and Subclasses in Programs and Methods 3

4. 4 12.1 What is Inheritance?

5. 5 12.1.1 Superclass/Subclass, Parent Class/Child Class Terminology The class at the top of an inheritance hierarchy has nothing above it. Any other class has exactly one class immediately above it in the hierarchy. Any given class may have more than one class above it, at different levels in the hierarchy.

6. The class immediately above a given class may be called the parent class or superclass. All classes above it are known generally as superclasses. 6

7. A class can have more than one class immediately below it. Below that may be others, and so on. A class immediately below a given class may be called a child class or a subclass. All classes below it are known generally as subclasses. 7

8. 8 12.1.2 "Is-a" or "Is-a-Kind-of" Relationships The relationship between items in an inheritance hierarchy can be described as an “is a” or “is a kind of” relationship. Any class that appears lower down in the hierarchy must be an example of, or a more specific kind of, whatever classes appear above it in the hierarchy.

9. In the field of biology the classification of all living things is based on this idea. This is referred to as taxonomy. The taxonomy of human beings is shown on the next overhead. This illustrates one relatively complete branch of an inheritance hierarchy. 9

10. 10 Kingdom: Animalia –Phylum: Chordata Class: Mammalia –Order: Primates »Family: Hominidae » Genus: Homo » Species: sapiens

11. 11 12.1.3 Inheritance Hierarchies are Tree- Like The UML-like diagram on the next overhead illustrates the tree-like nature of inheritance hierarchies. This is described as a tree, although it is customary to represent it “upside down”, with the root at the top.

12. 12

13. 13 12.1.4 In Java the Root Class and the Default Parent Class is Named Object In Java the single class at the top of the hierarchy, or the root of the tree, is a class named Object. All system supplied classes are arranged in a hierarchy beneath this class. When a programmer writes classes and a parent class is not specified, such classes become children, or immediate subclasses, of the Object class.

14. There is a syntax allowing programmers to specifically make one class a subclass of another. It will be covered later. 14

15. 15 12.1.5 Subclasses Inherit Instance Variables and Methods, but Not Constructors Classes in the hierarchy are related by inheritance. Any class that has classes above it in the hierarchy inherits characteristics of those superclasses. These characteristics include instance variables and methods. Constructors are not inherited.

16. It is natural, and possible, for subclasses to add instance variables and methods which do not exist in the superclasses. This is the main way in which subclasses distinguish themselves from their superclasses. There may also be situations where it is undesirable to inherit characteristics. There is syntax which thwarts inheritance. It will be covered later. 16

17. 17 12.1.6 Do Not Confuse Individual Inheritance with Class Inheritance Different uses of the term inheritance can potentially lead to confusion. Inheritance can be used to refer to the characteristics an individual child receives from a particular parent, for example. This is not the sense of inheritance as it's used here.

18. The taxonomic example shows inheritance among categories, not individuals. This does illustrate the sense of inheritance as it's used here. For example, the genus Homo is the parent class of the species sapiens in the hierarchy. Homo doesn't represent some individual parent and sapiens doesn't represent some individual child. 18

19. 19 12.1.7 The Hierarchy Containing Rectangle2D in the Java API Documentation The Java API documentation for the class Rectangle2D shows an inheritance hierarchy. java.lang.Object java.awt.geom.RectangularShape java.awt.geom.Rectangle2D Object is the parent class of RectangularShape and RectangularShape is the parent class of Rectangle2D.

20. The class names are fully qualified using dot notation to show which packages they are in, java.lang or java.awt.geom. Package membership does not indicate inheritance relationships. 20

21. 21 12.2 Writing the Code for Subclasses

22. 22 12.2.1 The Food Class Example Consider a class, FoodV1, which represents kinds of food items from the point of view of the store where they are sold. Code for this class is given on the next overhead. The instance variables for this class are name, wholesaleCost, and markup. By default, this class is a subclass of the Object class.

23. 23 public class FoodV1 { private String name; private double wholesaleCost; private double markup; public FoodV1() { } public void setName(String nameIn) { name = nameIn; } public String getName() { return name; }

24. 24 public void setWholesaleCost(double wholesaleCostIn) { wholesaleCost = wholesaleCostIn; } public double getWholesaleCost() { return wholesaleCost; } public void setMarkup(double markupIn) { markup = markupIn; } public double getMarkup() { return markup; } public double getPrice() { return (wholesaleCost + wholesaleCost * markup); }

25. 25 12.2.2 Creating Subclasses It is possible to create a class, TaxedFoodV1, which is a subclass of the FoodV1 class. Here is a UML diagram showing the inheritance relationship between these classes and the Object class:

26. 26

27. 27 12.2.3 The Keyword extends The keyword for specifying a subclass is extends. Syntactically, the child specifies its one parent; the parent doesn’t specify its potentially many children. Here is the code for the TaxedFoodV1, a child class of FoodV1:

28. 28 public class TaxedFoodV1 extends FoodV1 { private double taxRate; public TaxedFoodV1() { } public void setTaxRate(double taxRateIn) { taxRate = taxRateIn; } public double getTaxRate() { return taxRate; }

29. 29 12.2.4 Constructors There is nothing unusual about the TaxedFoodV1 class regarding construction It has a default constructor and an instance of the class can be constructed as usual: TaxedFoodV1 myTaxedFood = new TaxedFoodV1();

30. 30 12.2.5 The Inheritance of Instance Variables The TaxedFoodV1 class has one instance variable of its own, taxRate. The class also inherits all of the instance variables of the class FoodV1. An object of this class (e.g., myTaxedFood) has all of the following instance variables: nameinherited wholesaleCostinherited markupinherited taxRatenot inherited

31. 31 12.2.6 The Inheritance of Methods The TaxedFoodV1 class has get and set methods for the instance variable taxRate defined in it. It also inherits all of the methods (which were declared public) of the class FoodV1. After an instance of myTaxedFoodV1 has been constructed, calls to the inherited methods can be freely made on it.

32. TaxedFoodV1 myTaxedFood = new TaxedFoodV1(); myTaxedFood.setname(“Peas”); double retrievedCost = myTaxedFood.getWholesaleCost(); double retrievedPrice = myTaxedFood.getPrice(); 32

33. 33 12.3 Access to Instance Variables and Overriding Methods

34. 34 12.3.1 Inherited Instance Variables Are Not Directly Accessible Both (private) instance variables and (public) methods are inherited. Inherited instance variables declared private in the superclass (as they should be) are not directly accessible in the subclass. When using an instance of a subclass, it is possible to work with the object’s inherited instance variables by using the inherited get and set methods.

35. 35 12.3.2 Thwarting Inheritance by Overriding Methods As subclasses become more specific, it is possible that an inherited method does not completely accomplish what needs to be accomplished. It is syntactically possible for a subclass to have a method with the same name as a method in one of its superclasses, and with the same parameter list.

36. This is referred to as overriding the inherited method. If a call is made on an object of the subclass using that method name, the version of the method defined in the subclass is used, not the version in the superclass. Inheritance is thwarted by overriding. 36

37. 37 12.3.3 Do Not Confuse Overriding with Overloading It is also possible to write a method in a subclass with the same name as a method in one of its superclasses, but with a different parameter list. In this case you have not overridden the inherited method. This is overloading. The two should not be confused.

38. Overloading also applies in the simpler case of a single class A given class may have two methods with the same name but different parameter lists The system distinguishes between them based on the parameter list Having the same name, the two methods should accomplish approximately the same thing, but on the basis of different input parameters 38

39. 39 12.3.4 An Example Illustrating Overriding The method getPrice() as defined in the class FoodV1 calculates a checkout price based on the wholesale cost of the item and the markup charged by the store. The checkout price for a taxed food item should include the tax on that item. This shows how the method might be correctly implemented in the TaxedFoodV1 class:

40. 40 public double getPrice() { double retrievedCost; double retrievedMarkup; double costPlusMarkup; double price; retrievedCost = getWholesaleCost(); retrievedMarkup = getMarkup(); costPlusMarkup = retrievedCost + retrievedCost * retrievedMarkup; price = costPlusMarkup + costPlusMarkup * taxRate; return price; }

41. 41 12.3.5 Lack of Direct Access There is no direct access to the inherited instance variables. The code above has to use the get methods to access the inherited variables. retrievedCost = getWholesaleCost(); retrievedMarkup = getMarkup();

42. 42 12.3.6 Remembering the Implicit Parameter The code given on the previous overhead illustrated method calls “hanging in space” The standard way of calling a method is object.method() In the code above, the method calls were not made on objects That means that the calls were being made on the implicit parameter

43. The calls could be written using the implicit parameter. retrievedCost = this.getWholesaleCost(); retrievedMarkup = this.getMarkup(); The retrieved values come from whatever object the getPrice() method, which contains these calls, was called on. 43

44. 44 12.3.7 Review of Lack of Direct Access and Overriding This example illustrated implementing a version of the getPrice() method in a subclass which differs from the implementation that it would otherwise inherit. This is overriding. When calling the overridden method on a subclass object, the implicit parameter of the call to getPrice(), would be a TaxedFoodV1 object

45. The TaxedFood object would have wholesaleCost and markup variables by inheritance. However, in the subclass code for the getPrice() method, there would not be direct access to these inherited variables. The inherited variables can only be accessed through inherited get methods— whether done with calls “hanging in space” or calls on the implicit parameter, “this”. 45

46. 46 12.3.8 Using the Overridden Method Suppose that the following objects were constructed: FoodV1 myFood = new FoodV1(); TaxedFoodV1 yourFood = new TaxedFoodV1(); Suppose also that set methods had been called so that their price, markup, and taxRate variables had been set.

47. 47 Now consider the following two calls: double x = myFood.getPrice(); double y = yourFood.getPrice();

48. The two calls to getPrice() in the lines of code above are to two different versions of the method. Which version of the method is called depends on which kind of object it is called on, an instance of FoodV1 or an instance of TaxedFoodV1. 48

49. 49 12.3.9 Inheritance from Multiple Levels Consider the following general inheritance hierarchy:

50. 50 If methodX() is implemented in the Top class and not implemented in the other two classes, then it is inherited by both Middle and Bottom. If methodX() is implemented in Middle, then it does not exist for objects of the Top class; it is inherited by the Bottom class.

51. If methodX() is implemented in the Top class, overridden in the Middle class, and inherited by the Bottom class, the version nearest to the Bottom class as you move upwards through the hierarchy is inherited; this is the version implemented in the Middle class. 51

52. 52 12.3.10 Instance Variables Can't Be Overridden It is not possible to override instance variables. It is syntactically possible to declare instance variables in a subclass with the same name as instance variables in its superclasses (and with different types). It is unfortunate that this is syntactically possible, because from a practical point of view it is a big mistake to do something like this. It will be extremely difficult to unravel the meaning of the code.

53. The idea of overriding instance variables is also a problem conceptually. Instance variables should represent inherent characteristics of classes. If it seems desirable to change an instance variable in a subclass, that’s a sign that that class is in the wrong place in the inheritance hierarchy. 53

54. 54 12.4 The Meaning of Inheritance: Some Differences with the Sun Java Tutorial Presentation If you haven’t looked at the Java Tutorial, then there is no need to consider this section in the note files. With the exception of this overhead, it will not be covered in class in any case. If you have questions about it you should read the section in the note file (and ask questions if you have them).

55. 55 12.5 The Key Word super, Methods, and Construction

56. 56 12.5.1 Using super to Call an Overridden Method In the overridden getPrice() method of the TaxedFoodV1 class, the majority of the code simply duplicated the logic of the getPrice() method of the FoodV1 class. It was necessary to get the price including the markup and then apply the tax rate to that.

57. Finding the price with the markup is exactly what the getPrice() method does in the superclass. The example below shows how it is possible for the overridden method to make use of the version of the method defined above it in the hierarchy. 57

58. 58 public double getPrice() { double price; price = super.getPrice(); price = price + price * taxRate; return price; }

59. At execution time the key word super signals that the call to getPrice() is not a recursive call. The system looks in the hierarchy for the nearest class above the current class where getPrice() is implemented, and uses the version found there. The keyword super does not signify an object The method is called on the implicit parameter 59

60. 60 12.5.2 Subclass Constructors Don't Have Access to Inherited Instance Variables The keyword super also arises when writing subclass constructors which take parameters. Constructors in a subclass also do not have direct access to the (private) instance variables inherited from the superclass. For example, super is needed in order to write a constructor for the TaxedFoodV1 class which would take parameters for the inherited instance variables wholesaleCost and markup. This will be illustrated shortly

61. 61 12.5.3 If the Programmer Writes a Constructor, the System Doesn't Supply a Default Constructor It is possible to write a class with no constructors at all. If this is done, the system automatically provides an invisible default constructor. It is important to remember that as soon as the programmer writes any constructor for a class, then the system does not provide a default constructor. In this case, if a default constructor is needed, the programmer has to provide one.

62. 62 12.5.4 Using super When Writing a Subclass Constructor with Parameters The example so far has made use of default construction. Default subclass construction relies on the existence of a default constructor in the superclass. Default initialization of instance variables, including inherited ones, is handled automatically. The example will now be extended to illustrate construction with parameters.

63. 63 Here is a constructor for the superclass, FoodV2, which takes a full set of parameters for its instance variables: public FoodV2(String nameIn, double wholesaleCostIn, double markupIn) { name = nameIn; wholesaleCost = wholesaleCostIn; markup = markupIn; }

64. Here is a correct constructor for the subclass, TaxedFoodV2, which takes a full set of parameters, including parameters for the inherited variables: public TaxedFoodV2(String nameIn, double wholesaleCostIn, double markupIn, double taxRateIn) { super(nameIn, wholesaleCostIn, markupIn); taxRate = taxRateIn; } 64

65. 65 12.5.5 If You Use super, It has to be First; If You Don’t Use super, there has to be a Default Superclass Constructor When the system encounters a call to super() in a constructor, it looks for a constructor above the current class in the hierarchy. It will use the nearest constructor in the hierarchy above it which has a parameter list which matches the parameters used in the super() call. If you explicitly call super() in a subclass constructor, this call has to be the first line of code.

66. If you don’t explicitly call super(), then you are relying on the default constructor in the superclass. Construction depends on cascading calls to constructors up through the inheritance hierarchy, whether the calls are explicit calls to super() or whether they are implicit calls which rely on the existence of a default constructor in the superclass. 66

67. The actual creation of a new object ultimately stems from a call to the constructor in the Object class. The constructors below that class are responsible for initializing the instance variables. 67

68. 68 12.6 References to Classes and Subclasses in Programs and Methods

69. 69 12.6.1 Class Hierarchies Have to Be Written from the Top Down When creating a hierarchy of classes, you have to work your way from the top down. The code for a subclass can only be compiled if its superclasses exist. The code for superclasses should also be tested before the subclass code is written. A test program at any level includes code that makes use of all constructors and methods in the class to make sure that they work correctly.

70. Note on programming assignments The previous bullet bears repeating: Some of the programming assignments specify that certain classes be written and that test programs for those classes also be written. This is what is meant by a test program: Code that makes use of all constructors and methods in the class to make sure that they work correctly. 70

71. 71 12.6.2 Superclass References to Subclass Objects are Valid. This is Done without Casting Syntactically, a reference to a subclass object can always be assigned to a reference that is declared to be of the type of any of the subclass’s superclasses. This is logically valid because instances of classes lower down in the hierarchy are “a kind of” (a more specific kind of) the classes higher in the hierarchy.

72. Syntactically, this idea can be illustrated as follows: FoodV2 myFood; TaxedFoodV2 myTaxedFood = new TaxedFoodV2(“bread”,.50,.05,.07); myFood = myTaxedFood; 72

73. 73 12.6.3 Superclass References to Subclass Objects Don't Have Access to Methods Defined Only in the Subclass A superclass reference to a subclass object is distinctly limited, or has a distinct limitation. When working with a superclass reference, it is only possible to call methods defined in the superclass or methods inherited by the superclass. It is not possible to call methods on a superclass reference if the methods are only defined in the subclass.

74. 74 12.6.4 It is Possible to Recover a Subclass Reference by Casting Casting can be used in order to recover the actual class that a superclass reference belongs to. The previous code example is repeated on the next overhead with one line added. In the final line the TaxedFoodV2 reference is recovered from the FoodV2 reference:

75. FoodV2 myFood; TaxedFoodV2 myTaxedFood = new TaxedFoodV2(“bread”,.50,.05,.07); myFood = myTaxedFood; TaxedFoodV2 newTaxedFood = (TaxedFoodV2) myFood; 75

76. 76 12.6.5 Subclass References to Superclass Objects Are Not Valid Casting will not work if the type on the left is not the same type as the actual object on the right. Here is a gross example: /* NO! NO! NO! */ Ellipse2D.Double myEllipse = new Ellipse2D.Double(10, 20, 30, 40); TaxedFoodV2 myTaxedFood = (TaxedFoodV2) myEllipse;

77. 77 This looks more plausible but is equally impossible: /* NO! NO! NO! */ FoodV2 myFood = new FoodV2(“cheese”, 1.25,.06); TaxedFoodV2 myTaxedFood = (TaxedFoodV2) myFood;

78. Even though myFood and myTaxedFood are in the same inheritance hierarchy, myFood is a superclass object (only). It never was a taxed food, and a reference to a taxed food object cannot be recovered. 78

79. In general it is not valid to try and cast superclasses to subclasses because a superclass is not “a kind of” a subclass. Casting can recover the actual subclass of a superclass reference. It cannot recover a kind of reference that never existed. 79

80. Referring back to the taxonomic example, there is no problem with referring to a human being as an member of the class Animalia All humans are animals However, casting an Animalia reference to a human is problematic. What if the Animalia reference were a superclass reference to an instance of a spider? 80

81. 81 12.6.6 The Keyword instanceof Checks Whether an Object is an Instance of a Given Class The keyword instanceof functions as an operator that returns a boolean value. It compares the actual type of a reference to a given class. This code fragment shows its use to permit a valid cast and prevent a mistaken one: if(myFood instanceof TaxedFoodV2) TaxedFoodV2 newTaxedFood = (TaxedFoodV2) myFood;

82. 82 12.6.7 The Actual Parameter in a Method Call Can Be a Subclass of the Formal Parameter Type. Automatic Conversion to a Superclass Reference Occurs Reference type becomes critical when passing object references as parameters. A subclass object can always be assigned to a superclass reference. If a formal parameter is typed as a superclass reference in a method, it is permissible to pass a subclass object or reference as the actual, explicit parameter when calling the method.

83. 83 A new method, setMarkupToThisMarkup(), is given on the next overhead. This method is defined in the FoodV3 class. The method is designed to set the markup of one food item to the markup already stored in another. This is accomplished by passing the other object as a parameter to the method.

84. The parameter is typed FoodV3, the same as the class the method is defined in. public void setMarkupToThisMarkup(FoodV3 anotherFood) { double tempMarkup = anotherFood.getMarkup(); setMarkup(tempMarkup); } 84

85. 85 Suppose the following code exists in a program that uses the food classes: TaxedFoodV3 myTaxedFood = new TaxedFoodV3(“bread”,.50,.05,.07); TaxedFoodV3 yourTaxedFood = new TaxedFoodV3(“milk”,.75,.08,.07); myTaxedFood.setMarkupToThisMarkup(yourTaxedFood);

86. The third (last) line of code is the critical one. The new method is inherited by the TaxedFoodV3 subclass, making the call on myTaxedFood is possible. The actual, explicit parameter, yourTaxedFood, is an instance of TaxedFoodV3. In the method definition the formal parameter is typed FoodV3. 86

87. In other situations where the actual parameter type did not agree with the formal parameter type, the compiler detected an error. However, in this case there is no problem. When passing a parameter, the actual parameter is assigned to the formal parameter. It is OK to assign a subclass object to a superclass reference without casting. 87

88. The system knows that TaxedFoodV3 is a subclass of FoodV3. Therefore, when the actual parameter, a taxed food object, is passed, that reference is automatically converted to a FoodV3 superclass reference. 88

89. 89 12.6.8 In the Body of a Method Definition, Method Calls Can Be Made on a Formal Parameter Which Is a Superclass Reference This line of code appears in the body of the method: double tempMarkup = anotherFood.getMarkup(); If the actual parameter is a subclass object, then anotherFood is a superclass reference. A superclass reference is distinctly limited. It is only possible to call methods defined in the superclass on such a reference. This does not raise a problem.

90. The method getMarkup() is written in the FoodV3 (super) class. Therefore it's possible to call it on a superclass reference to a subclass object. The TaxedFoodV3 class inherits this method. The version defined in the superclass is appropriate for the actual subclass object it’s called on. If the method being called were overridden, that would still be OK. How that works will be described in a later section. 90

91. To summarize, the point of the example is that it is possible to pass a subclass object as an explicit parameter when the formal parameter is typed to a superclass. 91

92. It is also worth noting that the code for the method could be simplified. It is true that a superclass reference is distinctly limited and doesn’t have access to methods defined only in a subclass. It’s also true that a subclass object doesn’t have direct access to its inherited instance variables. 92

93. However, if you are writing code in the superclass, a superclass reference (to a subclass object) will have access to those variables (inherited by the subclass) which are defined in the superclass. In other words, the simpler version of the setMarkupToThisMarkup() method given on the next overhead will work, both if the parameter is a Food object or a TaxedFood object. 93

94. public void setMarkupToThisMarkup(FoodV3 anotherFood) { markup = anotherFood.markup; } /* Or: this.markup = anotherFood.markup; */ 94

95. 95 12.6.9 Example Code (Showing All Changes up to this Point) public class FoodV3 { private String name; private double wholesaleCost; private double markup; public FoodV3(String nameIn, double wholesaleCostIn, double markupIn) { name = nameIn; wholesaleCost = wholesaleCostIn; markup = markupIn; }

96. 96 public void setName(String nameIn) { name = nameIn; } public String getName() { return name; } public void setWholesaleCost(double wholesaleCostIn) { wholesaleCost = wholesaleCostIn; } public double getWholesaleCost() { return wholesaleCost; }

97. public void setMarkup(double markupIn) { markup = markupIn; } public double getMarkup() { return markup; } public double getPrice() { return (wholesaleCost + wholesaleCost * markup); } public void setMarkupToThisMarkup(FoodV3 anotherFood) { double tempMarkup = anotherFood.getMarkup(); setMarkup(tempMarkup); } 97

98. 98 public class TaxedFoodV3 extends FoodV3 { private double taxRate; public TaxedFoodV3(String nameIn, double wholesaleCostIn, double markupIn, double taxRateIn) { super(nameIn, wholesaleCostIn, markupIn); taxRate = taxRateIn; } public void setTaxRate(double taxRateIn) { taxRate = taxRateIn; }

99. public double getTaxRate() { return taxRate; } public double getPrice() { double price; price = super.getPrice(); price = price + price * taxRate; return price; } 99

100. What is the First Assignment Like? The contents of the first assignment are presented on the following overheads. When doing the assignment, you should work from the Word document, not these overheads. The assignment is given here so that it will be possible to go over it in class if there’s time after finishing the lecture. 100

101. Java Unit 12 Assignment Grading check-off checklist: 1. I will want to see that answers have been typed in for the 19 short answer questions. 2. You should have an ItemB.java class which compiles. 101

102. 3. You should have FoodV4.java, PackagedFoodV4.java, and BulkFoodV4.java classes which compile. 4. You should have a test program (.java file) for the three classes above which compiles and runs. When you prepare to demonstrate this, recall that if you used MyTerminalIO.java, it should also be in the folder so that your program will compile and run. 102

103. Assignment: 1. Describe in words what the class named Object is in Java. 2. What class in Java is at the very top of the inheritance hierarchy? 3. Do subclasses get copies of the instance variables that are declared private in their superclasses? 4. Do subclasses have free access to their inherited private instance variables? 5. Can the type of private (or public) instance variables be overridden in a subclass? 103

104. 6. Only one of the following statements is true. Which is it? A. Constructors are inherited. B. Constructors in subclasses rely on the existence of constructors in superclasses, but the constructors are not literally inherited. 7. Are public methods inherited? 8. Do subclasses have free access to their inherited public methods? 9. Can the implementation of an inherited method be overridden in a subclass? 104

105. 10. Suppose an inheritance hierarchy consists of classes named Top, Middle, and Bottom, in that relation. Suppose methodX() is defined in Bottom, but not above it. Can this method be called on objects of the Middle class? 11. Suppose an inheritance hierarchy consists of classes named Top, Middle, and Bottom, in that relation. Suppose methodX() is defined in Top, overridden in Middle, and is not overridden in Bottom. What happens if methodX() is called on an object of the Bottom class? 105

106. 12. Suppose an inheritance hierarchy consists of classes named Top, Middle, and Bottom, in that relation. Suppose methodX() is defined in Top and overridden in Bottom. What does the use of the key word super accomplish when used in the version of the method in Bottom? 13. Suppose the key word super is used in a subclass constructor definition. If so, where does it have to appear? 106

107. Two sketchy class definitions are shown on the next overheads. Assume that everything exists to make these classes work in reality. 107

108. public class ParentClass { public double method1(double inVal) { … } public double method2(double inVal) { … } public static double method3(ParentClass pClassRef, double inVal) { … double someResult = pClassRef.method2(inVal); … } … } 108

109. public class ChildClass extends ParentClass { public double method2(double inVal) { … } public double method4(double inVal) { … } … } 109

110. Also suppose that the following declarations and constructions are done: ParentClass myparent = new ParentClass(); ParentClass yourparent = new ParentClass(); ParentClass parentClassRef; ChildClass mychild = new ChildClass(); ChildClass childClassRef; 110

111. 14. Suppose that in the implementation of the version of method2() that occurs in the ChildClass it is necessary to call the version of method2() that occurs in the ParentClass. If the parameter being passed is inVal, what would the call look like? 15. Is this sequence OK? parentClassRef = mychild; double result = parentClassRef.method4(someVal); 111

112. 16. In what class is the version of method1() defined that is being used in the call? double result = mychild.method1(someVal); 17. In what class is the version of method2() defined that is being used in the call? double result = mychild.method2(someVal); 112

113. 18. In what class is the version of method2() defined that is being used when the code for method3() is run? (This question refers to the call to method2() which is made in the body of method3().) double result = yourparent.method3(myparent, someVal); 113

114. 19. In what class is the version of method2() defined that is being used when the code for method3() is run? (This question refers to the call to method2() which is made in the body of method3().) double result = yourparent.method3(mychild, someVal); 114

115. The complete code for a simple class is given on the next overhead. 115

116. public class ItemA { private double price; public ItemA() { } public ItemA(double priceIn) { price = priceIn; } public void setPrice(double priceIn) { price = priceIn; } public double getPrice() { return price; } 116

117. The following questions together form the definition of a subclass of the given class. They are given here as separate questions to illustrate how questions might be presented on a test. For the purposes of the assignment, write the code for ItemB and save it as a.java file, along with ItemA.java, so that it can be checked off by a successful compilation. 117

118. 20. Give the line of code which would declare ItemB as a subclass of ItemA. 21. Give the line of code which would give ItemB an int instance variable named units. (The assumption is that whatever unit you’re using, you record the nearest whole value.) 22. Write a set method, setUnits() with input parameter unitsIn. 118

119. 23. Write a get method, getUnits(). 24. Write a default constructor for ItemB. 25. Give a complete constructor for ItemB which would take input parameters priceIn and unitsIn and successfully use them to initialize the instance variables. 26. Write a method getUnitPrice() that will return the result of dividing price by units. 119

120. A new food hierarchy is described below. Your task is to write the code for all of the classes described and write a program that tests all of the constructors and methods contained in each of the classes. Because of the changes required, the food class will become version 4. In order to keep the naming of the subclasses consistent, they will also be named version 4. The idea is again to represent food items from the point of view of the store where they are sold. Packaged food comes in cans or boxes that contain a specific amount. Bulk food is measured at the time of sale. A UML diagram is shown on the next overhead. 120

121. 121

122. 27. The class FoodV4 should contain the following: Instance variables: String brand, String productName Methods: get and set methods for both instance variables, plus a method setBrandToThisBrand(Food anotherFoodItem) Constructors: one constructor that takes two parameters, one for each instance variable 122

123. The setBrandToThisBrand() method should be similar to the setMarkupToThisMarkup() method in the examples in the chapter. It is designed to illustrate passing an object reference as a parameter. The implicit parameter should receive a new value for its brand instance variable, the value currently in the explicit parameter. 123

124. 28. The class PackagedFoodV4 should contain the following: Instance variables: String units, double size, double itemCost Methods: get and set methods for the instance variables, plus a method named getUnitCost() Constructors: one constructor that takes 5 parameters, one for each instance variable 124

125. The instance variable units refers to the units in which the product is measured, such as grams or milliliters. The instance variable size tells how many of those units are in a package. The method getUnitCost() calculates the cost per unit based on the itemCost and the size of the item. 125

126. 29. The class BulkFoodV4 should contain the following: Instance variables: String units, double unitCost Methods: set and get methods for the instance variables, plus a method named findCost(double amount) which will return the cost of a given amount of the product Constructors: one constructor that takes 4 parameters, one for each instance variable 126

127. Notice that in this class there will be a method getUnitCost() which is a simple accessor method. It does not require calculation. Also, with respect to the value it returns, the method findCost() is similar to getItemCost() in the PackagedFood class. However, it is not a simple accessor. It is a method which takes an explicit parameter because it is not possible to determine the cost of a bulk food item without specifying the amount being bought or sold. 127

128. 30. Test the classes. This may be done with one big program, or with separate programs for the different classes. The test program should create instances of the objects, testing each of the constructors you have written, and it should also test each of the methods in each of the classes in order to make sure that they function as they should. It should be a particularly interesting test to see if the setBrandToThisBrand() method works when the implicit parameter is a PackagedFoodV4 item and the explicit parameter is a BulkFoodV4 item, for example, or the other way around. 128

129. The End 129