These three concepts are sometimes considered as the building block of Object Oriented Programming(OOP).<\/p>\n
We cover the following:<\/p>\n
<\/p>\n
Encapsulation is a construct in OOP that allows both the object and the operations performed on that object (methods) to be bundled into a class and restricts access to the methods of the class.<\/p>\n
When a class is defined, it is normally made up of properties and methods. The properties refers to the attributes of the class while the method are the operations that can be carried out on the object.<\/p>\n
Lets take for example, a class called Person, defined as follows:<\/p>\n
<\/p>\n
<\/p>\n
public<\/span> class<\/span> person<\/span>\u00a0<\/span>\r\n{<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>private<\/span> string Firstname;<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>private<\/span> string Fastname;<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>private<\/span> datetime DateOfBirth;<\/span>\r\n\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>protected<\/span> Age;<\/span>\r\n\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>public<\/span> datetime getDateOfBirth()<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>{<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span> \u00a0<\/span> return<\/span> person.<\/span>DateOfBirth<\/span>;<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span>}<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
In the example above class definition, the person class have been defined with four attributes, Firstname, Lastname, Age and DateOfBirth.<\/span>
\n
\n<\/span>The class have a method GetDateOfBirth() which returns the Date of Birth of the person.<\/span>
\nIn the person class, encapsulation is achieved by the used of the keywords, private, public and protected.<\/span>
\n
\n<\/span>The public keyword<\/span><\/b>
\nThis keyword allows makes the method or attribute accessible both from inside and outside the class.<\/span>
\n
\n<\/span>The private keyword<\/span><\/b>
\nAttributes and methods declared as private can only be accessible by methods inside the class. They can’t be accessible by external classes.<\/span>
\n
\n<\/span>The protected Keyword<\/span><\/b>
\nAttributes declared as protected can be accessed by from within the \u00a0class and is also accessible by derived from that class.<\/span><\/p>\n <\/p>\n
<\/p>\n
2. Inheritance<\/b><\/h3>\n
\n
Inheritance is an OOP concept that allows us to define a class bases on another class. So if two two object have similar attributes and one have been defined, the second object can inherit from the first one.
\nThis concepts make it easy to reuse existing code as well as reduces the size of code to be written. So when creating a new class, the programmer need not write completely new data members and functions, the programmer can designate the class to inherit attributes and functions of an existing class. Here the existing class is called the bases class and the new class that inherits the attributes is called derived class.<\/p>\n
The code below implemented in C# illustrates the concept of inheritance:<\/p>\n
<\/p>\n
\/\/This is the base class<\/span>\r\nclass<\/span> Shape<\/span>\r\n{<\/span>\r\n\u00a0<\/span> \u00a0<\/span> protected<\/span> int<\/span> width;<\/span>\r\n\u00a0<\/span> \u00a0<\/span> protected<\/span> int<\/span> height;<\/span>\r\n\r\n\u00a0<\/span> \u00a0<\/span> public<\/span> void<\/span> setWidth (<\/span>int<\/span> w)<\/span>\r\n\u00a0<\/span> \u00a0<\/span> {<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span> \u00a0<\/span> width =<\/span> w;<\/span>\r\n\u00a0<\/span> \u00a0<\/span> }<\/span>\r\n\u00a0<\/span> \u00a0<\/span> public<\/span> void<\/span> setHeight (<\/span>int<\/span> h)<\/span>\r\n\u00a0<\/span> \u00a0<\/span> {<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span> \u00a0<\/span> height =<\/span> h;<\/span>\r\n\u00a0<\/span> \u00a0<\/span> }<\/span> \u00a0<\/span> \u00a0<\/span>\r\n}<\/span>\r\n\r\n\/\/This is the derived class<\/span>\r\nclass<\/span> \u00a0<\/span>Triangle<\/span> :<\/span> Shape \u00a0<\/span>\/\/Triangle has Shape as the base class<\/span>\r\n{<\/span>\r\n\u00a0<\/span> \u00a0<\/span> public<\/span> getArea()<\/span>\r\n\u00a0<\/span> \u00a0<\/span> {<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span> \u00a0<\/span> \u00a0<\/span>return<\/span> (<\/span>1<\/span>\/<\/span>2<\/span> *<\/span> width *<\/span> height);<\/span>\r\n\u00a0<\/span> \u00a0<\/span> }<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
In the first class, Shape, the width and the height have is declared as protected, which means that they can be accessed by classes derived from it.<\/p>\n
The second class, Triangle does not have attributes of width and height but is meant to derive these properties from the base class, Shape<\/p>\n
The syntax for defining a derived class is<\/p>\n
<\/p>\n
class <derived_class> : <base_class><\/span><\/p>\n<\/h3>\n3. Polymorphism<\/b><\/h3>\n
\n
Polymorphism in Programming is a feature that allows an entity to have many forms. So a function is polymorphic if it can be applied on various types.
\nThere are three types of polymorphism, namely:<\/p>\n
Ad hoc Polymorphism<\/b>: In this type the same function perform different operations depending on the type of argument supplied.
\nThis is also called function overloading or operator overloading. We can illustrate this using the code fragment below:<\/p>\n
<\/p>\n
<\/p>\n
class<\/span> Demo<\/span>\r\n{<\/span>\r\n public<\/span> void<\/span> Add<\/span>(<\/span>int<\/span> x,<\/span> int<\/span> y)<\/span> \/\/ Performs <\/span>\r\n integer addition\r\n {<\/span>\r\n int<\/span> result =<\/span> x\u00a0<\/span>+<\/span> y\r\n Console.<\/span>Writeln<\/span>(<\/span>result);<\/span>\r\n }<\/span>\r\n}<\/span>\r\n\r\n public<\/span> Add<\/span>(<\/span>string s,<\/span> string t)<\/span> \/\/Concatenates the two strings<\/span>\r\n {<\/span>\r\n string result =<\/span> \u00a0<\/span>s.<\/span>Concat<\/span>(<\/span>t);<\/span>\r\n Console.<\/span>Writeln<\/span>(<\/span>result);<\/span>\r\n }<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
From the above class Demo, we see that two functions have been defined both having the same name. So the question would be: which of the definitions would be used when a call to this function is made? The function that would be called would depend on the parameters that are passed in at run time. If integer parameters are given at run time, then the first Add function is called which adds the two numbers together and displays the result. If however, two strings are passed in as parameter, the second function is called which concatenates the two strings and finds the result.<\/p>\n
Parametric Polymorphism<\/b>: Here, a function or data type is written generically such that it can handle values uniformly irrespective of their types. A function is a polymorphic function if it can evaluate or be applied to different types.<\/p>\n
Subtyping<\/b>: This is also called Subtype Polymorphism or inclusion polymorphism. This is when a method name denotes instances of different classes related by a base class. This is the most common type of polymorphism.<\/p>\n
The code fragments below illustrates this various types of polymorphism.<\/p>\n
<\/p>\n
<\/p>\n
public<\/span> class<\/span> Shape<\/span>\r\n{<\/span>\r\n public<\/span> in x {<\/span>get;<\/span> set;}<\/span>\r\n public<\/span> int<\/span> y {<\/span> get;<\/span> set;}<\/span>\r\n public<\/span> height {<\/span>get;<\/span> set}<\/span>\r\n public<\/span> width {<\/span>get;<\/span> set}<\/span>\r\n\r\n public<\/span> virtual void<\/span> Render<\/span>()<\/span> \/\/This is a virtual method<\/span>\r\n\u00a0<\/span> \u00a0<\/span>{<\/span>\r\n\u00a0<\/span> \u00a0<\/span> \u00a0<\/span> Console.<\/span>Write<\/span>(<\/span>\"Initializing drawing tasks...\"<\/span>);<\/span>\r\n\u00a0<\/span> \u00a0<\/span>}<\/span>\r\n}<\/span>\r\n<\/pre>\n <\/p>\n
The above class is the base class, Shape. Other classes would derive from this class for instance, Triangle, Rectangle, Circle, Square etc.
\nNote that the class method Draw have been declared as virtual. This means that if a class is derived from this base class, the derived class can also have a method with the same name and this method in the derived class can provide a definition that overrides the method in the base class.<\/p>\n
<\/p>\n
4. About Virtual Methods<\/b><\/h3>\n
A derived class can override a base class member only if the base class member have been declared as virtual or abstract. The derived member must use the override keyword to show that the method should override the one in the base class.
\nVirtual methods allow you to work with a number of related objects. So if we have a drawing application that have a base class Shape and a number of derived classes for particular shapes, then you may not know at the compile time which specific type of shape the user will create. This means that when the Draw method is invoked on a shape, the definition would be based on the particular shape it is being invoked on and this is determined at run time.<\/p>\n
The code below gives example of some derived classes from the base class, Shape.<\/p>\n
The code below is the derived class for Triangle<\/p>\n
<\/p>\n
\/\/ Derived class for Triangle<\/span>\r\nclass<\/span>