1. 1 Inheritance  Inheritance allows a software developer to derive a new class from an existing one  The existing class is called the parent class, or superclass, or base class  The derived class is called the child class or subclass.  As the name implies, the child inherits characteristics of the parent  That is, the child class inherits the methods and data defined for the parent class

2. Inheritance  To tailor a derived class, the programmer can add new variables or methods, or can modify the inherited ones  Software reuse is at the heart of inheritance  By using existing software components to create new ones, we capitalize on all the effort that went into the design, implementation, and testing of the existing software

3. 3 Inheritance  Inheritance relationships often are shown graphically in a UML class diagram, with an arrow with an open arrowhead pointing to the parent class Inheritance should create an is-a relationship, meaning the child is a more specific version of the parent Vehicle Car

4. 4 Deriving Subclasses  In Java, we use the reserved word extends to establish an inheritance relationship  See Words.java (page 384) Words.java  See Book.java (page 385) Book.java  See Dictionary.java (page 386) Dictionary.java class Car extends Vehicle { // class contents }

5. Book and Dictionary public class Book { protected int pages = 1500; //---------------------------------------------- // Prints a message about the pages of this book. //---------------------------------------------- public void pageMessage () { System.out.println ("Number of pages: " + pages); } public class Dictionary extends Book { private int definitions = 52500; //---------------------------------------------------- // Prints a message using both local and inherited values. //---------------------------------------------------- public void definitionMessage () { System.out.println ("Number of definitions: " + definitions); System.out.println ("Definitions per page: " + definitions/pages); } Dictionary webster=new Dictionary(); webster.pageMessage(); webster.definitionMessage();

6. 6 The protected Modifier  Visibility modifiers determine which class members are inherited and which are not  Variables and methods declared with public visibility are inherited; those with private visibility are not  But public variables violate the principle of encapsulation  There is a third visibility modifier that helps in inheritance situations: protected

7. 7 The protected Modifier  The protected modifier allows a member of a base class to be inherited into a child  Protected visibility provides more encapsulation than public visibility does  However, protected visibility is not as tightly encapsulated as private visibility  The details of each modifier are given in Appendix F  Protected variables and methods can be shown with a # symbol preceding them in UML diagrams

8. UML Diagram for Words Book # pages : int + pageMessage() : void Dictionary - definitions : int + definitionMessage() : void Words + main (args : String[]) : void

9. ShrinkingBall

10. 10 The super Reference  Constructors are not inherited, even though they have public visibility  Yet we often want to use the parent's constructor to set up the "parent's part" of the object  The super reference can be used to refer to the parent class, and often is used to invoke the parent's constructor  See Words2.java (page 388) Words2.java  See Book2.java (page 389) Book2.java  See Dictionary2.java (page 390) Dictionary2.java

11. Book and Dictionary public class Book2 { protected int pages; public Book2 (int numPages) { pages = numPages; } public void pageMessage () { System.out.println ("Number of pages: " + pages); } public class Dictionary2 extends Book2 { private int definitions; public Dictionary2 (int numPages, int numDefinitions) { super (numPages); definitions = numDefinitions; } public void definitionMessage () { System.out.println ("Number of definitions: " + definitions); System.out.println ("Definitions per page: " + definitions/pages); } Dictionary2 webster = new Dictionary2 (1500, 52500); webster.pageMessage(); webster.definitionMessage();

12. The super Reference  A child’s constructor is responsible for calling the parent’s constructor  The first line of a child’s constructor should use the super reference to call the parent’s constructor  The super reference can also be used to reference other variables and methods defined in the parent’s class

13. Super use in ShrinkingBall public class ShrinkingBall extends Ball { private double shrinkRate; public ShrinkingBall(Position pos, double radius, double vx, double vy, double shRate) { super(pos, radius, vx, vy); shrinkRate = shRate; } public void move(int tu) { super.move(tu); if (tu * shrinkRate > radius) radius = tu * shrinkRate; else radius = 0; }

14. Multiple Inheritance  Java supports single inheritance, meaning that a derived class can have only one parent class  Multiple inheritance allows a class to be derived from two or more classes, inheriting the members of all parents  Collisions, such as the same variable name in two parents, have to be resolved  Java does not support multiple inheritance  In most cases, the use of interfaces gives us aspects of multiple inheritance without the overhead

15. 15 Overriding Methods  A child class can override the definition of an inherited method in favor of its own  The new method must have the same signature as the parent's method, but can have a different body  The type of the object executing the method determines which version of the method is invoked  See Messages.java (page 392) Messages.java  See Thought.java (page 393) Thought.java  See Advice.java (page 394) Advice.java

16. Book and Dictionary public class Thought { // Prints a message. public void message() { System.out.println ("I feel like I'm diagonally parked in a " + "parallel universe."); System.out.println(); } public class Advice extends Thought { // Prints a message. This method overrides the parent's version. // It also invokes the parent's version explicitly using super. public void message() { System.out.println ("Warning: Dates in calendar are closer " + "than they appear."); super.message(); } Thought parked = new Thought(); Advice dates = new Advice(); parked.message(); dates.message(); // overridden

17. Overriding  A parent method can be invoked explicitly using the super reference  If a method is declared with the final modifier, it cannot be overridden  The concept of overriding can be applied to data and is called shadowing variables  Shadowing variables should be avoided because it tends to cause unnecessarily confusing code

18. 18 Overloading vs. Overriding  Don't confuse the concepts of overloading and overriding  Overloading deals with multiple methods with the same name in the same class, but with different signatures  Overriding deals with two methods, one in a parent class and one in a child class, that have the same signature  Overloading lets you define a similar operation in different ways for different data  Overriding lets you define a similar operation in different ways for different object types

19. 19 Class Hierarchies  A child class of one parent can be the parent of another child, forming a class hierarchy Business Gima Carsi Magazasi ServiceBusiness Yurtici Kargo RetailBusiness

20. 20 Class Hierarchies  Two children of the same parent are called siblings  Common features should be put as high in the hierarchy as is reasonable (otherwise code is duplicated)  An inherited member is passed continually down the line  Therefore, a child class inherits from all its ancestor classes  There is no single class hierarchy that is appropriate for all situations

21. Hierarchies  Lets say we want to create a MovingRectangle class  A MovingRectangle has a Position, velocity, height and width  We already have Position and Ball classes  How can we create a class hierarchy?  Notice that both Ball and Moving Rectangle has-a Position  Positioned Object?

22. First Try PositionedObject Position pos MovingRectangle double vx, vy; move(int tu); double height, width; Ball double vx, vy; move(int tu); double radius; Position double x,y; Although this is better than previous, vx, vy and the code for move is duplicated

23. Second Try PositionedObject Position pos MovingObject double vx, vy; move(int tu) Ball double radius; MovingRectangle double height, width; Position double x,y; This is an example of overdoing inheritane. Too many layers

24. Third Try MovingObject Position pos; double vx, vy; move(int tu); MovingRectangle double height, width; Ball double radius; Position double x,y; Here, no code duplication, no unnecessary layers. Given the current requirements, this seems like the best hierarchy

25. 25 The Object Class  A class called Object is defined in the java.lang package of the Java standard class library  All classes are derived from the Object class  If a class is not explicitly defined to be the child of an existing class, it is assumed to be the child of the Object class  Therefore, the Object class is the ultimate root of all class hierarchies

26. The Object Class  The Object class contains a few useful methods, which are inherited by all classes  For example, the toString method is defined in the Object class  Every time we have defined toString, we have actually been overriding an existing definition  The toString method in the Object class is defined to return a string that contains the name of the object’s class together along with some other information

27. The Object Class  All objects are guaranteed to have a toString method via inheritance  Thus the println method can call toString for any object that is passed to it  See Academia.java (page 398) Academia.java  See Student.java (page 399) Student.java  See GradStudent.java (page 400) GradStudent.java

28. toString() Example public class Student { protected String name; protected int numCourses; public Student (String studentName, int courses) { name = studentName; numCourses = courses; } public String toString() { String result = "Student name: " + name + "\n“ +"Number of courses: " + numCourses; return result; } public class GradStudent extends Student { private String source; private double rate; public GradStudent (String studentName, int courses, String support, double payRate) { super (studentName, courses); source = support; rate = payRate; } public String toString() { String result = super.toString(); result += "\nSupport source: " + source + "\n"; result += "Hourly pay rate: " + rate; return result; } Student susan = new Student ("Susan", 5); GradStudent frank = new GradStudent ("Frank", 3, "GTA", 12.75); System.out.println (susan); System.out.println (frank);

29. The Object Class  The equals method of the Object class returns true if two references are aliases  We can override equals in any class to define equality in some more appropriate way  The String class (as we've seen) defines the equals method to return true if two String objects contain the same characters  Therefore the String class has overridden the equals method inherited from Object in favor of its own version

30. Equals() example public boolean equals(Object obj) {Object Ball b = (Ball) obj; // gets an exception if obj is not of type Ball if (position.equals(b.getPosition()) && radius == b.radius && vx == b.getVx() && vy == b.getVy() ) return true; else return false; }

31. 31 Indirect Use of Members  An inherited member can be referenced directly by name in the child class, as if it were declared in the child class  But even if a method or variable is not inherited by a child, it can still be accessed indirectly through parent methods  See FoodAnalysis.java (page 403) FoodAnalysis.java  See FoodItem.java (page 404) FoodItem.java  See Pizza.java (page 405) Pizza.java

32. FoodItem public class FoodItem { final private int CALORIES_PER_GRAM = 9; private int fatGrams; protected int servings; public FoodItem (int numFatGrams, int numServings) { fatGrams = numFatGrams; servings = numServings; } private int calories() { return fatGrams * CALORIES_PER_GRAM; } public int caloriesPerServing() { return (calories() / servings); } public class Pizza extends FoodItem { // Sets up a pizza with the specified amount of fat (assumes // eight servings). public Pizza (int fatGrams) { super (fatGrams, 8); }

33. Polymorphism  Lets say a Vector v contains MovingRectangle and Ball objects.  We want to slow down all the objects to half their speeds for (int i =0; i < v.size(); v++) { Object o = v.get(i); if (o instanceof MovingRectangle) { MovingRectangle mr = (MovingRectangle) o; mr.setVx(mr.getVx() / 2); } else { Ball b = (Ball) o; b.setVx(b.getVx() / 2); }

34. Polymorphism  Regardless of the class of the object, we end up calling the same method, Movingobject.setVx()  Can’t we treat all objects simply as MovingObject’s? for (int i =0; i < v.size(); i++) { MovingObject mo = (MovingObject)v.get(i); mo.setVx(mo.getVx() / 2); }

35. Polymorphism  A reference can be polymorphic, which can be defined as "having many forms" obj.doIt();  This line of code might execute different methods at different times if the object that obj points to changes  Polymorphic references are resolved at run time; this is called dynamic binding  Careful use of polymorphic references can lead to elegant, robust software designs  Polymorphism can be accomplished using inheritance or using interfaces

36. 36 References and Inheritance  An object reference can refer to an object of its class, or to an object of any class related to it by inheritance  For example, if the Holiday class is used to derive a child class called Christmas, then a Holiday reference could be used to point to a Christmas object Holiday day; day = new Christmas(); Holiday Christmas

37. 37 References and Inheritance  Assigning a predecessor object to an ancestor reference is considered to be a widening conversion, and can be performed by simple assignment  Assigning an ancestor object to a predecessor reference can be done also, but it is considered to be a narrowing conversion and must be done with a cast  The widening conversion is the most useful  An Object reference can be used to refer to any object An ArrayList is designed to hold Object references

38. byte int The set of int values is a wider set than the set of byte values, and contains all members of the byte values set. byte b = 2; int a = b; //widening conversion b = a; // narrowing conversion, invalid b = (byte) a; // this is ok Holiday h = new Holiday(…); Christmas ch = h; // invalid, not all //holidays are christmas Christmas Holiday

39. Polymorphism via Inheritance  It is the type of the object being referenced, not the reference type, that determines which method is invoked  Suppose the Holiday class has a method called celebrate, and the Christmas class overrides it  Now consider the following invocation: day.celebrate();  If day refers to a Holiday object, it invokes the Holiday version of celebrate ; if it refers to a Christmas object, it invokes the Christmas version

40. Polymorphism via Inheritance  Consider the following class hierarchy: StaffMember pay() ExecutiveHourly VolunteerEmployee

41. Polymorphism via Inheritance  Now consider the task of paying all employees  See Firm.java (page 410) Firm.java  See Staff.java (page 412) Staff.java  See StaffMember.java (page 414) StaffMember.java  See Volunteer.java (page 415) Volunteer.java  See Employee.java (page 416) Employee.java  See Executive.java (page 417) Executive.java  See Hourly.java (page 418) Hourly.java