1. It extends another abstract class
2. It declares an abstract method.

1. For the deceleration. It\'s not contain the functional codes.
2. An abstract method is to ensure that subclasses of this class will include an implementation of this method.
3. Any concert class must implement all abstract methods it has inherited.which is class that is not abstract and therefore capable of being instantiated.

1. The only modifier that can be applied to local variables in final.
2. A top level interface can have public and abstract as access modifier
3. A top level class can have public, abstract and final as access modifiers. To make the class default do not specify any access modifier.
4. The string class is a final class. Final classes can improve performance as the methods are expanded inline.
5. All the methods of final class are also final.
6. Transient keyword can only be applied to member variables and it makes those variable non-persistable while serializing the object.
7. Java interfaces cannot have transient variables.
8. Volatile variables maintain a master copy in addition to the local copy of each thread and each thread has to keep its copy in sync with the local copy. They are useful to avoid concurrency problem when synchronization is not an option. They are somewhat slower.
9. The only modifier that can be applied to local variables in final.

1. HashMap
2. ArrayList

1. An Exception is an object type.
2. An exception is shorthand for exceptional condition,which is an occurrence that alters the normal flow of an application.

1. performing whatever cleanup is appropriate to the object,
2. Calling the superclass finalizer.

1. the declaration
2. initialization of variables
3. The boolean test expression and the iteration expression.

1. import statements do not make classes accessible;
2. all classes in the classpath are accessible.

1. To determine whether an object is of a given class or interface type 8 Glossary :
2. This comparison may not be made on primitive types and will result in a compile time error if it is attempted.

1. Group of methods, or a public interface.
2. Its must be implemented by any class that implements the interface.
3. An interface allows an object to be treated as a type declared by the interface implemented.

1. A java source file must meet strict requirements.
2. The java compiler will generate errors. Source files must end with a .java extension, and there may be only one public class per source code file.

1. memory management,         
2. network access,         
3. hardware abstraction, and so on.                           

1. Elements of a class
2. Including methods
3. Variables
4. Nested classes

1. For the specific function has a name,
2. May be passed parameters.
3. Its also may return a result.
4. Methods are found only with in classes.

1. class
2. method
3. variable declaration

1. Instruction
2. Operation
3. Statement

1. Here no duplicate keys and
2. The objects themselves may be duplicated.
3. The key may not be a null value. That\'s the main difference.

1. Its classes are defined as within the scope of another class, Which name is like enclosing class.
2. Its have not any implicit references to instances of the enclosing class.
3. It can access only static members and methods of the enclosing class.
4. These classes are often used to implement small helper classes such as iterators.

1. Its similar as static method.
2. Its accessed from a class directly, even though the class has not been instantiated.
3. Its value will be the same in every instance of the class.

1. The String class is final.
2. Its may not be subclassed.

1. byte
2. short
3. char
4. int

1. Its an independent line of execution.
2. Its a type of mini program .
3. Multiple line of execution method is also used in multiple threads.
4. Its executes instructions, any variables that are declares within the method, Its also called automatic variables.
5. Its stored in a private area of memory, which area is protected area and other threads cannot access. This allows any other thread to execute the same method on the same object at the same time without having its automatic variables unexpectedly modified.

1. public
2. protected
3. package
4. default

1. Decimal (base 10)
2. Octal (base 8)
3. Hexadecimal (base 16)

1. How to make an array reference variable (declare)
2. How to make an array object (construct)
3. How to populate the array with elements (initialize)

1. Initialize
2. Construct

1. int x = 9;
2. int[] dots = {3,6,x,8};

1. Declares an int array reference variable named dots.
2. Creates an int array with a length of four (four elements).
3. Populates the elements with the values 3, 6, 9, and 8.
4. Assigns the new array object to the reference variable dots.

1. Instance variable
2. Local variable

1. The length of the args array will always be equal to the number of command-line arguments.
2. args.length is one, meaning there is one element in the array, and it is at index zero.
3. length-1, you\'ll get an ArrayIndexOutOfBoundsException.

1. Public
2. Final
3. Static
4. Abstract

1. each source code file have a one public class only.
2. file name and class name should be same .
3. package should be first line in the source code if class is a part of package .
4. import and package statements apply to all classes within a source code file.

1. Access modifiers: public, protected, private
2. Non-access modifiers (including strictfp, final, and abstract.

1. Create an instance of class B
2. Extend class B (in other words, become a subclass of class B).
3. Access certain methods and variables within class B, depending on the access control of those methods and variables.

1. public
2. protected
3. default
4. private

1. transient
2. synchronized
3. native
4. strictfp

1. Makes a reference variable named b, of type Button.
2. Creates a new Button object on the heap.
3. Assigns the newly created Button object to the reference variable b.

1. > greater than
2. >= greater than or equal to
3. < less than
4. <= less than or equal to

1. == equals (also known as \"equal to\")
2. != not equals (also known as \"not equal to\")

1. Numbers
2. Characters
3. Boolean primitives
4. Object reference variables

1. + addition
2. - subtraction
3. × multiplication
4. / division

1. ++ increment (prefix and postfix)
2. -- decrement (prefix and postfix)

1. >> right shift
2. << left shift
3.  >>> unsigned right shift (also called zero-filled right shift)

1. && & AND
2. | inclusive OR
3. ^ exclusive OR
   
   

1. &
2. |
3. && short-circuit AND
4. || short-circuit OR

1. Make sure a char variable is declared before the switch statement.
2. Each case statement should be followed by a break.
3. The default value can be located at the end, middle, or top.

1. while,
2. do-while
3. for

1. Declaration and initialization of variables.
2. The boolean expression (conditional test)
3. The iteration expression

1. The outer label should appear just before the while loop begins. It does not matter if it is on the same line or not.
2. Make sure age is declared outside of the while loop.

1. Create an enclosing class called Propagate and a main() method, which will remain empty for now.
2. Create a method called reverse(). It takes an argument of a string and returns a String.
3. Check if the String has a length of 0 by using the length() method. If the length is 0, it will throw a new exception.
4. Now let\'s include the code to reverse the order of the String. Because this isn\'t the main topic of this chapter, the reversal code has been provided, but feel free to try it on our own.
   
   
   

1. Create an enclosing class called MyException and a main() method, which will remain empty for now.
2. Create a method called checkFood(). It takes a String argument and throws our exception if it doesn\'t like the food it was given. Otherwise, it tells us it likes the food. We can add any foods we aren\'t particularly fond of to the list.
3. Now in the main() method, We will get the command-line argument out of the String array, and then pass that String on to the checkFood() method. Because it\'s a checked exception, the checkFood() method must declare it, and the main() method must handle it (using a try/catch). Do not have main() declare the method, because if main() ducks the exception,

1. With no arguments
2. With a package name
3. With a class name

1. flexibility
2. maintainability

1. Vehicle is the superclass of Car.
2. Car is the subclass of Vehicle.
3. Car is the superclass of Subaru.
4. Subaru is the subclass of Vehicle.
5. Car inherits from Vehicle.
6. Subaru inherits from Car.
7. Subaru inherits from Vehicle.
8. Subaru is derived from Car.
9. Car is derived from Vehicle.
10. Subaru is derived from Vehicle.
11. Subaru is a subtype of Car.
12. Subaru is a subtype of Vehicle.

1. Car extends Vehicle means Car IS-A Vehicle.
2. Subaru extends Car means Subaru IS-A Car.

1. The argument list must exactly match that of the overridden method.
2. The return type must exactly match that of the overridden method.
3. The access level must not be more restrictive than that of the overridden method.
4. The access level can be less restrictive than that of the overridden method.
5. The overriding method must not throw new or broader checked exceptions than those declared by the overridden method. For example, a method that declares a FileNotFoundException cannot be overridden by a method that declares a SQLException, Exception, or any other non-runtime exception unless it\'s a subclass of FileNotFoundException.
6. The overriding method can throw narrower or fewer exceptions. Just because an overridden method takes risks doesn\'t mean that the overriding subclass exception takes the same risks. 
7. Bottom line: An overriding method doesn\'t have to declare any exceptions that it will never throw, regardless of what the overridden method declares.
8. We cannot override a method marked final.

1. Overloaded methods must change the argument list.
2. Overloaded methods can change the return type.
3. Overloaded methods can change the access modifier.
4. Overloaded methods can declare new or broader checked exceptions.
5. A method can be overloaded in the same class or in a subclass

1. But what really happens when we say new Horse() :
2. Horse constructor is invoked.
3. Animal constructor is invoked (Animal is the superclass of Horse).
4. Object constructor is invoked (Object is the ultimate superclass of all classes, so class Animal extends Object even though we don\'t actually type \"extends Object\" in to the Animal class declaration. It\'s implicit.) At this point we are on the top of the stack.
5. Object instance variables are given their explicit values (if any).
6. Object constructor completes.
7. Animal instance variables are given their explicit values (if any).
8. Animal constructor completes.
9. Horse instance variables are given their explicit values (if any).
10. Horse constructor completes.

1. Constructors can use any access modifier, including private. (A private constructor means only code within the class itself can instantiate an object of that type, so if the private-constructor class wants to allow an instance of the class to be used, the class must provide a static method or variable that allows access to an instance created from within the class.)
2. The constructor name must match the name of the class.
3. Constructors must not have a return type.
4. It\'s legal (but stupid) to have a method with the same name as the class, but that doesn\'t make it a constructor. If we see a return type, it\'s a method rather than a constructor.
5. If we don\'t type a constructor into our class code, a default constructor will be automatically generated by the compiler.
6. The default constructor is always a no-arg constructor.
7. If we want a no-arg constructor and we have typed any other constructor(s) into our class code, the compiler won\'t provide the no-arg constructor (or
8. any other constructor) for us. In other words, if we have typed in a constructor with arguments, we won\'t have a no-arg constructor unless we type it in ourself !
9. Every constructor must have as its first statement either a call to an overloaded
10. constructor (this()) or a call to the superclass constructor (super()).
11. If we do type in a constructor (as opposed to relying on the compiler-generated default constructor), and we do not type in the call to super(), the compiler will insert a no-arg call to super() for us.
12. A call to super() can be either a no-arg call or can include arguments passed to the super constructor.
13. A no-arg constructor is not necessarily the default constructor, although the default constructor is always a no-arg constructor. The default constructor is the one the compiler provides! While the default constructor is always a no-arg constructor, we are free to put in our own no-arg constructor.

1. What we can declare as a return type, and
2. What we can actually return as a value.

1. double ceil ( double a )
2. double floor ( double a )
3. double random ( )
4. double abs ( double a )
5. float abs ( float a )
6. int abs ( int a )
7. long abs ( long a )
8. double max ( double a, double b )
9. float max ( float a, float b )
10. int max ( int a, int b )
11. long max (long a, long b )
12. double min ( double a, double b )
13. float min ( float a, float b )
    
14. double sqrt ( double a )
15. int min ( int a, int b )
16. long min ( long a, long b )
17. double toDegrees ( double angleInRadians )
18. double toRadians ( double angleInDegrees )
19. double tan ( double a )
20. double sin ( double a )
21. double cos ( double a )
22. double sqrt ( double a )
23. int round ( float a )
24. long round ( double a )

1. To provide a mechanism to wrap primitive values in an object so that the primitives can be included in activities reserved for objects, like as being added to Collections, or returned from a method with an object return value.
   
   
2. To provide an assortment of utility functions for primitives. Most of these functions are related to various conversions converting primitives to and from String objects, and converting primitives and String objects to and from different bases (or radix), such as binary, octal, and hexadecimal.

1. 1st that takes a primitive of the type being constructed.
2. 2nd that takes a String representation of the type being constructed.
   
   

1. parseXxx() returns the named primitive.
2. valueOf() returns a newly created wrapped object of the type that invoked the method.

Now we  discuss to how comparing the two object references using the == operator evaluates true only when both references refer to the same object.We saw that the String class and the wrapper classes have overridden the equals() method. so that we could compare two different objects to see if their contents are meaningfully equivalent.

When we really need to know if two references are identical, use ==. But when we need to know if the objects themselves are equal, use the equals() method. For each class we write, we must decide if it makes sense to consider two different instances equal.For some classes, we might decide that two objects can never be equal.

Its a type of potential limitation.if we don\'t override equal() method.you won\'t be able to use the object as a key in a hashtable.

The equals() method in Object uses only the == operator for comparisons,so unless we override equals(), two objects are considered equal only if the two references refer to the same object.

If we would like to objects of our class to be used as keys for a Hashtable,then we must override equals() so that two different instances can be considered the same.

1. It is reflexive
2. It is symmetric
3. it is transitive.
4. It is consistent
5. For any non null reference value.

1. Add objects to the collection.
2. Remove objects from the collection.
3. Find out if an object (or group of objects) is in the collection.
4. Retrieve an object from the collection (without removing it).
5. Iterate through the collection, looking at each element (object) one after another.

1. Collection
2. Set
3. Sorted Set
4. List
5. Map
6. Sorted Map
   
   


Its similarly like Vector is the only class other than ArrayList to implement RandomAccess.this linkage gives us new method.for adding and removing from beginning or end.

1. Hash Set
2. LinkedHashSet
3. TreeSet

1. For any given object, finalize() will be called only once by the garbage collector.
2. Calling finalize() can actually result in saving an object from deletion.

1. static
2. method local
3. anonymous

1. The keyword this can be used only from within instance code. In other words, not within static code.
2. The this reference is a reference to the currently-executing object. In other words, the object whose reference was used to invoke the
3. currently-running method.
4. The this reference is the way an object can pass a reference to itself to some other code, as a method argument:
   
   

1. final
2. abstract
3. public
4. private
5. protected
6. static

1. here two classes are mentioned maggie and food.
2. maggie has one method mag()
3. Food has one instance variable, declared as type maggie.
4. That\'s it for Food. Food has no methods.

1. java.lang.Thread
2. java.lang.Runnable

1. start()
2. yield()
3. sleep()
4. run()

1. Extend the Thread class.
2. Override the run() method.

1. A new thread of execution starts.
2. The thread moves from the new state to the runnable state.
3. When the thread gets a chance to execute, its target run() method will run.

1. public final void wait()
2. public final void notify()
3. public final void notifyAll()

1. new
2. runnable
3. running
4. waiting/blocked/sleeping
5. dead

1. Sleeping
2. Waiting
3. Blocked because it needs an object\'s lock

1. Pick a thread to run, and keep it there until it blocks or completes its run() method
2. Time slice the threads in the pool to give everyone an equal opportunity to run.

1. Create a class and extend the Thread class.
2. Override the run() method of Thread. This is where the synchronized block of code will go.
3. For our three threaded objects to share the same object, we will need to create a constructor that accepts a StringBuffer object in the argument.
4. The synchronized block of code will obtain a lock on the StringBuffer object from step 3.
5. Within the block, output the StringBuffer 100 times and then increment the letter in the StringBuffer.
6. Finally, in the main() method, create a single StringBuffer object using the letter A, then create three instances of our class and start all three of them.

1. wait()
2. notify()
3. notifyAll()

1. wait()
2. notify()
3. notifyAll()

1. Instances variable are kept protected.
2. Getter and setter methods mainly provide the access to instance variable.

1. static variables live basically as long as their class lives.
2. instances variable live as long as their object lives.
3. local variable live as long as their method is on the stack; however ,if their method invokes another method.they are temporarily unavailable.
4. block variables live until the block completes.

1. Literals integers are implicitly int.
2. Integer expression always result in the int-sized result never smaller.
3. Here we know also that the Floating point numbers are implicitly doubles.
4. Compound assignment perform an automatic cast.
5. Reference variable holds the bits that are used to the refer to an object.

1. Its wrap primitives so that they can be handled like objects.
2. To provide utility methods for primitives.
   Wrappers are using most importance families method whch is three are there :
3. xxxValue()
4. parseXxx()
5. valueof()

1. There are two equality operators : == and !=.
2. Four types of things can be tested: number , characters,booleans,and reference variable.

1. Add
2. Substact
3. multyply
4. divide.

1. Prefix (-- or ++)
2. Post fix(-- or ++)

1. returns the value after the ? if the expression is true.
2. returns the value after the : if the expression is false.

1. &
2. |
3. ^
4. !
5. &&
6. ||

Each ThreadPoolExecutor also maintains some basic statistics, such as the number of completed tasks.

 A method is an ordinary member function of a class. It has its own name, a return type (which may be void), and is invoked using the dot operator.

StringBuffer 

One is int argc i.e. arguments count and the another is char *argv[] i.e. arguments vector which is an array of pointers to character strings.

The eqauls() method put the two strings in the two different arrays and compare the characters one by one.

 If all the characters are matched then this method will return true otherwise false.

The == operator checks whether the two strings points to the same the object or not. The == operator checks the bit pattern of the two references.

It must be subclassed by other class implementing the abstract method. 

The abstract class is modified by keyword \'abstract\'. 

Interface can be think of as fully abstract class.All the method within the interface are abstract must end with a semicolon followed by parantheses.

If a class implement an Interface,it must provide the definition to all the methods of the interface or it must be the abstract class.

 A final variable is just like a constant. It\'s value can not be change once it is initialized. It must be initialized at the time of variable declaration or the constructor completed.

Example: 

 package p1;

 public final class FinalClass{public void show(){System.out.println(\"This is a final class.\"); } }

 class FinalSub extends FinalClass{ //errorpublic static void main(String[] args){FinalClass f=new FinalClass();f.show();}} 

 Output: The above program will result an error in compilation like \'can\'t subclassed a final class\'.

A JavaBean is a simple class havingthe setter and getter methods for each property. 

It is good convension to implement the Serializable interface.

 Example: 

The synchronization is used to coordinate the activities between the multiple threads.

Java uses the monitor to synchronize the methods or the block of code. A \'synchronized\' keyword is used with the method signature or before a block of code.

 If all the thread of the class want to access the same method concurrently, monitor helps them to synchronize the accessone thread at a time by locking the resource being accessed on the accessing object.

Reflection provides the programmatic access to variables, methods, constructors to operate on objects.

 It is used to retrieve the member information for any loaded class. 

 Example:Class a=Class.forName(\"java.lang.String\");Method m[]=a.getDeclaredMethods();java.lang.reflect package provides classes such as Method,Modifier,Field,Constructor,Proxy etc. Using these classes we can retrieve the needed information of the loaded class.

All the subclasses of a serializedclass are also themseleves serialize. 

This interface contains no methods and used simply to identify being serialized.

 Its main purpose is to save the object state into a device or filefor the future use.

 This process is calles serialization. When we want to access the state of the object we make it deserialized.The classes that require serialization must implement the following methods for the serialization and deserialization process.

 private void writeObject(java.io.ObjectOutputStream out) throws IOException{//write the object state} private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException{//read the object state} The writeObject() method is responsible for saving the state of the object into a resource, i.e. device or a file. The readObject()method is responsible for the accessing the object state.

 For methods overloading you must change the argument list.

 You can change the number of parameter passed or their data types.The return type may be the same, doesn\'t matter.

 The finalize() method is declared in the java.lang.Object class.

 When you implement the finalize method, you are actually overriding it from the Object class.Your finalize() method must be declared as follows:

 protected void finalize () throws throwable{//some cleanup code here}

 AWT is a portable GUI library for stand-alone applications and/or applets. 

Swing implements a set of GUI components that build on AWT technology and provide a pluggable look and feel. Swing is implemented entirely in the Java programming language.AWT over Swing:*Speed*Applet Portability*Look and FeelSwing over AWT:*Portability*Behavior*Features

Using the JMF with the JFC/Swing is a heavy weight component. 

All AWT components are heavyweight and all Swing components are lightweight. Mixing the AWT components with Swing is painful task.

 Example: 

import java.applet.Applet;import java.awt.Graphics;

import java.applet.Applet; import java.awt.Graphics; public class HelloWorld extends Applet { public void paint(Graphics g) { g.drawString(\"Hello world!\", 50, 100); } }

The start() method is called applet is ready to display the content and called after the init() completed and before the paint() called.

 Exception is a class drived from the Throwable class. 

Two types of exception are there:Checked exception and Unchecked exception. If a checked exception is thrown by a method it must declare it or handle it by providing a try/catch block. 

Java provides the five keywords for handling the exception: try,catch,throw,throws and finally.When an exception is thrown,the class Exception or its subclassmust be instantiated and passed to the catch block as a parameter.

 A method can declare the exception using the keyword throws with the method signature and a list of exceptions type so that the calling methods can guard themselves. 

 For example: 

public void myMethod() throws IOException, ArithemeticException{//some code here that might cause the exception}If a method does not declare the exception then it must handle the exception by providing the try/catch block.For example:public void myMethod(){try{//some code here that might cause the arithematic exception}catch(ArithematicException e){}}

 That means you are not sure that the catch will be executed or not. 

 So it is better not to put the code inside the catch block which must be executed such as closing a file or a socket connection. Java provide another keyword \'finally\' for this purpose. 

The finally block must come immediately after the all catch blocks or after the try block if there is no catch associated with the try block. The finallyblock must be executed, doesn\'t matter the exception is thrown or not.

We get default access control if we don\'t use any of the access modifiers.

Java supports two types of polymorphism: static and dynamic polymorphism.

 Polymorphism can be achieved in java by method overloading (static polymorphism) and method overriding (dyanmic polymorphism). 

 Overloading: Using the same method name with multiple implementation in such a way that the argument list must be changed and return type may change. For overloading, change in the argument list is a must. Overloading resolve at the time of compilation.

 Overriding: Using the same method name with thesame argument list and return type called method overriding. However in Java 5, the ruturn type ofthe overrriding method may be changed with the subtype of the overridden method.

 The class which acquire the properties of another class (super class)is called subclass or drived class. 

Java provides the keyword \'extends\' to support the Inheritance.

 Example:

To overload amethod, you must change the arguments list. Thereturn type may or may not be change.

 A class can\'t extends more than one classbut an interface can extends more than oneinterface.Example:interface I1{//some abstract methods here}interface I2{//some abstract methods here}interface I3 extends I1,I2{//some abstract methods here}

It support multithreading, exception handling and automatic garbage collection facilities.Java supports various applications like:Web applications and web services.

 A method has a specific signature having the method name along with the parameter list and a return type. Methods describe the behaviour of the class. Methods are where the real work gets done,date get manipulated and algorithms implemented.

 Example:

 class Area{ //data variable double dim1; 

 double dim2;

 //methods public double calculateArea(double d1,double d2){ //some calculation code here}}

 The class which acquire the properties of another class (super class)is called subclass or drived class.

 Java provides the keyword \'extends\' to support the Inheritance. 

 Example:

 This bytecode is then executed by the JVM. A Java Virtual Machine (JVM) is a software program and data structures which use a virtual machine model to execute the instructions.

 JVM accepts accepts the byte code and provides output of that bytecode. 

A bytecode is highly optimized set of instructions.The JVM is combines a set of standard class libraries which implement the Java API (Application Programming Interface).

 Each of the above things is identified by their names in the program. 

They are not the thing themselves, they justpoint to the values in the memory. Identifiers follows some rules to be declared: * Identifiers must be composed of letters, numbers, the underscore _ and the dollar sign $. * Identifiers may only begin with a letter, the underscore or a dollar sign.

 Acess modifiers are public, protected and private.Non-access modifiers are abstract, final, static, transient, volatile, strictfp, and synchronized.

 JVM performs the garbage collection to free up the unnecessary memory which can\'t be reached through the object reference. We can\'t force the JVM to perform the garbage collection, but we can request the JVM by our program to to call the method System.gc(), but it is upto JVM to perform garbage collection or not.

If we modify a class with the final modifier, it means, that class can\'t be subclassed, i.e. we can not make a subclass of final class.If we declare a method to final, it means, that method will not be inheritin the subclass of that class in which the final method is declared.If we declared a final variable, it means, that the value of the variable can not be modified once it is initialized.

 An abstract class can have abstract and non-abstract methods, but an interface can have only abstract methods ends with the semicolon.

 An interface may also contain constant.Example:public interface MyInterface{int i1;static int i2;static final int i3;void showi1();public void showi2();public abstract showi3();}

 This will create an array of int of size 3. The size of the can\'t be increase once it is created.Vector is just like an array, but it is rescalable. That means we can increase or decrease the size of the vector. One most important thing about vector is that unlike array, vector can hold multiple types of element. Vector can be declared as:Vector v=new Vector();Vector provides the methods to manipulate the elements:v.add(\"Hello\");v.add(3);v.add(1,\"world!\");v.set(2,\"How are you!\");v.get(0);Use the vector if you want to store the multiple data types and don\'t know about the size.

Two types of casting are there in java:

We can directly assign the value of a variable to other variable if that variable can be easily fit by memory size into the other variable, this is called implicit casting.

 Example:

 int a=5; //a having 4 byte of memorybyte b=6; //b having 1 byte of memorya=b; 

//OK! byte b can be easily fit into an int a.b=a; //NO! int a can't be fit into the byte b.b=(byte)a;

 //OK! Explicit casting.The above statement telling the compiler that, I know there may be some loss of bits.

final methods can't be inherited.

final class can't be sub-classed.

finally is the block of code used with the try/catch block or the try block if there is no catch associated with the try block.

finalize It is useful where you want some code must be executed whether the exception is thrown or not.finalize is a method that is called by JVM just before the performing the garbage collection.

 But is not sure that this method will be called ore not, it depends upon the JVM.It is declared in the Object class. You can override the finalize() method.

 A single package may contain several classes and sub packages.

 Java provides the keyword \'package\' to declare the package. Each package has an identifier and can be import in the other package.

 Packages are introduced to resolve the class naming confliction that can arise when two programmers have the same name for their classes.Declaring a package:package p1;class abc{}Importing a package:package p2;import p1.abc;class xyz{}

For Example:

 try{throw new NullPointerException();}catch(NullPointerException e){} 

 The throws keyword is used with the method signature with the list of Exceptions type. This process is called exception declaration. It tells the calling method to guard themselves to declare the exception or handle it.

 For example:void calculate(int a,int b) throws ArithematicException{//some calculation code here}

 A single try block can have multiple catch associated with it but the each catch has an arguments according to the inheritance heirarchy of Exception. 

That means a subtype of Exception heirarchy must not be come in the catch block before the supertype of the Exception heirarchy. 

 Example:

 try{int i=3/0; //divide by zero exception}catch(Exception e){}catch(ArithematicException e){}

 The above code will result a compilation error \'unreachable code\' at the second catch statement because ArithematicException is a subtype of the Exception class. 

The above code should be like this:try{int i=3/0; //divide by zero exception}catch(ArithematicException e){}catch(Exception e){}

The Java Virtual Machine allows an application to have multiple threads of execution running concurrently

Every thread has a priority from one to ten.

 Threads with higher priority are executed in preference to threads with lower priority. Java provides two ways to create the Thread: * Extending the Thread class * Implementing the Runnable interface.

A single program or block of code can be executed by any number of treads. 

Some problems may arises with multi-threading if two or more threads manipulates the shared or global variable.

 But itis better to implement the Runnable interface, because if you extends the Thread class you willnot be able to extend any other class. One classcan extends only a single class but can implements many interfaces.

for exampleThread.sleep(7000);butthe suspend() method moves to waiting state untilthe resume() method gets called.

The most common reason for using the this keyword is because a field is shadowed by a method or constructor parameter.

 Example:public class PointExample { public int x = 0; public int y = 0; //constructor public Point(int x, int y) {this.x = x;this.y = y; }}

 Length and capacity of the StringBuffer object can be find out by the following two methods: * length() * capacity()Capacity of the StringBuffer is always plus 16 to the length. Example:class StringBufferExample { public static void main(String args[]) { StringBuffer sb = new StringBuffer(\"Hello World!\"); 

 System.out.println(\"Buffer value= \"+sb); System.out.println(\"Length = \" +sb.length()); System.out.println(\"Capacity = \" +sb.capacity()); }}

 * using the == operator, * using the equals() method.

 For Example:String s1=new String(\"Hello!\");String s2=new String(\"Hello!\");if(s1==s2) System.out.println(\"Equal using == operator.\");elseif (s1.equals(s2))System.out.println(\"Equal using equals method.\");elseSystem.out.println(\"Not Equal.\");

 Some of the facilities provided by System class: * Reading input from the keyboard.

 * Writing output to console. * Reading and writing system properties and environment variables Runtime class provides support for runtime environment.

The character value is used to look up five possible attributes of the character: white space, alphabetic, numeric, string quote, and comment character. Some Methods defined by StreamTokenizer class: * void whitespaceChars(int low, int hi) * void wordChars(int low, int hi) * String toString() * void slashStarComments(boolean flag) * void parseNumbers() * void ordinaryChars(int low, int hi) * int lineno() ,etc.

Saving the stateof the object for the future use into some file or the device is called the Serialization.

 When we want to use that object, we read the values of the variables from the file or device. 

This process is called De-serialization.

 When you use a Java technology-enabled browser to view a page that contains an applet, the applet\'s code is transferred to your system and executed by the browser\'s Java Virtual Machine (JVM).

The getDocumentBase() returns the URL to the host that server the HTML document.The getCodeBase() returns the URL to where the original applet class was loaded from.

 * Get a reference to the applet context * Call the showDocument method with a URL object as parameter.

 The following code can help here: import java.applet.*;

 public class MyApplet extends Applet { // Applet code here // load an html page public void showPage (String aPage) //aPage should contained address of the HTML page to be shown { URL url = null; try { url = new URL (aPage); } catch (MalformedURLException e) { //handle exception } if (url != null) { getAppletContext().showDocument (url); } } }

 It actually return the URL of the directory in which the document resides.

 The getCodeBase() method gets the base URL. 

This is the URL of the directory which contains this applet.It Returns:the base URL of the directory which contains this applet.

 Because the applets all run within the same Java context-that is, they are all in the same virtual machine together-appletscan invoke each other\'s methods.

The AppletContext class has some methods for locating another applet by name, or retrieving all the applets in the currentruntime environment. The AppletContext class in the java.applet package contains the two member functions getApplet and getApplets.

 By using these functions, an applet can find other applets and invoke methods on them.

 Example:Html file: Using the name attribute, you can refer to a applet: Applet anotherApplet = getApplet(\"applet1\"); anotherApplet.someMethod(); //calling any public method

Java�s Abstract Windowing Toolkit (AWT) communicates these actions to the programs using events. 

When the user interacts with a program, by clicking a command button, the system creates an event representing the action and delegates it to the event-handling code within the program. 

This code determines how to handle the event so the user gets the appropriate response. 

Java provides the Event class and each event is represented by an object that gives information about the event and identifies the event source. Whenever an event occured by an event sourse, 

An appropriate evetnt handler(EventListener) is called. The Event Listener knows that how to handle the handle.

 Event Handling Interfaces * ActionListener * AdjustmentListener * ComponentListener * ContainerListener * FocusListener * ItemListener * KeyListener * MouseListener * MouseMotionListener * WindowListener

 You don\'t have to override all the listener\'s method.

 Only one item may be selected from a Choice.

 A List may be displayed in such away that several List items are visible. A List supports the selection of one or more List items.

Only one card is visible at a time, and the container acts as a stack ofcards.

The ordering of cards is determined by thecontainer\'s own internal ordering of its component objects. The CardLayout class manages two or more components (usually JPanel instances) that share the same display space. CardLayout defines a set of methods that allow an application to flip through these cards sequentially, or to show a specified card.

 The addLayoutComponent(java.awt.Component, java.lang.Object) method can be used to associate a string identifier with a given card for fast random access.

 The GridBagLayout class is a flexible layout manager that aligns components vertically and horizontally, without requiring that the components be of the same size.

 Each GridBagLayout object maintains a dynamic, rectangular grid of cells, with each component occupying one or more cells, called its display area.GridLayout has the constructors :GridLayout(int rows, int cols) and GridLayout(int rows, int cols, int hgap, int vgap)The major difference between GridLayout and GridBagLayout is that GrigBagLayout supports components of different sizes, and you can specify layout options for each component. 

 Use the GridBagLayout when you need tabular layouts (or layouts that can be thought of as matrices) and when it is important to specify the resizing behavior of each component.

The Swing toolkit includes a rich set of components for building GUIs and adding interactivity to Java applications. It includes rich undo support, a highly customizable text package, integrated internationalization and accessibility support. Swing is completely written in Java to truly leverage the cross-platform capabilities of the Java platform. Swing is part of the Java Foundation Classes (JFC). 

The JFC also include other features important to a GUI program.Swing provides significantly enhanced functionality, such as actions, tables, trees, images buttons, tabs, toolbars, and sliders.

 An applet is a heavy-weight component, and JApplet is a light-weight component. 

The swing components provide better look and feel than awt.

 Swing components are derived from the javax.swing.* package and they are prefixed with a latter \'J\'(like JFrame, JButton, JApplet) Whereas applet is derived from the package java.applet.*

The user chooses which component to view by selecting the tab corresponding to the desired component. The add() method of JTabbedPane class is used to add container component to the JTabbedPane component of Java Swing.

 Example:import javax.swing.*;import java.awt.*;public class MyTabbedPane{ public static void main(String[] args){ JFrame f = new JFrame(\"My Tabbed Pane Frame\");f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); JTabbedPane t = new JTabbedPane(); frame.add(t, BorderLayout.CENTER); JButton b = new JButton(\"1\"); t.add(\"Tab 1\", button); b = new JButton(\"2\"); t.add(\"Tab 2\", button); frame.setSize(300,300); frame.setVisible(true); }}

 A JTree object does not actually contain your data; it simply provides a view of the data. 

Each row displayed by the tree contains exactly one itemof data, which is called a node.

 Every tree has a root node from which all nodes descend.

JTable does not contain data; it is simply a view of your data.

 The JTable class is an implementation of the Active Record design pattern.

 It is used for creating, reading, updating, and deleting records in the database table.

The Java Foundation Classes (JFC) are a graphical framework for building portable Java-based graphical user interfaces (GUIs).

 JFC consists of the Abstract Window Toolkit (AWT), Swing and Java 2D.

 A JAR file can be created by the command-line jar tool, or by using the java.util.jar API in the Java platform. JAR file format enables you to bundle multiple files into a single archive file.

 It is a meta data file that contains name-value pairs organized in different sections.

 If a JAR file is intended to be used as an executable file, the manifest file specifies the main class of the application.

 BeanInfo classes are design-time-only classes.If a bean implementor wants to provide information regarding methods, properties when they can provide a bean info class by implementing BeanInfo interface and provide information regarding the bean properties,methods etc.

 * BeanDescriptor * Beans * DefaultPersistenceDelegate * Encoder * EventHandler * EventSetDescriptor * Expression * FeatureDescriptor * IndexedPropertyDescriptor * Introspector * MethodDescriptor * ParameterDescriptor * PersistenceDelegate * PropertyChangeEvent * PropertyChangeListenerProxy * PropertyChangeSupport * PropertyDescriptor * PropertyEditorManager * PropertyEditorSupport * XMLDecoder * XMLEncoder

 * Java is the language of the Internet whereas C++ was designed mainly for systems programming, * Java supports object-oriented programming, same way as C++. * Java does not support operator overloading. 

 * Java does not include a preprocessor or support the preprocessor directives.

 * Java does not support multiple inheritance. * Java does not support destructors, but rather, add the finalize() function. * Java does not support templates. * Java does not support pointers.

The key difference is that processes are fully isolated from each other whereas threads share (heap) memory with other threads running in the same application. 

Threads share the address space of the process that created it; processes have their own address.

 You can override the update() method. The paint() in this case will simply call update(). public void update(Graphic g) { //Redisplay your window here.}public void paint(Graphics g) { update(g); // call to the update()method.}

 It allows programmers to take full advantage of the Java platform without having to abandon their investment in legacy code. JNI lets Java code use code and code libraries written in other languages, such as C and C++, and allows you to call Java code from within native code. 

 The JNI allows writing native methods to handle situations when an application cannot be written entirely in the Java programming language e.g. when the standard Java class library does not support the platform-specific features or program library. 

The JNI framework lets a native method utilize Java objects in the same way that Java code uses these objects.

You can use null layout for use a toolbar at the position where you want. 

You can also use DefaultToolBarLayout.

 A light weight component is one that subclasses java.awt.Component (or java.awt.Container) directly - implementing the look-and-feel of the component in Java rather than delegating the look-and-feel to a native peer.

These methods can only used to set or get the values of the variables. 

They neither contain any business logic nor do they interact with the database. 

 Whereas a plain old java class contains the business logic, provides some data processing capabilities, database interaction, etc.

 Applets are designed to run dynamically over the web.An application runs stand-alone, with the support of a virtual machine under the control of local user\' operating system.

 An application starts execution with the main() method. The main method here is nothing but the system method used to invoke the application.

When you \"implement\" an interface, you are stipulating that your class adheres to the \"contract\" of the interface that you specified. Use interfaces to say \"What objects can do\" or \"What can be done to an object. 

\"Interfaces are intended to define the what without defining the how. Interfaces provide a form of multiple inheritance. A class can extend only one other class. Interfaces are limited to public methods and constants with no implementation.

The basic numeric types such as int, long, double, etc., are not objects and need to be \"boxed\" into objects in order to pass them as Object parameters or call methods on them. Java does not support Multiple inheritance and operator overloading. Java uses static keyword.

We can perform a function declared as static without an object this violates real world reflection and object orientation.

 The example for multicast is the java eventhandling model.

 Examples: * java.io.Serializable, * java.lang.Cloneable, etcBoth of these interfaces declare no methods, by implementing them, a class signals some fact to the JVM (either it\'s OK to serialize it, or it\'s ok to clone it.) 

 The null interface is also called as Marker Interface or tagged interface.

 In Java, code is loaded (either from the disk or over the network) by a Class Loader. 

Class loaders perform two functions : First, the JVM needs to load the byte code for a particular class, it asks a class loader to find the byte code.

 Each class loader can use its own method for finding requested byte code files. Second, class loaders define the namespaces seen by different classes and how those namespaces relate to each other. 

Class Loaders provide Java\'s dynamic loading capability, which allows classes to arrive and depart from the runtime environment.In a JVM, each and every class is loaded by some instance of a java.lang.

ClassLoader. The ClassLoader class is located in the java.lang package and developers are free to subclass it to add their own functionality to class loading.Some of the class loaders in the JDK: * java.net.URLClassLoader * java.security.SecureClassLoader * java.rmi.server.RMIClassLoader * sun.applet.AppletClassLoader

Static means there is only one copy of that method is available to all the instances of the class. void is simply a return type of the method telling that this method will return nothing.main is an identifier to identify the method. The main() method is the entry point to the program.

 The StringBuffer is faster than String when performing simple concatenations.

 Example:String s=new String(\"Hello\");s.toUpperCase();The String object s is still pointing to \"Hello\" instead of \"HELLO\". Here a new string \"HELLO\" is created but did not assigned to any reference variable.But:StringBuffer sb=new StringBuffer(\"Hello\");sb.toUpperCase();The StringBuffer object sb is now pointing to the \"HELLO\".This is the main difference that string object are immutable and string buffer objects are mutable.

 Yes! String class is a wrapper class, it wraps the string literals to an object.

They both have the opposite meaning. An abstract class must be subclassed, whereas a final class must not be. An abstract method must be overridden whereas a final method can\'t be inherited, hence can\'t be overridden.

We can\'t call a start() method on a given Thread object for the second time. Hence a dead thread can\'t be restarted.

Applet constructor is just like any other constructor, they cannot be overridden.

 But Unchecked exception are RunTimeException, which do not to be handled or declared. Whereas Checked Exceptions must be handled by try/catch block or must be declared in the method signature.

Abstract class may have abstract and non-abstract methods. 

Interface may contain only abstract methods.

 Abstract class doesn\'t support multiple inheritance.Interface supports multiple inheritance.

Abstract class can have final, non-final, static and non-static variables.Interface has only static and final variables.Interface can\'t have static methods, main method or constructor.

Abstract class can provide the implementation of interface.Interface can\'t provide the implementation of abstract class.The abstract keyword is used to declare abstract class.The interface keyword is used to declare interface.Variables declared in a Java interface is by default final. An abstract class may contain non-final variables.

The serialization also keeps information to restore the fields during deserialization.To produce stream of bytes, the class should be inherited either from java.io.Serializable interface.which is marker interface.

So a method cannot be overloaded on the bases of return types.

Try block : It contains the statements which likely to throw an exception.

 If an exception raised, the remaining statements in the try block are skipped.Catch Block : Executed only if try block throws an exception.Finally Block : To maintain cleanup code