1. Inheritance - CIS 1068 Program Design and Abstraction
Zhen Jiang
CIS Dept.
Temple University
SERC 347, Main Campus
6/19/2018

2. Table of Contents Introduction to inheritance Inheritance Syntax More!
Overridding
OOP (object-oriented programming)
Polymorphism
Modifiers
Abstract class and interfaces
GUI
6/19/2018

3. 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
6/19/2018

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
6/19/2018

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: ".
6/19/2018

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);
6/19/2018

7. Compare these two! 6/19/2018 // 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);
Compare these two!
6/19/2018

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.
6/19/2018

9. That way we would be reusing the Employee code.
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 {
<copy all the contents from Employee class>
public void takeDictation(String text) {
System.out.println("Taking dictation of text: "
+ text); }
That way we would be reusing the Employee code.
6/19/2018

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.
6/19/2018

11. Syntax Creating a subclass, general syntax: Example:
public class <subclass name> extends <superclass name>
Example:
public class Secretary extends Employee {
.... }
By extending Employee, each Secretary object automatically has a getHours, getSalary, getVacationDays, and getVacationForm method.
6/19/2018

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

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…
6/19/2018

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.
6/19/2018

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
6/19/2018

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.
6/19/2018

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")‏
6/19/2018

18. Why not just have a 22-page manual for lawyers, 21-page manual for secretaries, 23-page manual for marketers, etc…?
6/19/2018

19. maintenance: If a common rule changes, only the common manual needs to be updated.
6/19/2018

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").
6/19/2018

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;} }
overriding 2 3
PubA a = new PubA(); PubB b = new PubB(); a.setX(); b.setX(); System.out.println(a.getX()); System.out.println(b.getX());
6/19/2018

22. Why inheritance? Need for Jbutton, FlowLayout, JTextField, etc
Need for a customized response from the computer for all GUI actions
6/19/2018

23. Constructor for superclass
6/19/2018

24. 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
6/19/2018

25. 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.
6/19/2018

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
6/19/2018

27. public class Employee { private double salary = 40000.00;
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
6/19/2018

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());
6/19/2018

29. public class Employee { protected double salary = 40000.00;
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
6/19/2018

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());
6/19/2018

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
6/19/2018

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.
6/19/2018

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(); } } 1 2
ProA a = new ProA(); ProB b = new ProB(); System.out.println(a.getX()); System.out.println(b.getB());
6/19/2018

34. Polymorphism
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.
6/19/2018

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).
6/19/2018

36. Polymorphism and parameters public class EmployeeMain {
public class Secretary extends Employee { public void takeDictation(String text) { System.out.println("Taking dictation of text: " text); } }
public class Marketer extends Employee { public void advertise() { System.out.println("Act now while supplies last!"); } public double getSalary() { return ; // $50, / year } }
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 =
Polymorphism
and
parameters
6/19/2018

37. Polymorphism and arrays 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 =
Polymorphism
and
arrays
6/19/2018

38. Assume that the following four classes have been declared:
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 {
System.out.println("bar 2");
Assume that the following four classes have been declared:
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");
6/19/2018

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(); }
6/19/2018

40. 6/19/2018

41. The code produces the following output:
baz
baz 1
foo 2
foo
foo 1
bar 2
mumble 2
6/19/2018

42. Kind of override under the standard of superclass!
6/19/2018

43. 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.
6/19/2018

44. 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.
6/19/2018

45. The difference is shadow!
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;} } 1 3
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);
The difference is shadow!
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); 1 3
6/19/2018

46.
6/19/2018

47. Exercises Slide 39 PolymorphismDemo
6/19/2018

48. Modifiers
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.
6/19/2018

49. 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.
6/19/2018

50. 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.
6/19/2018

51. 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; } }
6/19/2018

52. 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 { ... }

56. 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.

57. 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.

58. 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; }

59. 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 }

60. 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!

61. 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.

62. P636

63. 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.

64. public abstract class Closedshape{ public abstract double getArea(); }
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()); } }
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 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; } }
6/19/2018

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. Neither of their methods do the same thing.
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.”);

72. 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.

73. public interface Measurable{ public abstract double getArea(); }
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()); } }
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 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;} }
6/19/2018

74. public interface Measurable{ public abstract double getArea(); }
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()); } public static void display (Measurable fig){ System.out.println(fig.getArea()); }
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 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;} }
1.5
6/19/2018

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

76. Fruit.java FruitDemo.java http://www.cis.temple.edu/~jiang/Fruit.pdf
6/19/2018

77. Explanation of interfaceor

78. GUI Window interface (p640)
JFrame
Basic components
Button
Event

79. Multiple events
Label
Text field
Layouts
Other Buttons
Color