Object oriented programming inheritance

Programming in C#
Inheritance and Polymorphism
Renas R. Rekany
2018

Inheritance
▪ Inheritance allows a software developer to derive a new
class from an existing one.
▪ The existing class is called the parent, super, or base class.
▪ The derived class is called a child or subclass.
▪ The child inherits characteristics of the parent.
▪ Methods and data defined for the parent class.
▪ The child has special rights to the parents methods and data.
▪ Public access like anyone else
▪ Protected access available only to child classes.
▪ The child has its own unique behaviors and data.

Inheritance
▪ Inheritance relationships
are often shown
graphically in a class
diagram, with the arrow
pointing to the parent
class.
▪ Inheritance should create a
relationship, meaning the
child is a more specific
version of the parent.
Animal
Bird

Declaring a Derived Class
▪ Define a new class DerivedClass which extends
BaseClass
class BaseClass
{
// class contents
}
class DerivedClass : BaseClass
{
// class contents
}

Controlling Inheritance
▪ A child class inherits the methods and data defined for the
parent class; however, whether a data or method member of
a parent class is accessible in the child class depends on the
visibility modifier of a member.
▪ Variables and methods declared with private visibility are
not accessible in the child class
▪ However, a private data member defined in the parent class is still
part of the state of a derived class.
▪ Variables and methods declared with public visibility are
accessible; but public variables violate our goal of
encapsulation
▪ There is a third visibility modifier that helps in inheritance
situations: protected.

Inheritance
class color
{ public color() {MessageBox.Show("color"); }
public void fill(string s) { (Messagebox.Show(s); }
}
class green : color
{ public green() {MessageBox.Show ("green"); } }
private void button1_Click(object sender, EventArgs e)
{ green g = new green();
g.fill("red");
}

Inheritance
class animal
{ public animal() {MessageBox.Show("animal"); }
public void talk() {MessageBox.Show("animal talk"); }
public void greet() {MessageBox.Show("animal say hello"); } }
class dog : animal
{ public dog() {MessageBox.Show("dog"); }
public void sing() {MessageBox.Show("dog can sing"); } }
{ animal a = new animal();
a.talk();
a.greet();
dog d = new dog();
d.sing();
d.talk();
d.greet();
}

Notes about Inheritance
➢ Constructor can't be inheritance, they just invoked.
➢ First call base then derived
➢ Destructor can't be inheritance they just invoked.
➢ First call derived then base

Example
➢ Calculation
Add, Sub
➢ Calculation2
Mult, Div
Calculation1
Calculation2

Inheritance
class animal
{ public animal() {MessageBox.Show("animal"); }
public void talk() {MessageBox.Show("animal talk"); }
public void greet() {MessageBox.Show("animal say hello"); }
~animal() {MessageBox.Show("animal Destructor"); } }
class dog : animal
{ public dog() {MessageBox.Show("dog"); }
public void sing() {MessageBox.Show("dog can sing"); }
~dog() {MessageBox.Show("dog Destructor"); } }
{ animal a = new animal();
a.talk();
a.greet();
dog d = new dog();
d.sing();
d.talk();
d.greet(); }

Examples:
Base Classes and Derived Classes

Examples:
Base Classes and Derived Classes
Base class Derived classes
Student GraduateStudent
UndergraduateStudent
Shape Circle
Triangle
Rectangle
Loan CarLoan
HomeImprovementLoan
MortgageLoan
Employee FacultyMember
StaffMember
Account CheckingAccount
SavingsAccount

Single Inheritance
▪ Some languages, e.g., C++, allow Multiple
inheritance, which allows a class to be
derived from two or more classes, inheriting
the members of all parents.
▪ C# and Java support single inheritance,
meaning that a derived class can have only
one parent class.

Class Hierarchies
▪ A child class of one parent can be the parent
of another child, forming a class hierarchy
Animal
Reptile Bird Mammal
Snake Lizard BatHorseParrot

Class Hierarchies
CommunityMember
Employee Student Alumnus
Faculty Staff
Professor Instructor
GraduateUnder

Class Hierarchies
Shape
TwoDimensionalShape ThreeDimensionalShape
Sphere Cube CylinderTriangleSquareCircle

Class Hierarchies
▪ An inherited member is continually passed
down the line
▪ Inheritance is transitive.
▪ Good class design puts all common features
as high in the hierarchy as is reasonable.
Avoids redundant code.

References and Inheritance
▪ An object reference can refer to an object of its
class, or to an object of any class derived from it by
inheritance.
▪ For example, if the Holiday class is used to derive a
child class called Friday, then a Holiday reference
can be used to point to a Fridayobject.
Holiday day;
day = new Holiday();
…
day = new Friday();

Executive
- bonus : double
+ AwardBonus(execBonus : double) : void
+ Pay() : double
Hourly
- hoursWorked : int
+ AddHours(moreHours : int) : void
+ ToString() : string
+ Pay() : double
Volunteer
+ Pay() : double
Employee
# socialSecurityNumber : String
# payRate : double
+ Pay() : double
Polymorphism via Inheritance
StaffMember
# name : string
# address : string
# phone : string
+ Pay() : double

Type of Polymorphism
 At run time, objects of a derived class may be treated as objects of a
base class in places such as method parameters and collections or arrays.
When this occurs, the object's declared type is no longer identical to its
run-time type.
 Base classes may define and implement virtual methods, and derived
classes can override them, which means they provide their own
definition and implementation. At run-time, when client code calls the
method, the CLR looks up the run-time type of the object, and invokes
that override of the virtual method. Thus in your source code you can
call a method on a base class, and cause a derived class's version of the
method to be executed.

Overriding Methods
 C# requires that all class definitions
communicate clearly their intentions.
 The keywords virtual, override and new provide
this communication.
 If a base class method is going to be overridden
it should be declared virtual.
 A derived class would then indicate that it
indeed does override the method with the
override keyword.

Overriding Methods
▪ A child class can override the definition of an
inherited method in favor of its own
▪ That is, a child can redefine a method that it
inherits from its parent
▪ The new method must have the same signature
as the parent's method, but can have a different
implementation.
▪ The type of the object executing the method
determines which version of the method is
invoked.

Overriding Methods
 If a derived class wishes to hide a method in
the parent class, it will use the new keyword.
This should be avoided.

Overloading vs. Overriding
▪ Overloading deals with
multiple methods in the
same class with the same
name but different
signatures
▪ Overloading lets you
define a similar
operation in different
ways for different data
▪ Example:
▪ int foo(string[] bar);
▪ int foo(int bar1, float a);
▪ Overriding deals with two
methods, one in a parent
class and one in a child
class, that have the same
signature
▪ Overriding lets you define
a similar operation in
different ways for different
object types
▪ Example:
▪ class Base {
▪ public virtual int foo() {}
}
▪ class Derived {
▪ public override int foo()
{}}

Example
public class Base
{
public virtual void Show()
{
MessageBox.Show("Show From Base Class.");
} }
public class Derived : Base
{
public override void Show()
{
MessageBox.Show("Show From Derived Class.");
} }

Object oriented programming inheritance

More Related Content

What's hot (20)

Similar to Object oriented programming inheritance (20)

More from Renas Rekany (20)

Recently uploaded (20)

Object oriented programming inheritance