1. Inheritance
Chapter 5

2. Chapter 5 5.0 Inheritance Inheritance concept Access levels
Inheriting instances fields and methods
Object class and method overriding
Array of sub classes
Three-level inheritance

3. Inheritance: Terminology
There are a number of terms that you need to know in understanding inheritance.
Field : a variable that is part of a class
Method : a function that is part of a class
Constructor : a special method that is called when an object is created
Superclass : the class that is inherited from (parent class)
Subclass : the class that does the inheriting (child class)
extends : in Java the keyword extends means that a class will inherit from another class
Overload : a method is overloaded if there are two or more methods with the same name in a class. Each overloaded method has a different set of parameters. That's how you can tell which one will get called.
Override : a method is overridden if there is a method in the subclass that has the same name and the same set of parameters. The superclass method is then NOT inherited.

4. Inheritance: Concept
Object-oriented programming allows classes to inherit commonly used state and behaviour from other classes.
The idea of inheritance is simple but powerful. When you want to create a new class and there is already a class that includes some of the code that you want, you can derive your new class from the existing class.
Inheritance is a mechanism for a subclass to reuse code from a superclass.
You can reuse fields and methods of the existing class without having to write them yourself.
A mechanism that enables one class to inherit, both the behaviour and the attributes of another class.
Inheritance allows a software developer to derive a new class from an existing one.

5. Inheritance: Concept
The existing class is called the parent class, or superclass, or base class.
The derived class is called the child class or subclass.
As the name implies, the child inherits characteristics of the parent.
A subclass inherits all the members (fields, methods and nested classes) from its superclass.
Constructors are not members, so they are not inherited by subclasses but the constructors of the superclass can be invoked from the subclass.

6. Inheritance: Concept class mySuperClass
Superclass typically is-a general purpose class.
Subclass is a special case or customized version of the superclass.
When subclass is created, it inherits data and methods from its superclass.
Format for class inheritance is:
class mySuperClass
{ //data and methods for the superclass}
Subclass is usually located in its own java file.
class mySubClass extends mySuperClass
{ ….. }

7. Inheritance: Concept Employee ContractEmployee
Inheritance relationships are often shown graphically in a class diagram, with the arrow pointing to the parent class.
Inheritance should create an is-a relationship, meaning the child is more specific version of the parent
Employee
ContractEmployee

8. Inheritance: Benefit of Inheritance
Question: What are the benefits of inheritance?
State and functionality can be "shared" among objects: Inheritance reduces program development time by allowing us to reuse code. When we extend a class someone else has already built, we only need to add our changes. This is especially useful in the context of modifying code. Since all the shared code is inherited, any changes in the top level classwill be automatically propagated to all subclasses.
Substitutability/Polymorphism: A subclass can be used wherever an object of the superclassis required. An object of a single class can have multiple forms: either its own or that of one of the classes it extends.
Specialization through extension: We may easily extended a class to behave like a specialized version of the superclass.

9. Inheritance: Benefit of Inheritance
Question: What are the benefits of inheritance?
code reuse
reduce software complexity
reduces program development time

10. Inheritance: Drawback of Inheritance
Question: What are the drawbacks of inheritance?
Forces inheritance of specification, and does not check for true subtype relationship.
Subclasses are highly dependent on implementation of the superclass. Thus, "design and document for inheritance, or else prohibit it".
Inheritance forces a set of methods and fields on a class. You may not want some of these, and it is not necessary that all of these are required. There is no concept of partial inheritance.

11. Inheritance: Access Level: Variables and Methods
public
Accessible anywhere class name is accessible
protected
Accessible in the package that contains the class
Accessible in all subclasses
private
Accessible in the class only
If no access level is given:
Accessible in the package that contains the class.
Accessible in subclasses defined in the package that contains the class.
Not accessible in subclasses defined outside the package that contains the class.

12. Inheritance: Access Level: Variables and Methods
Method Visibility
Modifier Can be Accessed By
public any class
protected owning class, any subclass, any class in the same package
Private owning class
No Modifier owning class, any class in the same package

13. Inheritance: Implementation
A class diagram is a visual tool that provides you with an overview of a class.
It consists of a rectangle divided into three sections, the top section contains name of the class, middle section contains name and data types of the attributes and the bottom section contains the methods.
Employee
empNum: int
empSal: double
getEmpNum() : int
getEmpSal() : double
setEmpNum(int num) : int
setEmpSal(double sal) : double
The Employee class diagram

14. Inheritance: Implementation
Superclass: class Employee
Inheritance: Implementation
public class Employee{ //class private int empNum; //attributes private double empSal; public Employee(){ //constructor empNum=0; empSal=0.0; } public Employee(int n, double s){ //constructor empNum=n; empSal=s; public int setEmpNum(int num){ //mutator return empNum= num; public double setEmpSal(double sal){ //mutator return empSal= sal; public int getEmpNum(){ //acessor return empNum; public double getEmpSal(){ //acessor return empSal;

15. Inheritance: Implementation
You can create another class called EmployeeTerritory and provide three fields (empNum, empSal, empTerritory).
Where empNum, empSal
will be inherited from Employee
Employee
empNum: int
empSal: double
Employee()
Employee():int, double
getEmpNum(): int
getEmpSal(): double
setEmpNum(int num): int
setEmpSal(double sal): double
EmployeeTerritory
empTerritory: int
EmployeeTerritory()
EmployeeTerritory():int,double,int
getEmpTerritory(): int
setEmpTerritory(int territory): int
The figure shows the relation between Employee and the EmployeeTerritory is inheritance relationship.

16. Inheritance: Implementation
When using inheritance to create EmployeeTerritory, programmer
Save time because Employee fields and methods already exist
Reduce errors because the Employee methods have already been used and tested
Reduce the amount of learning required to use the new class
A class may be the parent for a child class and may be a child of another class. Just as with human relationships, a person is a child of some humans and a parent to others.
The syntax for deriving a child class from a parent class is:
class childClass extends parentClass
{ // new characteristics of the child class go here}

17. Inheritance: Implementation: extends
In Java, we use the reserved word extends to establish an inheritance relationship.
To instantiates the object, such as:
EmployeeTerritory AseanRep= new EmployeeTerritory();
AseanRep.getEmpNum();
AseanRep.getEmpSal();
AseanRep.getEmpTerritory();

18. Subclass: class establish an inheritance with Employee
class EmployeeTerritory extends Employee{
private int empTerritory;
public EmployeeTerritory(){
super();
empTerritory=0; }
public EmployeeTerritory(int n, double s, int num){
super(n,s);
public int getEmpTerritory(){
return empTerritory;
public int setEmpTerritory(int num){
return empTerritory=num;
establish an
inheritance with
Employee
One instance variable
Others inherited from Employee

19. Inheritance: Implementation: Proposition
Inheritance is one-way proposition; a child inherits from a parent, not the other way around. For example
Employee aClerk= new Employee();
Employee is the parent class and aClerk is an object of the parent class.
Superclass does not have access to the subclass methods. e.g:
aClerk.getEmpTerritory(); is NOT VALID
The Employee object does not have the access to EmployeeTerritory methods.
When creating the parent class, programmer does not know how many future subclasses it might have, or what their data or methods might look like.

20. Inheritance: Implementation: Constructor
When writing a program, programmer tends to forget about initialize a library component. Thus, the resources used by the element are still retained and easily end up running out of resources (memory).
This is the reason why constructor is needed.
With constructor, a special method automatically called when an object is created. That will release the memory resources when it’s no longer being used (in additional to garbage collector).
When we start a program we always initialize a field, e.g.
for(x=0; y.length() < x; x++)
Constructor works the same but instead of field it initialize the object.
With constructor, the class designer can guarantee initialization of every object.

21. Inheritance: Implementation: Constructor
What is a Constructor?
A special type of method that is called when an object is created. In Java, constructors have the same name as their class and have no return value in their declaration.
Purpose
to create an instance of a class.
Some of the differences between constructors and other Java methods:
Constructors never have an explicit return type.
Constructors cannot be directly invoked
(the keyword new must be used).
Constructors cannot be overridden, nor they are inherited.
Constructors cannot be final.
Constructors cannot be abstract.
Constructors cannot be static.

22. Inheritance: The super Reference
Accessing Superclass methods
All classes have at least one constructor. A constructor is used to initialize a new object of that type and looks like a method with the same name as the class but without a return type.
The Java constructor name is the same as the class name and is allowed multiple signatures.
When creating a class that doesn’t have constructor, Java will automatically supply a default constructor –one that never requires arguments.
When a superclass has a default constructor, you can create a subclass with or without its own constructor. However, if superclass contains only one constructor that require arguments, you must include at least one constructor for each for each subclass you create.

23. Inheritance: The super Reference
Accessing Superclass methods
Unlike members of a superclass, constructors of a superclass are not inherited by its subclasses, even though they have public visibility.
You must define a constructor for a class or use the default constructor added by the compiler.
The following statement calls the superclass’s constructor;
super();
A constructor for a child class always starts with an invocation of one of the constuctors in the parent class. If the parent class has several constructors then the one which is invoked is determined by matching argument lists.

24. Inheritance: Constructor & super Reference
Employee
idNum: int
balanceOwned: double
Customer(int id, double bal)://constructor
display(): void
RegularCustomer
discountRate: double
RegularCustomer(int id, double bal, double disR): //constructor
display(): void

25. Superclass Subclass constructor constructor
call superclass constructor

26. Application class
instantiates the object ?

27. Inheritance: The this Keyword
You can use the keyword this as the opposite of super. It refers to another constructor in the same class. If used, it must be the first line of the constructor. It refer to the current object.

28. Inheritance: The this Keyword
class Parent {
String name = "Parent"; }
class Child extends Parent {
String name = "Child";
public void print() {
System.out.println( name );
System.out.println( this.name);
System.out.println( super.name);
System.out.println( Parent.name);
System.out.println( ((Parent)this).name);
class SuperThis{
public static void main( String args[] ) {
Child whoAmI= new Child();
whoAmI.print(); ?

29. Inheritance: Method Override (replace)
A method is overridden if there is a method in the subclass that has the same name and the same set of parameters. The superclass method is then NOT inherited.
Overriding means creating a new set of method statements for the same method signature (name, number of parameters and parameter types).
Method overriding is seen when a superclass and a subclass have the same named method with the identical method inputs. It is said that the method in the subclass overrides method in the superclass.

30. Inheritance: Method Overload
Method overloading simply means that a class has several methods with the same name but different input parameters.

31. Inheritance: Example Rectangle Box Box height : double Box()
Box(double, double, double)
setDimension (double, double, double) : void
getHeight() : double
calcArea() : double
calcVolume() : double
toString() : String
Rectangle
length : double
width : double
Rectangle()
Rectangle(double, double)
setDimension (double, double): void
getLength(): double
getWidth(): double
calcArea(): double
calcPerimeter(): double
toString(): String
Rectangle
Box

32. Superclass: Rectangle
Inheritance: Example

33. Inheritance: Example Rectangle Box Box height : double Box()
Box(double, double, double)
setDimension (double, double, double): void
getHeight(): double
calcArea(): double
calcVolume(): double
toString(): String
Rectangle
Box

34. Subclass: Box

35. Inheritance: Example Output ? We need an application class. Rectangle
Box

36. Application class ?