You are on page 1of 15

OOPs Interview Questions

OOPs FAQs : Object Oriented Interview Questions

Class
A user-defined data structure that groups properties and methods. Class doesn’t occupies memory.

Object
Instance of Class is called object. An object is created in memory using keyword “new”.

Difference between Struct and Class


• <!--[if !supportLists]--> Struct are Value type and are stored on stack, while Class are
Reference type and are stored on heap.<!--[endif]-->
• <!--[if !supportLists]--> Struct “do not support” inheritance, while class supports
inheritance. However struct can implements interface.<!--[endif]-->
• <!--[if !supportLists]--> Struct should be used when you want to use a small data structure,
while Class is better choice for complex data structure.

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 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:

private int age;


public int Age
{
get
{
return age;
}
set
{
if(value <> 100)
//throw exception
else
age = value;
}
}

this Keyword
Each object has a reference “this” which points to itself.
<!--[if !supportLists]-->Two uses of this keyword.<!--[endif]-->
<!--[if !supportLists]-->o Can be used to refer to the current object.<!--[endif]-->
<!--[if !supportLists]-->o It can also be used by one constructor to explicitly invoke
another constructor of the same class.<!--[endif]-->
Eg1:
class Student
{
private string name;
private int age;
Student(string name, int age)
{
this.name = name;
this.age = age;
}
}
Eg2:
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
• <!--[if !supportLists]--> A constructor is a special method whose task is to initialize the
object of its class.<!--[endif]-->
• <!--[if !supportLists]--> It is special because its name is the same as the class name.<!--
[endif]-->
• <!--[if !supportLists]--> They do not have return types, not even void and therefore they
cannot return values.<!--[endif]-->
• <!--[if !supportLists]--> They cannot be inherited, though a derived class can call the base
class constructor.<!--[endif]-->
• <!--[if !supportLists]--> Constructor is invoked whenever an object of its associated class is
created.<!--[endif]-->
• 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().
<!--[if !supportLists]--><!--[endif]-->
Static Members of the class

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
{
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 Method of the class


<!--[if !supportLists]--> Methods that you can call directly without first creating an instance of a
class. Eg: Main() Method, Console.WriteLine()<!--[endif]-->
<!--[if !supportLists]--> You can use static fields, methods, properties and even constructors
which will be called before any instance of the class is created. <!--[endif]-->
<!--[if !supportLists]--> As static methods may be called without any reference to object,
you can not use instance members inside static methods or properties, while you may
call a static member from a non-static context. The reason for being able to call static
members from non-static context is that static members belong to the class and are
present irrespective of the existence of even a single object. <!--[endif]-->

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.
}
}
Finalize() Method of Object class
Each class in C# is automatically (implicitly) inherited from the Object class which contains a
method Finalize(). This method is guaranteed to be called when your object is garbage collected
(removed from memory). You can override this method and put here code for freeing resources that
you reserved when using the object.
For example
Protected override void Finalize()
{
try
{
Console.WriteLine(“Destructing Object….”);
//put some code here.
}
finally
{
base.Finalize();
}
}

Destructor
<!--[if !supportLists]--> A destructor is just opposite to constructor.<!--[endif]-->
<!--[if !supportLists]--> It has same as the class name, but with prefix ~ (tilde).<!--[endif]-->
<!--[if !supportLists]--> They do not have return types, not even void and therefore they cannot
return values.<!--[endif]-->
<!--[if !supportLists]--> destructor is invoked whenever an object is about to be garbage
collected<!--[endif]-->
Eg:
class person
{
//constructor
person()
{
}
//destructor
~person()
{
//put resource freeing code here.
}
}
What is the difference between the destructor and the Finalize() method? When does the
Finalize() method get called?
Finalize() corresponds to the .Net Framework and is part of the System.Object class. Destructors are
C#'s implementation of the Finalize() method. The functionality of both Finalize() and the
destructor is the same, i.e., they contain code for freeing the resources when the object is about to be
garbage collected. In C#, destructors are converted to the Finalize() method when the program is
compiled. The 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
• <!--[if !supportLists]--> Garbage collection is the mechanism that reclaims the memory
resources of an object when it is no longer referenced by a variable.<!--[endif]-->
• <!--[if !supportLists]--> .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().<!--[endif]-->
• <!--[if !supportLists]--> Advantage of Garbage collection : It prevents programming error
that could otherwise occur by incorrectly deleting or failing to delete objects.<!--[endif]-->

Enumeration
Enumeration improves code readability. It also helps in avoiding typing mistake.

Concept of Heap and Stack


Local Variables Stack
Free Memory Heap
(Larger Memory Area than Stack).

Global Variables
Permanent Storage area
Program Instruction

The Program Instruction and Global and Static variables are stored in a region known as permanent
storage area and the local variables are stored in another area called stack. The memory space
located between these two regions is available for dynamic memory allocation during execution of
program. This free memory region is called heap. The size of heap keeps on changing when
program is executed due to creation and death of variables that are local to functions and blocks.
Therefore, it is possible to encounter memory “overflow” during dynamic allocation process.

<!--[if !supportLineBreakNewLine]--> <!--[endif]-->


Value Type and Reference Type
A variable is value type or reference type is solely determined by its data type.
Eg: int, float, char, decimal, bool, decimal, struct, etc are value types, while object type such as
class, String, Array, etc are reference type.

Value Type
<!--[if !supportLists]--> As name suggest Value Type stores “value” directly.<!--[endif]-->
<!--[if !supportLists]--> For eg: <!--[endif]-->
<!--[if !supportLists]--> //I and J are both of type int<!--[endif]-->
<!--[if !supportLists]--> I = 20;<!--[endif]-->
<!--[if !supportLists]--> J = I;<!--[endif]-->
<!--[if !supportLists]--> int is a value type, which means that the above statements will
results in two locations in memory.<!--[endif]-->
<!--[if !supportLists]--> For each instance of value type separate memory is allocated.<!--
[endif]-->
<!--[if !supportLists]--> Stored in a Stack.<!--[endif]-->
<!--[if !supportLists]--> It Provides Quick Access, because of value located on stack.<!--
[endif]-->

Reference Type
<!--[if !supportLists]--> As name suggest Reference Type stores “reference” to the value.<!--
[endif]-->
<!--[if !supportLists]--> For eg: <!--[endif]-->
<!--[if !supportLists]--> Vector X, Y; //Object is defined. (No memory is allocated.)<!--
[endif]-->
<!--[if !supportLists]--> X = new Vector(); //Memory is allocated to Object. //(new is
responsible for allocating memory.)<!--[endif]-->
<!--[if !supportLists]--> X.value = 30; //Initialising value field in a vector class.<!--
[endif]-->
<!--[if !supportLists]--> Y = X; //Both X and Y points to same memory location. //No
memory is created for Y.<!--[endif]-->
<!--[if !supportLists]--> Console.writeline(Y.value); //displays 30, as both points to same
memory<!--[endif]-->
<!--[if !supportLists]--> Y.value = 50;<!--[endif]-->
<!--[if !supportLists]--> Console.writeline(X.value); //displays 50.<!--[endif]-->
<!--[if !supportLists]--> Note: If a variable is reference it is possible to indicate that it
does not refer to any object by setting its value to null;<!--[endif]-->
<!--[if !supportLists]--> Reference type are stored on Heap.<!--[endif]-->
<!--[if !supportLists]--> It provides comparatively slower access, as value located on heap.<!--
[endif]-->
ref keyword
Passing variables by value is the default. However, we can force the value parameter to be passed
by reference. Note: variable “must” be initialized before it is passed into a method.
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 won’t
compiled.

Boxing and Un-Boxing


Boxing: means converting value-type to reference-type.
Eg:
int I = 20;
string s = I.ToSting();
UnBoxing: means converting reference-type to value-type.
Eg:
int I = 20;
string s = I.ToString(); //Box the int
int J = Convert.ToInt32(s); //UnBox it back to an int.
Note: Performance Overheads due to boxing and unboxing as the boxing makes a copy of value
type from stack and place it inside an object of type System.Object in the heap.
Inheritance
The process of sub-classing a class to extend its functionality is called Inheritance.
It provides idea of reusability.

Order of Constructor execution in Inheritance


constructors are called in the order from the top to the bottom (parent to child class) in inheritance
hierarchy.

Order of Destructor execution in Inheritance


The destructors are called in the reverse order, i.e., from the bottom to the top (child to parent
class) in the inheritance hierarchy.
What are Sealed Classes in C#?
The sealed modifier is used to prevent derivation from a class. A compile-time error occurs if a sealed
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.

Fast Facts of Inheritance


<!--[if !supportLists]--> Multiple inheritance of classes is not allowed in C#.<!--[endif]-->
<!--[if !supportLists]--> In C# you can implements more than one interface, thus multiple
inheritance is achieved through interface.<!--[endif]-->
<!--[if !supportLists]--> The Object class defined in the System namespace is implicitly the
ultimate base class of all the classes in C# (and the .NET framework) <!--[endif]-->
<!--[if !supportLists]--> Structures (struct) in C# does not support inheritance, it can only
implements interfaces.<!--[endif]-->

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.
<!--[if !supportLists]-->1) Public – Allows the members to be globally accessible.<!--[endif]-->
<!--[if !supportLists]-->2) Private – Limits the member’s access to only the containing type.<!--
[endif]-->
<!--[if !supportLists]-->3) Protected – Limits the member’s access to the containing type and all
classes derived from the containing type.<!--[endif]-->
<!--[if !supportLists]-->4) Internal – Limits the member’s access to within the current
project.<!--[endif]-->

Method Overloading
<!--[if !supportLists]--> Method with same name but with different arguments is called method
overloading.<!--[endif]-->
<!--[if !supportLists]--> Method Overloading forms compile-time polymorphism.<!--[endif]-->
<!--[if !supportLists]--> Eg:<!--[endif]-->
class A1
{
void hello()
{ Console.WriteLine(“Hello”); }
void hello(string s)
{ Console.WriteLine(“Hello {0}”,s); }
}

Method Overriding
<!--[if !supportLists]--> Method overriding occurs when child class declares a method that has
the same type arguments as a method declared by one of its superclass.<!--[endif]-->
<!--[if !supportLists]--> Method overriding forms Run-time polymorphism.<!--[endif]-->
<!--[if !supportLists]--> 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.<!--[endif]-->
<!--[if !supportLists]--> Eg1:<!--[endif]-->
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()
{ Console.WriteLine(“Hello from Child”); }
}
static void main()
{
parent objParent = new child();
objParent.hello();
}
//Output
Hello from Child.

Concept of Interface
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);
}

public class Truck : IDrivable


{
public void GoForward(int Speed)
{
// Implementation omitted
}
}

public class Aircraft : IDrivable


{
public void GoForward(int Speed)
{
// Implementation omitted
}
}

public class Train : IDrivable


{
public void GoForward(int Speed)
{
// Implementation omitted
}
}

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.

Making choice between Interface and Abstract Class


In which Scenario you will go for Interface or Abstract Class?
Interfaces, like classes, define a set of properties, methods, and events. But unlike classes, interfaces
do not provide implementation. They are implemented by classes, and defined as separate entities from
classes. Even though class inheritance allows your classes to inherit implementation from a base class, it
also forces you to make most of your design decisions when the class is first published.
Abstract classes are useful when creating components because they allow you specify an invariant level
of functionality in some methods, but leave the implementation of other methods until a specific
implementation of that class is needed. They also version well, because if additional functionality is
needed in derived classes, it can be added to the base class without breaking code.

Difference between Interface and Abstract Class


Interfaces vs. Abstract Classes

Feature Interface Abstract class

Multiple A class may implement several A class may extend only one
inheritance interfaces. abstract class.

An abstract class can provide


Default An interface cannot provide any
complete code, default code,
implementatio code at all, much less default
and/or just stubs that have to be
n code.
overridden.

Static final constants only, can


use them without qualification in
classes that implement the
Both instance and static
interface. On the other paw,
constants are possible. Both
these unqualified names pollute
Constants static and instance intialiser code
the namespace. You can use
are also possible to compute the
them and it is not obvious
constants.
where they are coming from
since the qualification is
optional.

An interface implementation A third party class must be


Third party
may be added to any existing rewritten to extend only from the
convenience
third party class. abstract class.

An abstract class defines the


Interfaces are often used to core identity of its descendants.
describe the peripheral abilities If you defined a Dog abstract
of a class, not its central class then Damamation
Is-a vs -able identity, e.g. an Automobile descendants are Dogs, they are
or can-do class might implement the not merely dogable.
Recyclable interface, which Implemented interfaces
could apply to many otherwise enumerate the general things a
totally unrelated objects. class can do, not the things a
class is.

Plug-in You can write a new You must use the abstract class
replacement module for an as-is for the code base, with all
interface that contains not one its attendant baggage, good or
stick of code in common with bad. The abstract class author
the existing implementations. has imposed structure on you.
When you implement the Depending on the cleverness of
the author of the abstract class,
this may be good or bad.
Another issue that's important is
what I call "heterogeneous vs.
homogeneous." If
interface, you start from scratch
implementors/subclasses are
without any default
homogeneous, tend towards an
implementation. You have to
abstract base class. If they are
obtain your tools from other
heterogeneous, use an interface.
classes; nothing comes with the
(Now all I have to do is come up
interface other than a few
with a good definition of
constants. This gives you
hetero/homogeneous in this
freedom to implement a
context.) If the various objects
radically different internal
are all of-a-kind, and share a
design.
common state and behavior,
then tend towards a common
base class. If all they share is a
set of method signatures, then
tend towards an interface.

If the various implementations


If all the various
are all of a kind and share a
implementations share is the
Homogeneity common status and behavior,
method signatures, then an
usually an abstract class works
interface works best.
best.

Just like an interface, if your


If your client code talks only in
client code talks only in terms of
terms of an interface, you can
an abstract class, you can easily
Maintenance easily change the concrete
change the concrete
implementation behind it, using
implementation behind it, using
a factory method.
a factory method.

Slow, requires extra indirection


to find the corresponding
method in the actual class.
Speed Fast
Modern JVMs are discovering
ways to reduce this speed
penalty.

You can put shared code into an


The constant declarations in an abstract class, where you cannot
interface are all presumed into an interface. If interfaces
public static final, so you may want to share code, you will
leave that part out. You can't have to write other bubblegum
call any methods to compute to arrange that. You may use
Terseness
the initial values of your methods to compute the initial
constants. You need not declare values of your constants and
individual methods of an variables, both instance and
interface abstract. They are all static. You must declare all the
presumed so. individual methods of an abstract
class abstract.

If you add a new method to an If you add a new method to an


interface, you must track down abstract class, you have the
Adding all implementations of that option of providing a default
functionality interface in the universe and implementation of it. Then all
provide them with a concrete existing code will continue to
implementation of that method. work without change.