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

Object-Oriented Programming (OOP) is a software development paradigm that suggests developers split a program in building blocks known as objects. The OOP paradigm allows developers to define the object's data, functions, and its relationship with other objects.

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 ob objects that will always have the same features.

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:

The following sample code illustrates a sample class in C#,

/// 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;  
        }  
    }  
}

Listing 1. Sample class implementation in C#

The following sample code illustrates a sample class in VB.NET,

' 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 

Listing 2. Sample class implementation in VB.NET

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

Every object is composed by:

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.

The following code sample represents a structures in C#:

/// 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;  
        }  
    }  
}

Listing 3. Sample structure implementation in C#

The following code sample represents a structure in VB.NET,

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  
Public Property Y() As Integer  
Get  
Return _y  
End Get  
Set(ByVal Value As Integer)  
_y = value  
End Set  
End Property  
End Structure

Listing 4. Sample structure implementation in VB.NET

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

Continue Reading - OOPS Concepts And .NET - Part Two - Inheritance, Abstraction, And Polymorphism