OOPS

Inheritance

In the real world there are many objects that can be specialized. In OOP, a parent class can inherit its behavior and state to children classes. This concept was developed to manage generalization and specialization in OOP and is represented by a is-a relationship.

The following OO terms are commonly used names given to parent and child classes in OOP:

·         Superclass: Parent class.

·         Subclass: Child class.

·         Base class: Parent class.

·         Derived class: Child class

The most common real world sample to explain inheritance is the geometric shapes object model. Squares, circles, triangles, rectangles, pentagons, hexagons, and octagons are geometric shapes. The following figure shows a sample set of geometric figures:

Figure 2. The Shape class is the parent class. Square, Rectangle, and Circle are derived classes that inherit from Shape. The triangle-connector in the diagram represents an is-a relationship.

The .NET framework has many base classes. Everything is derived from System.Object. You can create almost anything you imagine using the built-in functionality provided in the .NET Framework Class Library.

To create a derived class in C#, the class declaration should be done as:

class child: parent

To create a derived class in VB.NET, the class declaration should be done as:

Class child
Inherits parent
End Class

Multiple inheritance

Multiple inheritance is the possibility that a child class can have multiple parents. Human beings have always two parents, so a child will have characteristics from both parents.

In OOP, multiple inheritance might become difficult to handle because it allows ambiguity for the compiler. There are programming languages such as C++ that allow multiple inheritance; however, other programming languages such as Java and the .NET Framework languages do not allow multiple inheritance. Multiple inheritance can be emulated in .NET using Multiple Interface Inheritance, which I will explain in Part 3 of this series.

Sealed class

A sealed class is a class that does not allow inheritance. Some object model designs need to allow the creation of new instances but not inheritance, if this is the case, the class should be declared as sealed.

To create a sealed class in C#, the class declaration should be done as:

sealed class Shape

To create a sealed class in VB.NET, the class declaration should be done as:

NonInheritable Class Shape

Abstraction

Abstraction is "the process of identifying common patterns that have systematic variations; an abstraction represents the common pattern and provides a means for specifying which variation to use" (Richard Gabriel).

An abstract class is a parent class that allows inheritance but can never be instantiated. Abstract classes contain one or more abstract methods that do not have implementation. Abstract classes allow specialization of inherited classes.

Figure 2 shows a Shape class, which is an abstract class. In the real world, you never calculate the area or perimeter of a generic shape, you must know what kind of geometric shape you have because each shape (eg. square, circle, rectangle, etc.) has its own area and perimeter formulas. The parent class shape forces all derived classes to define the behavior for CalculateArea() and CalculatePerimeter(). Another great example is a bank account. People own savings accounts, checking accounts, credit accounts, investment accounts, but not generic bank accounts. In this case, a bank account can be an abstract class and all the other specialized bank accounts inherit from bank account.

To create an abstract class in C#, the class declaration should be done as:

abstract class Shape

To create an abstract class in VB.NET, the class declaration should be done as:

MustInherit Class Shape

To following code shows a sample implementation of an abstract class:

/// C#
using System;
namespace DotNetTreats.OOSE.OOPSamples
{
public abstract class Shape
{
private float _area;
private System.Drawing.Color _color;
private float _perimeter;
public float Area
{
get
{
return _area;
}
set
{
_area = value;
}
}
public System.Drawing.Color Color
{
get
{
return _color;
}
set
{
_color = value;
}
}
public float Perimeter
{
get
{
return _perimeter;
}
set
{
_perimeter = value;
}
}
public abstract void CalculateArea();
public abstract void CalculatePerimeter();
}
}

Listing 1. The Shape abstract class in C#.

Polymorphism

Polymorphism allows objects to be represented in multiple forms. Even though classes are derived or inherited from the same parent class, each derived class will have its own behavior. Polymorphism is a concept linked to inheritance and assures that derived classes have the same functions even though each derived class performs different operations.

Figure 2 shows a Rectangle, a Circle, and Square. All of them are shapes and as shapes their area and perimeter can be calculated; however, each shape calculates its area in a specialized way. Declaring a member as abstract allows polymorphism. The Shape class defines the CalculateArea() and CalculatePerimeter() methods as abstract, this allows each derived class to override the implementation of the parent's methods.

To following sample code shows an implementation of a derived class (rectangle). The specific CalculateArea() and CalculatePerimeter() methods for the rectangle class illustrate polymorphism:

/// C#
using System;
namespace DotNetTreats.OOSE.OOPSamples
{
class Rectangle : Shape
{
private float _height;
private float _width;
public rectangle(float height, float width)
{
_height = height;
_width = width;
}
public float Height
{
get
{
return _height;
}
set
{
_height = value;
}
}
public float Width
{
get
{
return _width;
}
set
{
_width = value;
}
}
public override void CalculateArea()
{
this.Area = _height * _width;
}
public override void CalculatePerimeter()
{
this.Perimeter = (_height * 2) + (_width * 2);
}
}
}

Listing 2. Polymorphism represented in the Rectangle's methods.

Virtual keyword

The virtual keyword allows polymorphism too. A virtual property or method has an implementation in the base class, and can be overriden in the derived classes.

To create a virtual member in C#, use the virtual keyword:

public virtual void Draw()

To create a virtual member in VB.NET, use the Overridable keyword:

Public Overridable Function Draw()

Override keyword

Overriding is the action of modifying or replacing the implementation of the parent class with a new one. Parent classes with virtual or abstract members allow derived classes to override them.

To override a member in C#, use the override keyword:

public override void CalculateArea()

To override a member in VB.NET, use the Overrides keyword:

Public Overrides Function CalculateArea()

 

What is Run Time Polymorpism and Complie Time Polymmorpism
Overloading is compile time polymorphism because compiler checkes the method sigantures while compiling itself.(i. e: Method names Argument types argument creation order etc...)
Overriding is run time polymorphism.

compile time polymorphism -- method overloding
run time time polymorphism -- method overriding

Overloading is compile time polymorphism also called early binding.
Overriding is runtime polymorphism also called late binding.

compile time polymorpism also known as staic polymorpism
run time polymorpism also known as dynamic polymorpism
example for static poly is method overloading

example for dynamic poly is method overriding
static poly is linking method call at the time of compilation time
dynamic poly is linking method call at the time of runing time



What is an Object?

An object is a software bundle of variables and related methods. Objects are related to real life scenario. Class is the general thing and object is the specialization of general thing. Objects is instance of classes.

Declaration of an Object
ClassName objectName=new ClassName()

 Person objPerson= new Person()

 An object is characterized by concepts like

• Attribute
• Behavior
• Identity

 

What is Inheritance ?

• Inheritance, together with encapsulation and polymorphism, is one of the three primary characteristics (concept) of object-oriented programming
• Inheritance enables you to create new classes that reuse, extend, and modify the behavior that is defined in other classes
• The Class whose methods and variables are defined is called super class or base class
• The Class that inherits methods and variables are defined is called sub class or derived class
• Sometimes base class known as generalized class and derived class known as specialized class
• Keyword to declare inheritance is “:” (colon) in visual c#

Benefits of 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

What is Encapsulation ?

• Encapsulation is one of the fundamental principles of object-oriented programming.
• Encapsulation is a process of hiding all the internal details of an object from the outside world.
• Encapsulation is the ability to hide its data and methods from outside the world and only expose data and methods that are required
• Encapsulation is a protective barrier that prevents the code and data being randomly accessed by other code or by outside the class
• Encapsulation gives us maintainability, flexibility and extensibility to our code.
• Encapsulation makes implementation inaccessible to other parts of the program and protect from whatever actions might be taken outside the function or class.
• Encapsulation provides a way to protect data from accidental corruption
• Encapsulation hides information within an object
• Encapsulation is the technique or process of making the fields in a class private and providing access to the fields using public methods
• Encapsulation gives you the ability to validate the values before the object user change or obtain the value
• Encapsulation allows us to create a "black box" and protects an objects internal state from corruption by its clients.

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

What is Polymorphism ?

• Polymorphism is one of the primary characteristics (concept) of object-oriented programming
• Poly means many and morph means form. Thus, polymorphism refers to being able to use many forms of a type without regard to the details
• Polymorphism is the characteristic of being able to assign a different meaning specifically, to allow an entity such as a variable, a function, or an object to have more than one form
• Polymorphism is the ability to process objects differently depending on their data types
• Polymorphism is the ability to redefine methods for derived classes.

Types of Polymorphism

• Compile time Polymorphism
• Run time Polymorphism

What is Access Modifier?

Access modifiers determine the extent to which a variable or method can be accessed from another class or object.

• Private
• Protected
• Internal
• Protected Internal
• Public

Method Overriding 

When one class inherit from another class ,all the member of parent class become the member of child class .If there is a method of parent class that we want to predefined in child class. we can implement the concept of method overriding ,it means a method overriding of parents class and child class can have same method name with same parameter but parent class method will have "VIRTUAL"Keyword and child class method have "OVERRIDE"Keyword.

Method Overloading 

We can  used more than one Method with same name within same class but with different parameter that is called method overloading. When the basic functionality of more than one method is same but they are used different parameter, then we can implement method overloading.

Difference between Abstract and Interface

 Abstract Class
-Abstract class provides a set of rules to implement next class
-Rules will be provided through abstract methods
-Abstract method does not contain any definition
-While inheriting abstract class all abstract methods must be override
-If a class contains at least one abstract method then it must be declared as an “Abstract Class”
-Abstract classes cannot be instantiated (i.e. we cannot create objects), but a reference can be created
-Reference depends on child class object’s memory
-Abstract classes are also called as “Partial abstract classes”
-Partial abstract class may contain functions with body and functions without body
-If a class contains all functions without body then it is called as “Fully Abstract Class” (Interface)

Interface:
-If a class contains all abstract methods then that class is known as “Interface”
-Interfaces support like multiple inheritance
-In interface all methods r public abstract by default
-Interfaces r implementable
-Interfaces cannot be instantiated, but a reference can be created

difference between Abstract Class and Interface

a.    In abstract class method can have declaration as well as definition also. But Interface 

       should have only declaration.
b.    All the Methods are Public as default and don’t have any access Modifier Controls in 

       interface, whereas for abstract class we can have access modifier for methods.
c.    Abstract class can have constructor or destructor, whereas interface not.
d.    Abstract class can’t be part of multiple inheritance 

       and we can implement multiple interface.