Inheritance :

Inheritance is a way to form new classes (instances of which are called objects) using classes that
have already been defined.

Inheritance is employed to help reuse existing code with little or no modification.

The new classes, known as Sub-class or derived class, inherit attributes and behavior of the pre-

existing classes, which are referred to as Super-class or Base class.

C# supports two types of Inheritance mechanisms
1) Implementation Inheritance
2) Interface Inheritance
Implementation Inheritance:
When a class (type) is derived from another class (type) such that it inherits all the members of the base type it is
Implementation Inheritance
Interface Inheritance:
When a type (class or a struct) inherits only the signatures of the functions from another type it is Interface Inheritance.
Benefits of using Inheritance

Once a behavior (method) or property is defined in a super class (base class),that behavior or
property is automatically inherited by all subclasses (derived class).

Code reusability increased through inheritance

Inheritance provide a clear model structure which is easy to understand without much complexity
Using inheritance, classes become grouped together in a hierarchical tree structure
Code are easy to manage and divided into parent and child classes

public class ParentClass

{

public ParentClass()
{

Console.WriteLine("Parent Constructor.");

}
public void print()
{

Console.WriteLine("Parent Class.");

}
}
public class ChildClass : ParentClass
{

public ChildClass()
{

Console.WriteLine("Child Constructor.");

}
public static void Main()
{

ChildClass child = new ChildClass();

child.print();

}
Output:
Parent Constructor.
Child Constructor.
Parent Class.

Encapsulation :

Encapsulation is a procedure of covering up of the data & functions into a single unit called as class
An encapsulated object is often called an abstract data type.
Encapsulation can protect your data from accidental corruption.

Rather than defining the data in the form of public, we can declare those fields as private.
Code Example :

public class School

{
private string Schooldepartname;
public string SchoolDepartname
{
get
{
return Schooldepartname;
}
set
{
Schooldepartname =value;
}
}
}
public class Departmentmain
{
public static int Main(string[] args)
{

School d= new School();

d.SchoolDepartname="Communication";
Console.WriteLine("The Dept. Name is :{0}",d.SchoolDepartname);
return 0;
}
}
Output:
The Dept. Name is : Communication
Benefits of Encapsulation :

In Encapsulation fields of a class can be read-only or can be write-only.

A class can have control over in its fields.
A class can change data type of its fields anytime but users of this class do not need to change any

code.
From the above we can see the use of Encapsulation by using properties. The property has two accessor get and set. The get
accessor returns the value of the some property field. The set accessor sets the value of the some property field with the
contents of "value". Properties can be made read-only. This is accomplished by having only a get accessor in the property
implementation.

Abstraction :

Abstraction refers to the act of representing essential features without including

the background details or explanations.

Abstraction defines way to abstract or hide your data and members from outside world.
Classes use the concept of abstraction and are defined as a list of abstract attributes.
Simply speaking Abstraction is hiding the complexities of your class or struct or in a generic term
Type from outer world.

This is achieved by means of access specifiers.

Access Modifier

Description (who can access)

Private
Protected

Only members within the same type. (default for type members)
Only derived types or members of the same type.
Only code within the same assembly. Can also be code external to object as long as
it is in the same assembly. (default for types)
Either code from derived type or code in the same assembly. Combination of
protected OR internal.
Any code. No inheritance, external type, or external assembly restrictions.

Internal
Protected internal
Public
Code Example :

namespace AbstractionExample
{
public abstract class Shape
{
private float _area;

private float _perimeter;

public float Area

{
get
{
return _area;
}
set
{
_area = value;
}
}
public float Perimeter
{
get
{
return _perimeter;
}
set
{
_perimeter = value;
}
}
public abstract void CalculateArea();
public abstract void CalculatePerimeter();
}

Advantages of abstraction are the hiding of implementation details, component reuse, extensibility,
and testability. When we hide implementation details, we reveal a cleaner, more comprehensible and
usable interface to our users. We are separating our interface from our implementation, and this
makes component reuse more practical. Many, if not all of the object-oriented concepts we have
discussed throughout this document play a role in the abstraction principle. Working together, their
end goal is the same, to produce software that is flexible, testable, maintainable, and extensible.

Polymorphism :
May 11, 2011

Polymorphism means the ability to take more than one form.

An operation may exhibit different behaviors in different instances.
The behavior depends on the data types used in the operation.
Polymorphism is extensively used in implementing Inheritance.
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.

public class Customer

{
public virtual void CustomerType()
{
Console.WriteLine("I am a customer");
}
}
public class CorporateCustomer : Customer
{
public override void CustomerType()
{
Console.WriteLine("I am a corporate customer");
}
}
public class PersonalCustomer : Customer
{

public override void CustomerType()

{
Console.WriteLine("I am a personal customer");
}
}
public class MainClass
{
public static void Main()
{
Customer[] C = new Customer[3];
C[0] = new CorporateCustomer();
C[1] = new PersonalCustomer();
C[2] = new Customer();
foreach (Customer CustomerObject in C)
{
CustomerObject.CustomerType();
}
}
}
Output:
I am a corporate customer
I am a personal customer
I am a customer
Method Overloading ( Compile Time Polymorphism):

Method with same name but with different arguments is called method overloading.

Method Overloading forms compile-time polymorphism.

Example of Method Overloading:

class A1
{
void hello()
{

Console.WriteLine("Hello");
}

void hello(string s)
{
Console.WriteLine("Hello {0}", s);
}
}

Method Overriding (Run Time Polymorphism) :

Method overriding occurs when child class declares a method that has the same type arguments as
a methoddeclared by one of its superclass.

Method overriding forms Run-time polymorphism.

Note: By default functions are not virtual in C# and so you need to write virtual explicitly. While by

default in Java each function are virtual.

Example of Method Overriding:

class parent
{
virtual void hello()
{
Console.WriteLine("Hello from Parent");
}
}

class child : parent

{
override void hello()
{
Console.WriteLine("Hello from Child");
}

static void main()

{
parent objParent = new child();
objParent.hello();
}
Output:
Hello from Child.

Interface :
May 11, 2011

Interface is nothing but an contract of the system which can be implemented on accounts.
.Net doesn't support the multiple inheritance directly but using interfaces we can achieve
multiple inheritance in .net.

An Interface can only contains abstract members and it is a reference type.

Interface members can be Methods, Properties, Events and Indexers. But the interfaces only
contains declarationfor its members.

Class which inherits interface needs to implement all it's methods.

All declared interface member are implicitly public.

class Program
{
interface BaseInterface
{
void BaseInterfaceMethod();
}
interface DerivedInterface : BaseInterface
{
void DerivedToImplement();
}
class InterfaceImplementer : DerivedInterface
{

public void DerivedToImplement()

{
Console.WriteLine("Method of Derived Interface called.");
}
public void BaseInterfaceMethod()
{
Console.WriteLine("Method of Base Interface called.");
}
}
static void Main(string[] args)
{
InterfaceImplementer er = new InterfaceImplementer();
er.DerivedToImplement();
er.BaseInterfaceMethod();
Console.Read();
}
}
Output:
Method of Derived Interface called.
Method of Base Interface called.

Difference between Interface and abstract class, follow the below

link:
http://www.codeproject.com/Articles/11155/Abstract-Class-versusInterface

For array list:

http://www.dotnetperls.com/arraylist

For Linked List:

http://www.dotnetperls.com/linkedlist