Chapter - 4
OOP with C#
Objectives
Basic Class in C#
Visibility
Encapsulation
Inheritance
Accessor (get) and Mutator (set)
Named Property
Sealed classes
Polymorphism
Abstract Class and Method
2
C# Classes
A Class is a custom User Defined Type
(UDT)
A Class consists of data (attributes) and
functions (methods)
Example: To model a generic
Employee, we can define an Employee
Class
Employee Class
Employee
attributes:
string fullname;
int empID;
float currPay;
methods:
void GiveBonus(float amount);
void DisplayStats();
4
Source Code
using System;
namespace Employee
{
public class Employee
{
// private data
private string fullName;
private int empID;
private float currPay;
// Default ctor.
public Employee(){ }
// Custom ctor
public Employee(string fullName, int empID, float currPay)
{
// Assign internal state data. Note use of 'this' keyword
this.fullName = fullName;
this.empID = empID;
this.currPay = currPay;
}
Source Code (Contd)
// Bump the pay for this emp.
public void GiveBonus(float amount)
{currPay += amount;}
// Show the state
public void DisplayStats()
{
Console.WriteLine("Name: {0}", fullName);
Console.WriteLine("Pay: {0}", currPay);
Console.WriteLine("ID: {0}", empID);
}
public static void Main(string[ ] args)
{
Employee e = new Employee("Joe",111,23987.50F);
e.GiveBonus(200);
e.DisplayStats();
}
}
}
Method Overloading and 'this'
Overloading of Methods is same as C++.
Constructors can be overloaded.
For method resolution, return type alone is not
necessary!
Is the keyword 'this' always necessary?
Yes, if the parameter name and the class member
name are same. Otherwise No!
Static member functions can't use 'this' keyword.
Why?
The keyword 'this' can also be used to force one
constructor to call another during the object creation
Ex: public Employee(string fullName) : this(fullName,
GetEmpId(), currPay) { }
7
Basic OOP Concepts
Encapsulation
Inheritance
Hiding unnecessary implementation details
"is-a" and "has-a" relationship
"is-a" means sub-classes or derived classes
"has-a" means containment or delegation
Polymorphism
It is the ability of the language to treat related
objects the same way
When sub-classes override the behavior defined by
base a class, they are essentially redefining how
they respond to the same message
8
Examples
Encapsulation
DBReader f = new DBReader(); // details are hidden
is-a Relationship
f.Open("@C:\foo.mdf");
// process the database file
Object
f.Close();
Inheritance
Polymorphism
Shape
Hexagon
Shape
void Draw( )
has-a Relationship
Hexagon
Draw(
)
Circle
Draw(
)
Car
Radio
9
More Details: (1) Encapsulation
The main objective of encapsulation is: the
object's instance should be allowed to access
the internal member data directly. It also
provides the integrity of state data. How to do
this?
Using private, public, protected, and
protected internal keywords
To manipulate the private data, C# provides
two methods:
Define traditional accessor and mutator methods
Define a named property
10
Example
Accessor
class Employee
{
private string fullName;
public string GetName() { return fullName; }
..
Mutator
class Employee
{
private string fullName;
public string SetName(string n)
{ fullName = n; }
.
11
Class Properties
You can define a named property to avoid
using two different get and set methods
The property is a single named field which
wraps the private data. These property
names can then be used in Main( ).
Ex: Assume EmpID is the name of the property
public static void Main()
{
Employee e = new Employee();
p.EmpID = 111; // set
Console.WriteLine(e.EmpID); // get
}
12
C# get and set Methods
using System;
namespace get_set
{
class MyClass
{
private int a;
public int A // property
{
get // accessor
{
return a;
}
set // mutator
{
a = value;
}
}
}
class Class1
{
static void Main(string[] args)
{
MyClass obj = new MyClass();
obj.A = 20;
Console.WriteLine(obj.A);
}
}
}
get block accessor
set block mutator
A named property
13
Read-Only and Write-Only Properties
The named property A in the previous slide
was able to read and write. How to restrict the
access of A as R/W?
For Read-Only: simply define a property
without a set block
For write-only: simply define a property
without a get block
Ex:
public float Pay
public float Pay
{
{
get { return currPay; }
set { currPay = value; }
}
14
static: properties and constructors
The static keyword can be used for properties
also
The only difference is that, now these
properties are bound to a class and not to an
instance
Ex: Employee.EmpID = 111;
Can a constructor be declared as static?
Yes, but it is strange! Why? Because,
constructors are executed during object
creation
Static constructors are used to initialize static
data
15
Example static property
public class Employee
{
private static string companyName;
public static string Company
{
get { return companyName; }
set {companyName = value; }
}
}
public static void Main(string[ ] args)
{
Employee.Company = "Microsoft";
Console.WriteLine("The name is {0}", Employee. Company);
}
16
Example static constructor
public class Employee
{
private static string companyName;
static Employee()
{ companyName = "Microsoft"; }
}
public static void Main(string[ ] args)
{
// below statement is not needed
// Employee.Company = "Microsoft";
Console.WriteLine("The name is {0}",
Employee.Company);
}
17
Read-Only Fields
Read-Only properties provide data preservation: keyword
to be used is: "readonly"
Ex: public readonly int rofield;
You can't assign any value to the readonly fields, except in
a constructor
Ex: void SomeMethod()
{ rofield = 123; } // Error
Static readonly fields can also be used. It is useful to
associate many constant values bound to a class.
It may be look similar to 'const' declaration. The difference,
however, is that const is resolved at compile-time and
static readonly is resolved at run-time.
The other context in which it is valid to pass a readonly
field as an out or ref parameter.
18
More Details: (2) Inheritance
Inheritance facilitates code reuse
Inheritance provides dependency
between types
Inheritance comes in two flavors:
"is-a" relationship
"has-a" relationship
Let us start with "is-a" relationship
Employee
SalesPerso
n
Manager
19
Manager Derived Class
using System;
namespace Employee
{
public class Manager : Employee
{
private ulong numberOfOptions;
public ulong NumberOpts
{
get { return numberOfOptions; }
set { numberOfOptions = value; }
}
}
}
20
SalesPerson Derived Class
using System;
namespace Employee
{
public class SalesPerson : Employee
{
private int numerOfSales;
public int NumbSales
{
get { return numerOfSales; }
set { numerOfSales = value; }
}
}
}
21
Base class and Subclass Constructors
A subclass constructor automatically
calls the base class constructor, by
default
Example:
public Manager(string fullName, int empID, float
currPay, ulong numberOfOpts)
: base (fullName, empID, currPay)
{ numberOfOptions = numberOfOpts; }
22
More features of "is-a"
Multiple Inheritance
"protected " Keyword
In C#, a given class can have exactly one direct
base class
It is not permitted to have a single type with one or
more base classes
You know that a private member can't be accessed
by even subclasses
"protected " data or methods can be accessed by
subclasses
Sealed Classes
If you want to design a class that can't be
inherited, then use the keyword: "sealed "
A sealed class cannot also be an abstract class.
It also enables certain run-time optimizations
23
Example Sealed Classes
Employee
SalesPerso
n
Manager
PTSalesPerso
n
Add a subclass PTSalesPerson for
SalesPerson class to have part time sales
people.
Since we can't think of more child classes
under PTSalesPerson, we shall seal it
Sealed classes are most useful for designing
standalone classes. Ex: String class in the
System namespace
Example
public sealed PTSalesPerson : SalesPerson
{ . }
24
Containment/Delegation
or has-a relationship
Let us consider two classes: A Car class and
a Radio class
It is odd to think of Radio is a Car! Instead,
we can say a Car has a Radio
Car is called as Containing Class
Radio is called as Contained Class
To expose the functionality of the inner class
to the outside world requires delegation
Delegation means adding members to the
containing class that make use of the
contained class's functionality (Ex:
theMusicBox.TurnOn(state); )
25
More Details: (3) Polymorphism
Polymorphism is the ability for classes to provide different
implementations of methods that are called by the same
name.
Polymorphism allows a method of a class to be called
without regard to what specific implementation it provides.
For Example, assume that you have added a new method to
Employee class as:
public void GiveBonus(float amount)
{ currPay += amount; }
This method is common for all objects derived from
Employee. However, our objective is to design this to
behave differently for Manager and SalesPerson.
This means that the subclasses should be able to provide
different interfaces to Employee class
Polymorphism is achieved through " virtual " and " override "
keywords
26
Types of Polymorphism
Interface polymorphism - Multiple classes may
implement the same interface, and a single class may
implement one or more interfaces. Interfaces are
essentially definitions of how a class needs to respond.
An interface describes the methods, properties, and
events that a class needs to implement.
Inheritance polymorphism - Multiple classes may
inherit from a single base class. By inheriting, a class
receives all of the methods, properties, and events of
the base class in the same implementation as the base
class.
Polymorphism through abstract classes - Abstract
classes provide elements of both inheritance and
interfaces. An abstract class is a class that cannot be
instantiated itself; it must be inherited.
27
Example
public class Employee
{
public virtual void GiveBonus(float amount)
{ currPay += amount; }
}
public class SalesPerson : Employee
{
public override void GiveBonus(float amount)
{
int salesBonus = 0;
if (numberOfSales > 200)
salesBonus = 1000;
base.GiveBonus(amount + salesBonus);
}
}
Base Claass
You can reuse the base class method by using the keyword base
Alternatively, the subclass can completely redefine without calling
the base class method
28
Abstract Classes
An abstract class cannot be instantiated
directly, and it is a compile-time error to use
the new operator on an abstract class
An abstract class is permitted (but not
required) to contain abstract members
An abstract class cannot be sealed Why?
Ex: If the Employee class is declared as
abstract, the the following stmt. gives an error:
Employee e = new Employee();
What is the need for an abstract class?
Does it look OK if some one says
"I am an Employee"? or "I am a Sales Person"
29
Example
abstract class A
{
public abstract void F();
}
abstract class B: A
{
public void G() {}
}
class C: B
{
public override void F()
{ // actual implementation of F }
}
A
B
C
The abstract class A introduces an abstract method F.
Class B introduces an additional method G, but since it doesn't
provide an implementation of F, B must also be declared abstract.
Class C overrides F and provides an actual implementation. Since
there are no abstract members in C, C is permitted (but not
required) to be non-abstract.
30
Shape Class Design overview
It is more
intelligent
to declare
Draw() as
abstract
public abstract class Shape
{
public virtual void
Draw()
{}
}
Same as
pure
virtual
function
of C++
public class Circle :
Shape
public class Hexagon :
Shape
{
{}
public override void
Draw()
{ ...Draw(),
}
The subclass Circle does not override
whereas
}
Hexagon does
31
Method Hiding
Method hiding is opposite of Method overriding
Assume that Oval is-a type of Circle. Of course you can
define a method Draw() which overrides Draw() of its parent
class and provide its own versioning.
However, if we want to prevent the Oval class from inheriting
any previous logic, use "new" keyword
public class Oval : Circle
{
public Oval(){base.PetName = "Joe";}
// Hide base class impl if they create an Oval.
new public void Draw()
{
Console.WriteLine("Oval with class versioning");
}
}
new keyword breaks the relationship between base
class of abstract Draw() and the derived class version
32
new Modifier
// The new modifier
using System;
public class MyBaseC
{
public static int x = 55;
public static int y = 22;
}
Output:
100
55
22
public class MyDerivedC : MyBaseC
{
new public static int x = 100; // Name hiding
public static void Main( )
{
Console.WriteLine(x); // Display the overlapping value of x:
Console.WriteLine(MyBaseC.x); // Access the hidden value of x:
Console.WriteLine(y); // Display the unhidden member y:
}
}
33
End of
Chapter 4
34
