java

Need of method overriding in java ?

2011-12-16T02:30:00.000-08:00

If a super class method logic is not fulfilling sub class business requirements, sub class should override that method with required business logic. Usually in super class, methods are defined with generic logic which is common for all sub classes.

For instance if we take Shape type of classes all Shape classes like Rectangle,Square,Circle etc...should have methods area() and perimeter(). Usually these methods are defined in super class Shape with generic logic but in sub classes Rectangle,Square,Circle etc...these methods must have logic based on their specific logic. Hence in Shape sub classes, these two methods must be overridden with sub class specific logic.

We can also override the predefined methods like toString(),equals(),Hashcode() methods of object class, so that we can use it in different functionality. Let us take an example program.

class Example 
{
   void m1()
   {
      System.out.println("Example m1");
   }
   void m2()
   {
      System.out.println("Example m2");
      m1();
   }
}

class Sample extends Example
{
   void m1()
   {
      System.out.println("Sample m1");
   }
   public static void main(String[] args) 
   {
      Sample s = new Sample();
      s.m1();
      s.m2();
   }
}

Output:
Sample m1
Example m2
Sample m1

In the above program m1() method is overridden in sub class i.e Sample class. Whenever m2() method is called through sample class object first JVM checks m2() method in Sample class it is not available so JVM goes to super class i.e Example class m2() method, the method is there in that class so JVM executes m2() method in Example class, In that method whenever the control comes to m1() method JVM executes m1() method in Sample class because compiler replaces m1() by this.m1() after compilation. In 'this' variable current object reference is stored which is nothing but the Sample class object is stored in 'this' variable so Sample class m1() method is executed.One thing we have to keep in mind that Compiler will check only type of the variable but JVM checks object stored in the reference variable

Java method overriding rules?

2011-12-14T03:07:00.000-08:00

A method is said to be overriding method if it satisfies the below rules.

1.return type should be same as super class method.

In the below program we should not place return type as int we will get a compile time error, in order to override that method we should place the below method return type as void.

class Example{
   void m1(){ }
}

class Sample extends Example{
   void m1(){ }
}

class Sample extends Example{
   int m1(){ return 10;}
}

2.static modifier should not be removed or added.

class Example{
   void m1(){ }
}

class Sample extends Example{
   static void m1(){}
}

If we place modifier as static in sub class it leads to compile time error in the above program.

class Example{
   static void m1(){ }
}

class Sample extends Example{
   void m1(){}
}

If we should not place modifier as static in sub class it leads to compile time error in the above program.

3.access specifier should be same as super class method or it can be increased,but should not be decreased. The below table shows the allowed access specifiers for the sub class method based on super class method access specifier.

Super class method	Sub class method
Private	private,default,protected,public(method is not considered as overridden method because it is not inherited)
Package	package,protected,public
Protected	protected,public
Public	public

If the super class method is private and if we define the same method in sub class with or without private then the sub class method is not called as overriding method means they are not inherited, only super class's non private members are inherited . We have to keep in mind that constructor,blocks,private members are not inherited. If we are able to call super class members with 'super.' or by using sub class object then we can say they are inherited.

4. throws clause should not be added if super class method does not contain it. If super class method contain throws clause then in sub class, overriding method should contain throws clause with same exception class.

What is method overriding in java ?

2011-12-11T22:47:00.000-08:00

Redefining super class method in sub class is called method overriding. Method overriding, in object oriented programming, is a language feature that allows a sub class to provide a specific implementation of a method that is already provided by one of its super classes. The implementation in the sub class overrides (replaces) the implementation in the super class. If a method in sub class contains signature same as super class non private method, sub class method is treated as overriding method and super class method is treated as overridden method.

//Example.java

class Example  
{  
   void add(int a,int b){
      System.out.println("Example add:"+(a+b));
   }
   void sub(int a,int b){
      System.out.println("Example sub:"+(a-b));
   }
}

//Sample.java

class Sample extends Example  
{       
   void add(int a,int b){
      System.out.println("Sample add:"+(a+b));
   }
   public static void main(String[] args)  
   {  
      Sample s = new Sample();
   s.add(10,20);
   s.sub(10,20);
   }  
}

In the above program, add(int,int) method in Sample overrides add(int, int) in Example,because both methods have same signature and it is not private in Example class. Then Example class add() method is called overridden method, Sample class add() method is called overriding method. Here Sample class add() method is executed because add method is called from Sample class main method so first preference is given to Sample class add() method and it is executed. Here signature means add(int,int).

Can main method is executed from super classes ?

2011-12-11T21:29:00.000-08:00

Yes,if subclass doesn't have main method JVM will not through exception directly instead it search in super class complete hierarchy till object class. If main method is found in any of the super class it stops searching and executes main method from that class. Otherwise it throws an exception.Check below program.

//Example.java

class Example  
{  
   public static void main(String[] args)  
   {  
      System.out.println("Example main");
   }  
}

//Sample.java

class Sample extends Example  
{         
}

Then two .class files are created Example.class and Sample.class.

Differences between this and super keyword in java

2011-12-11T18:18:00.000-08:00

The following are the similarities and differences between this and super keyword. One thing keep in mind that we cannot print 'super' like 'this' why because super class non-static members memory doesn't have hashcode. And also keep in mind that super method is different from super keyword. super method is used to call super class constructor where as super keyword is used to access super class members.

this(current class)	super(super class)
1.It is a keyword used to store current object reference.	1.It is a keyword used to store super class object in sub class.
2.Pre define instance variable used to hold current object reference.	2.Pre define instance variable used to hold super class object reference through sub class object.
3.Used to separate state of multiple objects of same class and also used to separate local variables and class level variables in a non-static method if both have same name.	3.Used to seperate super class and subclass members if both have same name.
4.It must be used explicitly if non-static variables and local variables or parameter name is same.	4.It must be used explicitly if super class and sub class members have same names.
5.Can't be referred from static context. It can be printed, means can be called from System.out.println. For example System.out.println(this.x);	5.Can't be referred from static context.It can't be printed, means cannot be called from System.out.println. For example System.out.println(super.x); it leads to compile time error.

Use of super keyword in java ?

2011-12-10T09:09:00.000-08:00

The super is a java keyword,used to access the members of the super class.Use of keyword super is to access the hidden data variables of the super class hidden by subclass.

Ex:Suppose Example class is the super class in the below program that has two instance variables as int x and int y. Sample class is the subclass that also contains its own data members named x and y,then we can access the super class (Example class) variables x and y inside the subclass (Sample class) just by calling the following command.

super.member;

Here member can either be an instance variable or a method. super keyword most useful to handle situations where the local members of the subclass hide the members of the super class having the same name.

Hence super keyword can be defined as "it's a non static variable used to store super class non-static memory reference through current sub class object."

//Example.java

class Example
{
   int x=10;
   int y=20;
   void m1(){
      System.out.println("Example m1");
   }
}

//Sample.java

class Sample extends Example
{
   void m2(){
      System.out.println("x: "+x);
      System.out.println("y: "+y);
   }
   public static void main(String[] args)
   {
      Sample s = new Sample();
      s.m2();
   }
}

Output:

x: 10

y: 20

In the above program compiler first checks if the variables are available in that method or not which is nothing but local preference if they are available then they are accessed from that method itself if they are not available then compiler replaces x and y variables by this.x and this.y to check variables are present at sub class level, if the variables are not available in sub class they are replaced by super.x and super.y to access those variables if they are present in super class. This is the internal mechanism done by compiler. "this" and "super" keyword is placed implicitly. But if you want to place those keywords explicitly then check below program.

//Example.java

class Example
{
   int x=50;
   int y=60;
   void m1(){
      System.out.println("Example m1");
   }
}

//Sample.java

class Sample extends Example
{
   int x=30;//class level variables
   int y=40;

   void m2(){
      int x=10;//loacal preference 
      int y=20;

      System.out.println("x: "+x);
      System.out.println("y: "+y);
      System.out.println();
      System.out.println("x: "+this.x);
      System.out.println("y: "+this.y);
      System.out.println();
      System.out.println("x: "+super.x);
      System.out.println("y: "+super.y);
    }

   public static void main(String[] args){
      Sample s = new Sample();
      s.m2();
   }
}

Output:

  x: 10
  y: 20

  x: 30
  y: 40

  x: 50
  y: 60

What is super method in java ?

2011-12-08T20:26:00.000-08:00

super() method is used to call super class constructor from subclass constructor to create super class object .You might get a doubt that who does place this super() method in all constructors. Compiler only places the super method call in all constructors at the time of compilation.Even though we don't place super() method in constructor compiler places the super() method call in all constructors explicitly.

//Example.java

class Example extends Object
{
   Example(){
      //super();This method is placed by constructor implicitly to call object class constructor
      System.out.println("Example No-arg constructor");
   }
}

//Sample.java

class Sample extends Example
{
   Sample(){
      //super(); This method is placed by constructor implicitly
      System.out.println("Sample No-arg constructor");
   }
   public static void main(String[] args){
      Sample s = new Sample();
   }
}

Object class is nothing but the superclass of all classes it contains 11 methods. In the above program compiler automatically extends the object class in Example program even if you don't extend the object class

When super() method should be placed by developer ?

Developer should place super() method call in below two cases

1. If super class does not contain no-arg constructor that is if it contains parameterized constructor.

2. If developer wants to create super class object with parameterized constructor

In the above two cases developer should define constructor in sub class with explicit super() method call by passing argument of type same as super class constructor type.Check the below program.

//Example.java

class Example
{
   Example(){
      //super(); Compiler placed super method call
      System.out.println("Example no-arg constructor");
   }
   Example(int a){
      //super(); Compiler placed super method call
      System.out.println("Example int arg constructor");
   }
}

//Sample.java

class Sample extends Example
{
   Sample(){
      //super(); Compiler placed super method call
      System.out.println("Sample no-arg constructor");
   }
   Sample(int a){
      //super(); Compiler placed super method call
      System.out.println("Sample int-arg constructor");
   }
   public static void main(String[] args)
   {
      Sample s1 = new Sample();
      Sample s2 = new Sample(10);
   }
}

Output:

Example no-arg constructor
Sample no-arg constructor
Example no-arg constructor
Sample int-arg constructor

If we do not place super method call by passing a value in parameterized constructor,compiler places default super() method call ,then Example no-arg constructor is called shown in the above program. So if we want to call super class parameterized constructor developer need to place super method call explicitly with some value in subclass parameterized constructor by creating subclass object by passing some value. The below program shows the importance of super method call that should be placed explicitly.

//Example.java

class Example
{
   Example(){
      //super(); Compiler placed super method call
      System.out.println("Example no-arg constructor");
   }
   Example(int a){
      //super(); Compiler placed super method call
      System.out.println("Example int arg constructor");
   }
}

//Sample.java

class Sample extends Example
{
   Sample(){
      //super(); Compiler placed super method call
      System.out.println("Sample no-arg constructor");
   }
   Sample(int a){
      super(10);
      System.out.println("Sample int-arg constructor");
   }
   public static void main(String[] args)
   {
      Sample s1 = new Sample();
      Sample s2 = new Sample(10);
   }
}

Output:

Example no-arg constructor
Sample no-arg constructor
Example int arg constructor
Sample int-arg constructor

Compiler and JVM activities of a java program with inheritance

2011-12-06T06:46:00.000-08:00

Compiler Activities:

While compiling a class with inheritance relationship, compiler first compiles the super class and then it compiles the sub class

In finding method or variables definitions, compiler always first search in sub class. If it is not available in sub class, it searches in immediate super class. If there also it is not available compiler throws CE: "cannot find symbol"

This phenomenon is called local preference.

JVM Activities:

JVM also executes the invoked members from sub class, if that member definition is not available in sub class,JVM executes it from super class

Execution control flow in inheritance:

when sub class is loaded its entire super classes are loaded, and also when sub class object is created all its super class memory is created.

What is the order of execution of class members when we invoke them using sub class object ?

1. Class loading order is from super class to sub class. Static variables and static blocks execution is from super class to sub class

If you want to know that then type

java -verbose:class subclass-name in command prompt

and see the loading order of classes first super class is loaded into JVM and then subclass is loaded. Super class is loaded into JVM using extends keyword.

2. Object creation is from super class to sub class

Non static variables and non static blocks and constructor execution is from super class to sub class. Super class object is created by calling super class constructor from sub class constructor using super() keyword. Actually speaking object is not created for super class only memory is created.

3. Execution starts from sub class to super class

Invoked method is executed from sub class . If it is not defined in sub class, it is executed from super class

//Below program explains above points

//Example.java

class Example 
{
   static int a = m1();

   //static block starts
   static
   {
      System.out.println("Example SB - Example is loaded");
   }
   //static block ends

   int x = m2();

   //non-static block starts
   {
      System.out.println("Example-NSB");
   }
   //non-static block ends

   Example(){
      System.out.println("Example class constructor-object is created");
   }
   static int m1(){
      System.out.println("Example static variable is created");
      return 10;
   }
   int m2(){
      System.out.println("Example non-static varible is executed");
      return 20;
   }
   void abc(){
      System.out.println("Example abc");
   }
   void bbc(){
      System.out.println("Example bbc");
   }
}

//Sample.java

class Sample extends Example 
{
   static int b = m3();

   //static block starts
   static
   {
      System.out.println("Sample SB - Sample is loaded");
   }
   //static block ends

   int x = m4();

   //non-static block starts
   {
      System.out.println("Sample-NSB");
   }
   //non-static block ends

   Sample(){
      System.out.println("Sample class constructor-object is created");
   }
   static int m3(){
      System.out.println("Sample static variable is created");
      return 30;
   }
   int m4(){
      System.out.println("Sample non-static varible is executed");
      return 40;
   }
   void abc(){
      System.out.println("Sample abc");
   }

   public static void main(String[] args) 
   {
      System.out.println("main method");
      Sample s = new Sample();
      s.abc();
      s.bbc();
   }
}

In the above program first static variables and static blocks of super class (Example) are executed and then the static variables and static blocks of sub class (Sample) are executed. If all the static variables and blocks execution is completed then the main method is executed which is present in Sample class. After that object creation statement is executed control passes to Sample constructor and then passes to Example constructor due to the super() keyword that is placed by the compiler during compilation time.The super class of all classes is Object class so Object class statements are executed then Example class object is created means non-static variables and non-static blocks of Example class are executed then Example constructor statements are executed. So object creation of Example class is completed. Then non-static variables and non-static blocks of Sample class are executed and then Sample constructor statements are executed. Object creation of Sample class is completed. Finally invoked methods from sub class to super class are executed. This is the control flow of inheritance program.

The output for the above program is:

Example static variable is created
Example SB - Example is loaded
Sample static variable is created
Sample SB - Sample is loaded
main method
Example non-static varible is executed
Example-NSB
Example class constructor-object is created
Sample non-static varible is executed
Sample-NSB
Sample class constructor-object is created
Sample abc
Example bbc

How inheritance is implemented in java technically ?

2011-12-06T01:54:00.000-08:00

As the name suggests inheritance means to take something that is already made.It is one of the most important features of Object Oriented Programming. It is the concept that is used for reusability purpose. Inheritance is the mechanism through which we can derive classes from another classes.

Inheritance is the process of reusing class members from another class as if they were defined int that class. Through inheritance we can obtain one object property to another object.

Basically by implementing inheritance we are establishing a relation between two classes and then extending one class scope to another class.So that other class members can be accessed directly from this class by their names as if they were developed in this class.

Inheritance can be implemented in java using below two keywords:

1.extends

2.implements

Differences between extends and implements keywords

Although, Implements and Extends are two keywords that provide a mechanism to inherit attributes and behavior to a class in Java programming language, they are used for two different purposes. Implements keyword is used for a class to implement a certain interface, while Extends keyword is used for a subclass to extend from a super class. When a class implements an interface, that class needs to implement all the methods defined in the interface, but when a subclass extends a super class, it may or may not override the methods included in the parent class. Finally, another key difference between Implements and Extends is that, a class can implement multiple interfaces but it can only extend from one super class in Java. In general, usage of Implements (interfaces) is considered more favorable compared to the usage of Extends (inheritance), for several reasons like higher flexibility and the ability to minimize coupling. Therefore in practice, programming to an interface is preferred over extending from base classes.

Syntax:

class Example { }

class Sample extends Example { }

The class followed by extends keyword is called super class, here Example is super class, and the class that follows extends keyword is called subclass, here Sample is sub class.

Super class is also called as Parent / Base class

Sub class is also called as Child / Derived class

//The below program explains implementing inheritance

//Example.java

class Example 
{
   static int a=10;
   int x=20;
   static void m1()
   {
      System.out.println("Example m1");
   }
   void m2()
   {
      System.out.println("Example m2");
   }
}

//Sample.java

class Sample extends Example
{
   public static void main(String[] args) 
   {
      System.out.println(a);
      m1();
      Sample s = new Sample();
      System.out.println(s.x);
      s.m2();
   }
}

In the above program we accessed super class static members variable 'a' and m1() directly by their names and without creating super class object we also accessed non-static members variable 'x' and method m2() with sub class object.

What will be the problem if we do not follow encapsulation in designing a class ?

2011-12-05T23:09:00.000-08:00

If we do not follow encapsulation in designing a class, future changes will affect user programs. User programs must recompile and retest them completely.

Consider an example "In class we have variable that should be filled with a value by that class user" as shown in the below program.

//Example.java

class Example
{
   int x;
}

//Sample.java

class Sample
{
   public static void main(String[] args)
   {
      Example e = new Example();
      e.x=50;
      System.out.println(e.x);
      e.x=-10;
      System.out.println(e.x);
   }
}

Assume in initial project requirement document customer did not mention that the application should not allow negative numbers to store.So we gave direct access to the variable and user can store any value as shown above.

Assume in future,customer wants application not allows negative numbers.Then we should validate user given value before storing it in the variable.Hence application architecture should as like below.

Declare variable as private, to stop direct access, and define setter method to take value from user. Then user invokes this method to initialize variable.In this method we can validate the passed value before storing it in the variable.If it is <0 we can terminate assignment and informs the same to user, else we will store that data in variable.

Below program shows correct implementation of class by following encapsulation principle with required above validation logic.

//Example.java

class Example 
{
   private int x;
   public void setA(int x)
   {
      if(x>0)
      {
         this.x=x;
      }
      else
      {
         System.out.println("do no pass negative number");
      }
   }
   public  int getA()
   {
      return x;
   }
}

//Sample.java

class Sample 
{
   public static void main(String[] args) 
   {
      Example e = new Example();
      //e.x=50; CE:x has private access in Example
      //System.out.println(e.x); CE:x has private access in Example
      e.setA(50);
      System.out.println(e.getA());
      e.setA(-6);
      System.out.println(e.getA());
   }
}

Since we have changed the code after application is used by several programmers, every one now should rebuild their application to access variable through setter and getter methods. Otherwise their previous .class file code execution is failed with exception java.lang.IllegalAccessError.

It means since we are not followed encapsulation in developing class it leads lot of maintenance cost.Hence to avoid all these future problems we should always develop classes by following encapsulation principle, even though we do not have any validations before setting and getting variable, it is all required for future sake.

In the above program the variable x we cannot access from Sample class because it is declared as private.

The advantage in designing classes by following encapsulation principle is in future user programs are no need to be recompiled due to code change in setter and getter methods. Ultimately through encapsulation we are hiding implementation details from user.

Consider another example to understand need of encapsulation better, for example bike has 5 gears a method to change gears could reject any value that is less than 1 or greater than 5. If we provide direct access to variable we cannot reject storing a value <1 or >5

How can we develop Encapsulation technically in Java ?

2011-11-27T02:58:00.000-08:00

Ok, first review encapsulation definition again " Hiding class data from the outside world and accessing it only through publicly exposed methods".

It means restricting direct access of class variables to outside class members and providing accessibility to those variables through public methods is called encapsulation.

In Java encapsulation can be implemented

By declaring variables as private, to restrict direct access and

By defining one pair of public setter and getter methods to give access to private variables

The Rule on private access specifier members (variables and methods) is, they cannot be accessed from outside world of this class directly. Voilation leads to compile time error.

The below program explains developing a class by following encapsulation principle

// Bank.java

public class Bank
{
 //hiding class data
 private static final double MIN_BALANCE=5000;

 private long accno;
 private String username;
 private String password;
 private double balance;
 
 public Bank(long accno,String username,String password,double balance)
 {
  this.accno = accno;
  this.username = username;
  this.password = password;
  this.balance = balance;
 }
 //giving access to outside of the class members

 public void setAccno(long accno)
 {
  this.accno = accno;
 }
  
 public long getAccno()
 {
  return accno;
 }
 
 public void setUsername(String username)
 {
  this.username = username; 
 }

 public String getUsername()
 {
  return username;
 }
 
 public void setPassword(String password)
 {
  this.password = password;
 }
 
 public String getPassword()
 { 
  return password;
 }
 
 public void setBalance(double balance)
 {
  this.balance = this.balance + balance;
 }

 public double getBalance()
 {
  //add validation logic,if needed
  return balance;
 }
}

//Encapsulation.java

class Encapsulation
{
 public static void main(String[] args)
 {
  Bank iciciBank = new Bank(1,"siva","chaitanya",999999999);

  //accessing private variables directly from this class is not possible it leads to CE
  //System.out.println(iciciBank.balance);
  //System.out.println(iciciBank.username);
  //System.out.println(iciciBank.password);
  

  //access them through getXxx() methods 
  System.out.println(iciciBank.getUsername());
  System.out.println(iciciBank.getPassword());
  System.out.println(iciciBank.getBalance());

  //setting the variables with different values using setXxx() method
  iciciBank.setBalance(1000);
  
  iciciBank.setUsername("Pond James Pond");
  iciciBank.setPassword("siva chaitanya");
  
  System.out.println(iciciBank.getUsername());
  System.out.println(iciciBank.getPassword());
  System.out.println(iciciBank.getBalance());
 }
}

The advantage in providing variable access via setter and getter methods is we can authenticate user with proper authentication logic before setting or returning variable value. In the above program before giving balance details, in getBalance() method we can authenticate user. It is not possible if we provide direct access to balance variable.Here in the above example we have to execute Encapsulation program because it contains main method.

What are OOPS Principles ?

2011-11-25T03:47:00.000-08:00

OOPS principles are design patters those suggest how we should develop program to organize and reuse effectively with high scalability.The programming language that supports below principles is called as object oriented programming language.

1) Encapsulation

2) Inheritance

3) Polymorphism

Java supports Abstraction which is the backbone of all the above three oops principles. It is the supporting principle of OOPS that ensures all three principles working together to give final shape of the project.

Encapsulation:

The process of hiding internal data from the outside world and accessing it only through publicly exposed methods is known as data encapsulation.Let us take an example

In the above diagram father earns 1 crore per annum and deposited that money in bank in mothers account to protect it and withdrawing it later with proper authentication.This is called encapsulation.

Inheritance:

The process of reusing class members from another class as if it were defined in that class is called inheritance. It can also be defined as it is a process of obtaining one object property to other object is called inheritance

In the above diagram father is earning 1 crore per annum and one of the child reusing father's money in his/her own business to get more money or just spending it for enjoyment just like child 2 in the above diagram.This is called inheritance.

Polymorphism:

Having multiple forms of a method with same name is called polymorphism.

In the world so many persons will have the same name 'arnold' .This is called polymorphism.

Abstraction:

The process of removing or hiding unnecessary information is called abstraction.The process of providing necessary method prototype by removing/hiding unnecessary method logic is called as abstraction. Let us take an example

In the above diagram if we enter into books stall and if we ask shopkeeper for java books then he shows only java books hiding the unnecessary information and from that 100 books if we select 50 books that we like then another unnecessary 50 books he hides.Finally we select one book and remaining 49 books he hides.This is called abstraction

Comment for any doubts.......

Designing a class to create real world objects of type Person

2011-11-24T01:04:00.000-08:00

Identity is the hashcode of an object,it is a 32 bit integer number created randomly and assigned to an object by default by JVM. Each object will have a unique identity.

Developer can also generate hashcode of an object based on state of that object by overriding hashcode() method pf java.lang.objectclass. Then if state is changed automatically hashcode will be changed.

JVM generated hashcode will not be changed if object state is changed because it is not generated based on object state.Hashcode is used when object is stored in hashtable.Hashcode is used when object is stored in hashtable

To understand all above points, consider real world object person as an example.

Every person will have
state - eyes, ears, hands, legs, name, height, weight, foodhabits

Behavior - getName(), setName(), sleep(), eat().

we should consider below things to design a class(blueprint) to create objects of type person

What are the common attributes and individual attributes ?

What are the common behaviors, and individual behaviors ?

Every person has 2 eyes, 2 ears, 2 legs, 2 hands, so create these variables as static final variables to store values common for all person objects,it will save memory. Every person has his/her own name, height, weight, foodHabits so create these variables as non-static variables to store value individual to every object.

Create behaviors getName(), setName() methods as non-static methods to change name specific to Person object. Also eat() method should be a non-static method as it uses object data,non-static variable foodHabits. Create sleep() method as static method to execute logic common for all objects.

Check below program

//Person.java

class Person
{
//static variables having values common for all objects
static final int eyes=2;

static final int ears=2;

static final int hands=2;

static final int legs=2;

//non-static variable having values individual to every object

String name;

double height;

double weight;

String foodHabits;

//parameterized constructor to initialize object state with user given values

Person(String name,double height,double weight,String foodHabits)
{
     this.name       = name;

     this.height     = height;

     this.weight     = weight;

     this.foodHabits = foodHabits;
}

//parameterized non-static methods to change object state with user given values

void setName(String name)
{
     this.name = name;
}

void setheight(double height)
{
     this.height = height;
}

void setWeight(double weight)
{
     this.weight = weight;
}

void setfoodhabits(String foodHabits)
{
     this.foodHabits = foodHabits;
}

void printNHW()
{
     System.out.println("name: "+name);

     System.out.println("height: "+height);

     System.out.println("weight: "+weight);

     System.out.println("foodHabits: "+foodHabits);

}

}

//PersonUser.java

class PersonUser

{

public static void main(String[] args)

{

Person p1=new Person("venkatesh",6.0,80,"veg");

Person p2=new Person("balakrishna",5.9,180,"non-veg");

System.out.println("objects default state");

p1.printNHW();

p2.printNHW();

System.out.println(p1);

System.out.println(p2);

System.out.println("==================================");

p2.setName("balayya");

p2.setWeight(120);

System.out.println(p1);

System.out.println(p2);

System.out.println("objects changed state"); 

p1.printNHW();

p2.printNHW();

}

}

What is a class and object in java ?

2011-11-23T19:42:00.000-08:00

Java is an object oriented programming language. This means Java programs use objects and classes.So what is an object? An object is anything that really exists in the real world and can be distinguished from others. Every thing that we see physically will come into this definition , for example every human being, a book, a tree, and so on.

Now every object has properties and exhibits certain behaviour. Let us try to illustrate this point by taking an example of dog. It got properties like name,height,color,age etc. These properties are represented by variables. Now the object dog will have some actions like running,barking,eating etc. These actions are represented by various methods (functions) in our programming. In programming various tasks are done by methods only. So we can console that objects contain variables and methods.

A group of objects exhibiting same behaviour (properties and actions) will come under same group called class. A class represents a group name given to several objects. For example take the dogs: Tom,Jimmy,Pinky,Subbu etc . All these four exhibit same behaviour and hence belongs to the same group, called dog. So dog is a class name which contains four objects. In other words we can define a class as a specification or blueprint or template of an object that defines what goes to make up a particular sort of object. A class can be used as a model for creation of objects.

A class and object are almost the same with the difference that a class does not exist physically, while the object does. For example if we say dog; it forms a picture into our mind with 4 legs, 2 ears some length and height. This picture in our mind is class. If we tally that picture with the physical things around us, we can find Tom living in our house is satisfying these qualities. So tom physically exists is an object and not a class. In technical terms we say object as "It is an encapsulated form of all non static variables and non static methods of a particular class."The process of creating objects of a class is called instantiation.

Comment for any doubts.......

What is Object Oriented Programming Language ?

2011-11-23T18:27:00.000-08:00

OOP is an approach that provides a way of modularizing a program by creating partitioned memory area for both data and methods that can be used as template for creating copies of such modules(objects) on demand.

So Object Oriented Programming or OOP is a technique to create programs based on the real world object. Unlike procedural programming, here in the OOP programming model, programs are organized around objects and data rather than actions and logic.

The concepts and rules used in object-oriented programming provide these important benefits:

1) The concept of a data class makes it possible to define subclasses of data objects that share some or all of the main class characteristics. Called inheritance, this property of OOP forces a more thorough data analysis, reduces development time, and ensures more accurate coding.

2) Since a class defines only the data it needs to be concerned with, when an instance of that class (an object) is run, the code will not be able to accidentally access other program data. This characteristic of data hiding provides greater system security and avoids unintended data corruption.

3) The definition of a class is reusable not only by the program for which it is initially created but also by other object-oriented programs (and, for this reason, can be more easily distributed for use in networks).

4) The concept of data classes allows a programmer to create any new data type that is not already defined in the language itself.

Comment for any doubts.......

Why OOPS ?

2011-11-23T17:34:00.000-08:00

It is introduced to represent objects in programming languages and further to achieve security and to communicate with other programming languages, such as C, C++, .NET,PHP, HTML, JAVA etc. Object oriented programming enables programmers define not only the data, but also its associated behaviors/functions that can be applied to the data. It also enables programmers to create relationships between one object and another. For example, objects can inherit characteristics from other objects.To understand the importance of OOP we need to first understand the problem with procedural/structural programming practices.

Procedural programming was suitable for small projects. But as the program grew in size, along with it grew the maintenance nightmare. Also, since the modules were tightly integrated changes in one part of the module inadvertently breaks the other part. Team development was not truly achievable.The next big problem with procedural programming was with respect to re-usability. It was very difficult to write truly reusable code, with minimum maintenance.So why OOP? OOPs facilitates code reuse, team-development, eliminate redundant code,easy management of software complexity etc.

Comment for any doubts.......

What is a constructor and rules in defining constructor ?

2011-11-02T22:59:00.000-07:00

Constructor is a special method given in OOP language for creating and initializing object. In java, constructor role is only initializing object and new keyword role is creating object. In C++, constructor alone creates and initializes object.

Rules in defining constructor:

1) Constructor name should be same as class name.

2) It should not contain return type.

3) It should not contain modifiers.

4) In its logic, return statement with value is not allowed.

Note:

5) It can have all four accessibility modifiers(private,protected,default,public).

6) It can have parameters.

7) It can have throws clause-it means we can throw exception from constructor.

8) It can have logic, as part of logic it can have all legal statement except return statement with value.

9) We can place return; in constructor.

Constructor creation syntax is as follows

class Example 
{ 
   Example()
   {
      //All java legal statements are allowed except return statement
      ------;
      ------; 
      ------;
   }
}

Below application shows defining a class with constructor and its execution

class Example {
   Example()
   {
      System.out.println("constructor");
   }
   public static void main(String[] args)
   {
      System.out.println("main");     
      Example e = new Example();
   }
}

Whenever we compile the java file by using javac Example.java '.class' file is generated and when we execute the '.class' file by using java Example '.class' file is loaded into JVM, then the first statement that is executed by JVM is the main method and later main is printed by using System.out.println statement. After that object creation statement is executed. In that statement whenever the control comes to new Example(), then object is created and constructor is initialized. One thing we should keep in mind that object is created first and then the constructor is initialized. Whenever the execution comes to new Example(), if you carefully observe in that statement Example() is a method. So thats why constructor is called and it is executed.So we can say that constructor is also a method but it has a different functionality like initializing object.

Types of Literals and their default datatypes

2011-11-01T08:11:00.000-07:00

All Integer type Literals are by default of type int. If we want to represent them as long we must suffix 'l' or 'L' to the Literal. we do not have byte or short type Literals.

All floating type Literals are of type double by default. If we want to represent them as float we must suffix 'f' or 'F' to the Literals.

The data placed inside single quote is considered as char Literal

Rule: In single quote we are not allowed to place more than one character. We can place either '0' or '1' characters.

The data placed inside double quotes is considered as String Literal

Note: In double quotes we can place '0' or 'n' number of characters.

Below are the following Literals in Java

Comment for any doubts.....

What is a Literal ?

2011-11-01T07:49:00.000-07:00

Literal is a nothing but a constant. Literals represent numerical (integer or floating-point or double), character, boolean or string values. For example 10, 20.4, 'a', "a", "ab", true, false. Let us take a statement

int month=10;

In the above statement the literal is an integer value i.e 10. The literal is 10 because it directly represents the integer value.

Comment for any doubts.......

Why have Naming Conventions ?

2011-10-28T07:32:00.000-07:00

A naming convention is a rule to follow as you decide what to name your identifiers (e.g. class, package, variable, method, etc).Different Java programmers can have different styles and approaches to the way they program. By using standard Java naming conventions they make their code easier to read for themselves and for other programmers. Readability of Java code is important because it means less time is spent trying to figure out what the code does, leaving more time to fix or modify it.

We Should follow naming conventions because of the following reasons.

+ A program is written once and read many times.

+ During debugging

+ When adding to a program

+ When updating the program

+ When trying to understand the program

To illustrate the above points it's worth mentioning that most software companies will have a document that outlines the naming conventions they want their programmers to follow. A new programmer who becomes familiar with those rules will be able to understand code written by a programmer who might have left the company many years before hand.So anything that makes a program more readable and understandable saves lot of time even in short run.

Coding Standards and Naming Conventions in Java

2011-10-28T05:19:00.000-07:00

These Coding Standards and Naming Conventions are nothing but suggestions. If we follow these two while developing Java applications, then it is more readable and understandable. Sun define several coding standards, some of the important ones are

+ Every basic programming language element must have

comment.

+ Every operator must has preceding and trailing space.

+ Variable should not be created inside loops.

+ All "=" operator must be placed in same vertical line.

What are Java versions ?

2011-10-12T08:50:00.000-07:00

A version is a number used to identify the current features and enhancements developed in that software. Every software is developed with versions. In software all projects and products are developed with versions. In most of the cases the version number starts with '1.0'.

Project is a software that is developed specific to one customer.Product is also a software that is developed common for all companies.The only difference we come across during the project testing and product testing is :

In project testing we go through the Alpha Testing, Beta Testing, User Acceptance testing whereas in product testing we don't have this.In Both Project and Product testing we have to perform the below test to make sure that application is properly developed WRT requirements and meets the client expectation.

The test that are performed are

Unit test

Integration testing

System testing

Regression test

Retest

Below are sample products with their version numbers.

Comment for any doubts.......

Types of Java Software

2011-10-12T04:06:00.000-07:00

Java software is divided into two sub products

1) jdk (Java Development Kit)

2) jre (Java Run time Environment)

jdk has both "Compiler + JVM"

jre has only "JVM"

JVM is a sub-part of jre and jre is a sub-part of jdk. So in order to run any java application jre software is sufficient but if we need to compile and execute the java program we have to install jdk software.Below diagram shows the difference between jdk,jre and JVM.

How Java achieved Platform Independency ?

2011-10-11T09:47:00.000-07:00

Java achieved platform independency by moving machine language generation from compilation phase to execution phase by introducing byte codes and JVM. To support platform independency the program must execute in another operating system means that program must has machine language specific to the client computer OS. The client computer OS is only come to know only when program is downloaded and is being executed. So SUN moved machine language generation to execution phase.Below diagram shows Java's platform independency diagram.

Below is the another block diagram shows Java's platform independency.

From the above diagram we can conclude below points

1) In Java, compiler is Java specific not OS specific as it takes Java source code as input and generates Java byte codes as output.

2) But JVM is OS specific because it takes Java bytecodes and generates OS dependent Machine language.

3) Since JVM is OS dependent,Java software is also OS dependent because Java software means compiler + JVM.

4) But Java program is platform independent. Both because of JVM implementation

Comment for any doubts.....

What is Java Slogan ?

2011-10-11T07:56:00.001-07:00

"Write once Run anywhere"

Java is a platform independent programming language.It means that program is written once and the program is executed irrespective of the operating system.

Comment for any doubts.....