OOPS

Overview

 What is an Object?

 What is not an Object?

What is state of an Object?

What is the Lifecycle of an Object?

How will you distinguish two Objects?

What is the relationship between Class and Object?

Define Application using Objects?

 Principles of Object Orientation

Encapsulation

Inheritance

Polymorphism

Encapsulation is binding of State and Behavior together

 Inheritance is based on “is a” relationship.

Understanding Polymorphism with Examples.

 Class: A class is a template / skeleton / blueprint for creating an object.

 Object: An Object is an entity that has properties for validations, methods for functionality and events for depicting the change of state.

 Every object has the data and behavior with which they are differed. Data associated at any given instance of time is the state of an object.

Component: A ready to use third party object can be called as a Component. It can be replaced without any changes in the application. A component is generally used by a programmer as an object.

An application can be called as a collection of related objects exchanging messages with each other.

 Loosely coupled objects are better than tightly coupled objects i.e. the lesser the information given to other objects the better it is as the objects are loosely coupled the dependencies are less and stronger security.

Every object oriented language should have three features

·         Encapsulation

·         Inheritance

·         Polymorphism

 Encapsulation: Binding of data and behavior i.e. functionality of an object within a secured and controlled environment is encapsulation.

 Inheritance: The Process of acquiring the existing functionality of the parent and with new added features and functionality by a child object is called inheritance. The advantages of inheritance are Generalization, Extensibility and Reusability. For example: A calculator is a generalized form of mathematical operations where as a Scientific calculator is an Extended and Specific form.

 Polymorphism: An object in different forms and in each form it exhibits the same functionality but implemented in different ways. For example: A man who knows more than one language can speak any language he knows. Here the functionality is speech and person is the object. A faculty can take a form of Java Faculty or MSNET faculty and in both the forms he teaches, but what he teaches differs. Here functionality is teach and faculty is the object.

Object Creation and Instantiation In MS.NET when an object is created there is no way to get the address of an object. Only the reference to the object is given through which we can access the members of the class for a given object. When an object is created all the variables (value/ reference types) are allocated the memory in heap as a single unit and default values are set to them based on their data types.

Agenda:

1. Write a class and add field members to the class

2. Create an Object of the Class and understand the difference between object and reference.

3. Access the members of the object

4. Copy the reference in another reference variable.

5. Abandoning the object.

6. Working with Methods

7. Working with Properties

8. Constructor & Destructor.

9. Working with “static” Members

Working with Classes & Objects:

Account Example

Step 1: Create a new project (File à New Project). Name: AccountApplication, Project Type: C#, Template: Windows Application

Step 2: View à Solution Explorer, Right Click on Project à Add à Class and name it as Account

Step 3: Add to class the following code.

Code in C#:

class Account

{

public int Id;

public String Name;

public Decimal Balance;

 public Account()

 {

MessageBox.Show(“Object Created”);

 }

~Account()

{

 MessageBox.Show(“Object Destroyed”);

 }

}

Explanation: Account a; “a” is a refrence variable of type Account. Note: “a” is not an object of type Account. a = new Account();

Creates an object of type Account (allocating memory on heap to every member of the Account class) and its reference is assigned to „a‟.

Every member allocated memory is set to its default value based on the datatype.

The value of the reference variable is reference to an object on heap.

Account a; 'Declaration a1 = new Account(); 'Initialization

Step 4: In the AccountApplication, Change the name of the Form, “Form1” to “AccountForm” and design the following GUI

Step 5: For every control on the form set Text and Name properties.

Step 6: In DesignView, doubleclick on every button to generate event handlers in Code View of the Form

a.Id = 1; The above statement can be read as: “Id” menber of an object of type Account referenced by “a” is set to 1.

Note: If a reference variable is not intialized i.e referring to null, then trying to access any member using it will throw a runtime exception i.e. “NullReferenceException”.

Account a1; a1 = a //Copies the value of a (reference to the object) into a1 and thus both “a1” and “a” refers to the same object.

Note: One Object can have many references but one reference variable cannot refer to many objects.

Step 7: Add the following code to the AccountForm i.e Handle all the buttons Click event (Double click on button in design view)

Account Form Code in C#:

public partial class AccountForm: Form

 {

     Account a;

    private void btnCreate_Click(...)

    {

          a = new Account();

     }

private void btnGet_Click(...)

{

 txtId.Text = a.Id.ToString();

txtName.Text = a.Name;

txtBalance.Text = a.Balance.ToString();

}

private void btnClear_Click(...)

{

 txtId.Text = "";

txtName.Text = "";

 txtBalance.Text = "";

}

private void btnSet_Click(...)

{

a.Id = int.Parse(txtId.Text);

a.Name = txtName.Text;

 a.Balance = double.Parse(txtBalance.Text);

}

private void btnDestroy_Click(...)

 {

a = null;

}

private void btnClear_Click(...)

{

 txtId.Text = "";

txtName.Text = "";

 txtBalance.Text = "";

}

private void btnSet_Click(...)

{

a.Id = int.Parse(txtId.Text);

a.Name = txtName.Text;

a.Balance = double.Parse(txtBalance.Text);

}

private void btnDestroy_Click(...)

{

a = null;

}

private void btnGC_Click(...)

{

GC.Collect();

 }

private void btntemp_Click(...)

 {

 Account a1 = new Account();

a = a1;

}

private void btnGetGeneration_Click(...)

 {

 MessageBox.Show(GC.GetGeneration(a).ToString());

 }

}

Working with Methods

The methods of the object are used to describe the functionality / behavior.

 Notes:

1. An instance method of a class is always invoked using a reference to an object.

2. While writing a method in a class do not set to it any data as parameter or return type, anything which is already the data member in the same class.

3. In a method “ “this”(CS) is reference to the current object on which the method is invoked.

4. If parameter/local variable and data member of a class have same name, the local variable takes the precedence over data member and if data member has to accessed in such a method then “this” (CS) can be used.

5. The class should be always programmed in such a way that, it‟s not specific to any particular type of application so that the same class can reused in different applications / environment. For example, don‟t use in class functionality like MsgBox or Console.WriteLine or Button or Label or TextBox etc….

6. Whenever any of the business rules of an object or the integrity of the property or a method is violated, it should respond by throwing a runtime exception. For example in the above method Withdraw( ) we are checking for balance to be a minimum of 500, if violated an exception is raised.

Recommendation: A method name should start with uppercase and parameters should use camel notation. Step 8: In the Account Class add the following deposit and withdraw method.

public void Deposit(decimal amount)

{ this.Balance += amount }

public void Withdraw(decimal amount

{

if (this.Balance - amount < 500)

throw new ApplicationException("Insufficient Balance");

else

this.Balance -= amount

}

Step 9: Add Deposit (btnDeposit) and Withdraw (btnWithdraw) buttons and Amount (txtAmount) textbox to the AccountForm. Add the following code to the event handler of the btnDeposit and btnWithdraw.

pivate void btnDeposit_Click( . . . )

 { a.Deposit(decimal.Parse(txtAmount.Text)); }

private void btnWithraw_Click( . . . )

{ a.Withdraw(decimal.Parse(txtAmount.Text)); }

Working with Object Properties

1. A Property encapsulates a field member of the same class, so that the field member is not freely accessible outside the class and the required validation/restriction can be put over it.

2. A property is made of two blocks i.e. Get and Set. Get block is invoked when the property is used on RHS and Set block is invoked when the property is used on LHS.

3. A property procedure doesn‟t hold any data by itself instead it depends on some private field member of the class.

4. A Set block can validate the “Value” before it is assigned to the field member of the class being encapsulated by the property. Similarly the field member can be validated before its value is returned in the Get block.

5. Using a property the field member can be restricted with either “ReadOnly” or “WriteOnly” access.

6. A class which has all its field members as Private and if required restricted access to these members is given using Public Properties is called “Fully Encapsulated Class”.

Syntax in C#: Private <Datatype> _<propertyname>; public <Datatype> <PropertyName>  { [private] get { return _<propertyname>; } [private] set { _<propertyname> = value; }  }

                                                                             

Step 10: Add the properties for Name, Balance and Id with following conditions:

Balance should be ReadOnly.

Name should accept greater or equal to and 5 characters and less than or equal to 20 characters only

Id should be set only once.

Edit the code in the Account Class as below.

private int _Id

private string _Name

private decimal _Balance

public decimal Balance

{

get { return _Balance; }

}

public String _Name

{

get { return _Name; }

 set { if (value.Length > 8)

throw new ApplicationException("Name cannot be > 8 characters"); _Name = value; }

 }

private bool idAlreadySet;

public int Id

{

get { return _Id; } set { if (idAlreadySet) throw new ApplicationException("Id is already set"); _id = value; idAlreadySet = true; }

 }

Step 11: In btnSet_Click of AccountForm please replace a.Balance = Decimal.Parse(txtBalance.text) with a.Deposit(decimal.Parse(txtBalance.Text))

Constructors and Destructors

A constructor is a member method of a class which is automatically executed / called as soon as the object of that class is created and thus it is ideally used for initializing the field members of the object.

1. A constructor has same name as the class and doesn‟t have a return type not even void.

2. A constructor without a parameter is called default constructor and the one with parameters is called as Parameterized constructor.

3. If a class doesn’t have any form of constructor, a public default constructor is automatically added to it by the language compiler.

4. Copy Constructor is used to create a new object by duplicating the state of an existing object and this is done by copying the data members of existing object in new object data members.

Syntax in C#:

<Class name>()

{ //default constructor }

 <Class name>(<datatype> p1, …) { //parameterized constructor }

 <Class name>(<Class Name> <parname>) : this(. . .) { //copy constructor }

                                                            

Step 12: Add the Following code to the Account Class

public Account()

{ }

 public Account(int id, String name, decimal balance) : this()

 { this.Id = id; this.Name = name; this._Balance = balance; }

public Account(Account a) : this(a.Id,a.Name,a.Balance)

 { //this.Id = a.Id; //this.Name = a.Name; //this._Balance = a.Balance; }

 Step 13: In AccountForm make the following Changes:

 private void btnCreate_Click(. . .) Handles btnCreate.Click

 {

int id = int.Parse(txtId.Text);

string name = txtName.Text;

decimal initialBalance = decimal.Parse(txtBalance.Text);

 a = New Account(id,name, initialBalance);

}

Note: Once the above code is changed in AccountForm, btnSet_Click is no more useful and thus it can be removed

Destructor

A destructor is used to release the resources that an object is holding. When an object is ready to be destroyed Finalize method / Destructor is called on that object.

In C++, destructor of a class is responsible for destroying all the other objects which the object of this class has created during its lifetime. (In C++ we don‟t have Garbage collector)

In .NET, all the dependent objects are automatically ready for Garbage Collection when the main object doesn‟t have any references thus the destructor here doesn‟t have same significance as in C++.

Syntax in C#: Note: A destructor in C# cannot have any access modifiers ~<class name>() { }.

Because its not predictable when the Destructor method is going to be executed, its not recommended to only rely on destructor for releasing of resources and thus Microsoft has suggested two methods that can be invoked by the programmer for the release of resources i.e. Close() or Dispose().

Working with “static” Members

For every new instance of a class all the instance members are allocated memory, but static field members of a class are allocated memory only once irrespective of the number of objects created and they are allocated memory when the class is loaded. These members are also called class members and are accessed outside the class using class name.

Note: A class is loaded when either the static members of the class is accessed for the first time or when the first instance of the class is created. A class once loaded will remain in memory permanently and thus also are all static members of that class.

Note: A public static member of a class can be used as Global member of the application because it can be assessed using class name from any part of the application.

Static Constructor: A constructor is defined with the keyword as static (in C#). It is used to initialize the static member dynamically and is executed when the class is loaded.

This is invoked by the CLR when the class is loaded by it and hence cannot be overloaded nor can be declared with any accesses specifier like public or private.

 Series of events that occur when the first object is created:

1. Class is loaded.

2. Static members are loaded and allocated memory.

3. Static constructor is executed.

4. Instance members are loaded and allocated memory.

5. Instance constructor is executed.

Note: Static Constructor cannot access Instance members of the class. This is because when the static constructor is executed the instance members are not allocated any memory.

Code in C#:

 Step 14:

 public static int MinBalance = 500;

 Step 17:

 public static int _PrevId

private int Id;

Step 18: public Account()

{ _PrevId += 1; _Id = _PrevId; }

 Step 19: Id is now changed to ReadOnly Property

public int Id { get { return _Id } }

Step 15: In Withdraw method replace the constant value 500 with the static member "MinBalance"

Step 16: In Form: Add btnGetMB and btnSetMB buttons and txtMB textbox with the following code.

private void btnGetMB_Click(...) { txtMB.Text = Account.MinBalance.ToString(); }

Private Sub btnSetMB_Click(...) { Account.MinBalance = Decimal.Parse(txtMB.Text); }

Step 20: Because “Id” is now auto increment field, remove the id parameter from the constructor of Account Class

Step 21: Remove “id” argument while creating the Account object in btnCreate_Click of AccountForm        

Static Methods: A method which does not have anything to do with the state of the object can be marked as static method.

Eg: class File {

public static void Copy(string srcPath,string destPath) { . . . }

 }

Note: All methods and properties (procedures) of the class irrespective of whether they are static or not are allocated memory only once.

1. Outside the class a static members of a class can be accessed using class name where as the instance member of a class must be accessed using a reference variable referring to an object of that class.

2. Instance members of the class cannot be accessed in a static constructor or any other static method or property of the class (unless it is qualified by a reference variable referring to an object of that class).

For Example

 public static void Foo()

{

//_Balance = 100; // Is Invalid

Accout a = new Account();

a._Balance = 100; // IsValid because _Balance is qualified by “a” which is reference to an object.

}

3. An instance member can access static members of the class.

4. “this” cannot be used in the static member of a class.

5. A class in C# can be declared as static and such a class can have only static members and instance members are not allowed. Also such a class cannot be instantiated.

static class Demo { public static int P1; public static void Foo() { } }