Professional Documents
Culture Documents
Class
A user-defined data structure that groups properties and methods. Class doesnt occupies memory.
Object
Instance of Class is called object. An object is created in memory using keyword new.
What is the difference between instantiating structures with and without using the new keyword?
When a structure is instantiated using the new keyword, a constructor (no-argument or custom, if
provided) is called which initializes the fields in the structure. When a structure is instantiated without
using the new keyword, no constructor is called. Hence, one has to explicitly initialize all the fields of the
structure before using it when instantiated without the new keyword.
Encapsulation
Wrapping up of data and function into a single unit is known as Encapsulation.
Properties
Attribute of object is called properties. Eg1:- A car has color as property.
Eg2:
private string m_Color;;
public string Color
{
get
{
return m_Color;
}
set
{
m_Color = value;
}
}
Car Maruti = new Car();
Maruti.Color= White;
Console.Write(Maruti.Color);
Isn't it better to make a field public than providing its property with both set { } and get { } block? After all the
property will allow the user to both read and modify the field so why not use public field instead? Motivate your
1
Advance OOPS
answer
Not always! Properties are not just to provide access to the fields; rather, they are supposed to provide controlled
access to the fields of our class. As the state of the class depends upon the values of its fields, using properties
we can assure that no invalid (or unacceptable) value is assigned to the fields.
Eg:
2
Advance OOPS
class Circle
{
double x,y,radius;
Circle(double x){
this(x,0,1);
}
Circle(double x, double y){
this(x,y,1);
}
Circle(double x, double y, double radius){
this.x = x;
this.y = y;
this.radius = radius;
}
}
Constructor
A constructor is a special method whose task is to initialize the object of its class.
It is special because its name is the same as the class name.
They do not have return types, not even void and therefore they cannot return values.
They cannot be inherited, though a derived class can call the base class constructor.
Constructor is invoked whenever an object of its associated class is created.
Note: There is always atleast one constructor in every class. If you do not write a constructor, C#
automatically provides one for you, this is called default constructor. Eg: class A, default constructor is
A().
Static members belong to the whole class rather than to individual object
Static members are accessed with the name of class rather than reference to objects.
Eg:
class Test
{
public int rollNo;
public int mathsMarks;
public static int totalMathMarks;
}
class TestDemo
3
Advance OOPS
{
public static void main()
{
Test stud1 = new Test();
stud1.rollNo = 1;
stud1.mathsMarks = 40;
stud2.rollNo = 2;
stud2.mathsMarks = 43;
Test.totalMathsMarks = stud1.mathsMarks + stud2.mathsMarks;
}
}
Static Constructor
In C# it is possible to write a static no-parameter constructor for a class. Such a class is executed once, when
first object of class is created.
One reason for writing a static constructor would be if your class has some static fields or properties that need to
be initialized from an external source before the class is first used.
Eg:
Class MyClass
{
static MyClass()
{
//Initialization Code for static fields and properties.
}
}
4
Advance OOPS
For example
Protected override void Finalize()
{
try
{
Console.WriteLine(Destructing Object.);
//put some code here.
}
finally
{
base.Finalize();
}
}
Destructor
A destructor is just opposite to constructor.
It has same as the class name, but with prefix ~ (tilde).
They do not have return types, not even void and therefore they cannot return values.
destructor is invoked whenever an object is about to be garbage collected
Eg:
class person
{
//constructor
person()
{
}
//destructor
~person()
{
//put resource freeing code here.
}
}
5
Advance OOPS
Finalize() method is called by the .Net Runtime and we can not predict when it will be called. It is
guaranteed to be called when there is no reference pointing to the object and the object is about to be
garbage collected.
Garbage Collection
Garbage collection is the mechanism that reclaims the memory resources of an object when it is no
longer referenced by a variable.
.Net Runtime performs automatically performs garbage collection, however you can force the garbage
collection to run at a certain point in your code by calling System.GC.Collect().
Advantage of Garbage collection : It prevents programming error that could otherwise occur by
incorrectly deleting or failing to delete objects.
Enumeration
Enumeration improves code readability. It also helps in avoiding typing mistake.
Value Type
As name suggest Value Type stores value directly.
For eg:
//I and J are both of type int
I = 20;
J = I;
int is a value type, which means that the above statements will results in two locations in memory.
For each instance of value type separate memory is allocated.
Stored in a Stack.
It Provides Quick Access, because of value located on stack.
Reference Type
# As name suggest Reference Type stores reference to the value.
# For eg:
# Vector X, Y; //Object is defined. (No memory is allocated.)
# X = new Vector(); //Memory is allocated to Object. //(new is responsible for allocating memory.)
# X.value = 30; //Initializing value field in a vector class.
# Y = X; //Both X and Y points to same memory location. //No memory is created for Y.
# Console.writeline(Y.value); //displays 30, as both points to same memory.
# Y.value = 50;
6
Advance OOPS
out keyword
out keyword is used for passing a variable for output purpose. It has same concept as ref keyword, but passing a
ref parameter needs variable to be initialized while out parameter is passed without initialized.
It is useful when we want to return more than one value from the method.
Note: You must assigned value to out parameter in method body, otherwise the method wont compiled.
Inheritance
The process of sub-classing a class to extend its functionality is called Inheritance.
It provides idea of reusability.
7
Advance OOPS
class is specified as the base class of another class. (A sealed class cannot also be an abstract class)
Can you prevent your class from being inherited by another class?
Yes. The keyword sealed will prevent the class from being inherited.
Can you allow a class to be inherited, but prevent the method from being over-ridden?
Yes. Just leave the class public and make the method sealed.
Polymorphism
Polymorphism means same operation may behave differently on different classes.
Eg:
Method Overloading is an example of Compile Time Polymorphism.
Method Overriding is an example of Run Time Polymorphism
Does C#.net supports multiple inheritance?
No. A class can inherit from only one base class, however a class can implements many interface, which servers
some of the same purpose without increasing complexity.
How many types of Access Modifiers.
1) Public Allows the members to be globally accessible.
2) Private Limits the members access to only the containing type.
3) Protected Limits the members access to the containing type and all classes derived from the containing
type.
4) Internal Limits the members access to within the current project.
Method Overloading
Method with same name but with different arguments is called method overloading.
Method Overloading forms compile-time polymorphism.
Eg:
class A1
{
void hello()
{ Console.WriteLine(Hello); }
void hello(string s)
{ Console.WriteLine(Hello {0},s); }
8
Advance OOPS
Method Overriding
Method overriding occurs when child class declares a method that has the same type arguments as a
method declared 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.
Eg1:
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.
Virtual Method
By declaring base class function as virtual, we allow the function to be overridden in any of derived class.
Eg:
Class parent
{
virtual void hello()
{ Console.WriteLine(Hello from Parent); }
}
Class child : parent
{
override void hello()
9
Advance OOPS
What is Interface
An Interface is a group of constants and method declaration.
.Net supports multiple inheritance through Interface.
Interface states what to do, rather than how to do.
An interface defines only the members that will be made available by an implementing object. The
definition of the interface states nothing about the implementation of the members, only the parameters
they take and the types of values they will return. Implementation of an interface is left entirely to the
implementing class. It is possible, therefore, for different objects to provide dramatically different
implementations of the same members.
Example1, the Car object might implement the IDrivable interface (by convention, interfaces usually
begin with I), which specifies the GoForward, GoBackward, and Halt methods. Other classes, such as
Truck, Aircraft, Train or Boat might implement this interface and thus are able to interact with the Driver
object. The Driver object is unaware of which interface implementation it is interacting with; it is only
aware of the interface itself.
Example2, an interface named IShape, which defines a single method CalculateArea. A Circle class
implementing this interface will calculate its area differently than a Square class implementing the same
interface. However, an object that needs to interact with an IShape can call the CalculateArea method in
either a Circle or a Square and obtain a valid result.
Practical Example
public interface IDrivable
{
void GoForward(int Speed);
}
10
Advance OOPS
}
}
Extra
Each variable declared in interface must be assigned a constant value.
Every interface variable is implicitly public, static and final.
Every interface method is implicitly public and abstract.
Interfaces are allowed to extends other interfaces, but sub interface cannot define the methods declared
in the super interface, as sub interface is still interface and not class.
If a class that implements an interface does not implements all the methods of the interface, then the
class becomes an abstract class and cannot be instantiated.
Both classes and structures can implement interfaces, including multiple interfaces.
Multiple A class may implement several A class may extend only one
inheritance interfaces. abstract class.
11
Advance OOPS
12
Advance OOPS
If your client code talks only in Just like an interface, if your client
terms of an interface, you can code talks only in terms of an
Maintenance easily change the concrete abstract class, you can easily
implementation behind it, using a change the concrete implementation
factory method. behind it, using a factory method.
13