Académique Documents
Professionnel Documents
Culture Documents
OOPS Concept
Summary
The following article kicks off a three-part article series that will present definitions and
samples for different Object-Oriented Programming concepts and its implementation in
.NET. The first part will examine the concepts of classes, objects, and structures. The
second part will examine the concepts of inheritance, abstraction, and polymorphism. The
third and last part will examine the concepts of interface, multiple interface, inheritance,
collections, and overloading.
Introduction
Microsoft created the .NET Framework using OOP, and knowing this concepts has
helped me to understand the .NET Framework and to design and develop better software
components. The purpose of this article is to describe the basic OOP concepts using real
world scenarios and to provide some code samples that demonstrate how to work with
OOP and .NET.
Class
The most common definition states that a class is a template for an object. Suppose that
someone builds a paper pattern for a shirt. All the shirts done with the same paper pattern
will be identical (same design, size, etc.). In this sample, the paper pattern is the class
and the shirt is the object. To build the same exact shirt over and over, you need the
paper pattern as a template. Another great example are house plans and blueprints. The
plans and blueprints define the number of rooms, the size of the kitchen, the number of
floors, and more. In this real world sample, the house plans and blueprints are the class
and the house is the object. In OOP you program a class as a template for a specific
object or groups of objects that will always have the same features.
Just as data has various types so objects can have different types. These collections of
objects with identical characteristics are collectively known as a class. We can define
classes and create instances of them, which are the actual objects.
Class members
A class has different members, and developers in Microsoft suggest to program them in
the following order:
Access keywords
Access keywords define the access to class members from the same class and from other
classes. The most common access keywords are:
• Public: Allows access to the class member from any other class.
• Private: Allows access to the class member only in the same class.
• Protected: Allows access to the class member only within the same class and
from inherited classes.
• Internal: Allows access to the class member only in the same assembly.
• Protected internal: Allows access to the class member only within the same
class, from inherited classes, and other classes in the same assembly.
• Static: Indicates that the member can be called without first instantiating the
class.
/// C#
///Imported namespaces
using System;
/// Namespace: Consider using CompanyName.Product.ComponentType
namespace DotNetTreats.OOSE.OOP_CSharp
{
///Class declaration
public class employee
{
///Fields
private string _name;
private int _salary;
///Constants
private const int anualBonus = 1000;
///Constructor
public employee()
{
}
///Properties
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
public int Salary
{
get
{
return _salary;
}
set
{
_salary = value;
}
}
/// Event handlers
public event EventHandler OnPromotion
{
add
{
}
remove
{
}
}
/// Methods
public void DuplicateSalary()
{
_salary = _salary*2;
}
}
}
' VB.NET
'Imported namespaces
Imports System
' Namespace: Consider using CompanyName.Product.ComponentType
Namespace DotNetTreats.OOSE.OOP_VBNET
'Class declaration
Public Class employee
'Fields
Private _name As String
Private _salary As Integer
'Constants
Private Const anualBonus As Integer = 1000
'Constructors
Public Sub New()
MyBase.New()
End Sub
'Properties
Public Property Name() As String
Get
Return _name
End Get
Set(ByVal Value As String)
_name = value
End Set
End Property
Public Property Salary() As Integer
Get
Return _salary
End Get
Set(ByVal Value As Integer)
_salary = value
End Set
End Property
' Event handlers
Public Event OnPromotion As EventHandler
'Methods
Public Sub DuplicateSalary()
_salary = (_salary * 2)
End Sub
End Class
End Namespace
Object
Objects are the building blocks of OOP and are commonly defined as variables or data
structures that encapsulate behavior and data in a programmed unit. Objects are items that
can be individually created, manipulated, and represent real world things in an abstract
way.
Object composition
• Object identity: Means that every object is unique and can be differentiated from
other objects. Each time and object is created (instantiated) the object identity is
defined.
• Object behavior: What the object can do. In OOP, methods work as functions
that define the set of actions that the object can do.
• Object state: The data stored within the object at any given moment. In OOP,
fields, constants, and properties define the state of an object.
Structures
Not everything in the real world should be represented as a class. Structures are suitable
to represent lightweight objects. Structures can have methods and properties and are
useful for defining types that act as user-defined primitives, but contain arbitrary
composite fields. The .NET Framework defines some structures such as
System.Drawing.Rectangle, System.Drawing.Point, and System.Drawing.Color.
/// C#
struct Point
{
private int _x;
private int _y;
Point(int x, int y)
{
this._x = x;
this._y = y;
}
public int X
{
get
{
return _x;
}
set
{
_x = value;
}
}
public int Y
{
get
{
return _y;
}
set
{
_y = value;
}
}
}
' VB.NET
Structure Point
Private _x As Integer
Private _y As Integer
Sub New(ByVal x As Integer, ByVal y As Integer)
MyBase.New()
Me._x = x
Me._y = y
End Sub
Public Property X() As Integer
Get
Return _x
End Get
Set(ByVal Value As Integer)
_x = value
End Set
End Property
Conclusion
OOP is full of abstract concepts, and the best approach to understand them is practical
and not only theoretical. I learned more OOP after making some designs and after
implementing some components. The concepts presented in this article might clarify the
meaning, but I strongly recommend to go and have fun playing around with OOP. In this
article, I examined the concept of classes, objects, and structs. The second part will
examine the concepts of inheritance, abstraction, and polymorphism.
Reference