Download public double getSalary()

Inheritance - CIS 1068
Program Design and Abstraction
Zhen Jiang
CIS Dept.
Temple University
SERC 347, Main Campus
Email: [email protected]
4/30/2017
1
Table of Contents










Introduction to inheritance
Inheritance
Syntax
More!
Overridding
OOP (object-oriented programming)
Polymorphism
Modifiers
Abstract class and interfaces
GUI
4/30/2017
2
Introduction

Write an Employee class with methods that
return values for the following properties of
employees at a particular company:




4/30/2017
Work week: 40 hours
Annual salary: $40,000
Paid time off: 2 weeks
Leave of absence form: Yellow form
3
// A class to represent employees
public 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
}
}
4/30/2017
4

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: ".
4/30/2017
5
// A class to represent secretaries
public 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);
}
}
4/30/2017
6
// A class to represent employees
public class Employee {
public int getHours() {
return 40;
}
// A class to represent secretaries
public class Secretary {
public int getHours() {
return 40;
}
public double getSalary() {
return 40000.0;
}
public double getSalary() {
return 40000.0;
}
public int getVacationDays() {
return 10;
}
public int getVacationDays() {
return 10;
}
public String getVacationForm() {
return "yellow";
}
public String getVacationForm() {
return "yellow";
}
}
public void takeDictation(String text) {
System.out.println("Taking dictation of text: "
+ text);
}
}
4/30/2017
7
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.
4/30/2017
8

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.
4/30/2017
9



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.
4/30/2017
10
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.
4/30/2017
11

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);
}
}
4/30/2017
12
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…
4/30/2017
13
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.
4/30/2017
14
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
}
}
4/30/2017
15
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.
4/30/2017
16

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")
4/30/2017
17

Why not just have a 22-page manual for lawyers,
21-page manual for secretaries, 23-page manual for
marketers, etc…?
4/30/2017
18

maintenance: If a common rule changes, only the
common manual needs to be updated.
4/30/2017
19


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").
4/30/2017
20
//base class
public class PubA {
public int x = 1;
public void setX(){
x=2;
}
public int getX(){
return x;
}
}
4/30/2017
//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());
21
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
4/30/2017
22
Constructor for superclass
4/30/2017
23
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
}
}
4/30/2017
24
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.
4/30/2017
25

Question: If a method is declared private, does a
subclass inherit it?


If a method is declared private, can a subclass
call it?


Actually, yes. Subclasses inherit everything that they
don’t override.
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
4/30/2017
26
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
}
4/30/2017
27

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() method
System.out.println(“My salary is “ + c.getSalary());
}
4/30/2017
28
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
}
4/30/2017
29

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() method
System.out.println(“My salary is “ + c.getSalary());
}
4/30/2017
30
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
}
}
public String getVacationForm() {
return "yellow";
// use the yellow form
}
4/30/2017
31
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.
4/30/2017
32
//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());
4/30/2017
33
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.
4/30/2017
34
Employee Laura = new Lawyer();
System.out.println(Laura.getSalary());
System.out.println(Laura.getVacationForm());


// 40000.0
// "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).
4/30/2017
35
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 50000.0; // $50,000.00 / year
}
}
public class EmployeeMain {
public static void main(String[] args) {
Secretary laura = new Secretary();
Marketer mark = new Marketer();
printInfo(laura);
printInfo(mark);
}
}
Polymorphism
and
parameters
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.0
vacation days = 10
vacation form = yellow
salary = 50000.0
vacation days = 10
vacation form = yellow
4/30/2017
36
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.0
vacation days = 10
Polymorphism
and
arrays
salary = 50000.0
vacation days = 10
4/30/2017
37
Exercises

Assume that the following four classes have been declared:
public class Foo {
public void method1() {
System.out.println("foo 1");
}
public class Baz extends Foo {
public void method1() {
System.out.println("baz 1");
}
public void method2() {
System.out.println("foo 2");
}
public String toString() {
return "baz";
}
}
public String toString() {
return "foo";
}
}
public class Bar extends Foo {
public void method2() {
System.out.println("bar 2");
}
}
4/30/2017
public class Mumble extends Baz {
public void method2() {
System.out.println("mumble 2");
}
}
38

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();
}
4/30/2017
39
4/30/2017
40

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
4/30/2017
41

Kind of override under the standard of
superclass!
4/30/2017
42
Variable Shadowing:
Something to avoid!!

Polymorphism applies to methods in Java

But not to fields!
public class A
int x = 1;
int method()
}
public class B
int x = 2;
int method()
}
4/30/2017
{
{ return 1; }
extends A {
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.
{ return 2; }
43

Variable Shadowing:



4/30/2017
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.
44
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;}
}
4/30/2017
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);
45

http://www.cis.temple.edu/~jiang/1068_modifier_inheritance.pdf
4/30/2017
46

Exercises


Slide 39
PolymorphismDemo




4/30/2017
www.cis.temple.edu/~jiang/PolymorphismDem
o.pdf
www.cis.temple.edu/~jiang/Person.pdf
www.cis.temple.edu/~jiang/Student.pdf
www.cis.temple.edu/~jiang/Undergradaute.pdf
47
Modifiers

Public


4/30/2017
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.
48

Private



4/30/2017
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.
49

Protected


4/30/2017
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.
50

Default (like public)



4/30/2017
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; }
}
51
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.

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.
53
final Example
// A class to represent employees
public 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()!
54
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 { ... }
55
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();

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 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.
P636
http://docs.oracle.com/javase/tutorial/java/Iand
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.
public abstract class Closedshape{
public abstract double 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 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.0
7.0685834705770345
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; }
4/30/2017
}
64
Going full abstract

What if our abstract class had no nonabstract 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
65
Interfaces
Let's say you have the following two
related classes:
public class Scientist {
public class Engineer {

public void discover() {
System.out.println(“Eureka!
have found it!“);
}
I
public void publish() {
System.out.println(“My
research is better than yours.”);
}
}

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.
66
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
67
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);
}
68
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.
69
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.”);
}
}
70
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.”);
}
}
71
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.
public interface Measurable{
public abstract double 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 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.0
7.0685834705770345
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;}
4/30/2017
}
73
public interface Measurable{
public abstract double getArea(); }
public class shapeApp {
public static void main(String [] args){
// Rectangle r = new Rectangle(2, 3);
public class Circle implements Measurable{ // Circle c = new Circle(1.5);
private double radius;
// System.out.println(r.getArea());
public Circle (double r){
// System.out.println(c.getArea());
radius = r; }
Measurable r = new Rectangle(2, 3);
//polymorphism
public double getArea (){
display(r);
return Math.PI*radius*radius; }
Circle c = new Circle(1.5);
Measurable m = c;
public double getCircumference(){
display(m);
return radius; }
// (m.getCircumference()); not allowed
}
Circle t = (Circle) m;
System.out.println(t.getCircumference());
public class Rectangle implements Measurable{
}
private int length=0;
public static void display (Measurable fig){
private int width=0;
System.out.println(fig.getArea());
public Rectangle(int l, int w){
}
length=l;
width=w; }
6.0
7.0685834705770345
public double getArea (){
1.5
return length*width;}
4/30/2017
74
}
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!

Fruit.java


http://www.cis.temple.edu/~jiang/Fruit.pdf
FruitDemo.java

4/30/2017
http://www.cis.temple.edu/~jiang/FruitDe
mo.pdf
76

Explanation of interface


P612
or
http://docs.oracle.com/javase/tutorial/java/co
ncepts/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