CORE-JAVA (Threads)

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *

* What is a task’s priority and how is it used in scheduling?
A task’s priority is an integer value that identifies the relative order in which it should be executed with respect to other tasks. The scheduler attempts to schedule higher priority tasks before lower priority tasks. The JVM defines a range of ten logical priorities for Java threads, including:
java.lang.Thread.MIN_PRIORITY = 1
java.lang.Thread.NORM_PRIORITY = 5
java.lang.Thread.MAX_PRIORITY = 10
These values 1 to 10 are passed into Thread.setPriority(int) to assign priorities to Java threads. The default priority of a Java thread is NORM_PRIORITY.
In concurrent programming, there are two basic units of execution: processes and threads. When programming with threads we have one thread actually executing at any given moment.
A PROCESS has a self-contained execution environment. A process generally has a complete, private set of basic run-time resources; in particular, each process has its own memory space. Most implementations of the Java virtual machine run as a single process. A Java application can create additional processes using a ProcessBuilder object. Multiprocess applications are beyond the scope.
Threads are lightweight processes. Both PROCESSES and THREADS provide an execution environment, but creating a new thread requires fewer resources than creating a new process. Threads exist within a process, every process has at least one. Threads share the process's resources, including memory and open files. From the application programmer's point of view, you start with just one thread, called the main thread. This thread has the ability to create additional threads, as we'll.

* What are the disadvantages of using threads?
Deadlock describes a situation where two or more threads are blocked forever, waiting for each other. Its a rare case scenario. It does not happen all the time.
Happens when two threads are invoked on the same class synchronized method and are both waiting to enter another synchronized method. Both are waiting over other to exit the entered method block. (See Example) (compile online)

* Can a lock be acquired on a class? (thread)
Yes, a lock can be acquired on a class. This lock is acquired on the class’s Class object. To synchronize threads, the Java programming language uses monitors, which are a high-level mechanism for allowing only one thread at a time to execute a region of code protected by the monitor. The behavior of monitors is explained in terms of locks; there is a lock associated with each object.
Thread Locks: A synchronized method automatically performs a lock action when it is invoked; its body is not executed until the lock action has successfully completed. If execution of the method's body is ever completed, either normally or abruptly, an unlock action is automatically performed on that same lock.

* What is the difference between YIELD and SLEEP?
* The Thread.yield() method, causes the currently executing thread object to temporarily pause and allow other threads to execute. YIELD will make a thread to pause until an unless there are no more threads waiting in the Ready-to-run state. If there are other threads in the Ready-to-run state, their priorities determine which thread gets to execute. The YIELD() method gives other threads of the same priority a chance to run. If there are no equal priority threads in the "Runnable" state, then the YIELD is ignored and the thread continues its execution.
* The Thread.sleep(long millis) method, causes the thread to pause its execution and transit to the Sleeping state. The thread will sleep for at least the time specified in its argument. SLEEP thread cannot be made to run until and unless the specified time is completed. SLEEP will throw an InterruptedException if interrupted to run before the specified time.
Difference between the methods Thread.sleep() and Object.wait():
The code sleep(1000); puts thread aside for exactly one second. It cannot be interrupted to start before the specified time.
The code wait(1000), causes a wait of up to one second. A thread can stop waiting and start running before the specified time, if it receives the Object.notify() or Object.notifyAll() call. The method wait() is defined in the class Object and the method Thread.sleep() is defined in the class Thread. Object.notify()
Object.wait(long timeout)
A thread may be blocked because:
1) It has been put to sleep for a set amount of time
2) It is suspended with a call to suspend() and will be blocked until a resume() message
3) The thread is suspended by call to wait(), and will become runnable on a notify or notifyAll message.

* What is the purpose of the wait(), notify(), and notifyAll() methods?
IMP: These methods can be invoked only from within a synchronized context (synchronized method or synchronized block), otherwise, the call will result in an IllegalMonitorStateException.
These methods are used on the "shared object" of thread inter-communication that synchronizes on the same object. Object.NOTIFY() method on an object wakes up a single thread. Object.NOTIFYALL() wakes up all the threads. All the awakened threads compete for the resource, but only one thread gets the resource and the others go back to waiting.
Object.wait() method must be enclosed within a try catch block (Checked Exception). The releasing of the lock of the shared object by the thread allows other threads to run and execute synchronized code on the same object after acquiring its lock. The Object.wait() method causes the current thread to wait until another thread notifies it of a changed condition. The wait(),notify(), and notifyAll() methods are used to provide an efficient way for threads to wait for a "shared resource". When a thread executes an object's wait() method, it enters the waiting state. It only enters the ready state after another thread invokes the object's notify() or notifyAll() methods.

* Whats the difference between notify() and notifyAll()?
Object.notify() is used to unblock one waiting thread; notifyAll() is used to unblock all of them. Using notify() is preferable (for efficiency) when only one blocked thread can benefit from the change (for example, when freeing a buffer back into a pool). notifyAll() is necessary (for correctness) if multiple threads should resume (for example, when releasing a "writer" lock on a file might permit all "readers" to resume).

/* Below example shows three threads, manipulating the same stack. All of them are PUSHING elements on the stack. Note: All the threads are using the same Object's synchronized method, within which the wait() and notify() are called. Runtime exception occurs if not called within a synchronized block. */

public class WaitAndNotify { (compile online)
-public static void main(String[] args) { StackClass stack = new StackClass(5);
--new StackPusher("One", stack); new StackPusher("Two", stack); new StackPusher("Three", stack);
--try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } /*end main*/ } /*end class*/

class StackPusher extends Thread { StackClass stack;
-StackPusher(String threadName, StackClass stack) {
--super(threadName); this.stack = stack; setDaemon(true); start(); }
---public void run() { while (true) { stack.push(new Integer(3)); } } /*end run*/} /*end thread*/

class StackClass { private Object[] stackArray; private volatile int topOfStack;
-StackClass (int capacity) { stackArray = new Object[capacity]; topOfStack = 0; }
--public synchronized void push(Object element) { // IMPORTANT: synchronized method is a must.
---while (topOfStack <= 4 ) { ---if (topOfStack >=0 && topOfStack <= 4) { stackArray[topOfStack] = element; } ---if (topOfStack >= 4) {
------try { topOfStack=0; wait(); }
------catch (InterruptedException e) { e.printStackTrace(); } }
---topOfStack = topOfStack + 1; notify(); } /*end while*/} /*end push*/} /*end class*/

* When a thread blocks on I/O, what state does it enter?
A thread enters the waiting state when it blocks on I/O.

* What are the high-level thread states?
The high-level thread states are READY, RUNNING, WAITING, and DEAD. When a thread is created and started, it is in the "Ready state".

* What state is a thread in when it is executing?
An executing thread is in the "running state".

* How can a dead thread be restarted? (THREAD)
A dead thread cannot be restarted.

* What state does a thread enter when it terminates its processing?
When a thread terminates its processing, it enters the DEAD state.

* What invokes a thread's run() method?
After a thread is started, with its start() method or that of the Thread class, the JVM invokes the thread's run() method when the thread is initially executed.

* What method is invoked to cause an object to begin executing as a separate thread?
The START() method of the Thread class is invoked to cause an object to begin executing as a separate thread.

* What happens when a thread cannot acquire a LOCK on an object?
If a thread attempts to execute a synchronized method or statement and if it's unable to acquire an object's lock, it enters the WAITING state until the lock becomes available.

* How does multi-threading take place on a computer with a single CPU?
The operating system's Task Scheduler/Processor allocates execution time to multiple tasks. By quickly switching between executing tasks, it creates the impression as if tasks are executed sequentially.

* What happens when you invoke a thread's INTERRUPT method while it is sleeping or waiting?
When a task's interrupt() method is executed, the task enters the READY state and will throw an InterruptedException when it enters the running state. A thread can be awakened abruptly by invoking the interrupt() method on the SLEEPing thread object. Note that this method is not static, thus can be used only when inherited.

* What are three ways in which a thread can enter the WAITING state?
A thread can enter the waiting state by invoking its SLEEP() method.
When blocked by I/O, and by unsuccessfully attempting to acquire an object's LOCK. By invoking an object's WAIT() method.
It can also enter the waiting state by invoking its (deprecated) SUSPEND() method.

* What are the two basic ways in which classes that can be run as threads may be defined?
A thread class may be declared as a subclass of THREAD, or it may implement the RUNNABLE interface. Implementing interface encourages multiple inheritance.

* What method must be implemented by all threads?
All tasks must implement the run() method, whether they are a subclass of THREAD or implement the RUNNABLE interface. (Ex.)
class RunnableThread implements Runnable {
---Thread runner; // instance of Thread
---public RunnableThread() { } // 1st Constructor
---public RunnableThread(String threadName) { // 2nd Constructor
-----runner = new Thread(this, threadName); // (1) Create a new thread.
-----System.out.println(runner.getName());
-----runner.start(); } // (2) Start the thread.
---public void run() { System.out.println(Thread.currentThread()); } }
public class RunnableExample {
---public static void main(String[] args) {
-----Thread thread1 = new Thread(new RunnableThread(), "thread1");
-----Thread thread2 = new Thread(new RunnableThread(), "thread2");
-----RunnableThread thread3 = new RunnableThread("thread3");
---//Start the threads
---thread1.start();
---thread2.start();
try { //delay for one second
---Thread.currentThread().sleep(1000); }
---catch (InterruptedException e) { }
---System.out.println(Thread.currentThread()); } } (compile online)

* What is daemon thread and which method is used to create the daemon thread?
A: Daemon thread is a LOW priority thread which runs intermittently in the BACK-GROUND for the benefit of other threads. An example of a daemon thread is the garbage collector. setDaemon() method is used to create a daemon thread. The Java Virtual Machine exits when the only threads running are all daemon threads. This method must be called before the thread is started. Using setDaemon(true) will stop the thread execution when main() completes. Daemon threads mean that they end when there are no more non-daemon threads running.

* Why do threads block on I/O?
Threads block on i/o (that is enters the waiting state) so that other threads may execute while the i/o Operation is performed.

* What is the difference between preemptive scheduling and time slicing? (threads)
Under preemptive scheduling, the highest priority task executes until it enters the waiting or dead states or a higher priority task comes into existence. Under time slicing, a task executes for a predefined slice of time and then reenters the pool of ready tasks. The scheduler then determines which task should execute next, based on priority and other factors.

* What are the different identifier states of a Thread?
The different identifiers of a Thread are:
R - RUNNING or runnable thread
S - SUSPENDED thread
CW - CONDITIONAL WAITING - Thread waiting on a condition variable
MW - MONITOR WAITING - Thread waiting on a monitor lock
MS - MONITOR SUSPENDED - Thread suspended waiting on a monitor lock

* Describe synchronization in respect to multi-threading. (synchronize)
A: With respect to multi-threading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared variable while another thread is in the process of using or modifying the same shared variable. This usually leads to significant errors.

* What are synchronized methods and synchronized statements? (synchronize)
A: Synchronized METHODS are methods that are used to control access to an object. A thread only executes a synchronized method after it has acquired the LOCK for the method's object or class. (Ex.)
--public class SynchronizedCounter {
----private int c = 0;
----public synchronized void increment() { c++; } }
Synchronized STATEMENTS are similar to synchronized methods. But they can be used within non-synchronized methods (Ex:). Synchronized statements must specify the object that provides the intrinsic lock. A synchronized statement can only be executed after a thread has acquired the LOCK for the object or class referenced in the synchronized statement.
public class MsLunch {
--private long c1 = 0; private long c2 = 0;
--private Object lock1 = new Object(); private Object lock2 = new Object();
public void inc1() { --synchronized(lock1) { c1++; } }
public void inc2() { --synchronized(lock2) { c2++; } } }

* What is an object's LOCK and which object's have locks? (synchronize)
An object's lock is a mechanism that is used by multiple threads to obtain synchronized access to the object. Synchronization is built around an internal entity known as the monitor lock. A thread may execute a synchronized method of an object only after it has acquired the object's lock. All objects and classes have locks. A class's lock is acquired on the class's Class object.


*[Read: How long can we wait?] *[Read: An attempt for definition.]

Read:
Life is Beautiful.
*Creating successful constructive personality. *Why God Gave Us Friends? *Way to Paradise. *Creating the Beautiful World. *Doing the job of goodness. *Life is Meaningful. *The A to Z for Goodness. *Life is full of Tests. *History Proves That. *Love in different forms. *True to the heart.

CORE-JAVA (Utils):

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *
* What is the Collections API? (collections framework)
Java.util Collections API is a set of CLASSES and INTERFACES that support operations on collections of objects. They provide useful DATA STRUCTURES and ALGORITHMS. Some of the Classes are: Vector, Hashtable, and Arrays. It provides methods that perform useful computations, such as searching and sorting, on objects that implement collection interfaces. Collections are used to store, retrieve, manipulate, and communicate aggregate data. (Java.UTIL)

* What is the List interface? (Java.util.List Interface)
Java.util.List interface provides support for ORDERED collections of objects. Also called as SEQUENCE collection. Lists may contain duplicate elements. Elements are based on their numerical position in the list (integer index). Some of the classes which Implement List Interface are: ArrayList, LinkedList, Vector, AbstractList, etc. (Tutor) (Linked List) (Framework)
(Ex:) public interface List extends Collection {
// Positional access:
Element get(int index); - Returns the element at the specified position in this list. Element set(int index, E element); - Replaces the element at the specified position. boolean add(E element); - Appends the element to the end. void add(int index, E element); - Inserts the specified element. Element remove(int index); - Removes the element at index. boolean addAll(int index, Collection c); - Inserts all of the collection elements.
// Search:
int indexOf(Object o); - Returns the index of the first occurrence else returns -1. int lastIndexOf(Object o); - Returns the index of the last occurrence.
// Iteration:
ListIterator listIterator(); - Returns a list iterator of the elements. ListIterator listIterator(int index); - starting at the specified position.
// Range-view:
List subList(int from, int to); - Returns a view of the portion. }

* What is an Iterator? (corejava)
A: An Iterator is a object or routine for accessing items from a list, array or stream, one at a time. It is used to step through the elements of a Collection. Some of the collection classes provide traversal of their contents via a java.util.Iterator interface. It has three methods:
--boolean hasNext() //Returns true if the iteration has more elements.
--Element next() //Returns the next element in the iteration.
--void remove() //Removes from the underlying collection the last element returned by the iterator (optional operation). This interface allows us to walk a collection of objects, operating on each object in turn. Iterators allow the caller to remove elements from the underlying collection during the iteration. Remember when using Iterators that they contain a snapshot of the collection at the time the Iterator was obtained; generally it is not advisable to modify the collection itself while traversing an Iterator. Ex:
public static void main( String aArguments ) {
List<.string> flavours = new ArrayList<.string>();
Iterator<.string> flavoursIter = flavours.iterator();
while ( flavoursIter.hasNext() ){
System.out.println( flavoursIter.next() );

What is HashMap and Map? (Util)
A: Map is Interface and Hashmap is class that implements that.
A Map is an object that maps KEYS to VALUES. A map cannot contain duplicate keys. Each key can map to at most one value. The Map interface replaces the JDK 1.1 Dictionary class and is used to associate keys with values.
Both key and value are objects. Methods: containsKey(Object key) and containsValue(Object value)
Ex: Map m = new HashMap(); // Create a Map object.

Difference between HashMap and HashTable? (Util)
A: The HashMap class is roughly equivalent to HashTable, except that it is unsynchronized and permits nulls. (HashMap allows null values and null key where as HashTable doesn't allow).
HashMap does not guarantee that the order of the map will remain constant over time.
HashTable is synchronized and HashMap is not.

Difference between Vector and ArrayList? (Util)
A: Vector is synchronized and thus thread safe, whereas ArrayList is not. Thus Vector is slower but safer. When inserting an element into an ArrayList or a Vector, these objects will need to expand their internal arrays (if they run out of room). (Ex:) Vector vector = new Vector(); ArrayList array = new ArrayList(); vector.add(int , element); (String)vector.get(i); etc.
A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.
However Vector does possess a slight advantage since it can set the increment value. The Vector class provides the capability to implement a growable array of OBJECTS. (Tutor)

* Which java.util classes and interfaces support event handling?
The EventObject class and the EventListener interface support event processing.

* What is the highest-level event class of the event-delegation model?
The java.util.EventObject class is the highest-level class in the event-delegation class hierarchy.

* What is the GregorianCalendar class?
The java.util.GregorianCalendar provides support for traditional Western calendars used by most of the world.

* What is the Locale class?
The Locale class is used to tailor program output to the conventions of a particular geographic, political, or cultural region.
Locale(String language, String country, String variant) - Constructor.
The language argument is a valid ISO Language Code. The country argument is a valid ISO Country Code. The variant argument is a vendor or browser-specific code. For example, use WIN for Windows, MAC for Macintosh.

* What is the SimpleTimeZone class?
The SimpleTimeZone class provides support for a Gregorian calendar.

* What is the Collection interface?
The java.util.Collection interface provides support for the implementation of a mathematical bag - an unordered collection of objects that may contain duplicates.

* What is the Set interface?
The java.util.Set interface provides methods for accessing the elements of a finite mathematical set. Sets do not allow duplicate elements.

* What is the purpose of the enableEvents() method? (awt)
The java.awt.Component.enableEvents() method is used to enable an event for a particular object. Normally, an event is enabled when a listener is added to an object for a particular event. The enableEvents() method is used by objects that handle events by overriding their event-dispatch methods.

* What is the ResourceBundle class?
The java.util.ResourceBundle class is used to store locale-specific resources that can be loaded by a program to tailor the program's appearance to the particular locale in which it is being run.

* * * * * * * * * * * * *
* [Read:Relationships-and-Happiness!] *[God-gave-us-everything.] *[Steps-Involved-In-Relationships.] *[Life-is-full-of-Tests.] *[Some-of-the-aspects-which-materialize-the-relationships.]

Read:
Winning Publications.
*Significance-of-Nava-ratna(Nava-Graha). *Amazing-Constructive-Vibrations. *The-Piercing-of-the-ears(karnavedha) . *Nature-Cure. *Steps-to-improve-work-place. *Steps-Involved-In-Relationships. *Some-of-the-aspects-which-materialize-the-relationships.

DESIGN-PATTERN

* Describe the visitor design pattern.
The visitor pattern is one of the standard patterns in the "Gang of Four" Design Patterns book. The pattern provides a powerful mechanism to invoke a type-dependent operation without explicitly testing for the type. However, using visitors is not mandatory.
It Represents an operation to be performed on the elements of an object structure. Visitor lets you define a new operation without changing the classes of the elements on which it operates. The root of a class hierarchy defines an abstract method to accept a visitor. Subclasses implement this method with visitor.visit(this). The Visitor interface has visit methods for all subclasses of the baseclass in the hierarchy. (Review) (Example)

* What is a design pattern?
A design pattern systematically names, motivates, and explains a general design that addresses a recurring design problem. (MVC) (J2EE)

CORE-JAVA (Packages):

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *
Controlling Access to Members of a Class.

* State the significance of PUBLIC, PRIVATE, PROTECTED, DEFAULT modifiers both singly and in combination.
State the effect of package relationships on declared items qualified by these modifiers. (packages)
A: PUBLIC class is visible in other packages, field is visible everywhere (class must be public too)
PRIVATE variables or methods may be used only by an instance of the same class that declares the variable or method, A private feature may only be accessed by the class that owns the feature.
PROTECTED Is available to all classes in the same package and also available to all subclasses of the class that owns the protected feature. This access is provided even to subclasses that reside in a different package from the class that owns the protected feature.
DEFAULT is what we get by default ie, without any access modifier. It means that it is visible to all within a particular package.

Access Levels

Modifier	Class	Same Package	Subclass of any package	World /Other Package
public	Y	Y	Y	Y
protected	Y	Y	Y	N
no modifier	Y	Y	N	N
private	Y	N	N	N

* What is the difference between a public and a non-public class? (PACKAGE)
A public class may be accessed outside of its package. A non-public class may not be accessed outside of its package.

* What is a Java package and how is it used?
A Java package is a naming context for classes and interfaces. A package is used to create a separate name space for groups of classes and interfaces. Packages are also used to organize related classes and interfaces into a single API unit and to control accessibility to these classes and interfaces. (FAQ)

* What modifiers may be used with a top-level class?
A top-level class may be PUBLIC, ABSTRACT, or FINAL.

* If a class is declared without any access modifiers, where may the class be accessed?
A class that is declared without any access modifiers is said to have package access. This means that the class can only be accessed by other classes and interfaces that are defined within the SAME PACKAGE.

* If a variable is declared as private, where may the variable be accessed?
A private variable may only be accessed within the SAME CLASS in which it is declared.

Does importing a package imports the subpackages as well? e.g. Does importing com.MyTest.* also import com.MyTest.UnitTests.*?
A: No we have to import the subpackages explicitly. Importing com.MyTest.* will import classes in the package MyTest only. It will not import any class in any of it's subpackage. (Managing)
Read the system time just before the method is invoked and immediately after method returns. Take the time difference, which will give you the time taken by a method for execution. To put it in code: long start = System.currentTimeMillis (); method (); long end = System.currentTimeMillis (); System.out.println ("Time taken for execution is " + (end - start)); Remember that if the time taken for execution is too small, it might show that it is taking zero milliseconds for execution. Try it on a method which is big enough, in the sense the one which is doing considerable amount of processing.

* If a method is declared as PROTECTED, where may the method be accessed?
A protected method may only be accessed by classes or interfaces of the SAME PACKAGE or by SUB-CLASSES of the class in which it is declared (same or other package).

* What modifiers can be used with a LOCAL INNER CLASS?
OUTER classes can only be declared Public or package private (Default). A local-INNER-class may be FINAL or ABSTRACT with same modifiers as of the outer class. Non-Static INNER classes can be final, abstract, public, private, and protected. Static INNER classes do not have access to OUTER members. (Local-Inner)

* Are the imports checked for validity at compile time? e.g. will the code containing an import such as java.lang.ABCD compile?
A: Yes the imports are checked for the semantic validity at compile time. The code containing above line of import will not compile. It will throw an error saying, can not resolve symbol: class ABCD location: package io import java.io.ABCD;

* Can a top level class be private or protected?
A: No. A top level class (outer class) can not be private or protected. It can have either "PUBLIC" or no modifier, DEFAULT (package private). Thus outer classes can only be declared public or package private. If a top level class is declared as private the compiler will complain that the "modifier private is not allowed here". This means that a top level class can not be private. Same is the case with protected. (the default, also known as package-private)

Where and how can you use a private constructor?
A: Private constructor can be used if you do not want any other class to instantiate the object , the instantiation is done from a static public method, this method is used when dealing with the factory method pattern when the designer wants only one controller (factory method ) to create the object.

* What restrictions are placed on the location of a package statement within a source code file?
A package statement must appear as the first line in a source code file (excluding blank lines and comments).

* Which package is always imported by default?
The java.lang package is always imported by default.

* What are the practical benefits, if any, of importing a specific class rather than an entire package (e.g. import java.net.* versus import java.net.Socket)?
It makes NO DIFFERENCE in the generated class files since only the classes that are actually used are referenced by the generated class file. There is another practical benefit to importing single classes, and this arises when two (or more) packages have classes with the SAME NAME. For Example java.util.Timer and javax.swing.Timer, for example. If I import java.util.* and javax.swing.* and then try to use "Timer", I get an error while compiling (the class name is ambiguous between both packages). The class we need was the javax.swing.Timer class, and the only classes we plan on using in java.util are Collection and HashMap. In this case, some people will prefer to import java.util.Collection and import java.util.HashMap instead of importing java.util.*. This will now allow them to use Timer, Collection, HashMap, and other javax.swing classes without using fully qualified class names.


*[Read:Life-is-full-of-Tests.] *[Things-become-Inevitable!] *[Realizations-In-Real-Life.]

Read:

*Realizations. *Realizations-In-Real-Life. *Amazing-Constructive-Vibrations. *Astrology. *Creating-Leaders. *How-ideas-are-concluded-and-decisions-are-materialized. *Relationships-&-Partnerships. *The-path-of-victory. *An-attempt-for-definition. *Speak-with-a-heart. *These-are-contagious. *Happy-kingdom. *MIRACLES. *Better-to-create-one ! *Cast-God-Religion ! *Things-become-inevitable ! *We-are-all-looking-for! *Phase-of-Life. *Destiny-Karma-and-God. *Struggle-Perfection-Money. *Independence-and-Freedom. *Relationships-and-Happiness.

CORE-JAVA (JVM):

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *
Do I need to import java.lang package any time? (JVM)
A: We need not, as it is by default loaded internally by the JVM.

Can I import same package/class twice? Will the JVM load the package twice at runtime? (JVM)
A: One can write code to import the same PACKAGE or same CLASS multiple times. Neither compiler nor JVM complains about it. And the JVM will internally load the class ONLY ONCE no matter how many times you import the same class.

* What is the difference amongst JVM Spec, JVM Implementation, JVM Runtime ? (JVM)
The JVM SPECIFICATION is the BLUE-PRINT for the JVM generated and owned by Sun.
The JVM IMPLEMENTATION is the actual implementation of the spec by a VENDOR.
And the JVM RUNTIME is the actual running INSTANCE of a JVM implementation.

* What is a compilation unit? (JVM)
A compilation unit is a Java SOURCE code file (ClassName.java).

* Difference between JRE And JVM and JDK. (JVM)
The JVM is used to execute class file.
The "JRE" is the Java Runtime Environment. JRE is an implementation of the Java Virtual Machine which actually executes Java programs. Java Runtime Environment is used to execute through browser.
The "JDK" is the Java Development Kit. JDK is bundle of software that is use to develop Java based software. Typically, each JDK contains one (or more) JRE's along with the various development tools like the Java source compilers, bundling and deployment tools, debuggers, development libraries, etc.

* What gives java it's "write once and run anywhere" nature? (JVM)
Java is compiled to be a BYTE CODE which is the intermediate language between SOURCE code and MACHINE code. This byte code is not platform specific and hence can be fed to any platform. After being fed to the JVM, which is specific to a particular operating system, the platform specific machine code is generated thus making java platform independent.

What environment variables do I need to set on my machine in order to be able to run Java programs? (environment)
A: CLASSPATH and PATH are the two variables.

* When does the compiler supply a DEFAULT constructor for a class?
If a class contains no constructor declarations, then a default constructor that takes no parameters is automatically provided. If the class is the origin and does not have any super classes then the default constructor has an empty body. Otherwise, the default constructor takes no parameters and simply invokes the superclass constructor with no arguments.

* What is your platform's default character encoding?
If you are running Java on English Windows platforms, it is probably Cp1252. If you are running Java on English Solaris platforms, it is most likely 8859_1.


*[ Creating-Super-Power.] *[Immigration.] *[Religion.] *[Responsibility.] *[Meaningful-Life.] *[Good-&-Bad.] *[Moral-Values.] *[Miss-Utilization.] *[Critical-Mass.]

Read:

*Realizations. *Realizations-In-Real-Life. *Amazing-Constructive-Vibrations. *Astrology. *Creating-Leaders. *How-ideas-are-concluded-and-decisions-are-materialized. *Relationships-&-Partnerships. *The-path-of-victory. *An-attempt-for-definition. *Speak-with-a-heart. *These-are-contagious. *Happy-kingdom. *MIRACLES. *Better-to-create-one ! *Cast-God-Religion ! *Things-become-inevitable! *We-are-all-looking-for! *Phase-of-Life. *Destiny-Karma-and-God. *Struggle-Perfection-and-Money. *Independence-and-Freedom. *Relationships-and-Happiness.

CORE-JAVA (Casting):

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *
* What is casting? (casting) (Primitive Conversion)
There are two types of casting, casting between primitive NUMERIC types and casting between OBJECT references.
Casting between numeric types is used to convert larger values, such as DOUBLE values, to smaller values, such as BYTE values. This is Explicit Casting (Narrowing). Which needs conversion. Where as Implicit casting is direct assigning from one form to another.
(Ex:) The WIDENING primitive conversions: FROM (byte) TO (short, int, long, float, or double) do not lose any information, the numeric value is preserved exactly in direct convertion (strictfp) (implicit).
Lets consider: int in = 1234567890; float fl = in;
POSSIBLE: (fl - in = 0) OR (fl = in) (this is strictfp with precision) (implicit)
POSSIBLE: "in" is NOT EQUAL to "(int)fl" ( this is explicit casting, lose precision)
* The NARROWING primitive conversions: FROM (double) TO (byte, short, char, int, long, or float) may lose information and precision.
float fmin = Float.NEGATIVE_INFINITY; float fmax = Float.POSITIVE_INFINITY;
POSSIBLE: long lmax = (long)fmin; // (this is explicit casting) and will compile, BUT lose precision.
NOT-POSSIBLE: long lmax = fmin; // (this is strictfp) (implicit) will NOT compile.
* Casting between OBJECT references is used to refer to an object by a compatible class, interface, or array type reference. Also see: Object Casting.
MountainBike is descended from Bicycle and Object. Thus MountainBike can be assigned to Object or Bicycle. (Ex:)
POSSIBLE: Object obj = new MountainBike(); This is called implicit casting. (Sub-class to super class)
POSSIBLE: MountainBike myBike = (MountainBike)obj; This is explicit casting. (Super class to sub-class)

* When can an object reference be cast to an interface reference? (casting)
An object reference be cast to an interface reference when the object implements the referenced interface.

* Can a Byte object be cast to a double value? (casting)
Yes, a byte object can be cast to a double value explicitly but may lose precision. The correct way of conversion is directly assigning the byte to double implicitly. As this is a Widening primitive conversion.

* Can a double value be cast to a byte? (casting)
Yes, a double value can be cast to a byte explicitly. As it cannot be done implicitly. As this is a Narrowing primitive conversion.

* What is numeric promotion? (casting)
Numeric promotion is the Implicit conversion of a smaller numeric type to a larger numeric type, so that integer and floating-point operations may take place. In numerical promotion, byte, char, and short values are converted to int values. The int values are also converted to long values, if necessary. The long and float values are converted to double values, as required.

* What is Downcasting? (casting)
Downcasting is the Explicit casting from a general to a more specific type, i.e. casting down the hierarchy.

* What is the difference between instanceof and isInstance? (casting)
instanceof is a keyword operator where as isInstance() is a method in class "Class".
instanceof compares "object" with "Class Name". isInstance compares "object of Class" with "object of Class Name".
isInstance needs to be in try catch blocks and needs an instance of "Class" to be created with Class.forName("Class").
instanceof is used to check to see if an object can be cast into a specified type without throwing a cast class exception. (Ex:) (Ex:)
if (obj instanceof MountainBike) { MountainBike myBike = (MountainBike)obj; } (Explicit Casting)
isInstance() Determines if the specified Object is assignment-compatible with the object represented by this Class. This method is the dynamic equivalent of the Java language instanceof operator. The method returns true if the specified Object argument is non-null and can be cast to the reference type represented by this Class object without raising a ClassCastException. It returns false otherwise.
(Ex:) class Parent{}
class Child extends Parent implements MyInterface{}
interface MyInterface{}
Parent obj1 = new Parent(); Parent obj2 = new Child();
try { Class cls = Class.forName("Parent");
cls.isInstance(obj2); // true } catch (Throwable e) { }
obj1 instanceof Parent; // true
obj1 instanceof Child; // false
obj1 instanceof MyInterface; // false
obj2 instanceof Parent; // true
obj2 instanceof Child; // true
obj2 instanceof MyInterface; // true

What are wrapper classes? (casting)
A: Java provides specialized classes corresponding to each of the primitive data types. These are called wrapper classes. They are e.g. Integer, Character, Double etc.

Why do we need wrapper classes? (casting)
A: It is sometimes easier to deal with primitives as objects. Moreover most of the collection classes store objects and not primitive data types. And also the wrapper classes provide many utility methods also. Because of these reasons we need wrapper classes. And since we create instances of these classes we can store them in any of the collection classes and pass them around as a collection. Also we can pass them around as method parameters where a method expects an object.

* What happens when you add a double value to a String?
The result is a String object.

* What are wrapped classes?
Wrapped classes are classes that allow primitive types to be accessed as objects.


*[Read:Realizations-In-Real-Life.]*[Interview-With-God!]*[He-is-the-one!]*[Convert-Bad-to-Good.] *[Good-Wishes.] *[River-Crossing-Puzzles.] *[Amazing-Vibrations.] *[Creative-Personality.]*[Religion.]*[Happy-Kingdom.] *[Significance-of-Nava-Ratna.] *[Story:The-Monkey’s-Justice.]
*

Read:

*Realizations. *Realizations In Real Life. *Amazing Constructive Vibrations. *Astrology. *Creating Leaders. *How ideas are concluded and decisions are materialized. *Relationships & Partnerships. *The path of victory. *An attempt for definition. *Speak with a heart. *These are contagious. *Happy kingdom. *MIRACLES. *Better to create one ! *Cast, God and religion ! *Things become inevitable ! *We are all looking for! *Phase of Life. *Destiny, Karma and God. *Struggle, perfection and Money. *Independence and Freedom. *Relationships and Happiness.

CORE-JAVA (Networking (I/O) ):

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *
* What is the purpose of the File class? (i/o)
The File class is used to create objects that provide access to the files and directories of a local file system.

* What class allows you to read objects directly from a stream? (i/o)
The ObjectInputStream class supports the reading of objects from input streams.

* What an I/O filter? (i/o)
An I/O filter is an object that reads from one stream and writes to another, usually altering the data in some way as it is passed from one stream to another.

* What is the difference between the File and RandomAccessFile classes? (i/o)
The File class encapsulates the files and directories of the local file system. The RandomAccessFile class provides the METHODS needed to directly ACCESS DATA contained in ANY PART of a file.

* What interface must an object implement before it can be written to a stream as an object? (i/o)
An object must implement the Serializable or Externalizable interface before it can be written to a stream as an object.

* What information is needed to create a TCP Socket? (I/O)
The Local System's IP Address and Port Number. And the Remote System’s IP Address and Port Number.

* What value does read() return when it has reached the end of a file? (i/o)
The read() method returns -1 when it has reached the end of a file.

* What is the difference between the Reader/Writer class hierarchy and the InputStream/OutputStream class hierarchy? (i/o)
The Reader/Writer class hierarchy is CHARACTER-oriented, and the InputStream/OutputStream class hierarchy is BYTE-oriented.

* What value does readLine() return when it has reached the end of a file?
The readLine() method returns NULL when it reaches the end of a file.

* * * * * * * * * * * * *
*[Read:Religion-of-the-Universe.] *[Religion-and-cast.] *[Putting-our-sincere-efforts.] *[Blind-Men-And-The-Elephant.]

Here is a small "Story of grandpa" to explain what's the "Logic of good and bad".

Read:
Perceptions.
*Issue-of-Illegal-Immigration. *To-which-religion-does-this-universe-belongs-to? *Law-and-order-helps-to-maintain-justice. *Implementing-regulations-by-justice. *Puttting-our-sincere-efforts. *Religion-and-cast. *Impact-of-reservation-based-on-religion-and-cast. *Free-and-Fare-Education-system/Electoral-system.

RMI-XML:

*[READ: Why-JAVA] *[Start-Learning-JAVA] *[Why-Java's-Hot] *[Start-Using-LINUX] *[Java-Q-&-A] *[Question] *[Java-SE-6-Doc] *[Struts-Doc] *[Java-Tutorial-Index] *[Java-Certification]
*[Tech.] *[Struts.] *[Servlet.] *[JSP.] *[EJB.] *[JNDI-JMS] *[SQL.] *[JDBC.]
CORE-JAVA: *[OOP] *[CLASS] *[ABSTRACT] *[EXCEPTIONS] *[THREADS] *[UTILS] *[PACKAGES] *[JVM] *[CASTING] *[NETWORKING] *[RMI-XML] *
* What is the difference between URL instance and URLConnection instance? (Networking)
A URL instance represents the location of a resource, and a URLConnection instance represents a link for accessing or communicating with the resource at the location.

* What are the two important TCP Socket classes? (Networking)
Socket and ServerSocket. ServerSocket is used for normal two-way socket communication. Socket class allows us to read and write through the sockets. getInputStream() and getOutputStream() are the two methods available in Socket class.

* Can RMI and Corba based applications interact ?
Yes they can. RMI is available with IIOP as the transport protocol instead of JRMP.

* How many types of protocol implementations does RMI have?
RMI has at least three protocol implementations: Java Remote Method Protocol(JRMP), Internet Inter ORB Protocol(IIOP), and Jini Extensible Remote Invocation(JERI). These are alternatives, not part of the same thing, All three are indeed layer 6 protocols for those who are still speaking OSI reference model.

* Does RMI-IIOP support dynamic downloading of classes?
No, RMI-IIOP doesn't support dynamic downloading of the classes as it is done with CORBA in DII (Dynamic Interface Invocation).Actually RMI-IIOP combines the usability of Java Remote Method Invocation with the interoperability of the Internet Inter-ORB Protocol (IIOP).So in order to attain this interoperability between RMI and CORBA,some of the features that are supported by RMI but not CORBA and vice versa are eliminated from the RMI-IIOP specification.

* Does RMI-IIOP support code downloading for Java objects sent by value across an IIOP connection in the same way as RMI does across a JRMP connection?
Yes. The JDK 1.2 support the dynamic class loading.

* * * * * * * * * * * * *
* [Read: Partnerships in Life.] *[Read: God gave us everything.]

* [Read: Steps Involved In Relationships.] *[Read: Life is full of Tests.]

* [Read: Some of the aspects which materialize the relationships.]

"WE" has More Power than "I". Please leave a comment if you encounter any problems or have any suggestions.

Read: