http://www.aspdotnet-suresh.com/2010/04/introduction-to-object-oriented.html
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
OOPterms 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
publicclassstudent
{
}
studentobjstudent=newstudent ();
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 Textboxcontrol, you always used, is made out of
the Textboxclass, which defines its appearance and capabilities. Each
time you drag a Textboxcontrol, you are actually creating a new instance
of the Textboxclass.
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
publicclassAperture
{
public Aperture ()
{
}
protecteddouble height;
protecteddouble width;
protecteddouble thickness;
publicdouble 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
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:-
publicclassClass1
{
int i;
//No Access specifier means private
public int
j;
// Public
protectedint k;
//Protected data
internalint m;
// Internal means visible inside assembly
protectedinternalint n;
//inside assembly as well as to derived classes
outside assembly
staticint x;
// This is also private
publicstaticint y;
//Static means shared across objects
[DllImport("MyDll.dll")]
publicstaticexternintMyFoo();
//extern means declared in this assembly defined in
some other assembly
publicvoid 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
Class1obj = newClass1();
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 letstry
to copy the same code inside Main method and try
to compile
[STAThread]
staticvoid Main()
{
//Access specifiers comes into picture only when you
create object of class outside the class
Class1 obj = newClass1();
// 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]
staticvoid Main()
{
//Access specifiers comes into picture only when you
create object of class outside the class
Class1 obj = newClass1();
// 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;
PublicclassBaseClass
{
PublicBaseClass ()
{
Console.WriteLine ("Base Class Constructor executed");
}
Publicvoid Write ()
{
Console.WriteLine ("Write method in Base Class executed");
}
}
PublicclassChildClass:
BaseClass
{
PublicChildClass ()
{
Console.WriteLine("Child Class Constructor executed");
}
Publicstaticvoid Main ()
{
ChildClass CC = newChildClass ();
CC.Write ();
}
}
In the Main () method in ChildClass we create an instance
of childclass. Then we call the write () method. If you observe the ChildClass
does not have a write() method in it. This write () method has been inherited
from the parent BaseClass.
The output of the above program is
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.
In C# the syntax for specifying BaseClass and ChildClass
relationship is shown below. The base class is specified by adding a colon, ":",
after the derived class identifier and then specifying the base class name.
Syntax: class ChildClassName: BaseClass
{
//Body
}
C# supports single class inheritance only. What this means
is, your class can inherit from only one base class at a time. In the code
snippet below, class C is trying to inherit from Class A and B at the same time.
This is not allowed in C#. This will lead to a compile time error: Class 'C'
cannot have multiple base classes: 'A' and 'B'.
publicclassA
{
}
publicclassB
{
}
publicclassC
: A, B
{
}
In C# Multi-Level inheritance is possible. Code snippet below demonstrates
mlti-level
inheritance. Class B is derived from Class A. Class C is
derived from Class B. So class C, will have access to all members present in
both Class A and Class B. As a result of multi-level inheritance Class has
access to A_Method(),B_Method() and C_Method().
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;
PublicclassA
{
PublicvoidA_Method ()
{
Console.WriteLine ("Class A Method Called");
}
}
PublicclassB:
A
{
PublicvoidB_Method ()
{
Console.WriteLine ("Class A Method Called");
}
}
PublicclassC:
B
{
PublicvoidC_Method ()
{
Console.WriteLine ("Class A Method Called");
}
Publicstaticvoid Main ()
{
C C1 = newC ();
C1.A_Method ();
C1.B_Method ();
C1.C_Method ();
}
}
When you derive a class from a base class, the derived class will inherit all
members of the
base class except constructors. In the code snippet below
class B will inherit both M1 and M2 from Class A, but you cannot access M2
because of the private access modifier. Class members declared with a private
access modifier can be accessed only with in the class. We will talk about
access modifiers in our later article.
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;
PublicclassA
{
Publicvoid M1 ()
{
}
Privatevoid M2 ()
{
}
}
PublicclassB:
A
{
Publicstaticvoid Main ()
{
B B1 = newB ();
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.
Using System;
PublicclassParent
{
Publicvoid Write ()
{
Console.WriteLine ("Parent Class write method");
}
}
PublicclassChild:
Parent
{
Publicnewvoid Write ()
{
Console.WriteLine ("Child Class write method");
}
Publicstaticvoid Main ()
{
Child C1 = newChild ();
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:
It allows you to invoke methods of
derived class through base class reference during runtime.
It has the ability for classes to
provide different implementations of methods that are called through the same
name.
Polymorphism is of
two types:
Compile time polymorphism/Overloading
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;
namespacemethod_overloading
{
classProgram
{
publicclassPrint
{
publicvoid display(string
name)
{
Console.WriteLine ("Your name is : " + name);
}
publicvoid display(int
age, float marks)
{
Console.WriteLine ("Your age is : " + age);
Console.WriteLine ("Your marks are :" + marks);
}
}
staticvoid Main(string[]
args)
{
Printobj = newPrint ();
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;
namespacemethod_overloading_polymorphism
{
ClassProgram
{
PublicclassShape
{
Publicvoid 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);
}
PublicvoidArea(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);
}
publicvoid 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);
}
}
Staticvoid Main (string[]
args)
{
Shapeob = newShape ();
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.
No comments:
Post a Comment