Class:
It is a collection of objects. or we can say class describes , what an object is.
Object:
It is a real time entity. That is a real world existance of any substance can be called as an object. 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, a Student (object) can give the name or
address. In pure OOP terms an object is an instance of a class.
Class is composed of three things
name, attributes, and operations
public
class student
{
}
student blessy=new student ();
According to the above sample we can
say that Student object, named blessy , has created as an object of student 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 Triangle
{
public Triangle()
{
}
protected double height;
protected double width;
public double getarea()
{
Double area=height * width ;
if (area<0)
return 0;
return area;
}
}
In this example we encapsulate some data such as height, width and method getarea. 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 and method getarea. 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.
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.
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
//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
//some other assembly
public void
myFun2()
{
//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;
}
}
[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;
}
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
();
}
}
- 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
}
{
//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'.
public class A
{
}
public class B
{
}
public class C : 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.
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 ();
}
}
- 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.
Are private class members inherited to the derived class?
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:
- 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;
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 ("Blessy");
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.
0 comments:
Post a Comment