 Abstraction: Showing the essential and hiding the non-Essential is known as

Abstraction.
 Encapsulation: The Wrapping up of data and functions into a single unit is known as
Encapsulation. Encapsulation is the term given to the process of hiding the
implementation details of the object. Once an object is encapsulated, its implementation
details are not immediately accessible any more. Instead they are packaged and are only
indirectly accessed via the interface of the object.
 Inheritance: is the Process by which the Obj of one class acquires the properties of Obj’s
another Class. A reference variable of a Super Class can be assign to any Sub class
derived from the Super class. Inheritance is the method of creating the new class based
on already existing class, the new class derived is called Sub class which has all the
features of existing class and its own, i.e sub class.
Adv: Reusability of code , accessibility of variables and methods of the Base class by the
Derived class.
 Polymorphism: The ability to take more that one form, it supports Method Overloading &
Method Overriding.
 Method overloading: When a method in a class having the same method name with
different arguments (diff Parameters or Signatures) is said to be Method Overloading.
This is Compile time Polymorphism. Using one identifier to refer to multiple items in the
same scope.
 Method Overriding: When a method in a Class having same method name with same
arguments is said to be Method overriding. This is Run time [Link] a
different implementation of a method in a subclass of the class that originally defined
the method.
1. In Over loading there is a relationship between the methods available in the same
class ,where as in Over riding there is relationship between the Super class method and
Sub class method.
2. Overloading does not block the Inheritance from the Super class , Where as in
Overriding blocks Inheritance from the Super Class.
3. In Overloading separate methods share the same name, where as in Overriding Sub
class method replaces the Super Class.
4. Overloading must have different method Signatures , Where as Overriding methods
must have same Signatures.
Dynamic dispatch: is a mechanism by which a call to Overridden function is resolved
at runtime rather than at Compile time , and this is how Java implements Run time
Polymorphism.
 Dynamic Binding: Means the code associated with the given procedure call is not known
until the time of call the call at run time. (it is associated with Inheritance & Polymorphism).
 Bite code: Is a optimized set of instructions designed to be executed by Java-run time
system, which is called the Java Virtual machine (JVM), i.e. in its standard form, the JVM is
an Interpreter for byte code.
JIT- is a compiler for Byte code, The JIT-Complier is part of the JVM, it complies byte code
into executable code in real time, piece-by-piece on demand basis.

Final classes : String, Integer , Color, Math

Abstract class : Generic servlet, Number class
o variable:An item of data named by an [Link] variable has a type,such as int or
Object,andascope
o class variable :A data item associated with a particular class as a whole--not with
particular instances of the class. Class variables are defined in class definitions. Also called
a static field.
o instance variable :Any item of data that is associated with a particular object. Each
instance of a class has its own copy of the instance variables defined in the class. Also
called a field.
o local variable :A data item known within a block, but inaccessible to code outside the
block. For example, any variable defined within a method is a local variable and can't be
used outside the method.
o class method :A method that is invoked without reference to a particular object. Class
methods affect the class as a whole, not a particular instance of the class. Also called a
static method.
o instance method :Any method that is invoked with respect to an instance of a class. Also
called simply a method.
 Interface: Interfaces can be used to implement the Inheritance relationship between the
non-related classes that do not belongs to the same hierarchy, i.e. any Class and any
where in hierarchy. Using Interface, you can specify what a class must do but not how it
does.
 A class can implement more than one Interface.
 An Interface can extend one or more interfaces, by using the keyword extends.
 All the data members in the interface are public, static and Final by default.
 An Interface method can have only Public, default and Abstract modifiers.
 An Interface is loaded in memory only when it is needed for the first time.
 A Class, which implements an Interface, needs to provide the implementation of all the
methods in that Interface.
 If the Implementation for all the methods declared in the Interface are not provided , the
class itself has to declare abstract, other wise the Class will not compile.
 If a class Implements two interface and both the Intfs have identical method declaration,
it is totally valid.
 If a class implements tow interfaces both have identical method name and argument
list, but different return types, the code will not compile.
 An Interface can’t be instantiated. Intf Are designed to support dynamic method
resolution at run time.
 An interface can not be native, static, synchronize, final, protected or private.
 The Interface fields can’t be Private or Protected.
 A Transient variables and Volatile variables can not be members of Interface.
 The extends keyword should not used after the Implements keyword, the Extends must
always come before the Implements keyword.
 A top level Interface can not be declared as static or final.
 If an Interface species an exception list for a method, then the class implementing the
interface need not declare the method with the exception list.
 If an Interface can’t specify an exception list for a method, the class can’t throw an
exception.
 If an Interface does not specify the exception list for a method, the class can not throw
any exception [Link] general form of Interface is
Access interface name {
return-type method-name1(parameter-list);
type final-varname1=value;
}
-----------------------
Marker Interfaces : Serializable, Clonable, Remote, EventListener,

[Link] is the Package of all classes and is automatically imported into all Java
Program
Interfaces: Clonable , Comparable, Runnable
 Abstract Class: Abstract classes can be used to implement the inheritance relationship
between the classes that belongs same hierarchy.
 Classes and methods can be declared as abstract.
 Abstract class can extend only one Class.
 If a Class is declared as abstract , no instance of that class can be created.
 If a method is declared as abstract, the sub class gives the implementation of that class.
 Even if a single method is declared as abstract in a Class , the class itself can be
declared as abstract.
 Abstract class have at least one abstract method and others may be concrete.
 In abstract Class the keyword abstract must be used for method.
 Abstract classes have sub classes.
 Combination of modifiers Final and Abstract is illegal in java.
 Abstract Class means - Which has more than one abstract method which doesn’t have
method body but at least one of its methods need to be implemented in derived Class.

The general form of abstract class is :

abstract type name (parameter list);

The Number class in the [Link] package represents the abstract concept of
numbers. It makes sense to model numbers in a program, but it doesn't make sense to
create a generic number object.

 Difference Between Interfaces And Abstract class ?

o All the methods declared in the Interface are Abstract, where as abstract class must
have atleast one abstract method and others may be concrete.
o In abstract class keyword abstract must be used for method, where as in Interface we
need not use the keyword for methods.
o Abstract class must have Sub class, where as Interface can’t have sub classes.
o An abstract class can extend only one class, where as an Interface can extend more
than one.

What are access specifiers and access modifiers ?

Accesss specifiers Access modifiers

Public Public
Protected Abstract
Private Final
Static
Volatile Constant
Synchronized
Transient
Native

 Public : The Variables and methods can be access any where and any package.
 Protected : The Variables and methods can be access same Class, same Package & sub
class.
 Private : The variable and methods can be access in same class only.

Same class - Public, Protected, and Private

Same-package & subclass - Public, Protected
Same Package & non-sub classes - Public, Protected
Different package & Sub classes - Public, Protected
Different package & non- sub classes - Public

Identifiers : are the Variables that are declared under particular Datatype.

Literals: are the values assigned to the Identifiers.

 Static : access modifier. Signa: Variable-Static int b; Method- static void

meth(int x)
 When a member is declared as Static, it can be accessed before any objects of its
class are created and without reference to any object. Eg : main(),it must call before any
object exit.
 Static can be applied to Inner classes, Variables and Methods.
 Local variables can’t be declared as static.
 A static method can access only static Variables. and they can’t refer to this or
super in any way.
 Static methods can’t be abstract.
 A static method may be called without creating any instance of the class.
 Only one instance of static variable will exit any amount of class instances.

 Final : access modifier

 All the Variables, methods and classes can be declared as Final.
 Classes declared as final class can’t be sub classed.
 Method ‘s declared as final can’t be over ridden.
 If a Variable is declared as final, the value contained in the Variable can’t be
changed.
 Static final variable must be assigned in to a value in static initialized block.

 Transient : access modifier

 Transient can be applied only to class level variables.
 Local variables can’t be declared as transient.
 During serialization, Object’s transient variables are not serialized.
 Transient variables may not be final or static. But the complies allows the
declaration and no compile time error is generated.

 Volatile: access modifier

 Volatile applies to only variables.
 Volatile can applied to static variables.
 Volatile can not be applied to final variables.
 Transient and volatile can not come together.
 Volatile is used in multi-processor environments.

 Native : access modifier

 Native applies to only to methods.
 Native can be applied to static methods also.
 Native methods can not be abstract.
 Native methods can throw exceptions.
 Native method is like an abstract method. The implementation of the abstract
class and native method exist some where else, other than the class in which the method
is declared.

 Synchronized : access modifier

 Synchronized keyword can be applied to methods or parts of the methods only.
 Synchronize keyword is used to control the access to critical code in multi-
threaded programming.

Declaration of access specifier and access modifiers :

Class - Public, Abstract, Final

Inner Class - Public, Protected, Private, Final, Static,
Anonymous - Public, Protected, Private, Static
Variable - Public, Protected, Private, Final, Static, Transient, Volatile, Native
Method - Public, Protected, Private, Final, Abstract, Static, Native,
Synchronized
Constructor - Public, Protected, Private
Free-floating code block - Static, Synchronized
  Package : A Package is a collection of Classes Interfaces that provides a high-
level layer of access protection and name space management.

 Finalize( ) method:
 All the objects have Finalize() method, this method is inherited from the Object
class.
 Finalize() is used to release the system resources other than memory(such as file
handles& network connec’s.
 Finalize( ) is used just before an object is destroyed and can be called prior to
garbage collection.
 Finalize() is called only once for an Object. If any exception is thrown in the
finalize() the object is still eligible for garbage collection.
 Finalize() can be called explicitly. And can be overloaded, but only original method
will be called by Ga-collect.
 Finalize( ) may only be invoked once by the Garbage Collector when the Object is
unreachable.
 The signature finalize( ) : protected void finalize() throws Throwable { }

 Constructor( ) :
 A constructor method is special kind of method that determines how an object is
initialized when created.
 Constructor has the same name as class name.
 Constructor does not have return type.
 Constructor cannot be over ridden and can be over loaded.
 Default constructor is automatically generated by compiler if class does not have
once.
 If explicit constructor is there in the class the default constructor is not generated.
 If a sub class has a default constructor and super class has explicit constructor the
code will not compile.

 Object : Object is a Super class for all the classes. The methods in Object class as
follows.
Object clone( ) final void notify( ) Int hashCode( )
Boolean equals( ) final void notify( )
Void finalize( ) String toString( )
Final Class getClass( ) final void wait( )
 Class : The Class class is used to represent the classes and interfaces that are
loaded by the JAVA Program.
 Character : A class whose instances can hold a single character value. This class also
defines handy methods that can manipulate or inspect single-character data.
constructors and methods provided by the Character class:
Character(char) : The Character class's only constructor, which creates a
Character object containing the value provided by the argument. Once a
Character object has been created, the value it contains cannot be changed.
compareTo(Character) :An instance method that compares the values held by
two character objects.
equals(Object) : An instance method that compares the value held by the current
object with the value held by another.
toString() : An instance method that converts the object to a string.
charValue() :An instance method that returns the value held by the character
object as a primitive char value.
isUpperCase(char) : A class method that determines whether a primitive char
value is uppercase.

 String: String is Immutable and String Is a final class. The String class provides for
strings whose value will not change.
One accessor method that you can use with both strings and string buffers is the
length() method, which returns the number of characters contained in the string or the
string buffer. The methods in String Class:-
 toString( ) equals( ) indexOff( ) LowerCase( )
charAt( ) compareTo( ) lastIndexOff( ) UpperCase( )
getChars( ) subString( ) trim( )
getBytes( ) concat( ) valueOf( )
toCharArray( ) replace( )
ValueOf( ) : converts data from its internal formate into human readable formate.
 String Buffer : Is Mutable , The StringBuffer class provides for strings that will be
modified; you use string buffers when you know that the value of the character data will
change.
In addition to length, the StringBuffer class has a method called capacity, which
returns the amount of space allocated for the string buffer rather than the amount of
space used.
The methods in StringBuffer Class:-
length( ) append( ) replace( ) charAt( ) and setCharAt( )
capacity( ) insert( ) substring( ) getChars( )
ensureCapacity( ) reverse( )
setLength( ) delete( )

 Wraper Classes : are the classes that allow primitive types to be accessed as Objects.
These classes are similar to primitive data types but starting with capital letter.
Number Byte Boolean
Double Short Character
Float Integer
Long
 primitive Datatypes in Java :
According to Java in a Nutshell, 5th ed boolean, byte, char, short, long float, double, int.

Float class : The Float and Double provides the methods isInfinite( ) and isNaN( ).
isInfinite( ) : returns true if the value being tested is infinetly large or small.
isNaN( ) : returns true if the value being tested is not a number.

 Character class : defines forDigit( ) digit( ) .

ForDigit( ) : returns the digit character associated with the value of num.