OOPS concepts part .2
OOPS
Concepts
Class:
It is a collection of objects.
Object:
It is a real time entity.
An object can be considered a "thing"
that can perform a set of related activities. The set of activities that
the object performs defines the object's behavior. For example, the hand can
grip something or a Student (object) can give the name or
address. In pure OOP terms an object is an instance of a class
The above template describe about
object Student
Class is composed of three things name,
attributes, and operations
public class student
{
}
student objstudent=new student ();
According to the above sample we can
say that Student object, named objstudent, has created out of the
student class.
In real world you will often find many
individual objects all of the same kind. As an example, there may be
thousands of other bicycles in existence, all of the same make and model. Each
bicycle has built from the same blueprint. In object-oriented terms, we say
that the bicycle is an instance of the class of objects known as bicycles. In
the software world, though you may not have realized it, you have already used
classes. For example, the Textbox control, you always used, is
made out of the Textbox class, which defines its appearance and
capabilities. Each time you drag a Textbox control, you are
actually creating a new instance of the Textbox class.
Encapsulation:
Encapsulation is a process of binding
the data members and member functions into a single unit.
Example for encapsulation is class. A
class can contain data structures and methods.
Consider the following class
public class Aperture
{
public Aperture ()
{
}
protected double height;
protected double width;
protected double thickness;
public double get volume()
{
Double volume=height * width * thickness;
if (volume<0)
return 0;
return volume;
}
}
In this example we encapsulate some data such as height, width, thickness and method Get Volume. Other methods or objects can interact with this object through methods that have public access modifier
In this example we encapsulate some data such as height, width, thickness and method Get Volume. Other methods or objects can interact with this object through methods that have public access modifier
Abstraction:
Abstraction is a process of hiding the
implementation details and displaying the essential features.
Example1: A Laptop consists of many
things such as processor, motherboard, RAM, keyboard, LCD screen, wireless
antenna, web camera, usb ports, battery, speakers etc. To use it, you don't
need to know how internally LCD screens, keyboard, web camera, battery,
wireless antenna, speaker’s works. You just need to know how to operate the
laptop by switching it on. Think about if you would have to call to the
engineer who knows all internal details of the laptop before operating it. This
would have highly expensive as well as not easy to use everywhere by everyone.
So here the Laptop is an object that is
designed to hide its complexity.
How to abstract: - By using Access
Specifiers
.Net has five access Specifiers
Public -- Accessible outside the class
through object reference.
Private -- Accessible inside the class only through member functions.
Protected -- Just like private but Accessible in derived classes also through member functions.
Internal -- Visible inside the assembly. Accessible through objects.
Protected Internal -- Visible inside the assembly through objects and in derived classes outside the assembly through member functions.
Let’s try to understand by a practical example:-
Private -- Accessible inside the class only through member functions.
Protected -- Just like private but Accessible in derived classes also through member functions.
Internal -- Visible inside the assembly. Accessible through objects.
Protected Internal -- Visible inside the assembly through objects and in derived classes outside the assembly through member functions.
Let’s try to understand by a practical example:-
public class Class1
{
int i; //No Access
specifier means private
public int j; // Public
protected int k; //Protected
data
internal int m; // Internal
means visible inside assembly
protected internal int n; //inside
assembly as well as to derived classes outside assembly
static int x; // This is
also private
public static int y; //Static means
shared across objects
[DllImport("MyDll.dll")]
public static extern int MyFoo(); //extern means
declared in this assembly defined in some other assembly
public void myFoo2()
{
//Within a class if you
create an object of same class then you can access all data members through
object reference even private data too
Class1 obj = new Class1();
obj.i =10; //Error can’t
access private data through object.But here it is accessible.:)
obj.j =10;
obj.k=10;
obj.m=10;
obj.n=10;
// obj.s =10; //Errror
Static data can be accessed by class names only
Class1.x = 10;
// obj.y = 10; //Errror
Static data can be accessed by class names only
Class1.y = 10;
}
}
Now lets try to copy the
same code inside Main method and try to compile
[STAThread]
static void Main()
{
//Access specifiers comes
into picture only when you create object of class outside the class
Class1 obj = new Class1();
// obj.i =10; //Error
can’t access private data through object.
obj.j =10;
// obj.k=10; //Error
can’t access protected data through object.
obj.m=10;
obj.n=10;
// obj.s =10; //Errror
Static data can be accessed by class names only
Class1.x = 10; //Error can’t
access private data outside class
// obj.y = 10; //Errror
Static data can be accessed by class names only
Class1.y = 10;
}
What if Main is inside another assembly
[STAThread]
static void Main()
{
//Access specifiers comes
into picture only when you create object of class outside the class
Class1 obj = new Class1();
// obj.i =10; //Error
can’t access private data through object.
obj.j =10;
// obj.k=10; //Error
can’t access protected data through object.
// obj.m=10; // Error
can’t access internal data outside assembly
// obj.n=10; // Error
can’t access internal data outside assembly
// obj.s =10; //Errror
Static data can be accessed by class names only
Class1.x = 10; //Error can’t
access private data outside class
// obj.y = 10; //Errror
Static data can be accessed by class names only
Class1.y = 10;
}
In object-oriented software, complexity
is managed by using abstraction.
Abstraction is a process that involves identifying
the critical behavior of an object and eliminating irrelevant and complex
details.
Inheritance:
Inheritance is a process of deriving
the new class from already existing class
C# is a complete object oriented
programming language. Inheritance is one of the primary concepts of
object-oriented programming. It allows you to reuse existing code. Through
effective use of inheritance, you can save lot of time in your programming and
also reduce errors, which in turn will increase the quality of work and
productivity. A simple example to understand inheritance in C#.
Using System;
Public class BaseClass
{
Public BaseClass ()
{
Console.WriteLine ("Base Class Constructor
executed");
}
Public void Write ()
{
Console.WriteLine ("Write method in Base Class
executed");
}
}
Public class ChildClass: BaseClass
{
Public ChildClass ()
{
Console.WriteLine("Child Class Constructor
executed");
}
Public static void Main
()
{
ChildClass CC = new ChildClass ();
CC.Write ();
}
}
Output:
Base Class Constructor executed
Child Class Constructor executed
Write method in Base Class executed
this output proves that when we create an instance of a child class, the base class constructor will automatically be called before the child class constructor. So in general Base classes are automatically instantiated before derived classes.
Syntax: class ChildClassName: BaseClass
{
//Body
}
{
//Body
}
public class A
{
}
public class B
{
}
public class C : A, B
{
}
Note: Classes can inherit from multiple interfaces at the same time. Interview Question: How can you implement multiple inheritance in C#? Ans : Using Interfaces. We will talk about interfaces in our later article.
Using System;
Public class A
{
Public void A_Method ()
{
Console.WriteLine ("Class A Method Called");
}
}
Public class B: A
{
Public void B_Method ()
{
Console.WriteLine ("Class A Method Called");
}
}
Public class C: B
{
Public void C_Method ()
{
Console.WriteLine ("Class A Method Called");
}
Public static void Main
()
{
C C1 = new
C ();
C1.A_Method ();
C1.B_Method ();
C1.C_Method ();
}
}
Common Interview Question: Are private class members inherited to the derived class?
Ans: Yes, the private members are also inherited in the derived class but we will not be able to access them. Trying to access a private base class member in the derived class will report a compile time error.
Using System;
Public class A
{
Public void M1 ()
{
}
Private void M2 ()
{
}}
Public class B: A
{
Public static void Main
()
{
B B1 = new
B ();
B1.M1 ();
//Error, Cannot access private member M2
//B1.M2 ();
}}
Method Hiding and
Inheritance We will look at an example of how to hide a method in C#.
The Parent class has a write () method which is available to the child class.
In the child class I have created a new write () method. So, now if I create an instance of
child class and call the write () method, the child class write () method will
be called. The child class is hiding the base class write () method. This is
called method hiding.
If we want to call the parent class write () method, we would have to type cast the child object to Parent type and then call the write () method as shown in the code snippet below.
If we want to call the parent class write () method, we would have to type cast the child object to Parent type and then call the write () method as shown in the code snippet below.
Using System;
Public class Parent
{
Public void Write ()
{
Console.WriteLine ("Parent Class write method");
}}
Public class Child: Parent
{
Public new void Write ()
{
Console.WriteLine ("Child Class write method");
}
Public static void Main
()
{
Child C1 = new Child ();
C1.Write ();
//Type caste C1 to be of type Parent and
call Write () method
((Parent) C1).Write ();
}}
Polymorphism:
When a message can be processed in
different ways is called polymorphism. Polymorphism means many forms.
Polymorphism is one of the fundamental
concepts of OOP.
Polymorphism provides following
features:
Polymorphism is of two types:
1.
Compile time polymorphism/Overloading
2.
Runtime polymorphism/Overriding
Compile Time Polymorphism
Compile time polymorphism is method and
operators overloading. It is also called early binding.
In method overloading method performs
the different task at the different input parameters.
Runtime Time Polymorphism
Runtime time polymorphism is done using
inheritance and virtual functions. Method overriding is called runtime
polymorphism. It is also called late binding.
When overriding a method, you
change the behavior of the method for the derived class. Overloading a
method simply involves having another method with the same prototype.
Caution: Don't confused method overloading with
method overriding, they are different, unrelated concepts. But they sound
similar.
Method overloading has nothing to do
with inheritance or virtual methods.
Following are examples of methods
having different overloads:
void area(int side);
void area(int l, int b);
void area(float radius);
Practical example of Method Overloading
(Compile Time Polymorphism)
using System;
namespace method_overloading
{
class Program
{
public class Print
{
public void display(string name)
{
Console.WriteLine ("Your name is : " + name);
}
public void display(int age, float marks)
{
Console.WriteLine ("Your age is : " + age);
Console.WriteLine ("Your marks are :" + marks);
} }
static void Main(string[] args)
{
Print obj = new Print ();
obj.display ("George");
obj.display (34, 76.50f);
Console.ReadLine ();
} } }
Note: In the code if you observe display
method is called two times. Display method will work according to the number of
parameters and type of parameters.
When and why to use method overloading
Use method overloading in situation
where you want a class to be able to do something, but there is more than one
possibility for what information is supplied to the method that carries out the
task.
You should consider overloading a
method when you for some reason need a couple of methods that take different
parameters, but conceptually do the same thing.
Method overloading showing many forms.
using System;
namespace method_overloading_polymorphism
{
Class Program
{
Public class Shape
{
Public void Area (float r)
{
float a = (float)3.14 * r;
// here we have used function overload
with 1 parameter.
Console.WriteLine ("Area of a circle: {0}",a);
}
Public void Area(float l, float b)
{
float x = (float)l* b;
// here we have used function overload
with 2 parameters.
Console.WriteLine ("Area of a rectangle: {0}",x);
}
public void Area(float a, float b, float c)
{
float s = (float)(a*b*c)/2;
// here we have used function overload
with 3 parameters.
Console.WriteLine ("Area of a circle: {0}", s);
}
}
Static void Main
(string[] args)
{
Shape ob = new Shape ();
ob.Area(2.0f);
ob.Area(20.0f,30.0f);
ob.Area(2.0f,3.0f,4.0f);
Console.ReadLine ();
}
}
}
Things to keep in mind while method
overloading
If you use overload for method, there
are couple of restrictions that the compiler imposes.
The rule is that overloads must be
different in their signature, which means the name and the number and type of
parameters.
There is no limit to how many overload
of a method you can have. You simply declare them in a class, just as if they
were different methods that happened to have the same name.
Constructors and
Destructors:
Classes have complicated internal
structures, including data and functions, object initialization and cleanup for
classes is much more complicated than it is for simple data structures.
Constructors and destructors are special member functions of classes that are
used to construct and destroy class objects. Construction may involve memory allocation
and initialization for objects. Destruction may involve cleanup and
deallocation of memory for objects.
Constructors and destructors obey the
same access rules as member functions. For example, if you declare a
constructor with protected access, only derived classes and friends can use it
to create class objects.
The compiler automatically calls
constructors when defining class objects and calls destructors when class
objects go out of scope. A constructor does not allocate memory for the class
object it’s this pointer refers to, but may allocate
storage for more objects than its class object refers to. If memory allocation
is required for objects, constructors can explicitly call the new
operator. During cleanup, a destructor may release objects allocated by the
corresponding constructor. To release objects, use the delete
operator.
Example of Constructor
class C
{
private int x;
private int y;
public C (int i, int j)
{
x = i;
y = j;
}
public void display ()
{
Console.WriteLine(x + "i+" + y);
}
}
Example of Destructor
Example of Destructor
class D
{
public D ()
{
// constructor
}
~D ()
{
// Destructor
}
}
Comments