Inheritance - CIS 1068 Program Design and Abstraction

Inheritance - CIS 1068 Program Design and Abstraction

Zhen Jiang

CIS Dept.

Temple University

1050 Wachman Hall, Main Campus

Email: [email protected]/21/23

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

204/21/23

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

304/21/23

4

// A class to represent employeespublic class Employee { public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return 40000.0; // $40,000.00 / year } public int getVacationDays() { return 10; // 2 weeks' paid vacation }

public String getVacationForm() { return "yellow"; // use the yellow form }}

04/21/23

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: ".

04/21/23

6

// A class to represent secretariespublic class Secretary { public int getHours() { return 40; // works 40 hours / week } public double getSalary() { return 40000.0; // $40,000.00 / 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); }}

04/21/23

7

// A class to represent employeespublic class Employee { public int getHours() { return 40; } public double getSalary() { return 40000.0; } public int getVacationDays() { return 10; }

public String getVacationForm() { return "yellow"; }}

// A class to represent secretariespublic class Secretary { public int getHours() { return 40; } public double getSalary() { return 40000.0; } public int getVacationDays() { return 10; }

public String getVacationForm() { return "yellow"; } public void takeDictation(String text) { System.out.println("Taking dictation of text: " + text); }}

04/21/23

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.

04/21/23

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 secretariespublic 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.04/21/23

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.

04/21/23

11

Syntax

Creating a subclass, general syntax: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.04/21/23

12

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

04/21/23

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…04/21/23

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.

04/21/23

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 50000.0; // $50,000.00 / year

}

}

04/21/23

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.

04/21/23

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")

04/21/23

18

Why not just have a 22-page manual for lawyers, 21-page manual for secretaries, 23-page manual for marketers, etc…?

04/21/23

19

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

04/21/23

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").

04/21/23

04/21/23 21

//base classpublic class PubA { public int x = 1; public void setX(){ x=2; } public int getX(){ return x; }}

//attribute & method inheritancepublic 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());

04/21/23 22

Why inheritance? Need for Jbutton, FlowLayout, JTextField, etc

http://www.cis.temple.edu/~jiang/Extend_action.pdf

Need for a customized response from the computer for all GUI actions http://www.cis.temple.edu/~jiang/

MultiEventSource.pdf

04/21/23 23

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

2404/21/23

Use the super() method to call the superclass’s constructor

public class Marketer extends Employee {// inherits double salary

public Marketer(double initialSalary){

//construct superclasssuper(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.

04/21/23 25

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 level04/21/23

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 }


04/21/23

28

Subclasses cannot see salary directly!public class CEO extends Employee {

public void giveMyselfRaise() {

salary += 1000000.00; // 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() methodSystem.out.println(“My salary is “ + c.getSalary());

}}

04/21/23

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 }


04/21/23

30

Subclasses can see protected variables and methods just fine.

public class CEO extends Employee { public void giveMyselfRaise() { salary += 1000000.00; // 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() methodSystem.out.println(“My salary is “ +

c.getSalary());}

}04/21/23

31

What would happen if ....public class Employee { private double salary = 40000.00;

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 }


04/21/23

32

public class CEO extends Employee {

public void giveMyselfRaise() {

addToSalary(1000000.00);

}}

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.

04/21/23

04/21/23 33

//base classpublic class ProA { private int x = 1; protected void setX(int a){ x=a; }

protected int getX(){ return x; }}

//sub classpublic 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.

04/21/23

Polymorphism

35

Employee Laura = new Lawyer();

System.out.println(Laura.getSalary()); // 40000.0

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

04/21/23

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 = 40000.0vacation days = 10vacation form = yellow

salary = 50000.0vacation days = 10vacation form = yellow

04/21/23

Polymorphism and

parameters

public class Marketer extends Employee { public void advertise() { System.out.println("Act now while supplies last!"); }

public double getSalary() { return 50000.0; // $50,000.00 / 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 = 40000.0vacation days = 10

salary = 50000.0vacation days = 10

04/21/23

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:

04/21/23

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();}

04/21/23

4004/21/23

41

The code produces the following output:

bazbaz 1foo 2

foofoo 1bar 2

bazbaz 1mumble 2

foofoo 1foo 2

04/21/23

Kind of override under the standard of superclass!

04/21/23 42

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 1System.out.println(a2.method()); // prints 2

System.out.println(a1.x); // prints 1System.out.println(a2.x); // prints 1 still! // Not like method, which prefers to its own.

04/21/23 43

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.

04/21/23 44

04/21/23 45

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);

http://www.cis.temple.edu/~jiang/1068_modifier_inheritance.pdf

04/21/23 46

Exercises Slide 39 PolymorphismDemo

www.cis.temple.edu/~jiang/PolymorphismDemo.pdf

www.cis.temple.edu/~jiang/Person.pdf www.cis.temple.edu/~jiang/Student.pdf www.cis.temple.edu/~jiang/

Undergradaute.pdf

04/21/23 47

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

04/21/23 48

04/21/23 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.

04/21/23 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.

04/21/23 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; }}

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 employeespublic class Employee { public int getHours() { return 40; // works 40 hours / week } public final double getSalary() { return 40000.0; // $40,000.00 / 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 = 40000.0;

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 {


// 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 static void main(String [] args) {

Employee e; // NO ERROR: reference is fine

e = new Employee(); // ERROR! No constructor

}

}

Extending an abstract classpublic 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 45000.0;

}

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.

P636http://docs.oracle.com/javase/tutorial/

java/IandI/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.

04/21/23 64

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());}}6.07.0685834705770345

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.

04/21/23 73

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 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());}}6.07.0685834705770345

04/21/23 74

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 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());}6.07.06858347057703451.5

Comparable interface Define the Comparable interfacepublic interface Comparable {

public int compareTo(Object other);

}

public interface Comparable<T> {

public int compareTo(T other);

}

Return a comparable value!

Fruit.java http://www.cis.temple.edu/~jiang/

Fruit.pdf FruitDemo.java

http://www.cis.temple.edu/~jiang/FruitDemo.pdf

04/21/23 76

Explanation of interface P612 or

http://docs.oracle.com/javase/tutorial/java/concepts/interface.html

GUI Window interface (p640)

www.cis.temple.edu/~jiang/ShowButtonDemo.pdf

www.cis.temple.edu/~jiang/BuktoonDemo.pdf

JFrame Basic components

Button Event

Multiple events Label Text field Layouts Other Buttons Color

Inheritance - CIS 1068 Program Design and Abstraction

Documents

Transcript of Inheritance - CIS 1068 Program Design and Abstraction