CS 112 Introduction to Programming

1. CS 112 Introduction to Programming Inheritance Yang (Richard) Yang Computer Science Department Yale University 308A Watson, Phone: 432-6400 Email: yry@cs.yale.edu

2. Admin • Class project

3. Recap: OOP Analysis m 1 m 2 1 1 1 m GeoMap Region Color A composition relationship An associationrelationship Polygon Point

4. Recap: OOP Analysis: Controller Structure • Retrieve region • Batch: retrieve list of all regions • Specific: retrieve one specific region • Coloring • Map properties of a region to a color

5. Recap: OOP Analysis • Encapsulation is a key problem solving technique for large, complex problems • A good way to learn more is to read about designs of large-scale OOP software systems

6. Software Design and Reuse • Question: What programming language feature(s) have we covered to allow software reuse?

7. Outline • Admin and recap • Class inheritance • why and how?

8. A Law Firm Problem: Setting • Consider the following law firm: • Work time policy: Employees work 40 hours / week. • Pay policy: Employees make a base salary of $50,000 per year, except that • legal secretaries make 10% extra over base per year, • marketers make 20% extra over base per year, • lawyers who reach partner level get bonus. • Vacation policy: Employees have 2 weeks of paid vacation leave per year, except that • lawyers get an extra week on top of base, • employees should use a yellow form to apply for leave, except for lawyers who use a pink form.

9. A Law Firm Problem: Setting • Each type of employee has some job functions: • Lawyers know how to sue. • Marketers know how to advertise. • Secretaries know how to prepare ordinary documents. • Legal secretaries know how to prepare both ordinary documents and legal documents.

10. An Employee class public class Employee { public int hours() { return 40; // works 40 hours / week } public double pay() { return 50000.0; // $50,000.00 / year } public int vacationDays() { return 10; // 2 weeks' paid vacation } public String vacationForm() { return "yellow"; // use the yellow form } public String toString() { String result = "Hours: " + hours() + "\n"; result += "Pay: " + pay() + "\n"; result += "Vacation days: " + vacationDays() + "\n"; result += "Vacation Form: " + vacationForm() + "\n"; return result; } }

11. Question: Writing class Secretary • Secretaries are employees who can prepare documents.

12. Secretary class: Attempt 1 public class Secretary { public int hours() { return 40; // works 40 hours / week } public double pay() { return 50000.0; // $50,000.00 / year } public int vacationDays() { return 10; // 2 weeks' paid vacation } public String vacationForm() { return "yellow"; // use the yellow form } public String toString() { String result += "Hours: " + hours() + "\n"; result += "Pay: ” + pay() + "\n"; result += "Vacation days: " + vacationDays() + "\n"; result += "Vacation Form: " + vacationForm() + "\n"; return result; } public void prepareDoc(String text) { System.out.println(“Working on Document: " + text); } }

13. Desire for code-sharing prepareDoc is the only unique behavior in Secretary. We'd like to be able to say: // A class to represent secretaries. public class Secretary { <copy all the contents from the Employee class> public void prepareDoc(String text) { System.out.println(“Work on Document: " + text); } }

14. Inheritance • Inheritance: A way to allow a software developer to reuse classes by deriving 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 classor subclass. • As the name implies, the child inherits characteristics of the parent • The child class inherits every method and every data field defined for the parent class

15. Animal Bird - weight : int + getWeight() : int Inheritance • Inheritance relationships are often shown graphically in a class diagram, with the arrow pointing to the parent class Inheritance should create an is-a relationship, meaning the child is a more specific version of the parent - flySpeed : int + fly() : void

16. Animal - weight : int + getWeight() : int Inheritance • The child class inheritsall methods and data defined for the parent class an animal object weight = 120getWeight() a bird object Bird weight = 100 flySpeed = 30 getWeight() fly() - flySpeed : int + fly() : void

17. Deriving Subclasses: Syntax public class <name> extends <superclass> { } For example:class Animal { // class contents private int weight; public int getWeight() {…} } class Bird extends Animal { private int flySpeed; public void fly() {…}; }

18. Exercise: Implement Secretary

19. Improved Secretary code // A class to represent secretaries. public class Secretary extends Employee { public void prepareDoc(String text) { System.out.println(“Working on document: " + text); } } • By extending Employee, each Secretary object now: • receives methods hours, pay, vacationDays, vacationForm, toString from Employee’s definition automatically • can be treated as an Employee by client code (seen later) • Now we only write the parts unique to each type.

20. Outline • Admin and recap • Class inheritance • why and how? • inheritance and object construction

21. Inheritance and Constructor • When constructing an object, Java makes sure that the constructor of the parent is first called • If no parent constructor called, Java automatically inserts super() as the first statement in the constructor of a child class: public class Secretary extends Employee { public Secretary () { // super() is automatically inserted System.out.println(“In Secretary()”); } … }

22. Example public class Secretary extends Employee { public Secretary() { // super() is automatically inserted System.out.println(“In Secretary()”); } … } public class Employee { public Employee() { System.out.println(“In Employee()”); } … } public static void main(String[] args) { Secretary seth = new Secretary(); } Output: In Employee() In Secretary()

23. Exercise: Add Name to Employee public class Employee { private String name; public Employee(String name) { this.name = name; } … }

24. Problem with constructors • Now that we've added the constructor to the Employee class, our subclasses do not compile. • The short explanation: Once we write a constructor (that requires parameters) in the superclass, we must now write constructors for our employee subclasses as well. • The long explanation: (next couple slides)

25. The explanation • Constructors aren't inherited. • The Employee subclasses don't inherit the public Employee(String name) constructor. • After defining public Employee(String), Java sees that we have a constructor, and will no longer provide the default Employee constructor. • i.e., public Employee() is not defined unless we define it explicitly • But public Secretary() { // super() is automatically inserted but not defined // in Employee System.out.println(“In Secretary()”); }

26. super and Constructor • If you insert super(…)as the first statement in child’s constructor, Java will not insert the default parent constructor: public class Secretary extends Employee { public Secretary(String name) {super(name); System.out.println(“In Secretary()”); } … } public class Employee { private String name; public Employee(String name) { System.out.println(“In Employee()”); this.name = name; } … }

27. Example: Picture Type • Raster graphics. Basis for image processing. • Set of values. 2D array of Colorobjects (pixels). • API.

28. Exercise: Extending the Picture Type • Although the Picture class is quite useful already, it misses some useful filtering functions such as grayScale, scaling • Goal: create a new type InstaPic with all of the existing methods defined in Picture, with two additional methods: gray and scale

29. Monochrome Luminance • Monochrome luminance. Effective brightness of a color (NTSC formula):Y = 0.299r + 0.587g + 0.114b. import java.awt.Color; publicclass Luminance { publicstaticdouble lum(Color c) { int r = c.getRed(); int g = c.getGreen(); int b = c.getBlue(); return.299*r +.587*g +.114*b; } }

30. Grayscale Filter mandrill.jpg

31. Color Compatibility • Q. Which font colors will be most readable with which background colors on computer and cell phone screens? • A. Rule of thumb: difference in luminance should be  128. 255 208 105 47 28 14 publicstatic boolean compatible(Color a, Color b) { return Math.abs(lum(a)- lum(b)) >= 128.0; }

32. Scaling Filter mandrill.jpg (298-by-298)

33. Image Scaling • Goal. Shrink or enlarge an image to desired size. • Assume uniform strategy to convert from ws-by-hs to wt-by-ht: (x,y) y ? (x ws/wt, yhs/ht) target image(wt-by-ht) source image(ws-by-hs)

34. Scaling Filter • Scaling filter. Creates two Pictureobjects and two windows. % java Scale mandrill.jpg 400 200 mandrill.jpg (298-by-298)

35. Back to Law Firm: Implementing the Lawyer class: Attempt 1 // A class to represent lawyers. public class Lawyer extends Employee { public void sue() { System.out.println("I'll see you in court!"); } }

36. Problem • We want lawyers to inherit mostbehaviors from employee, but we want to replace parts with new behavior: • Lawyers get an extra week of paid vacation over base vacation (a total of 3). • Lawyers use a pink form when applying for vacation leave.

37. Defining Methods in the Child Class: Overriding Methods • A child class can (have the option to) override the definition of an inherited method in favor of its own • that is, a child can redefine a method that it inherits from its parent • the new method must have the same signature as the parent's method, but can have different code in the body • The method invoked is always the one defined in the child class, if the child class refines (overrides) a method

38. Lawyer class // A class to represent lawyers. public class Lawyer extends Employee { // overrides getVacationDays from Employee class public int vacationDays() { return 15; // 3 weeks vacation } // overrides getVacationForm from Employee class public String vacationForm() { return "pink"; } public void sue() { System.out.println("I'll see you in court!"); } }

39. Overloading deals with multiple methods in the same class with the same name but different signatures Overloading lets you define a similar operation in different ways for different data Overriding deals with two methods, one in a parent class and one in a child class, that have the same signature Overriding lets you define a similar operation in different ways for different object types Overloading vs. Overriding

40. Marketer class • Exercise: Complete the Marketer class. Marketers can advertise and make 20% more than the base ($60,000 total).

41. Marketer class // A class to represent marketers. public class Marketer extends Employee { public void advertise() { System.out.println("Act while supplies last!"); } // override public double pay() { return 60000.0; // $60,000.00 / year } } Problem of design?

42. A Problem public class Marketer extends Employee { public double pay() { return 60000.0; } ... } • Problem: The Marketer‘s salaries are based on the Employee’s base salary (20% more than base), but the pay code does not reflect this.

43. Changes to Common Behavior • Imagine a company-wide change affecting all employees. • Example: Everyone is given a $10,000 raise due to inflation. • The base employee salary is now $60,000. • Marketers should now make $72,000. • We must modify our code to reflect this policy change.

44. Modifying the superclass // A class to represent employees in general (20-page manual). public class Employee { public int hours() { return 40; // works 40 hours / week } public double pay() { return 60000.0; // $60,000.00 / year } ... } • Issue: the Marketer subclass is still incorrect. • It has overridden pay to return another value. • Requirement: derived behavior is based on base behavior

45. Calling overridden methods Subclasses can call overridden methods with super super.<method>(<parameters>) • Exercise: Modify Marketer to derive pay for marketers from base pay.

46. Improved subclasses public class Marketer extends Employee { public void advertise() { System.out.println("Act now while supplies last!"); } // override and invoke the parent’s version public double pay() { return super.pay() * 1.2; } }

47. Exercise: Revise Lawyer to Maintain Consistency

48. Solution public class Lawyer extends Employee { public String vacationForm() { return "pink"; } public int vacationDays() { return super.vacationDays() + 5; } public void sue() { System.out.println("I'll see you in court!"); } }