OOPS Concepts-JAVA

Java OOPs (Object-Oriented Programming) Concepts(oo)

Note: This blog is just to share our Knowledge if there are any mistakes please let us know.

What is oo programming..?

OO has strong historical roots in other paradigms and practices. It came about to address problems commonly grouped together as the “software crisis.”

It does not solve any questions its just a piece of solution for problems.

 Object Oriented programming gives solution to a problem by using these concepts.

OOPs Concept in Java

·       Polymorphism

·        Inheritance

·        Encapsulation

·        Abstraction

·        Class

·        Object

·        Method

·        Message Passing

 

Note: We are going to explain these concepts in Java programming.

1)Polymorphism:

 

POLYMORPHIC:  MANY FORMS.

 

Polymorphism is  something (function argument, variable, etc) can be of more than one type.

 

Not limited to OO languages.If we take concept of operater overloading. For example in C, we have operators like +, -, *, etc, which operate for all primitive types.

In other words we don’t have separate ”+ int”, ”+ float”, ”+ char” etc, operators for each type.So we can call “+ “as polymorphic.

 

 

In Java Polymorphism achieved by following:

1.      Overloading

2.      Overriding


Method overloading

means having two or more methods with the same name but different signatures in the same scope. These two methods may exist in the same class or another one in base class and another in derived class,It is  compile time execution(polymorphism) or early binding.

class Person

{

    private String firstName;

    private String lastName;

Person()

        {

            this.firstName = "";

            this.lastName = "";

        }

Person(String FirstName)

                            {

            this.firstName = FirstName;

            this.lastName = "";

                                }

Person(String FirstName, String LastName)

{

    this.firstName = FirstName;

    this.lastName = LastName;

}

}

Calling Overloaded Methods.

Person(); // as a constructor and call method without parameter

Person(userFirstName); // as a constructor and call method with one parameter

Person(userFirstName,userLastName); // as a constructor and call method with one parameter

When to use Method Overloading?

Generally, you should consider overloading a method when you have required same reason that take different signatures, but conceptually do the same thing.



Method Overriding :

means having a different implementation of the same method in the inherited class. These two methods would have the same signature, but different implementation. One of these would exist in the base class and another in the derived class. These cannot exist in the same class.

Step 1: In this example we will define a base class called Circle

class Circle

{

protected double radius;

public Circle(double radius)

{ this.radius = radius; }

public double getArea()

{

return Math.PI*radius*radius;

}

}

When the getArea method is invoked from an instance of the Circle class, the method returns the area of the circle.

Step 2

The next step is to define a subclass to override the getArea() method in the Circle class. The derived class will be the Cylinder class. The getArea() method in the Circle class computes the area of a circle, while the getArea method in the Cylinder class computes the surface area of a cylinder.

The Cylinder class is defined below.

class Cylinder extends Circle

{

protected double length;

public Cylinder(double radius, double length)

{

super(radius);

this.length = length;

}

public double getArea()

{

// method overriden here

return 2*super.getArea()+2*Math.PI*radius*length;

}

}

When the overriden method (getArea) is invoked for an object of the Cylinder class, the new definition of the method is called and not the old definition from the superclass(Circle).

Example code

This is the code to instantiate the above two classes

Circle myCircle;

myCircle = new Circle(1.20);

Cylinder myCylinder;

myCylinder = new Cylinder(1.20,2.50);

 

 

2)Inheritance:

·        The concept of getting properties of one class object to another class object is known as inheritance.

·        Here properties means variable and methods.

Types of Inheritance:

1.      Multiple inheritance.

2.      Multilevel inheritance.

 

Multilevel Inheritance:

·        Getting the properties from one class object to another class object level wise with some priority is known as multilevel inheritance.

 

class A{ 

}

class B extends A{ 

} 

class C extends B{

}

 

 

Multiple inheritance:

·        The concept of Getting the properties from multiple class objects to sub class object with same priorities is known as multiple inheritance.

·        Java Doesn't Support multiple Inheritance.

·        multiple inheritance achieve by using interfaces

 

/Multiple inheritance program

interface A{

public void  show();

}

interface B{

public void  display();

}

Class C Implements A,B{

}

3)Encapsulation:

Simply, encapsulation means the bringing together of a set of attributes and methods into an object definition and hiding their implementational structure from the object's users.

Therefore, how an object structures and implements its attributes and methods is not visible to other objects using it. Direct access to an object's attributes is not permitted and any changes to the object's data can only be effected indirectly via a set of publicly available methods.

 

Why encapsulate and hide?

• You can delay the resolution of the details until after the design.

• You can change it later without a ripple effect.

• It keeps your code modular.

How we do this separation is with two separate pieces for each class, an implementation and an interface.

 

Basic java example program on data encapsulation

 

public class EncapsulationDemo {

  String name;

  int rno;

  String address;

public String getName() {

       return name;

 }

public void setName(String name) {

        this.name = name;

} 

public int getRno() {

       return rno;

}

public void setRno(int rno) {

     this.rno = rno;

}

public String getAddress() {

        return address;

}

 public void setAddress(String address) {

    this.address = address;

}

public void showInfo(){

 

      System.out.println("Name: "+getName());

      System.out.println("R.No: "+getRno());

      System.out.println("Name: "+getAddress());

 

    }

}

 

4) Abstraction

 

Humans deal with complexity by abstracting details away.

Abstraction is used to hide certain details from the user that they might find irrelevant

Examples:

• Driving a car doesn’t require knowledge of internal combustion engine; sufficient to think of a car as simple transport.

 • Stereotypes are negative examples of abstraction.

 To be useful, an abstraction (model) must be smaller than what it represents. (road map vs photographs of terrain vs physical model).

 

Difference between Abstraction and Encapsulation

 

Abstraction

Encapsulation

Abstraction solves the issues at the design level.

Encapsulation solves it implementation level.

Abstraction is about hiding unwanted details while showing most essential information.

Encapsulation means binding the code and data into a single unit.

Abstraction allows focussing on what the information object must contain

Encapsulation means hiding the internal details or mechanics of how an object does something for security reasons.

 

The above  are the main 4 oops concepts.

 

5) Message Passing:

Definition: Message passing is the procedure through which objects communicate with each other bypassing the reliable information to run the program such as a request for the execution of the function or request to pass the values.

The message includes the information of the information to be sent and the name of the object or function.

6 )Class:

Definition: A class is a user-defined entity through which the objects are created. It represents a collection of properties or methods that is common to every object of a similar kind.

 

7) Objects:

Definition: It is the basic unit of the Object-Oriented Programming(OOPs) it is used to represent the real-life entity. Any typical java program includes many objects, and these objects interact with each other through the invoking method.

 

8) Method:

Definition: A method is a collection of statements that are used to perform the specific task and it returns the obtained value to the caller. A method is also capable of performing a specific task without returning any values. In Java, unlike other languages, a method should be a part of the class.

 


Conclusion:

These are the  important oops concept which are helped to design a solution to problems

 

 

This not oops concept I like this visulazation and i like to share with you

pass by value

Any Quires Comment below

Note: This blog is just to share our Knowledge if there are any mistakes please let us know.

Thanks.

 

 Reference: programcodelib.com,Carl Erickson Atomic Object, LLC


Comments

Post a Comment

Popular posts from this blog

JavaScript: Async functions (async/await)

Image
JavaScript: Async functions (async/await) I am sure that many of you are using async and await already. But, I think it deserves a little more attention.   Every one should remember Mozilla docs is your friend. Here is the MDN definition for async and await: async: “An asynchronous function is a function which operates asynchronously via the event loop, using an implicit Promise to return its result. But the syntax and structure of your code using async functions is much more like using standard synchronous functions.”   await:  “An async function can contain an await expression that pauses the execution of the async function and waits for the passed Promise's resolution, and then resumes the async function's execution and returns the resolved value. Remember, the await keyword is only valid inside async functions.”   Confused………..   Lets put this defination in this way   A function defined as async is a function that can perform asynchronous actions but still look synchro
Read more

DATA Structures :Binary Search Trees

Image
Bnary Search Trees Binary tree is a tree that each node in it has maximum of two children. Binary search tree (BST) is a binary tree which its elements positioned in special order. In each BST all values(i.e key) in left sub tree are less than values in right sub tree. This is a simple implementation of Binary Search Tree Insertion using Python. class Node:   def __init__(self, val):  self.l_child = None  self.r_child = None  self.data = val def insert(root, node):        if root is None:             root = node        else :             if  root.data > node.data:                  if root.l_child is None:                       root.l_child = node                  else :                       insert(root.l_child, node)        else :             if root.r_child is None:                  root.r_child = node             else :
Read more

Angular 2+ :@view Child

Image
ANGULAR2 @view Child Viewchild offers one way interaction fro . m parent to child. There is no return mes . sage or output from child when ViewChild is used. ViewChild is used for component to template communication. It is used to ref . erence a directive or element or component.  Example  let element = document.getElementById('elementId'); @ViewChild('elementV . ariable') elementRef; // template reference variable @ViewChild(NgModel) filterInput: NgModel; // a ngular directive - on template would look like: <input [(ngModel)]='listfilter'> @ViewChild(Pare . ntComponent) Parent: (ParentComponent) // child com . ponent - on template would look like: <child-component[input1]='some.input'> Detailed Example We ha . ve a DataListC . omponent that shows som . e information. DataListComponent has PagerComponent as it's child. When user . makes a search on DataListComponent, it gets a data from a servic . e and ask Pag
Read more

Angular -Lazy Loading

Lazy Loading   What Is Lazy Loading..? Lazy loading is a process were angular loads the modules only when it is needed without loading all at once. It is also called as on-demand loading.   Why Lazy Loading..?   Lazy loading modules helps us decrease the start-up time. Angular app can become bigger in size if we add more and more modules for improving features of the app. As the app grows bigger the slower it loads.   By Loading only a part of the app (i.e. lazy loading), the app appears to run faster to the user. The faster loading app gives you a performance boost and results in good user experience.   Lazy loading reduce the bundle size of the app which help to boot fast.   How Lazy loading Work…? In angular lazy loading works on module level. Single Components cannot be loaded lazily. Angular Router Module is the place where we implement lazy Loading. The loadChildren method of the Angular Router is responsible to load the modules. For loading the module
Read more

DBMS-Data Models

Image
Data Models   A data model is a picture or description which shows how the data is to be arranged to achieve a given task. It is a clear model which specifies how the data items are arranged in a given model. Some data models which gives a clear picture which shows the manner in which the data records are connected or related within a file structure. These are called structural data models. DBMS organize and structure data so that it can be retrieved and manipulated by different users and application programs The data structures and access techniques provided by a particular DBMS are called its data model.     Types Of Data Models:   1)Hierarchical databases model 2)Network databases model 3)Relational databases model 4) Object oriented databases model   Hierarchical databases model:   Hierarchical Databases is most commonly used with mainframe systems. It is one of the oldest methods of organizing and storing data and it is still used by some orga
Read more