Inheritance - CIS 1068 Program Design and Abstraction Zhen Jiang CIS Dept. Temple University 1050 Wachman Hall, Main Campus 110/9/2015

Table of Contents Introduction to inheritance Inheritance Syntax More! Overridding OOP (object-oriented programming) Polymorphism Modifiers Abstract class and interfaces GUI 210/9/2015

Introduction Write an Employee class with methods that return values for the following properties of employees at a particular company: Work week: 40 hours Annual salary: $40,000 Paid time off: 2 weeks Leave of absence form: Yellow form 310/9/2015

4 // A class to represent employees public class Employee { public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return ; // $40, / year } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } 10/9/2015

5 Write a Secretary class with methods that return values for the following properties of secretaries at a particular company: Work week: 40 hours Annual salary: $40,000 Paid time off: 2 weeks Leave of absence form: Yellow form Add a method takeDictation that takes a string as a parameter and prints out the string prefixed by "Taking dictation of text: ". 10/9/2015

6 // A class to represent secretaries public class Secretary { public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return ; // $40, / year } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } public void takeDictation(String text) { System.out.println("Taking dictation of text: " + text); } 10/9/2015

7 // A class to represent employees public class Employee { public int getHours() { return 40; } public double getSalary() { return ; } public int getVacationDays() { return 10; } public String getVacationForm() { return "yellow"; } // A class to represent secretaries public class Secretary { public int getHours() { return 40; } public double getSalary() { return ; } public int getVacationDays() { return 10; } public String getVacationForm() { return "yellow"; } public void takeDictation(String text) { System.out.println("Taking dictation of text: " + text); } 10/9/2015

8 Inheritance: Is-a relationship is-a relationship: A hierarchical connection where one category can be treated as a specialized version of another. Examples: Every secretary is an employee. Every square is a rectangle. Every dog is a mammal. 10/9/2015

9 code reuse: The practice of writing program code once and using it in many contexts. We'd like to be able to say the following: // A class to represent secretaries public class Secretary { public void takeDictation(String text) { System.out.println("Taking dictation of text: " + text); } } That way we would be reusing the Employee code. 10/9/2015

10 inheritance: A way to specify a relationship between two classes where one class inherits the state and behavior of another. The child class (also called subclass) inherits from the parent class (also called superclass). The subclass receives a copy of every field and method from the superclass. 10/9/2015

11 Syntax Creating a subclass, general syntax: public class extends Example: public class Secretary extends Employee {.... } By extending Employee, each Secretary object automatically has a getHours, getSalary, getVacationDays, and getVacationForm method. 10/9/2015

12 // A class to represent secretaries public class Secretary extends Employee { public void takeDictation(String text) { System.out.println("Taking dictation of text: " + text); } 10/9/2015 Improved Secretary class:

13 Writing even more classes Write a Marketer class that represents marketers who have the same properties as general employees, but instead of making only a paltry $40,000, marketers make $50,000! Can we still leverage the Employee class or do we have to re-write everything, because one method ( getSalary ) is different? If only Marketer could write a new version of the getSalary method, but inherit everything else… 10/9/2015

14 Overriding methods override: To write a new version of a method in a subclass to replace the superclass's version. To override a superclass method, just write a new version of it in the subclass. This will replace the inherited version. 10/9/2015

15 Marketer class // A class to represent marketers public class Marketer extends Employee { public void advertise() { System.out.println("Act now while supplies last!"); } public double getSalary() { return ; // $50, / year } 10/9/2015

16 OOP: Based in reality or too convenient? At many companies, all new employees attend a common orientation to learn general rules (e.g., what forms to fill out when). Each person receives a big manual of these rules. Each employee also attends a subdivision-specific orientation to learn rules specific to their subdivision (e.g., marketing department). Everyone receives a smaller manual of these rules. 10/9/2015

17 The smaller manual adds some rules and also changes (read: overrides) some rules from the large manual (e.g., "use the pink form instead of the yellow form")‏ 10/9/2015

18 Why not just have a 22-page manual for lawyers, 21-page manual for secretaries, 23-page manual for marketers, etc…? 10/9/2015

19 maintenance: If a common rule changes, only the common manual needs to be updated. 10/9/2015

20 The 20 page manual manner is useful to be able to specify general rules that will apply to many groups. Locality A person can look at the manual for lawyers and quickly discover all rules that are specific to lawyers. It is also useful to specify a smaller set of rules for such a particular group, including being able to replace rules from the overall set (overriding, e.g., "use the pink form instead of the yellow form"). 10/9/2015

21 //base class public class PubA { public int x = 1; public void setX(){ x=2; } public int getX(){ return x; } } //attribute & method inheritance public class PubB extends PubA { public void setX(){ x=3;} } PubA a = new PubA(); PubB b = new PubB(); a.setX(); b.setX(); System.out.println(a.getX()); System.out.println(b.getX());

10/9/ Why inheritance? Need for Jbutton, FlowLayout, JTextField, etc Need for a customized response from the computer for all GUI actions

10/9/ Constructor for superclass

public class Employee { private double salary; public Employee(double initialSalary) { salary = initialSalary; } public int getHours() { return 40; // 40 hours per week } public double getSalary() { return salary; } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } 2410/9/2015

Use the super() method to call the superclass’s constructor public class Marketer extends Employee { // inherits double salary public Marketer(double initialSalary) { //construct superclass super(initialSalary); } - For every constructor of a subclass, the call to super() must be the first statement in the subclass’s constructor. - Make sure to give the same number of arguments as there are parameters in the definition of the superclass’s constructor. 10/9/201525

26 Question: If a method is declared private, does a subclass inherit it? Actually, yes. Subclasses inherit everything that they don’t override. If a method is declared private, can a subclass call it? NO! Only code inside the same class can call a private method. What if you want a subclass to be able to use it? Use the protected access level 10/9/2015

27 public class Employee { private double salary = ; public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return salary; } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } 10/9/2015

28 Subclasses cannot see salary directly! public class CEO extends Employee { public void giveMyselfRaise() { salary += ;// Compile-time Error! } public static void main(String [] args) { CEO c = new CEO(); // This is fine, no error here // Access to salary field is indirect // We’re accessing the public getSalary() method System.out.println(“My salary is “ + c.getSalary()); } 10/9/2015

29 public class Employee { protected double salary = ; public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return salary; } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } 10/9/2015

30 Subclasses can see protected variables and methods just fine. public class CEO extends Employee { public void giveMyselfRaise() { salary += ;// No longer an error } public static void main(String [] args) { CEO c = new CEO(); // This is fine, no error here // Access to salary field is indirect // We’re accessing the public getSalary() method System.out.println(“My salary is “ + c.getSalary()); } 10/9/2015

31 What would happen if.... public class Employee { private double salary = ; public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return salary; } public void addToSalary(double raise) { salary += raise; } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } 10/9/2015

32 public class CEO extends Employee { public void giveMyselfRaise() { addToSalary( ); } } CEO still has its own copy of the salary field, and this code will change the value of it appropriately. The fact that salary is private simply means that CEO can't access it directly. It can still call public (or protected) superclass methods that can access it. 10/9/2015

33 //base class public class ProA { private int x = 1; protected void setX(int a){ x=a; } protected int getX(){ return x; } } //sub class public class ProB extends ProA { public int getB(){ setX(2); // your next step is to return x // but “return x” does not work // due to the private modifier, so return getX(); } } ProA a = new ProA(); ProB b = new ProB(); System.out.println(a.getX()); System.out.println(b.getB());

34 A reference variable of type T can refer to an object of any subclass of T. Employee Laura = new Lawyer(); Employee Mark = new Marketer(); polymorphism: The ability for the same code to be used with several different types of objects and behave differently depending on the type of object used. 10/9/2015 Polymorphism

35 Employee Laura = new Lawyer(); System.out.println(Laura.getSalary()); // System.out.println(Laura.getVacationForm()); // "pink" You can call any method from Employee on the person variable, but not any method specific to Lawyer (such as sue ). Once a method is called on that object, it behaves in its normal, overridden way (as a Lawyer, not as a normal Employee ). 10/9/2015

36 public class EmployeeMain { public static void main(String[] args) { Secretary laura = new Secretary(); Marketer mark = new Marketer(); printInfo(laura); printInfo(mark); } public static void printInfo(Employee empl) { System.out.println("salary = " + empl.getSalary()); System.out.println("days = " + empl.getVacationDays()); System.out.println("form = " + empl.getVacationForm()); System.out.println(); } } Output: salary = vacation days = 10 vacation form = yellow salary = vacation days = 10 vacation form = yellow 10/9/2015 Polymorphism and parameters public class Marketer extends Employee { public void advertise() { System.out.println("Act now while supplies last!"); } public double getSalary() { return ; // $50, / year } } public class Secretary extends Employee { public void takeDictation(String text) { System.out.println("Taking dictation of text: " + text); } }

37 public class EmployeeMain2 { public static void main(String[] args) { Employee[] employees = {new Secretary(), new Marketer() }; for (int i = 0; i < employees.length; i++) { System.out.println("salary = " + employees[i].getSalary()); System.out.println("vacation days = " + employees[i].getVacationDays()); System.out.println(); } } } Output: salary = vacation days = 10 salary = vacation days = 10 10/9/2015 Polymorphism and arrays

38 Exercises public class Foo { public void method1() { System.out.println("foo 1"); } public void method2() { System.out.println("foo 2"); } public String toString() { return "foo"; } public class Bar extends Foo { public void method2() { System.out.println("bar 2"); } public class Baz extends Foo { public void method1() { System.out.println("baz 1"); } public String toString() { return "baz"; } public class Mumble extends Baz { public void method2() { System.out.println("mumble 2"); } Assume that the following four classes have been declared: 10/9/2015

39 What would be the output of the following client code? Foo[] pity = { new Baz(), new Bar(), new Mumble(), new Foo() }; for (int i = 0; i < pity.length; i++) { System.out.println(pity[i]); pity[i].method1(); pity[i].method2(); System.out.println(); } 10/9/2015

4010/9/2015

41 The code produces the following output: baz baz 1 foo 2 foo foo 1 bar 2 baz baz 1 mumble 2 foo foo 1 foo 2 10/9/2015

Kind of override under the standard of superclass! 10/9/201542

Variable Shadowing: Something to avoid!! Polymorphism applies to methods in Java But not to fields! public class A { int x = 1; int method() { return 1; } } public class B extends A { int x = 2; int method() { return 2; } } A a1 = new A(); A a2 = new B(); System.out.println(a1.method()); // prints 1 System.out.println(a2.method()); // prints 2 System.out.println(a1.x); // prints 1 System.out.println(a2.x); // prints 1 still! // Not like method, which prefers to its own. 10/9/201543

Variable Shadowing: When a class extends another class and defines a field with the same name, each object of the subclass contains two fields with that name. The supclass’s version of the field is said to shadow the subclass’s version, making the subclass’s version invisible within that class. This is called variable shadowing. 10/9/201544

10/9/ public class A { protected int x = 1; protected void setX(int a){ x=a; } protected int getX(){ return x;} } public class B extends A { protected int x = 3; public int getX(){ return x; } public int getB(){ return x;} } A a = new A(); B b = new B(); System.out.println(a.getX()); System.out.println(b.getX()); System.out.println(b.getB()); System.out.println(a.x); System.out.println(b.x); A a = new A(); A b = new B(); System.out.println(a.getX()); System.out.println(b.getX()); //System.out.println(b.getB()); System.out.println(a.x); System.out.println(b.x);

10/9/201546

Exercises Slide 39 PolymorphismDemo o.pdf o.pdf /9/201547

Public A class, method, constructor, interface etc declared public can be accessed from any other class. Therefore fields, methods, blocks declared inside a public class can be accessed from any class belonging to the Java Universe. Because of class inheritance, all public methods and variables of a class are inherited by its subclasses. Modifiers 10/9/201548

10/9/ Private Methods, Variables and Constructors that are declared private can only be accessed within the declared class itself. Private access modifier is the most restrictive access level. Class and interfaces cannot be private. Variables that are declared private can be accessed outside the class only if public accessor methods are present in the class.

10/9/ Protected Variables, methods and constructors which are declared protected in a superclass can be accessed only by the subclasses. Protected access gives the subclass a chance to use the helper method or variable, while preventing a nonrelated class from trying to use it.

10/9/ Default (like public) Default access modifier means we do not explicitly declare an access modifier for a class, field, method etc. A variable or method declared without any access control modifier is available to any other class in the same package. For example: public class Logger { String format; String getFormat() { return this.format; } public void setFormat(String f) { format = f; } }

Abstract and Interfaces What have you learnt from the above exercises on “extends”? Is it good to block the use of subclass method that is not declared in super class? Good, because methods can be in template. In the security control, no leakage! Is it good to have the direct access of attribute? Better not, if it is not in your control. See how complicate it is in the variable shadowing.

53 Suppose we’ve defined an Employee class, and we don’t want someone to come along and muck it up E.g., we don’t want a CEO subclass that gives itself a raise The final keyword indicates that some definition (of a class, method, or field) cannot be changed or overridden by a subclass.

54 final Example // A class to represent employees public class Employee { public int getHours() { return 40; // works 40 hours / week } public final double getSalary() { return ; // $40, / year } public int getVacationDays() { return 10; // 2 weeks' paid vacation } public String getVacationForm() { return "yellow"; // use the yellow form } No subclass is allowed to change the definition of getSalary()!

55 final fields, methods, and classes The final keyword can be applied to fields (as we’ve seen before): // no code may change the value of salary, //including a subclass’s code public final double salary = ; Or to methods: // subclasses cannot override the getSalary method public final double getSalary() { return salary; } Or even to classes: // the Employee class cannot be extended // It can’t have any subclasses at all! public final class Employee {... }

Opposite of final The final keyword prevents subclasses from changing (overriding) code Sometimes, you want to do the opposite: Force another programmer or piece of code to finish parts of a class.

Example: Employee salary Let’s say you want every subclass of Employee to have a salary, but you want the subclass to decide what the salary should be. We can define an “abstract” getSalary() method: public abstract double getSalary(); Note: no method definition! Abstract method declarations don’t provide definitions, just signatures. They are there to force subclasses to provide the definitions.

Abstract Rules (1) If a class has an abstract method, or it inherits an abstract method that it doesn’t override, then the class must be declared abstract. public abstract class Employee { public abstract double getSalary(); // you can mix abstract and non-abstract methods // in an abstract class public int getHours() { // Note: not abstract! return 40; }

Abstract Rules (2) If a class is abstract, it can’t have a constructor.  No Employee object can be constructed  But you can declare Employee references. public abstract class Employee { public abstract double getSalary(); public static void main(String [] args) { Employee e;// NO ERROR: reference is fine e = new Employee(); // ERROR! No constructor }

Extending an abstract class public class Lawyer extends Employee { // since Employee declares an abstract getSalary, // Lawyer must define getSalary by overriding it // or else Lawyer must be an abstract class public double getSalary() { return ; } public static void main(String [] args) { Employee e;// Fine, no problem e = new Lawyer(); // Also fine (polymorphism) e = new Employee(); // ERROR! No constructor! }

Abstract classes: what’s the point? If you can’t construct objects for a class, what’s the point of the class? How can we use it? Short Answer: polymorphism. We can use references of type Employee as a place to store Lawyers, Secretaries, CEOs, etc. Because getSalary() is declared in Employee, e.getSalary() is legal syntax, even though getSalary() is not defined in Employee.

P636 I/abstract.html

Exercise Create an abstract ClosedShape class with an abstract getArea() method Write non-abstract subclasses Rectangle and Circle Write main methods for each that construct an object and print its area. Do not use attribute to store area information.

10/9/ public abstract class Closedshape{ public abstract double getArea(); } public class Rectangle extends Closedshape{ private int length=0; private int width=0; public Rectangle(int l, int w){ length=l; width=w; } public double getArea (){ return length*width; } } public class Circle extends Closedshape{ private double radius; public Circle (double r){ radius = r; } public double getArea (){ return Math.PI*radius*radius; } public double getCircumference(){ return radius; } } public class shapeApp { public static void main(String [] args){ Rectangle r = new Rectangle(2, 3); Circle c = new Circle(1.5); System.out.println(r.getArea()); System.out.println(c.getArea()); } }

65 Going full abstract What if our abstract class had no non- abstract methods? public abstract class Employee { public abstract double getSalary(); public abstract int getHours(); public abstract String getVacationForm(); } Each subclass would have different definitions. They share only the names of their methods. Java has an alternative way to do this: interfaces

66 Interfaces Let's say you have the following two related classes: public class Scientist { public void discover() { System.out.println(“Eureka! I have found it!“); } public void publish() { System.out.println(“My research is better than yours.”); } public class Engineer { public void discover() { System.out.println(“Cool, what did I just do?“); } public void publish() { System.out.println(“I don't know how this happened, but it works.”); } Neither of their methods do the same thing.

67 Code Reuse But they're still similar – they both discover and publish. Can we get code reuse? interface Researcher { void discover(); void publish(); } Now we can create Researcher references

68 Using Interface Objects public static void researchCycle(Researcher r) { r.discover(); r.publish(); } public static void main(String [] args) { Researcher researcher1 = new Scientist(); Researcher researcher2 = new Engineer(); // Interfaces have no constructors // They can only be used as types for references researcher2 = new Researcher(); // ERROR! researchCycle(researcher1); researchCycle(researcher2); }

69 Using Interfaces Interfaces are a way of specifying what objects are capable of, without saying how. Interface variables can execute any of the methods listed in the interface, but the behavior depends on the class of the object That is, interface variables are polymorphic. There are no constructors for interfaces. They are not classes, and no objects of that run-time type are created. They are compile-time types for references.

70 Implementing Interfaces public class Scientist implements Researcher { public void discover() { System.out.println(“Eureka! I have found it!“); } public void publish() { System.out.println(“My research is better than yours.”); }

71 public class Engineer implements Researcher { public void discover() { System.out.println(“Whoa, what did I just do?“); } public void publish() { System.out.println(“I don't know how this happened, but it works.”); }

Exercise Create an interface Measurable class with an non-abstract getArea() method Write subclasses Rectangle and Circle to implement the above interface Write main methods for each that construct an object and print its area. Do not use attribute to store area information.

10/9/ public interface Measurable{ public abstract double getArea(); } public class Rectangle implements Measurable{ private int length=0; private int width=0; public Rectangle(int l, int w){ length=l; width=w; } public double getArea (){ return length*width;} } public class Circle implements Measurable{ private double radius; public Circle (double r){ radius = r; } public double getArea (){ return Math.PI*radius*radius; } public double getCircumference(){ return radius; } } public class shapeApp { public static void main(String [] args){ Rectangle r = new Rectangle(2, 3); Circle c = new Circle(1.5); System.out.println(r.getArea()); System.out.println(c.getArea()); } }

10/9/ public interface Measurable{ public abstract double getArea(); } public class Rectangle implements Measurable{ private int length=0; private int width=0; public Rectangle(int l, int w){ length=l; width=w; } public double getArea (){ return length*width;} } public class Circle implements Measurable{ private double radius; public Circle (double r){ radius = r; } public double getArea (){ return Math.PI*radius*radius; } public double getCircumference(){ return radius; } } public class shapeApp { public static void main(String [] args){ // Rectangle r = new Rectangle(2, 3); // Circle c = new Circle(1.5); // System.out.println(r.getArea()); // System.out.println(c.getArea()); Measurable r = new Rectangle(2, 3); //polymorphism display(r); Circle c = new Circle(1.5); Measurable m = c; display(m); // (m.getCircumference()); not allowed Circle t = (Circle) m; System.out.println(t.getCircumference()); }

Comparable interface Define the Comparable interface public interface Comparable { public int compareTo(Object other); } public interface Comparable { public int compareTo(T other); } Return a comparable value!

Fruit.java FruitDemo.java mo.pdf mo.pdf 10/9/201576

Explanation of interface P612 or ncepts/interface.html

GUI Window interface (p640) JFrame Basic components Button Event

Multiple events Label Text field Layouts Other Buttons Color