oops questions
OOPs questions
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
Multiple inheritance of classes is not allowed in C#.
In C# you can implements more than one interface, thus multiple inheritance is achieved through interface. The Object class defined in the System namespace is implicitly the ultimate base class of all the classes in C# (and the .NET framework)
Structures (struct) in C# does not support inheritance, it can only implements interfaces.
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 member’s access to only the containing type.
3) Protected – Limits the member’s access to the containing type and all classes derived from the containing type.
4) Internal – Limits the member’s 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); }
}
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()
{ Console.WriteLine(“Hello from Child”); }
}
static void main()
{
parent objParent = new child();
objParent.hello();
}
//Output
Hello from Child.
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.
· 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.
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.
Nice efforts...
ReplyDeleteGood
ReplyDeleteIt is explained in simple language and thoroughly.Appreciable Work guys and very informative as well.
ReplyDeleteWow......very good article i found on interface.However I think you should post some more concepts like abstraction,encapsulation & whatever remaining.
ReplyDeletePlease post all that you know coz it gives us(mostly freshers)some idea.Thanks man!
Its nice one to just rewind Ur concept fast, just one advise make proper indenting to the lines and paragraphs as it is Little troubling in reading.........
ReplyDeletevery useful to me.Thank u very much
ReplyDelete