A single object acts differntly in different situation is called Polymorphism.

Remember that the only way to access an object is through a reference variable, and there are a few key things to remember about references:

• A reference variable can be of only one type, and once declared, that type can never be changed (although the object it references can change).
• A reference is a variable, so it can be reassigned to other objects, (unless the reference is declared final).
• A reference variable’s type determines the methods that can be invoked on the object the variable is referencing.
• A reference variable can refer to any object of the same type as the declared reference, or—this is the big one—it can refer to any subtype of the
  declared type!
• A reference variable can be declared as a class type or an interface type. If the variable is declared as an interface type, it can reference any object of any class that implements the interface.
  Examples

class PlayerPiece extends GameShape, Animatable { // NO!
// more code
}

A class cannot extend more than one class. That means one parent per class. A class can have multiple ancestors, however, since class B could extend class A, and class C could extend class B, and so on. So any given class might have multiple classes up its inheritance tree, but that’s not the same as saying a class directly extends two classes.

The process of acquiring properties and methods from one class into an another class, without changing the existing code is called inheritance.

Examples:

public class Car {
// Cool Car code goes here
}
public class Subaru extends Car {
// Important Subaru-specific stuff goes here
// Don’t forget Subaru inherits accessible Car members which
// can include both methods and variables.
}

A Car is a type of Vehicle, so the inheritance tree might start from the Vehicle class as follows:
public class Vehicle { … }
public class Car extends Vehicle { … }
public class Subaru extends Car { … }

In OO terms, you can say the following:
Vehicle is the superclass of Car.
Car is the subclass of Vehicle.
Car is the superclass of Subaru.
Subaru is the subclass of Vehicle.
Car inherits from Vehicle.
Subaru inherits from both Vehicle and Car.
Subaru is derived from Car.
Car is derived from Vehicle.
Subaru is derived from Vehicle.
Subaru is a subtype of both Vehicle and Car.

Rules for an Interface

• All interface methods are implicitly public and Abstract.
• All variables defined in an interface must be public, static, and final in other words, interfaces can declare only constants, not instance variables.
• Interface methods must not be static.
• Because interface methods are abstract, they cannot be marked final, strictfp, or native.
• An interface can extend one or more other interfaces.
• An interface cannot extend anything but another interface.
• An interface cannot implement another interface or class.
• An interface must be declared with the keyword interface.

Examples

public interface Bounceable {
public abstract void bounce();
public abstract void setBounceFactor(int bf);
}

Why make a class if you can’t make objects out of it? Because the class might be just too, well, abstract. For example, imagine you have a class Car that has generic methods common to all vehicles. But you don’t want anyone actually creating a generic, abstract Car object. How would they initialize its state? What color would it be? How many  seats? Horsepower? All-wheel drive? Or more importantly, how would it behave? In other words, how would the methods be implemented? No, you need programmers to instantiate actual car types such as BMWBoxster and SubaruOutback. We’ll bet the Boxster owner will tell you his car does things the Subaru can do “only in its dreams.” Take a look at the following abstract class:
abstract class Car {
private double price;
private String model;
private String year;
public abstract void goFast();
public abstract void goUpHill();
public abstract void impressNeighbors();
// Additional, important, and serious code goes here
}

The preceding code will compile fine. However, if you try to instantiate a Car in another body of code, you’ll get a compiler error something like this:
AnotherClass.java:7: class Car is an abstract
class. It can’t be instantiated.
Car x = new Car();
1 error

package myPackage;
public final class Animal {
public void Method() { }
}
Now, if we try to compile the Dog subclass:
package dgPackage;
import myPackage.Animal;
class Dog extends Animal{ }
We get an error something like
Can’t subclass final classes: class
myPackage.Animal class Dog extends Animal{
1 error

1. Public
2. Private
3. Protected

Non- Access Modifiers

Strictfp, final and abstract

There are 4 level of access. They are

1. Public
2. private
3. protected
4. Default

Public Access:

A class declared with  public keyword can be accessed  by any class within the package and also with different packages.

Example:

Package myPackage;

public Class Animal {}

This changes the Animal class so it will be visible to all classes in all packages.The class can now be instantiated from all other classes, and any class is now free to
subclass (extend from) it.

Private Access:

A class declared with private keyword, can be accessed within a class and within a package . It cannot be inherited.

Example:

Package myPackage;

Private  class Animal {}

The above class is not visible by any class.

Protected Acess:

A class declared with Protected keyword, can be accessed only by its subclass within a package and also with different package.

Class myClass

{

int abc;

}

In the above example, myClass is a Identifiers. int is a Keyword and again abc is a Identifier.

All the Java components like class, variables & methods need names. In java, these names are called Identifiers.

Examples of legal and illegal identifiers follow, first some legal identifiers:
int _v;
int $c;
int ______2_w;
int _$;
int this_is_a_very_detailed_name_for_an_identifier;

The following are illegal :
int   :b;
int   -d;
int   e#;
int   .f;
int   7g;

KEYWORDS

Like all programming languages, Java has a set of built-in keywords. These keywords must not be used as identifiers.

Examples of Java Keywords:

abstract ,boolean, break, byte, case, catch, auto,int,char……

• CLASS – A Class is a user defined template for multiple objects. That describes the kinds of state and behavior that objects of its type support.
• OBJECT – An object is an instance of that class. Object will have its own state, and access to all of the behaviors defined by its class.
• STATE(Instance variables) – Each object (instance of a class) will have its own unique set of instance variables as defined in the class. Collectively, the
  values assigned to an object’s instance variables make up the object’s state.
• BEHAVIOR(Instance methods) -  Methods are where the class’ logic is stored. Methods arewhere the real work gets done. They are where algorithms get executed, and data gets manipulated.