Skip to main content

OOPs simply explained

What is OOPs ? It is Object Oriented Programming. It comprises of

  1. Polymorphism
  2. Encapsulation
  3. Inheritance
  4. Abstraction
Already lost me ? Now here it is read about OOPs as if you deal with it every day. Let's take at OOPs from a Corporate world point of view. There is an organization which comprises of several employees which form a hierarchy.
Now every employee has their way of working, some work hard, some like to delegate and some are smart. Though everyone does work in office, they do it in their own way. This is Polymorphism (implementing a function differently while keeping the semantics of function same).
Employees are after all humans, we all have secrets. We have our own perspective which we may or may not share with everyone i.e. we have state and behavior only accessible to us. We share some of our secrets with our closest friends, some of our perspective to a group of people depending upon our status. In the end we do keep everything close and private, nothing is visible clearly to the outer world. This is Encapsulation (state are private variables and most of the behavior is in protected methods, objects share state and behavior only through methods which again have access modifiers for better control).
Inheritance is simple. We all are employees, we all get salary on the end of month, we all have performance ratings, performance bonus payouts. We all are subjected to rules and regulations of organization. We all have to live by certain norms designed for employees. This all behavior is inherited by us because we are employees.
Abstraction sounds tricky especially if we compare it to encapsulation. First let me clear what abstraction is. So we all work in teams, a team is associated with a project. Each project originates from a client. Now not everyone on the team is in direct communication with client. Client just hands over the requirements to a point of contact, a Manager or Sales guy and then expects a product at the end of the deadline. We as team work on the requirements, follow some processes but all of this is abstracted away from client. He just gets one contact to pass on the parameters and how those parameters are used and end product is achieved does not matter; hence Abstraction. If you look at encapsulation, it is more focused on each object while abstraction is seen from the point of orchestration of functionality which is usually achieved by interaction between multiple objects.

Comments

Popular posts from this blog

Guide : Spring Boot with Apache CXF for REST services

In this series of guide, we are going to explore writing REST services with Apache CXF using Spring Boot. The project is build using maven. I assume that you already know how to use maven. Step 1 : Adding dependencies for Spring Boot By default you have to inherit the parent pom of spring boot, but that cannot be followed everytime, so I use an alternative to that. I basically add spring boot pom as dependency so that it brings all the dependencies. <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <spring.version>1.4.3.RELEASE</spring.version> <cxf.version>3.1.10</cxf.version> </properties> <dependencies> <dependency> <!-- Alternative to inheriting from parent spring pom --> <groupId>org.springframework.boot</groupI…

Enabling CXF goodies in Spring Boot

In this post we are going to add some of the CXF features to our existing app that we developed in previous post. These features are : ID LoggingJackson Provider for POJO to JSON conversionSwagger 2 documentationStep 1: Configuration class Create a RestServer class in config package as shown below
package org.blog.config;importcom.fasterxml.jackson.jaxrs.json.JacksonJsonProvider;importorg.apache.cxf.feature.LoggingFeature;importorg.apache.cxf.jaxrs.swagger.Swagger2Feature;importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;/** * Created by Anand_Rajneesh on 3/23/2017. */@ConfigurationpublicclassRestServer{@Beanpublic JacksonJsonProvider jsonProvider(){returnnewJacksonJsonProvider();}@Beanpublic LoggingFeature loggingFeature(){returnnewLoggingFeature();}@Beanpublic Swagger2Feature swagger(){ Swagger2Feature swagger =new Swagger2Feature(); swagger.setBasePath("/services"); swagger.setContact("…

Power of declarative syntax of Lambda

Since Java has introduced lambda, writing code has become a breeze especially when it comes to expressing what you want to computer to do rather than how to do it. The following is a question from Project Euler and is solved using lambdas in Java8.

Let d(n) be defined as the sum of proper divisors of n (numbers less than n which divide evenly into n). If d(a) = b and d(b) = a, where ab, then a and b are an amicable pair and each of a and b are called amicable numbers. For example, the proper divisors of 220 are 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 and 110; therefore d(220) = 284. The proper divisors of 284 are 1, 2, 4, 71 and 142; so d(284) = 220. Evaluate the sum of all the amicable numbers under 10000.  A simple brute force solution is to check every number from 2 to 10000 and if its  an amicable number then add it to sum. Listing it in steps you are basically doing 3 things: Take numbers from 2 to 10000If number is amicableAdd it In Java 7 one will basically start a for loop, mak…