What is polymorphism in Object Oriented Programming (OOPS)

Languages?

In object-oriented programming, polymorphism is a generic term that means

'many shapes'. (from the Greek meaning "having multiple forms").
Polymorphism is briefly described as "one interface, many implementations."
polymorphism is a characteristic of being able to assign a different meaning or
usage to something in different contexts - specifically, to allow an entity such as
a variable, a function, or an object to have more than one form.

There are two types of polymorphism one is compile time polymorphism and
the other is run time polymorphism. Compile time polymorphism is functions
and operators overloading. Runtime time polymorphism is done using
inheritance and virtual functions. Here are some ways how we implement
polymorphism in Object Oriented programming languages

Interface and abstract methods

Like in C# or JAVA different classes implement a common interface in different
ways; is an example of Runtime polymorphism. The interface defines the
abstract member functions (no implementation). In class that implement the
interface; we define body of those abstract members according to the
requirement. Means single definition in interface but multiple implementation in
child classes.

Virtual member functions

Using virtual member functions in an inheritance hierarchy allows run-time
selection of the appropriate member function. A virtual function is a member
function of the base class and which is redefined by the derived class. Such
functions can have different implementations that are invoked by a run-time
determination of the subtype (virtual method invocation, dynamic binding).

What is a Virtual Functions in class?

A virtual function is a member function of the base class and which is

redefined by the derived class. When a derived class inherits the class containing
the virtual function, it has ability to redefine the virtual functions.

A virtual function has a different functionality in the derived class according to

the requirement. The virtual function within the base class provides the form of
the interface to the function. Virtual function implements the philosophy of one
interface and multiple methods (polymorphism).

The virtual functions are resolved at the run time. This is called dynamic
binding. The functions which are not virtual are resolved at compile time which
is called static binding. A virtual function is created using the keyword virtual
which precedes the name of the function.
What is Encapsulation in Object Oriented Programming (OOPS)
Languages?

Encapsulation is the procedure of covering up of data and functions into a

single unit. Encapsulation (also information hiding) consists of separating the
external aspects of an object which are accessible to other objects, from the
internal implementation details of the object, which are hidden from other
objects.

A process, encapsulation means the act of enclosing one or more items within a
(physical or logical) container (Class).

Object-oriented programming is based on encapsulation. When an objects

state and behavior are kept together, they are encapsulated. That is, the data
that represents the state of the object and the methods (Functions and Subs)
that manipulate that data are stored together as a cohesive unit.

The object takes requests from other client objects, but does not expose its
the details of its data or code to them. The object alone is responsible for its own
state, exposing public messages for clients, and declaring private methods that
make up its implementation. The client depends on the (hopefully) simple public
interface, and does not know about or depend on the details of the
implementation.

For example, a HashTable object will take get() and set() requests from other
objects, but does not expose its internal hash table data structures or the code
strategies that it uses.

Explain the advantages of Encapsulation in Object Oriented

Programming Languages.

Benefits of Encapsulation in oops:

Encapsulation makes it possible to separate an objects implementation from its
behavior to restrict access to its internal data. This restriction allows certain
details of an objects behavior to be hidden. It allows us to create a "black box"
and protects an objects internal state from corruption by its clients.

Encapsulation is a technique for minimizing interdependencies among modules

by defining a strict external interface. This way, internal coding can be changed
without affecting the interface, so long as the new implementation supports the
same (or upwards compatible) external interface. So encapsulation prevents a
program from becoming so interdependent that a small change has massive
ripple effects.

The implementation of an object can be changed without affecting the

application that uses it for: Improving performance, fix a bug, consolidate code
or for porting.

Limitations and Restrictions of Interface

The essential idea to remember is that an interface never contains any

implementation. The following restrictions and imitations are natural
consequences of this:

You're not allowed any fields in an interface, not even static ones. A field is an
implementation of an object attribute.

You're not allowed any constructors in an interface. A constructor contains the

statements used to initialize the fields in an object, and an interface does not
contain any fields!

You're not allowed a destructor in an interface. A destructor contains the

statements used to destroy an object instance.

You cannot supply an access modifier. All methods in an interface are implicitly
public.

You cannot nest any types (enums, structs, classes, interfaces, or delegates)
inside an interface.
You're not allowed to inherit an interface from a struct or a class. Structs and
classes contain implementation; if an interface were allowed to inherit from
either, it would be inheriting some implementation

What is an Object?

An object is an instance of a class. It can be uniquely identified by its name and

it defines a state which is represented by the values of its attributes at a
particular time.

An object can be considered a "thing" that can perform a set of activities. The
set of activities that the object performs defines the object's behavior.
The state of the object changes according to the methods which are applied to it.
We refer to these possible sequences of state changes as the behavior of the
object. So the behavior of an object is defined by the set of methods which can
be applied on it.

Objects can communicate by passing messages to each other.

What is inheritance?

Inheritance is the mechanism which allows a class A to inherit properties of a

class B. We say "A inherits from B''. Objects of class A thus have access to
attributes and methods of class B without the need to redefine them.

If class A inherits from class B, then B is called superclass of A. A is called

subclass of B. Objects of a subclass can be used where objects of the
corresponding superclass are expected. This is due to the fact that objects of the
subclass share the same behavior as objects of the superclass. However,
subclasses are not limited to the state and behaviors provided to them by their
superclass. Subclasses can add variables and methods to the ones they inherit
from the superclass.

In the literature you may also find other terms for "superclass" and "subclass".
Superclasses are also called parent classes or base classes. Subclasses may also
be called child classes or just derived classes.

Inheritance Example
Like a car, truck or motorcycles have certain common characteristics- they all
have wheels, engines and brakes. Hence they all could be represented by a
common class Vehicle which encompasses all those attributes and methods that
are common to all types of vehicles.

However they each have their own unique attributes; car has 4 wheels and is
smaller is size to a truck; whereas a motorcycle has 2 wheels. Thus we see a
parent-child type of relationship here where the Car, Truck or Motorcycle can
inherit certain Characteristics from the parent Vehicle; at the same time having
their own unique attributes. This forms the basis of inheritance; Vehicle is the
Parent, Super or the Base class. Car, Truck and Motorcycle become the Child,
Sub or the Derived class

Explain some characteristics of inheritance.

A class inherits the members of its direct base class. Inheritance means that a
class implicitly contains all members of its direct base class, except for the
constructors and destructors of the base class.

Some important aspects of inheritance are:

Inheritance is transitive. If C is derived from B, and B is derived from A, then C
inherits the members declared in B as well as the members declared in A.
A derived class extends its direct base class. A derived class can add new
members to those it inherits, but it cannot remove the definition of an inherited
member.

Constructors and destructors are not inherited, but all other members are,
regardless of their declared accessibility. However, depending on their declared
accessibility, inherited members might not be accessible in a derived class.

A derived class can hide inherited members by declaring new members with the
same name or signature. Note however that hiding an inherited member does
not remove that member; it merely makes that member inaccessible in the
derived class.

An instance of a class contains a set of all instance fields declared in the class
and its base classes, and an implicit conversion exists from a derived class type
to any of its base class types. Thus, a reference to an instance of some derived
class can be treated as a reference to an instance of any of its base classes.

A class can declare virtual methods, properties, and indexers, and derived
classes can override the implementation of these function members. This
enables classes to exhibit polymorphic behavior wherein the actions performed
by a function member invocation varies depending on the run-time type of the
instance through which that function member is invoked.

What is the use of parameter array?

A parameter array enables a many-to-one relationship: many arguments can be

represented by a single parameter array. In other words, parameter arrays
enable variable length argument lists.

A parameter array is declared with a params modifier in C#. There can be only
one parameter array for a given method, and it must always be the last
parameter specified. The type of a parameter array is always a single
dimensional array type. A caller can either pass a single argument of this
array type, or any number of arguments of the element type of this array
type.

What is an Interface in Microsoft.Net?

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

Interface's members can be Events, Methods, Properties and Indexers. But the
interface contains only declaration for its members. Any implementation must be
placed in class that realizes them. The interface can't contain constants, data
fields, constructors, destructors and static members. All the member
declarations inside interface are implicitly public.

What is the method of class?

A method is a member that implements a computation or action that can be

performed by an object or class. Methods have a (possibly empty) list of formal
parameters, a return value (or void), and are either static or non- static. Static
methods are accessed through the class. Non-static methods, which are also
called instance methods, are accessed through instances of the class. Methods
can be overloaded, which means that multiple methods may have the same
name so long as they have unique signatures. The signature of a method
consists of the name of the method and the number, modifiers, and types of its
formal parameters. The signature of a method does not include the return type.

What is a constant?

A constant is a class member that represents a constant value: a value that can
be computed at compile-time.

Constants are permitted to depend on other constants within the same program
as long as there are no circular dependencies. The example

class Constants
{
public const int A = 1;
public const int B = A + 1;
}
shows a class named Constants that has two public constants

What is a field?

A field is a variable that is associated with a class or struct, or an instance of a

class or struct. A field declared with the static modifier defines a static variable,
and a field declared without this modifier defines an instance variable. A static
field is associated with a type, whereas an instance variable is associated with an
instance.

What is static member of class?

A static member belongs to the class rather than to the instances of the class. In
C# data fields, member functions, properties and events can be declared static.
When any instances of the class are created, they cannot be used to access the
static member.

To access a static class member, use the name of the class instead of an
instance variable
Static methods and Static properties can only access static fields and static
events.

Like: int i = Car.GetWheels;

Here Car is class name and GetWheels is static property.

Static members are often used to represent data or calculations that do not
change in response to object state.

What is the difference between value parameter and reference

parameter?

A value parameter is used for "in" parameter passing, in which the value of an
argument is passed into a method, and modifications of the parameter do not
impact the original argument. A value parameter refers to its own variable, one
that is distinct from the corresponding argument. This variable is initialized by
copying the value of the corresponding argument

A reference parameter is used for "by reference" parameter passing, in which

the parameter acts as an alias for a caller-provided argument. A reference
parameter does not itself define a variable, but rather refers to the variable of
the corresponding argument. Modifications of a reference parameter impact the
corresponding argument.

What is the difference between abstract class and interface?

We use abstract class and interface where two or more entities do same type of
work but in different ways. Means the way of functioning is not clear while
defining abstract class or interface. When functionality of each task is not clear
then we define interface. If functionality of some task is clear to us but there
exist some functions whose functionality differs object by object then we declare
abstract class.

We can not make instance of Abstract Class as well as Interface. They

only allow other classes to inherit from them. And abstract functions
must be overridden by the implemented classes. Here are some
differences in abstract class and interface.

An interface cannot provide code of any method or property, just the

signature. We dont need to put abstract and public keyword. All the
methods and properties defined in Interface are by default public
and abstract. An abstract class can provide complete code of
methods but there must exist a method or property without body.

A class can implement several interfaces but can inherit only one
abstract class. Means multiple inheritance is possible in .Net through
Interfaces.

What is a static class?

We can declare a static class. We use static class when there is no data or
behavior in the class that depends on object identity. A static class can have
only static members. We can not create instances of a static class using the new
keyword. .NET Framework common language runtime (CLR) loads Static classes
automatically when the program or namespace containing the class is loaded.

Here are some more features of static class:

• Static classes only contain static members.

• Static classes can not be instantiated. They cannot contain Instance
Constructors
• Static classes are sealed.
• What is static member of class?

A static member belongs to the class rather than to the instances of the
class. In C# data fields, member functions, properties and events
can be declared static. When any instances of the class are created,
they cannot be used to access the static member.
What is the difference between reference parameter and output
parameter?

• Modifications of a reference parameter and output parameter impact the

corresponding argument. So an output parameter is similar to a reference
parameter, except that the initial value of the caller-provided argument is
unimportant.
• In C# a reference parameter is declared with a ref modifier but an output
parameter is declared with an out modifier. Properties are defined with
property declarations. The first part of a property declaration looks quite
similar to a field declaration. The second part includes a get accessor
and/or a set accessor.

Properties that can be both read and written, include both get and set
accessors. The get accessor is called when the property's value is read;
the set accessor is called when the property's value is written. In a set
accessor, the new value for the property is made available via an implicit
parameter named value

What is the property of class?

• A property is a member that provides access to an attribute of an object

or a class. Examples of properties include the length of a string, the size
of a font, the caption of a window, the name of a customer, and so on.

Properties are a natural extension of fields. Both are named members with
associated types, and the syntax for accessing fields and properties is the
same. However, unlike fields, properties do not denote storage locations.
Instead, properties have accessors that specify the statements to be
executed when their values are read or written.