Related Tutorials


 
 

Share on Google+Share on Google+

OOPs Concept

Advertisement
Introduction: In this section, we will discuss the OOPs concepts along with fundamentals used to develop the java applications and programs.

OOPs Concept

     

Introduction:  In this section, we will discuss the OOPs concepts along with  fundamentals  used to develop the java applications and programs.

OOP means Object Oriented Programming. This is a technique used to create programs around the real world entities. In OOPs programming model, programs are developed around objects and data rather than actions and logics. In OOPs, every real life object has properties and behavior. This feature is achieved in java through the class and object creation. They contains properties (variables of some type) and behavior (methods). OOPs provides better flexibility and compatibility for developing large applications.

Class: A class defines the properties and behavior (variables and methods) that is shared by all its objects. It is a blue print for the creation of  objects.

Object:  Object is the basic entity of object oriented programming language. Class itself does nothing but the real functionality is achieved through their objects. Object is an instance of the class. It takes the properties (variables) and uses the behavior (methods) defined in the class. 

Encapsulation, Inheritance and Polymorphism are main pillars of OOPs. These have been described below :

Encapsulation: Encapsulation is the process of binding together the methods and data variables as a  single entity. This keeps both the  data and functionality code safe  from the outside world. It hides the data within the class and makes it available only through  the methods. Java provides different accessibility scopes (public, protected, private ,default) to hide the data from outside. For example, we can create a class "Check" which has a variable "amount" to store the current amount. Now to manipulate  this variable we can create methods. For example to set the value of amount create setAmount() method and to get the value of amount create getAmount() method . Here is the code for "Check" class :

class Check{
  private int amount=0;

  public int getAmount(){
   return amount;
  }
  public void setAmount(int amt){
   amount=amt;
  } 
}

public class Mainclass{
  public static void main(String[] args){
   int amt=0;
   Check obj= new Check();
   obj.setAmount(200);
   amt=obj.getAmount(); 
   System.out.println("Your current amount is :"+amt);

   }
}

Here the data variable "amount" and methods setAmount() and  getAmount() are enclosed together with in a single entity called the "Check" class. These two methods are used to manipulate  this variable i.e. set and get the current value of amount.

Inheritance: Inheritance allows a class (subclass) to acquire the properties and behavior of another class (superclass). In java, a class can inherit only one class(superclass) at a time but a class can have any number of subclasses. It helps to reuse, customize and enhance the existing code. So it helps to write a code accurately and reduce the development time. Java uses extends keyword to extend a class.

class A{
  public void fun1(int x){
   System.out.println("int in A");
  }
  
}

class extends A{
  public void fun2(int x,int y){
   fun1(6);  // prints "int in A" 

   System.out.println("int in B");  
  }
}

public class C{
  public static void main(String[] args){
   B obj= new B();
   obj.fun2(2); 
   }
}

In the above example,  class B extends class A and so acquires properties and behavior of class A. So we can call method of A in class B.

Polymorphism : Polymorphism allows one interface to be used for a set of actions i.e. one name may refer to different functionality. Polymorphism allows a object to accept different requests of a client (it then properly interprets the request like choosing appropriate method) and responds  according to the current state of the runtime system, all without bothering the user. 

There are two types of polymorphism :

  1. Compile-time polymorphism
  2. Runtime Polymorphism

In compiletime Polymorphism, method to be invoked is determined at the compile time. Compile time polymorphism is supported through the method overloading concept in java. 

Method overloading means having multiple methods with same name but with different signature (number, type and order of parameters).

class A{
  public void fun1(int x){
  System.out.println("int");
  }
  public void fun1(int x,int y){
  System.out.println("int and int");
  }
}
public class B{
  public static void main(String[] args){
  A obj= A();
   
// Here compiler decides that fun1(int)
 is to be called and "int" will be printed.

  obj.fun1(2); 

// Here compiler decides that fun1(int,int)
 is to be called and "int and int" will be printed.
 
  obj.fun1(2,3); 
  }
}

In rumtime polymorphism, the method to be invoked is determined at the run time. The example of run time polymorphism is method overriding. When a subclass contains a method with the same name and signature as in the super class then it is called as method overriding.

class A{
  public void fun1(int x){
   System.out.println("int in A");
  }
  public void fun1(int x,int y){
   System.out.println("int and int");
  }
}

class extends A{
  public void fun1(int x){
   System.out.println("int in C");
  }
}

public class D{
  public static void main(String[] args){
   A obj;
 
   obj= 
new A(); // line 1
   obj.fun1(2) // line 2 (prints "int in A")
 
   obj=
new C() // line 3
   obj.fun1(2) // line 4 (prints "int in C")
  }
}

In the above program, obj has been declared as A type. In line 1, object of class A is assigned. Now in the next line, fun1(int) of class A will be called. In line 3, obj has been assigned the object of class C so fun1(int) of class C will be invoked in line 4. Now we can understand that same name of the method invokes different functions, defined in different classes, according to the current type of variable "obj". This binding of  method code to the method call is decided at run time.

Advertisements

If you enjoyed this post then why not add us on Google+? Add us to your Circles



Liked it!  Share this Tutorial


Follow us on Twitter, or add us on Facebook or Google Plus to keep you updated with the recent trends of Java and other open source platforms.

Posted on: February 25, 2008

Related Tutorials

Discuss: OOPs Concept   View All Comments

Post your Comment


Your Name (*) :
Your Email :
Subject (*):
Your Comment (*):
  Reload Image
 
 
Comments:9
Eshitha Isanka Prasad
March 5, 2013
Polymorphism

this is a great tutorial and thanks a lot for providing it. there are some errors in this..So, I wish to reconsider yourself them..Thanks with no limit.
bhagyashree
December 21, 2011
oops Concept

i like it!!!!!!
saroja
March 27, 2012
about this article

very very nice....... thank u
RubiniKrishnan
May 4, 2012
About Polymorphism

Thanks for your help which make me to get clear idea about the Polymorphism.......
sunil rawat
June 11, 2012
oops

what do you think are the major issues facing the software industry today?
karmegam
July 16, 2012
oops concept

good concept sir, with simple english
vinny
July 27, 2012
Inheritance

public class C{ public static void main(String[] args){ B obj= new B(); obj.fun2(2); } } fun2 has 2 arguements does it compile, it s typo i think
Bala
January 25, 2014
Inheritance program dont compile

C:\xyz>javac c.java c.java:17: error: method fun2 in class B cannot be applied to given types; obj.fun2(2); ^ required: int,int found: int reason: actual and formal argument lists differ in length 1 error ------------ After changing obj.fun2(2); to obj.fun2(2,3); it compiles ------------
Bala
January 25, 2014
Compile-time polymorphism dont compile

C:\bala>javac B.java B.java:11: error: cannot find symbol A obj= A(); ^ symbol: method A() location: class B 1 error -------- After changing A obj= A(); to A obj= new A(); it compiles --------
DMCA.com