Regular Expressions for Integration Server

Introduction

A regular expression is a text string that describes some set of strings. Regular expressions are a pattern-matching technique supported in a variety of tools and software but are most commonly known from UNIX tools such as grep, sed, vi and emacs. Using regular expressions (regex for short) you can determine if a string matches a specific pattern.
webMethods Integration Server provides regex support. The syntax and usage is described in the webMethods Developer User's Guide (Appendix D in version 4.6, Appendix B in 6.0).
This webMethods Ezine article addresses using regex patterns in:

• The label property of a child step within a BRANCH
• webMethods Query Language (WQL) statements
• Built-in String Services

---

Regex in Labels

Using regular expressions can greatly simplify your BRANCH constructs. The regular expression in a label must be surrounded with slashes. As an example, consider the common task of needing to determine if a pipeline variable contains at least one non-space character. Without using regex the FLOW steps to accomplish this might look like this:

Using a regular expression can greatly simplify the steps needed. The following FLOW steps accomplish this easily:

The following table provides a few regular expressions samples for common tasks.

Regex statement Is "True" if... /.+/ BRANCH switch has one or more characters, including just spaces. Strings that are $null or are empty will not be selected by this label (e.g. BRANCH won't take this path). Strings that have only spaces will take this branch. /^ISA/ BRANCH switch variable starts with the characters "ISA". /[^ ]/ BRANCH switch variable is not null, is not empty, and contains at least one non-space character. /webMethods$/ BRANCH switch variable ends with the string "webMethods". /[^ \t\r\n]/ BRANCH switch variable is not null, not empty, and contains at least one non-whitespace character.

---

regex and WQL

WQL is the webMethods precursor to XQL. Both languages are supported by the query service (pub.xml:queryXMLNode in v6.0, pub.web:queryDocument in v4.6 and earlier). WQL supports using regex to specify a pattern-matching string to select members of an element array.
This facility is described in the Working with XML Documents document shipped with v6.0 and in the Developer User's Guide with v4.6 and earlier. From an example described in the webMethods documentation, the following query:

doc.bitterrootboards['*Pro Series*'].text

returns every bitterrootboards element that contains the string "Pro Series" anywhere within it. WQL coupled with regex provides significant power and flexibility in processing XML.

---

regex and Built-In String Services

There are two built-in services that support regex:

1. pub.string:lookupTable
2. pub.string:replace

The pub.string:lookupTable service can use a regular expression to perform a lookup on the table. It returns the first value in the table whose key matches the specified regex pattern.
The pub.string:replace service supports using a regular expression as the search string. Erik Versteijnen provided an example in the webMethods Discussion Forums post to strip leading zeroes from a number. The screen shot below is the results tab after running pub.string:replace.

In this example, "+0000" in the inString is replaced by "+" as shown by the variable named value. The search string can be described as "look at the beginning of the string for a + followed by one or more zeroes." The search string uses these regex features:

• The ^ specifies that the pattern must be at the start of the inString.
• The + character has a special meaning in regex. For this pattern we want to use the + character literally. The \ escapes the + telling the regex engine to use + as a literal rather than a regex operator.
• The 0 is used literally. The second + character is a regex operator indicating that the preceding element (in this case the character 0) can occur 1 or more times.

We can add some flexibility to Eric's regex example to support a optional leading + or - and keep it in the resulting value. The screen shot below again shows the results tab after running pub.string:replace with the indicated parameters. Note the differences in the searchString parameter in this example as compared to the first example.

The search string in this second example can be described as "look at the beginning of the string for an optional + or - followed by one or more zeroes." This search string uses these regex features:

• The ^ specifies that the pattern must be at the start of the inString.
• The parentheses indicate a subexpression that can be used as a substitution variable in the replacement string. In this case, any leading + or - will be placed where $1 appears, so the resulting value will have the same leading sign as the input string. If there is no leading sign, then the resulting value will not have a leading sign.
• The brackets indicate a character set. The set here is the + and the - characters. The \ escapes the + (since it is a regex operator character and we want to use it literally).
• The ? is a regex operator which indicates that the preceding item can occur zero or one times. The preceding item in this case is a character set, so the pattern will match only if one of the characters from the set appears in inString.
• The 0 is used literally. The second + is a regex operator indicating that the preceding element (in this case the character 0) can occur 1 or more times.

As you can see, just a few characters in a regular expression can do quite a bit of work. Any regular expression can be used to search for and replace substrings.
The best way to learn to use regular expressions is to play around with them. Run pub.string:replace directly in Developer to learn the basics and expand your regex abilities.

---

Summary

Regular expressions are a powerful way to easily process strings and control process flow. While they can't do everything (e.g. using regex to try to trim whitespace from all elements in an XML string would be ill-advised) they can make many tasks a breeze.

http://wiki.customware.net/repository/display/WMFAQ/JDBC+Adapter+and+WmDB

Java Singleton design pattern

Java Singleton design pattern 

Java Singleton design pattern is one of the design pattern that governs the instantiation of an object in Java. This design pattern suggest that only one instance of a Singleton object is created by the JVM. This pattern is useful when exactly one object is needed to coordinate actions across the system.

How the Singleton pattern works?

Following is the source of simple class that follows singleton pattern.
public class SimpleSingleton {
    private static SimpleSingleton INSTANCE = new SimpleSingleton();
     //Marking default constructor private
    //to avoid direct instantiation.
    private SimpleSingleton() {
    }
    //Get instance for class SimpleSingleton
    public static SimpleSingleton getInstance() {
        return INSTANCE;
}

    }
}
In above code snippet, we have declared a static object reference to SimpleSingleton class called INSTANCE and is returned every time getInstance() is called. In this design, the object will be instantiate when the class will be loaded and before the method getInstance() is being called. Demand loading (lazy loading) also called initialization on demand holder idiom is not seen in this implementation.
We can change this code to add lazy init (Instantiate only when first time getInstance() is called) into this. Following is the code snippet for that.

public class SimpleSingleton {

    private SimpleSingleton singleInstance = null;

     

    //Marking default constructor private

    //to avoid direct instantiation.

    private SimpleSingleton() {

    }

    //Get instance for class SimpleSingleton

    public static SimpleSingleton getInstance() {

     

        if(null == singleInstance) {

            singleInstance = new SimpleSingleton();

        }

     

        return singleInstance;

    }

}

Do you need Singleton pattern?

Singletons are useful only when you need one instance of a class and it is undesirable to have more than one instance of a class.
When designing a system, you usually want to control how an object is used and prevent users (including yourself) from making copies of it or creating new instances. For example, you can use it to create a connection pool. It’s not wise to create a new connection every time a program needs to write something to a database; instead, a connection or a set of connections that are already a pool can be instantiated using the Singleton pattern.
The Singleton pattern is often used in conjunction with the factory method pattern to create a systemwide resource whose specific type is not known to the code that uses it. An example of using these two patterns together is the Abstract Windowing Toolkit (AWT). In GUI applications, you often need only one instance of a graphical element per application instance, like the Print dialog box or the OK button.

Problems with Singletons

A simple design pattern like Singleton also has few problem:

Construct in a multi-thread environment

It may happen that in a multi-threaded environment two or more threads enter the method getInstance() at the same time when Singleton instance is not created, resulting into simultaneous creation of two objects.
Such problems can be avoided by defining getInstance() method synchronized.

?

1	public static synchronized SimpleSingleton getInstance() { }

Cloning can spoil the game

Although we have taken enough precaution to make the Singleton object work as singleton, Cloning the object can still copy it and result into duplicate object. The clone of the singleton object can be constructed using clone() method of the object. Hence it is advisable to overload clone() method of Object class and throw CloneNotSupportedException exception.

public Object clone() throws CloneNotSupportedException {

      throw new CloneNotSupportedException();

}

The Singleton pattern is widely used and has proved its usability in designing software. Although the pattern is not specific to Java, it has become a classic in Java programming.

core java interview questions

Core java interview questions Q1) Why is main() method static? Ans) To access the static method the object of the class is not needed. The method can be access directly with the help of ClassName. So when a program is started the jvm search for the class with main method and calls it without creating an object of the class.
Q2) What is the difference between static methods and instance methods? Ans) instance method belongs to the instance of a class therefore it requires an instance before it can be invoked, whereas static method belongs to the class itself and not to any class instance so it doesn’t need an instance to be invoked. Instance methods use dynamic (late) binding, whereas static methods use static (early) binding. When the JVM invokes a class instance method, it selects the method to invoke based on the type of the object reference, which is always known at run-time. On the other hand, when the JVM invokes a static method, it selects the method to invoke based on the actual class of the object, which may only be known at compile time.
Q3) Can static block throw exception? Ans) Yes, static block can throw only Runtime exception or can use a try-catch block to catch checked exception. Typically scenario will be if JDBC connection is created in static block and it fails then exception can be caught, logged and application can exit. If System.exit() is not done, then application may continue and next time if the class is referred JVM will throw NoClassDefFounderror since the class was not loaded by the Classloader.
Q4 What is difference between abstract class and interface? Ans) 1) A class is called abstract when it contains at least one abstract method. It can also contain n numbers of concrete method.Interface can contain only abstract( non implemented) methods. 2) The abstract class can have public,private,protect or default variables and also constants. In interface the variable is by default public final. In nutshell the interface doesnt have any variables it only has constants. 3) A class can extend only one abstract class but a class can implement multiple interfaces. 4) If an interface is implemented its compulsory to implement all of its methods but if an abstract class is extended its not compulsory to implement all methods. 5) The problem with an interface is, if you want to add a new feature (method) in its contract, then you MUST implement those method in all of the classes which implement that interface. However, in the case of an abstract class, the method can be simply implemented in the abstract class and the same can be called by its subclass.
Q5) Explain with example to describe when to use abstract class and interface? Ans) Consider a scenario where all Cars will have 4 tyres and other features can be different. In this case any subclass of Car has to have 4 tyres. This is a case where abstract class will be used and a default implementaion for tyres will be provided. public abstract class Car{ public abstract String getCarName(); public final int getNoOfTyres(){    return 4; } } Consider a scenario where Cars can have any number of tyres and other features can also be different. In this case interface will be created. public interface Car{ public abstract String getCarName(); public abstract int getNoOfTyres(); }
Q6) Does java support multiple interitance? Why? Ans) Java doesnt support multiple inheritance but it provide a way through which it can enact it. Consider the scenario is C++ Class A{ public void add(){ // some text } } Class B{ public void add(){ // some text } } Class C extends A,B{ public static void main(String arg[]){ C objC = new C(); objC.add(); // problem, compiler gets confused and cant decide to call Class A or B method. } This problem is called Diamond problem. This problem in java is taken care with the use of interfaces In Java similar problem would look like: interface A{ add(); } interface B{ add(); } class C implements A,B{ add(){ // doesnt matter which interface it belong to } }
Q7) Can this keyword be assigned null value? Ans) No
Q8) What are the different types of references in java? Ans) Java has a more expressive system of reference than most other garbage-collected programming languages, which allows for special behavior for garbage collection. A normal reference in Java is known as a strong reference. The java.lang.ref package defines three other types of references—soft, weak, and phantom references. Each type of reference is designed for a specific use. A SoftReference can be used to implement a cache. An object that is not reachable by a strong reference (that is, not strongly reachable), but is referenced by a soft reference is called softly reachable. A softly reachable object may be garbage collected at the discretion of the garbage collector. This generally means that softly reachable objects will only be garbage collected when free memory is low, but again, it is at the discretion of the garbage collector. Semantically, a soft reference means "keep this object unless the memory is needed." A WeakReference is used to implement weak maps. An object that is not strongly or softly reachable, but is referenced by a weak reference is called weakly reachable. A weakly reachable object will be garbage collected during the next collection cycle. This behavior is used in the class java.util.WeakHashMap. A weak map allows the programmer to put key/value pairs in the map and not worry about the objects taking up memory when the key is no longer reachable anywhere else. Another possible application of weak references is the string intern pool. Semantically, a weak reference means "get rid of this object when nothing else references it." A PhantomReference is used to reference objects that have been marked for garbage collection and have been finalized, but have not yet been reclaimed. An object that is not strongly, softly or weakly reachable, but is referenced by a phantom reference is called phantom reachable. This allows for more flexible cleanup than is possible with the finalization mechanism alone. Semantically, a phantom reference means "this object is no longer needed and has been finalized in preparation for being collected."
Q9) How to change the heap size of a JVM? Ans) The old generation's default heap size can be overridden by using the -Xms and -Xmx switches to specify the initial and maximum sizes respectively: java -Xms -Xmx program For example: java -Xms64m -Xmx128m program
Q10) What is difference between instanceof and isInstance(Object obj)? Ans) Differences are as follows: 1) instanceof is a reserved word of Java, but isInstance(Object obj) is a method of java.lang.Class. 2) instanceof method is used to check the type of an object which are known at compile time and isInstance() could only be called on class, San instance of java.lang.Class. if (obj instanceof MyType) { ... }else if (MyType.class.isInstance(obj)) { ... } 3) instanceof is used of identify whether the object is type of a particular class or its subclass but isInstance(obj) is used to identify object of a particular class.
Q2) What is the use of final keyword? Ans) The final keyword can be assigned to Class level variable method class Objects If a final is assigned to a variable, the variable behaves as a constant. It means that the value of variable once set cannot be changed. final int i=1; i =5; // error If a final is assigned to a method then it cannot be overridden in its child class. class Parent { final void print(){             System.out.println(“Inside”); } } class Child extends Parent{ public final void print(){             // error cannot override final method             System.out.println(“Inside”); } } If a class is made as final, then no other class can extend it and make it as parent class. E.g. String Class. Final objects are instantiated only once. i.e final Map map = new HashMap(); map.put(“key”,”value”); map = new HashMap();  // error Q3) What is use of synchronized keyword? Ans) This keyword is used to prevent concurrency. Synchronized keyword can be applied to static/non-static methods or a block of code. Only one thread at a time can access synchronized methods and if there are multiple threads trying to access the same method then other threads have to wait for the execution of method by one thread. Synchronized keyword provides a lock on the object and thus prevents race condition. E.g. public void synchronized method(){}  public void synchronized staticmethod(){} public void myMethod(){             synchronized (this){             // synchronized keyword on block of  code             } } Q4) What is volatile keyword? Ans) In general each thread has its own copy of variable, such that one thread is not concerned with the value of same variable in the other thread. But sometime this may not be the case. Consider a scenario in which the count variable is holding the number of times a method is called for a given class irrespective of any thread calling, in this case irrespective of thread access the count has to be increased. In this case the count variable is declared as volatile. The copy of volatile variable is stored in the main memory, so every time a thread access the variable even for reading purpose the local copy is updated each time from the main memory. The volatile variable also have performance issues. Q5) What is a transient variable? Ans) If some of the properties of a class are not required to be serialized then the varaibles are marked as transient. When an object is deserialized the transient variables retains the default value depending on the type of variable declared and hence lost its original value. Q6) What is a strictfp modifier? Ans) Strictfp is used with variable only . It is used to restrict floating point calculations ( fp ) to ensure portability ( platform Independent ). When this modifier is specified, the JVM adheres to the Java specifications ( IEEE-754 floating-point specification ) and returns the consistent value independent of the platform. That is, if you want the answers from your code (which uses floating point values) to be consistent in all platforms, then you need to specify the strictfp modifier. Q7) What is a static variable? Ans) Static keyword can be used with the variables and methods but not with the class but there are static class. Anything declared as static is related to class and not objects. Static variable : Multiples objects of a class shares the same instance of a static variable.Consider the example: public class Counter{   private static int count=0;  private int nonStaticcount=0;   public void incrementCounter(){   count++;   nonStaticcount++;   }   public int getCount(){  return count;  }  public int getNonStaticcount(){  return nonStaticcount;  }  public static void main(String args[]){   Counter countObj1 = new Counter();  Counter countObj2 = new Counter();   countObj1.incrementCounter();   countObj1.incrementCounter();   System.out.println("Static count for Obj1: "+countObj1.getCount());   System.out.println("NonStatic count for Obj1: "+countObj1.getNonStaticcount());   System.out.println("Static count for Obj2: "+countObj2.getCount())   System.out.println("NonStatic count for Obj2: "+countObj2.getNonStaticcount())   } Output Static count for Obj1: 2 NonStatic count for Obj1: 2 Static count for Obj2: 2 NonStatic count for Obj2: 0 In the above program obj1 and obj2 share the same instance of static variable count hence if the value is incremented by one object , the incremented value will be reflected across the other objects. Q8) What is a static method? Ans)A method defined as static is called static method. A static method can be accessed without creating the objects. Just by using the Class name the method can be accessed. Static method can only access static variables and not local or global non-static variables. For eg: public class Test{ public static void printMe(){ System.out.println("Hello World"); } } public class MainClass{  public static void main(String args[]){   Test.printMe()     }  } OutPut: Hello World Also static method can call only static methods and not non static methods. But non-static methods can call static mehtods. Q9) Why static methods cannot access non static variables or methods? Ans) A static method cannot access non static variables or methods because static methods doesnt need the object to be accessed. So if a static method has non static variables or non static methods which has instantiated variables they will no be intialized since the object is not created and this could result in an error. Q10) What is static class ? Ans) A class cannot be declared static. But a class can be said a static class if all the variables and methods of the class are static and the constructor is private. Making the constructor private will prevent the class to be instantiated. So the only possibility to access is using Class name only Q9) What is throw keyword? Ans) Throw keyword is used to throw the exception manually. It is mainly used when the program fails to satisfy the given condition and it wants to warn the application.The exception thrown should be subclass of Throwable.   public void parent(){   try{    child();   }catch(MyCustomException e){ }   }   public void child{   String iAmMandatory=null;    if(iAmMandatory == null){     throw (new MyCustomException("Throwing exception using throw keyword");    }   } Q10) What is use of throws keyword? Ans) If the function is not capable of handling the exception then it can ask the calling method to handle it by simply putting the throws clause at the function declaration.   public void parent(){   try{    child();   }catch(MyCustomException e){ }   }   public void child throws MyCustomException{    //put some logic so that the exception occurs.   }
Q11) Java supports pass by value or pass by reference? Ans) Java supports only pass by value. The arguments passed as a parameter to a method is mainly primitive data types or objects. For the data type the actual value is passed. Java passes the references by value just like any other parameter. This means the references passed to the method are actually copies of the original references.Java copies and passes the reference by value, not the object. Thus, method manipulation will alter the objects, since the references point to the original objects.Consider the example:  public void tricky(Point arg1, Point arg2)  {    arg1.x = 100;    arg1.y = 100;    Point temp = arg1;    arg1 = arg2;    arg2 = temp;  }  public static void main(String [] args)  {    Point pnt1 = new Point(0,0);    Point pnt2 = new Point(0,0);    System.out.println("X: " + pnt1.x + " Y: " +pnt1.y);    System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);    System.out.println(" ");    tricky(pnt1,pnt2);    System.out.println("X: " + pnt1.x + " Y:" + pnt1.y);    System.out.println("X: " + pnt2.x + " Y: " +pnt2.y);  } OutPut: X: 0 Y: 0 X: 0 Y: 0 X: 100 Y: 100 X: 0 Y: 0 The method successfully alters the value of pnt1, even though it is passed by value; however, a swap of pnt1 and pnt2 fails! This is the major source of confusion. In the main() method, pnt1 and pnt2 are nothing more than object references. When you pass pnt1 and pnt2 to the tricky() method, Java passes the references by value just like any other parameter. This means the references passed to the method are actually copies of the original references.
Q12) What is memory leak? Ans) A memory leak is where an unreferenced object that will never be used again still hangs around in memory and doesnt get garbage collected.
Q13) What is the difference between equals() and ==? Ans) == operator is used to compare the references of the objects. public bollean equals(Object o) is the method provided by the Object class. The default implementation uses == operator to compare two objects. But since the method can be overriden like for String class. equals() method can be used to compare the values of two objects.  String str1 = "MyName";  String str2 = "MyName";  String str3 = str2;  if(str1 == str2){  System.out.println("Objects are equal")  }else{  System.out.println("Objects are not equal")  }  if(str1.equals(str2)){  System.out.println("Objects are equal")  }else{  System.out.println("Objects are not equal")  }  Output:  Objects are not equal  Objects are equal  String str2 = "MyName";  String str3 = str2;  if(str2 == str3){  System.out.println("Objects are equal")  }else{  System.out.println("Objects are not equal")  }  if(str3.equals(str2)){  System.out.println("Objects are equal")  }else{  System.out.println("Objects are not equal")  }  OutPut:  Objects are equal  Objects are equal
Q14) How to make sure that Childclass method actually overrides the method of the superclass? Ans) The @Override annotation can be added to the javadoc for the new method. If you accidently miss an argument or capitalize the method name wrong, the compiler will generate a compile-time error.
Q15) How to find the size of an object? Ans)The heap size of an object can be found using -          Runtime.totalMemory()-Runtime.freeMemory() .

Q16) Can an abstract class have a static method? Ans) Yes an abstract class have a static method and it can be accessed by any other class(even not a concrete class).

Q17) Can an abstract class have a constructor? Ans) Yes an abstract class have a default and parameterized constructors.

Q18) Why static methods cannot access non static variables or methods? Ans) A static method cannot access non static variables or methods because static methods doesnt need the object to be accessed. So if a static method has non static variables or non static methods which has instantiated variables they will no be intialized since the object is not created and this could result in an error.

Q19) What is difference between stringbuffer and stringbuilder? Ans) The only difference between StringBuffer and StringBuilder is that StringBuilder is unsynchronized whereas StringBuffer is synchronized. So when the application needs to be run only in a single thread then it is better to use StringBuilder. StringBuilder is more efficient than StringBuffer. Criteria to choose among StringBuffer and StringBuilder 1)If your text can change and will only be accessed from a single thread, use a StringBuilder 2)because StringBuilder is unsynchronized. If your text can changes, and will be accessed from multiple threads, use a StringBuffer because StringBuffer is synchronous.

Q20) Consider a scenario in which the admin want to sure that if some one has written System.exit() at some part of application then before system shutdown all the resources should be released. How is it possible? Ans) This is possible using Runtime.getRuntime().addShutdownHook(Thread hook). Straight from Java Spec: This method registers a new virtual-machine shutdown hook. The Java virtual machine shuts down in response to two kinds of events: 1. The program exits normally, when the last non-daemon thread exits or when the exit (equivalently, System.exit) method is invoked, or 2. The virtual machine is terminated in response to a user interrupt, such as typing ^C, or a system-wide event, such as user logoff or system shutdown. A shutdown hook is simply an initialized but unstarted thread. When the virtual machine begins its shutdown sequence it will start all registered shutdown hooks in some unspecified order and let them run concurrently. When all the hooks have finished it will then run all uninvoked finalizers if finalization-on-exit has been enabled. Finally, the virtual machine will halt. Note that daemon threads will continue to run during the shutdown sequence, as will non-daemon threads if shutdown was initiated by invoking the exit method. Once the shutdown sequence has begun it can be stopped only by invoking the halt method, which forcibly terminates the virtual machine.

Q21) What is the difference between final, finally and finalize() in Java? Ans) final - constant declaration. A final variable act as constant, a final class is immutable and a final method cannot be ovrriden. finally - handles exception. The finally block is optional and provides a mechanism to clean up regardless of what happens within the try block (except System.exit(0) call). Use the finally block to close files or to release other system resources like database connections, statements etc. finalize() - method helps in garbage collection. A method that is invoked before an object is discarded by the garbage collector, allowing it to clean up its state. Should not be used to release non-memory resources like file handles, sockets, database connections etc because Java has only a finite number of these resources and you do not know when the garbage collection is going to kick in to release these non-memory resources through the finalize() method.

Q22) How does Java allocate stack and heap memory? Ans) Each time an object is created in Java it goes into the area of memory known as heap. The primitive variables like int and double are allocated in the stack, if they are local method variables and in the heap if they are member variables (i.e. fields of a class). In Java methods local variables are pushed into stack when a method is invoked and stack pointer is decremented when a method call is completed. In a multi-threaded application each thread will have its own stack but will share the same heap. This is why care should be taken in your code to avoid any concurrent access issues in the heap space. The stack is threadsafe (each thread will have its own stack) but the heap is not threadsafe unless guarded with synchronisation through your code.

Q23) Explain re-entrant, recursive and idempotent methods/functions? Ans) A method in stack is re-entrant allowing multiple concurrent invocations that do not interfere with each other. A function is recursive if it calls itself. Given enough stack space, recursive method calls are perfectly valid in Java though it is tough to debug. Recursive functions are useful in removing iterations from many sorts of algorithms. Allrecursive functions are re-entrant but not all re-entrant functions are recursive. Idempotent methods are methods, which are written in such a way that repeated calls to the same method with the same arguments yield same results. For example clustered EJBs, which are written with idempotent methods, can automatically recover from a server failure as long as it can reach another server.

Q24)Can a private variable or method of a class can be accessed? Ans) Yes its possible using reflection.

Q25)What is difference between static block and the init block? Or Difference between Static {} and {} Ans) The static block is loaded when the class is loaded by the JVM for the 1st time only whereas init {} block is loaded every time class is loaded. Also first the static block is loaded then the init block. public class LoadingBlocks {    static{     System.out.println("Inside static");    }    {     System.out.println("Inside init");    }    public static void main(String args[]){     new LoadingBlocks();     new LoadingBlocks();     new LoadingBlocks();    } } Output: Inside static Inside init Inside init Inside init

Q26)Why inner class can access only final variable? Ans) Local classes can most definitely reference instance variables. The reason they cannot reference non final local variables is because the local class instance can remain in memory after the method returns. When the method returns the local variables go out of scope, so a copy of them is needed. If the variables weren't final then the copy of the variable in the method could change, while the copy in the local class didn't, so they'd be out of synch. Anonymous inner classes require final variables because of the way they are implemented in Java. An anonymous inner class (AIC) uses local variables by creating a private instance field which holds a copy of the value of the local variable. The inner class isn't actually using the local variable, but a copy. It should be fairly obvious at this point that a "Bad Thing"â„¢ can happen if either the original value or the copied value changes; there will be some unexpected data synchronization problems. In order to prevent this kind of problem, Java requires you to mark local variables that will be used by the AIC as final (i.e., unchangeable). This guarantees that the inner class' copies of local variables will always match the actual values.

Q27)What is fully abstract class? Ans) An abstract class which has all methods as abstract and all fields are public static final.

Q28)What is dynamic binding and static binding? Ans) Method invocation The Java programming language provides two basic kinds of methods: instance methods and class (or static) methods. The difference are: 1. Instance methods require an instance before they can be invoked, whereas class methods do not. 2. Instance methods use dynamic (late) binding, whereas class methods use static (early) binding. When the Java virtual machine invokes a class method, it selects the method to invoke based on the type of the object reference, which is always known at compile-time. On the other hand, when the virtual machine invokes an instance method, it selects the method to invoke based on the actual class of the object, which may only be known at run time.

Q29) What is Java Reflection? Ans)Reflection is commonly used by programs which require the ability to examine or modify the runtime behavior of applications running in the Java virtual machine. Drawbacks of Reflection: Reflection is powerful, but should not be used indiscriminately. If it is possible to perform an operation without using reflection, then it is preferable to avoid using it. The following concerns should be kept in mind when accessing code via reflection. Performance Overhead: Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications. Security Restrictions: Reflection requires a runtime permission which may not be present when running under a security manager. This is in an important consideration for code which has to run in a restricted security context, such as in an Applet. Exposure of Internals: Since reflection allows code to perform operations that would be illegal in non-reflective code, such as accessing private fields and methods, the use of reflection can result in unexpected side-effects, which may render code dysfunctional and may destroy portability. Reflective code breaks abstractions and therefore may change behavior with upgrades of the platform.

Q30) When an obj is passed through a function , u can set the properties but u cannot set a new memory location? Ans) It is because when u pass an object the address value is passed and stored in some new address . like if address 1234 is passed , it is stored in 4567 location. So if u change in the value of an object it will take the address from 4567 and do 1234.setXXX(). If u set the object to null it will set 4567=null.

What is difference between overloading and overriding?
Ans: a) In overloading, there is a relationship between methods available in the same class whereas in overriding, there is relationship between a superclass method and subclass method.
        b) Overloading does not block inheritance from the superclass whereas overriding blocks inheritance from the superclass.
        c) In overloading, separate methods share the same name whereas in overriding,subclass method replaces the superclass.
        d) Overloading must have different method signatures whereas overriding  must have same signature.

What is the difference between this() and super()?
Ans: this() can be used to invoke a constructor of the same class whereas super() can be used to invoke a super class constructor.

What are different types of access modifiers?
Ans: public: Any thing declared as public can be accessed from anywhere.
        private: Any thing declared as private can't be seen outside of its class.
        protected: Any thing declared as protected can be accessed by classes in the same package and subclasses in the other packages.
        default modifier : Can be accessed only to classes in the same package.


What is final, finalize() and finally?
Ans: final : final keyword can be used for class, method and variables.
    A final class cannot be subclassed and it prevents other programmers from subclassing a secure class to invoke insecure methods.
    A final method can' t be overridden
A final variable can't change from its initialized value.
         finalize( ) : finalize( ) method is used just before an object is destroyed and can be called just prior to
         garbage collection.
         finally : finally, a key word used in exception handling, creates a block of code that will be executed after a   try/catch block has completed and before the code following the try/catch block. The finally block will execute whether or not an exception is thrown.
For example, if a method opens a file upon exit, then you will not want the code that closes the file to be bypassed by the exception-handling mechanism. This finally keyword is designed to address this      contingency.  

    
What is Garbage Collection and how to call it explicitly?
Ans: When an object is no longer referred to by any variable, java automatically reclaims memory used by that  object. This is known as garbage collection.
         System.gc() method may be used to call it explicitly.


What is  finalize() method ?
Ans: finalize () method is used just before an object is destroyed and can be called just prior to garbage collection.



What are Transient and Volatile Modifiers?
Ans: Transient: The transient modifier applies to variables only and it is not stored as part of its object's
        Persistent state. Transient variables are not serialized.
        Volatile: Volatile modifier applies to variables only and it tells the compiler that the variable modified by
        volatile can be changed unexpectedly by other parts of the program.



What is interface and its use?
Ans: Interface is similar to a class which may contain method's signature
only but not bodies and  it is a formal set of method and constant declarations that must be defined by the class that implements it.Interfaces are useful for:
a)Declaring methods that one or more classes are expected to implement
b)Capturing similarities between unrelated classes without forcing a class relationship.
c)Determining an object's programming interface without revealing the actual body of the class.

What is an abstract class?
Ans: An abstract class is a class designed with implementation gaps for subclasses to fill in and is deliberately incomplete.

What is the difference between abstract class and interface?
Ans: a) All the methods declared inside an interface are abstract whereas abstract class must have at least one abstract method and others may be concrete or abstract.
        b) In abstract class, key word abstract must be used for the methods
 whereas interface we need not use that keyword for the methods.
c) Abstract class must have subclasses whereas interface can't have subclasses.

What is the difference between String and String Buffer?
Ans: a) String objects are constants and immutable whereas StringBuffer objects are not.
    b) String class supports constant strings whereas  StringBuffer class supports growable and modifiable strings.

What is the difference between exception and error?
Ans: The Exception class defines mild error conditions that your program encounters.
        Ex: Arithmetic Exception, FilenotFound exception
        Exceptions can occur when
         -- try to open the file, which does not exist
         -- the network connection is disrupted
         -- operands being manipulated are out of prescribed ranges
         -- the class file you are interested in loading is missing
        The Error class defines serious error conditions that you should not attempt to recover from. In most cases it is advisable to let the program terminate when such an error is encountered.
        Ex: Running out of memory error, Stack overflow error.


What is the difference between process and thread?
Ans: Process is a program in execution whereas thread is a separate path of execution in a program.

What is multithreading and what are the methods for inter-thread communication and what is the class  in which these methods are defined?
Ans: Multithreading is the mechanism in which more than one thread run independent of each other within the process.
        wait (), notify () and notifyAll() methods can be used for inter-thread communication and these methods are in Object class.
               wait( ) : When a thread executes a call to wait( ) method, it surrenders the object lock and enters into a waiting state.
        notify( ) or notifyAll( ) : To remove a thread from the waiting state, some other thread must make a call to  notify( ) or notifyAll( ) method on the same object.

What is the class and interface in java to create thread and which is the most advantageous method?
Ans: Thread class and Runnable interface can be used to create threads and using Runnable interface is the most advantageous method to create threads because we need not extend thread class here.


What are the states associated in the thread?
Ans: Thread contains ready, running, waiting and dead states.

What is synchronization?
Ans: Synchronization is the mechanism that ensures that only one thread is accessed the resources at a time.

When you will synchronize a piece of your code?
Ans: When you expect your code will be accessed by different threads and these threads may change a particular data causing data corruption.

 What is deadlock?
Ans: When two threads are waiting each other and can't precede the program is said to be deadlock.

what class name of wait() and notify()
Object

can we used static with synchronicated keyword and why?
Class instances are Objects and can be synchronized via static synchronized methods


What is daemon thread and which method is used to create the daemon thread?
Ans: Daemon thread is a low priority thread which runs intermittently in the back ground doing the garbage collection operation for the java runtime system. setDaemon() is used to create a daemon thread.

5. What is synchronization and why is it important?
With respect to multithreading, 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 object while another thread is in the process of using or updating that object's value. This often leads to significant errors.

6. Can a lock be acquired on a class?
Yes, a lock can be acquired on a class. This lock is acquired on the class's Class object.

7. What's new with the stop(), suspend() and resume() methods in JDK 1.2?
The stop(), suspend() and resume() methods have been deprecated in JDK 1.2.

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

What is the difference between preemptive scheduling and time slicing?
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 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.

When a thread is created and started, what is its initial state?
A thread is in the ready state after it has been created and started.
What invokes a thread's run() method?
After a thread is started, via its start() method or that of the Thread class, the JVM invokes the thread's run() method when the thread is initially executed.

What is the purpose of the wait(), notify(), and notifyAll() methods?
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.


What are wrapper classes?
Ans: Wrapper classes are classes that allow primitive types to be accessed as objects.

What are Vector, Hashtable, LinkedList and Enumeration?
Ans: Vector : The Vector class provides the capability to implement a growable array of objects.
    Hashtable : The Hashtable class implements a Hashtable data structure. A Hashtable indexes and stores objects in a dictionary using hash codes as the object's keys. Hash codes are integer values that identify  objects.
LinkedList: Removing or inserting elements in the middle of an array can be done using LinkedList. A    LinkedList stores each object in a separate link whereas an array stores object references in consecutive   locations.
Enumeration: An object that implements the Enumeration interface generates a series of elements, one at a time. It has two methods, namely hasMoreElements( ) and nextElement( ). HasMoreElemnts( ) tests if this enumeration has more elements and nextElement method returns successive elements of the series.
What is the difference between set and list?
Ans: Set stores elements in an unordered way but does not contain duplicate elements.
list :stores  elements in an ordered way but may contain duplicate elements.

What is serialization and deserialization?
Ans: Serialization is the process of writing the state of an object to a byte stream.
        Deserialization is the process of restoring these objects.


What is meant by Serialization and Externalization? Serialization is a Marker interface,so what is the use of WriteObject() anf ReadObject(), Where it is actually used? Give me some real time examples?
Marker Interface is used by java runtime engine (JVM) to identify the class for special processing.

Sterilization is a process of converting state of an object to stream of bytes that can be sent over network or can be stored in a file or in database to be reconstructed into Object Later when required. Remember EJB spec, all EJB (Session or Entity) implements Serializable interface indirectly, in case of Statefull session bean it can be Passivated or Activated (Persisted by writing it to file system or Database this is done by container).

Externalization is same as Sterilization except that WriteObject() and ReadObject() method are called by JVM during sterilization an desterilization of object. One thing you can do with Externalization is that you can store extra information into object like STATIC variables and transient variables or you can add more information if you have any business need. One good example is compressing and uncompressing of data to send it through network or converting one format to other like a BMP image to JPEG or GIF format.


What are drivers available?
Ans:  a)     JDBC-ODBC Bridge driver
b)       Native API Partly-Java driver
c)    JDBC-Net Pure Java driver
Native-Protocol Pure Java driver


What are the steps involved for making a connection with a database or how do you connect to a  database?
Ans: a)    Loading the driver : To load the driver, Class.forName( ) method is used.
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
When the driver is loaded, it registers itself with the java.sql.DriverManager class as an available  database driver.
b)Making a connection with database : To open a connection to a given database,
      DriverManager.getConnection( ) method is used.
          Connection con = DriverManager.getConnection ("jdbc:odbc:somedb", "user",  "password");
c)Executing SQL statements : To execute a SQL query, java.sql.statements class is used.   
      createStatement( ) method of Connection to obtain a new Statement object.
           Statement stmt  = con.createStatement( );
      A query that returns data can be executed using the executeQuery( ) method of  Statement. This method        executes the statement and returns a java.sql.ResultSet that encapsulates the retrieved data:
           ResultSet rs = stmt.executeQuery("SELECT * FROM some table");
d)    Process the results : ResultSet returns one row at a time. Next( ) method of ResultSet  object can be called to move to the next row.  The getString( ) and getObject( ) methods are used for retrieving  column values:
                      while(rs.next( ) ) {
                          String event = rs.getString("event");
                          Object count = (Integer) rs.getObject("count");

What are the types of statements in JDBC?
Ans: Statement                -- To be used createStatement() method for executing single SQL statement
PreparedStatement To be used preparedStatement() method for executing same SQL statement over and over
CallableStatement    -- To be used prepareCall( ) method for multiple SQL statements over and over

What is RMI and steps involved in developing an RMI object?
Ans: Remote Method Invocation (RMI) allows java object that executes on one machine and to invoke the method
        of a Java object to execute on another machine.
        The steps involved in developing an RMI object are:
a)    Define the interfaces
b)    Implementing these interfaces
c)    Compile the interfaces and their implementations with the java compiler
d)    Compile the server implementation with RMI compiler
e)    Run the RMI registry
Run the application


What is RMI architecture?
Ans: - RMI architecture consists of four layers and each layer performs specific functions:
a) Application layer             ---- contains the actual object definition
b) Proxy layer                      ---- consists of stub and skeleton
c) Remote Reference layer  ---- gets the stream of bytes from the transport layer and sends it to the proxy layer
d) Transportation layer        ---- responsible for handling the actual machine-to-machine communication

How stub and skeleton?

rmic
what is UnicastRemoteObject?
Ans: All remote objects must extend UnicastRemoteObject, which provides functionality that is needed to make   objects available from remote machines.

Explain the methods, rebind( ) and lookup() in Naming class?
Ans: rebind( ) of the Naming class(found in java.rmi) is used to update the RMI registry on the server machine.
        Naming. rebind("AddSever", AddServerImpl);
lookup( ) of the Naming class accepts one argument, the rmi URL and returns a  reference to an object of    type AddServerImpl.


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.

How are Observer and Observable used?
Objects that subclass the Observable class maintain a list of observers. When an Observable object is updated it invokes the update() method of each of its observers to notify the observers that it has changed state. The Observer interface is implemented by objects that observe Observable objects.

What is dom and Sax

SAX can be really fast at runtime if your object model is simple. In this case, it is faster than DOM, because it bypasses the creation of a tree based object model of your information. On the other hand, you do have to write a SAX document handler to interpret all the SAX events (which can be a lot of work).

When to use DOM

If your XML documents contain document data (e.g., Framemaker documents stored in XML format), then DOM is a completely natural fit for your solution. If you are creating some sort of document information management system, then you will probably have to deal with a lot of document data. An example of this is the Datachannel RIO product, which can index and organize information that comes from all kinds of document sources (like Word and Excel files). In this case, DOM is well suited to allow programs access to information stored in these documents.
However, if you are dealing mostly with structured data (the equivalent of serialized Java objects in XML) DOM is not the best choice. That is when SAX might be a better fit.

When to use SAX

If the information stored in your XML documents is machine readable (and generated) data then SAX is the right API for giving your programs access to this information. Machine readable and generated data include things like:
Java object properties stored in XML format queries that are formulated using some kind of text based query language (SQL, XQL, OQL) result sets that are generated based on queries (this might include data in relational database tables encoded into XML).
So machine generated data is information that you normally have to create data structures and classes for in Java. A simple example is the address book which contains information about persons, as shown in Figure 1. This address book XML file is not like a word processor document, rather it is a document that contains pure data, which has been encoded into text using XML.
When your data is of this kind, you have to create your own data structures and classes (object models) anyway in order to manage, manipulate and persist this data. SAX allows you to quickly create a handler class which can create instances of your object models based on the data stored in your XML documents. An example is a SAX document handler that reads an XML document that contains my address book and creates an AddressBook class that can be used to access this information. The first SAX tutorial shows you how to do this. The address book XML document contains person elements, which contain name and email elements. My AddressBook object model contains the following classes:
AddressBook class, which is a container for Person objects
Person class, which is a container for name and email String objects.

What is Jaxb

Java Architecture for XML Binding (JAXB) is a specification (or standard) that automates the mapping between XML documents and Java objects and vice versa. One of the primary components of JAXB is the schema compiler. The schema compiler is the tool used to generate Java bindings from an XML schema document. If used in its default mode (for non-trivial applications), the compiler usually generates bindings that are awkward to work with. This article will look at various methods you can use to customize the generated bindings.


Q   What are the OOPS Concept?
Ans Abtraction    Inheritence    Polymorphism    Encapsulation
E.G Package    Extends        System.out    Class
                Run-Time Polymorphism

Q What is difference betn having and where clause?
The difference is that WHERE operates on individual rows, while HAVING operates on groups.

Q what is Polymorphism?
In java there are two type of polymorphism: overloading type and overriding type.

When you override methods, java determines the proper methods to call at the program’s run time, not at the compile time. Overriding occurs when a class method has the same name and signature as a method in parent class. Overloading occurs when several methods have same names with different method signature. Overloading is determined at the compile time.

In Polymorphism does variable can be overriding?
No.
Example :
Class parent {
Int x = 0;
}
class child extends parent{
int x =0;
}
public staic void main(String args[]) {
parent p = new child();
System.out.println(p.x); → this will be of parent class x.
}

which is map interface is a part of collection?
No.

There are several differences between HashMap and Hashtable in Java:

1. Hashtable is synchronized, whereas HashMap is not. This makes HashMap better for non-threaded applications, as unsynchronized Objects typically perform better than synchronized ones.
2. Hashtable does not allow null keys or values. HashMap allows one null key and any number of null values.
3. One of HashMap's subclasses is LinkedHashMap, so in the event that you'd want predictable iteration order (which is insertion order by default), you could easily swap out the HashMap for a LinkedHashMap. This wouldn't be as easy if you were using Hashtable.

How will you address the scenario given below to decide on collection object to work with:
- Multiple keys with multiple values
- Multiple keys with single value
- Single key with multiple values
- Single key with single value
A. In the given scenario, HashMap will be the best choice. As long as the keys are unique, one can enter multiple values in an ArrayList and associate this with a key inside HashMap and retrieve those multiple values from unique key.

How to synchronized  Map ?
SortedMap sortedMap = Collections.synchronizedSortedMap(new TreeMap());
SortedSet sortedSet = Collections.synchronizedSortedSet(new TreeSet());

Why is it advisable to override hashCode() method as well, when equals() method is overridden?
A. When equals() method is overridden, then each object must have same hashcode for pair of objects which have equals() method overridden.If the .hashCode() method of your custom class doesn't work the same way your .equals() method works, the results of your code will be erroneous.

.How a TreeSet different from HashSet?
A.One line answer is : TreeSet contains-> Unique and Ordered/Sorted values(as per natural order or based on Comparator implemented logic).It is backed by TreeMap.

While HashSet contains-> Unique values but not Ordered/Sorted
Q What is Volatile keyword in Java?

Ans The volatile modifier is used when you are working with multiple threads.
   The Java language allows threads that access shared variables to keep private working  
   copies of the variables; this allows a more efficient implementation of multiple threads.
   These working copies need be reconciled with the master copies in the shared main memory
   only at prescribed synchronization points, namely when objects are locked or unlocked. As a rule,
   to ensure that shared variables are consistently and reliably updated,
   a thread should ensure that it has exclusive use of such variables by obtaining a lock that,
   conventionally, enforces mutual exclusion for those shared variables. "



1.
Class A
{
int a;
    method A()
    {}
}

Class B Extends A
{
int a;
    method A()
    {}
}
A temp= new B
temp.method(); (** method of class b will called)


2.Java is never passed by reference it is passed by copy of value.

3.what is Daemon thread
Answer . Daemon thread are service  provider to other thread
       One can create Daemon thread by using API setDaemon
E.g    JVM uses Daemon thread for Garbage collection which happens in background.

4. can user call finalize() method explicitly
Ans yes

5. Explanation of Delegation in java.
Answer .kind of not handling the exception and passing or throwing it,so it can be catched by parent.

5a. What is anonymous class
Answer. It is class without name.
for E.g
public Iterator iterator() {
return new Iterator()
{
int currentItem = items.size() - 1;
public boolean hasNext()
{ ... }
public Object next()
{ ... }
public void remove() { ... }
}
}

Can an anonymous class be declared as implementing an interface and extending a class?
Answer: An anonymous class may implement an interface or extend a superclass, but may not be declared to do both.

6. If class a extends b and b extends c then what is the flow of constructor if i say new
  c
Answer. a,b,c

7. Difference between ArrayList and Vector.
Answer. Vector is syncronised and increase by 100% all time where as Arraylist is unsyncronised and increased by 50 %


8. What are the dfferent ways to make class serializable.
Answer .class shoule implement serializable other way is ....)

9. what is UniCastRemoteObject and it's Use.
Answer. Used for exporting a remote object with JRMP(Java Remote Method protocol)
    and obtaining a stub that communicates to the remote object. (need to check easy explanation)


10.What if i declare method as final.
Answer . (base class can't use it)

11.     Scope of all Accessfiers(for e.g public,private,protected)
Answer   public variables can be access thoughout the package  
     private variables can be access within the same class(but not in base class)
     protected variables can be access within class and base class. (need to verify)

12. what is different between thread.sleep and thread.yield
Answer.sleep will make thread to sleep for specific milliseconds.and yield pause current thread then allow to execute other thread.

13. What is stub and skeleton.
Answer. stub and skeleton holds signature of an Interface.stub is on client side and skeleton is on seerver side.

14. How many layers are there in RMI.
Answer.They are three
    a. Stub and Skeleton Layer(The stub and skeleton layer is responsible for marshaling
    and unmarshaling the data and transmitting and receiving them to/from the Remote Reference Layer)

    b. Remote Reference Layer(responsible for carrying out the invocation)
    c. Transpot Layer (is responsible for setting up connections, managing requests, monitoring them and listening for incoming calls)

15    Steps to Implement RMI
a.    Write and compile Java code for interfaces will extend Remote
b.    Write and compile Java code for implementation classes will extend     unicastremoteObject
c.    Generate Stub and Skeleton class files from the implementation classes
d.    Write Java code for a remote service host program
e.    Develop Java code for RMI client program
f.    Install and run RMI system


15. What are the modifiers can be used in Interface?
Ans Only Public or Abstarct can be used as an Modifiers.

16. What it will return true or false if String s1= 'hello' s2 ='hello'
   for s1.equals s2 and s1==s2?
Ans s1.equals s2 will return True because it will compare Contents and s1==s2 will compare Reference so it will return False.

17. what is difference between Interface and Abstract?
Ans Interface is 100% Abstarct

18. How will you know that your method is RemoteInterface?
Ans Interface will Extend Remote

19. What are the different types of XML Documents?
Ans DTD- Document type defination XML-Extensible Markup Language
   The Different types of XML are xslt,xsd.

20. What are different types of Exceptions?
Ans Two Handled and UnHAndled Exception
   Handled Exception are exception which are all subclass of Exception except Runtime Exception
   Unhandled Exception are all Errors and all subclasses of it as well as Runtime and its Subclass   

21. What is the Heriarchy of Exception?
Ans It start's from Object-Throwable-Exception.

22. Can object be created of Abstract class?
Ans NO

23. Is it necessary that Abstarct class should have Abstract method?
Ans NO


24. How do you know that RMI Connection is TCP or UDP?
ANs UDP has sockect connection ---  need to chk wrt to java.

25. How many ways you can load the JDBC Drivers?
Ans 1.Class.forName()
   2.Driver d = new org.gjt.mm.mysql.Driver();
   3.java -Djdbc.drivers=org.gjt.mm.mysql.Driver ProgName

   

26. What are the Sequential steps to Establish Connection to any Database?
Ans 1. String uri = "jdbc:mysql://localhost/test"
   2. Connection con =DriverManager.getConnection(uri, username, password);
   3. Statement smt = con.createStatement();
   4. ResultantSet rs = smt.executeQuery(SQL String);


27. What is Throawable?
Ans super class of all Exception

28. Can you customize the Exception and How and is it possible to customize any Exception Like ArrayOutOFBoundException?
Ans Yes

29. In RMI Client extends what as well Server Extends what?
Ans  server extends UniCastRemoteObject.
       

30. What is output of s1+1 or 1+s1 where s1='hello'?
Ans 1. hello1 & 2. 1hello

31. What are different types JDBC Drivers?
Ans 1 JDBC-ODBC bridge drivers
   2 Native-API partly Java drivers
   3 Net-protocol All-Java drivers
   4 Native-protocol All-Java drivers

32. Prepared statement and Prepared Call difference?
Ans Prepared Staement is used for building Query by passing Query
   PreparedStatement pstmt = con.prepareStatement("UPDATE EMPLOYEES
                                    SET SALARY = ? WHERE ID = ?");
  pstmt.setBigDecimal(1, 153833.00)
  pstmt.setInt(2, 110592)

   Where as Callable Statement is used to execute Procedure   

33. How many types of joins are there?
Ans Inner Join & Outer Join & SelfJoin

    Example of InnerJoin
SELECT suppliers.supplier_id, suppliers.supplier_name, orders.order_date
FROM suppliers, orders
WHERE suppliers.supplier_id = orders.supplier_id;

    Example of LeftoutterJoin
select suppliers.supplier_id, suppliers.supplier_name, orders.order_date
from suppliers, orders
where suppliers.supplier_id = orders.supplier_id(+);

    Example of SelfJoin
Select  a.empid,a.empname,b.mgid from emp a,emp b Where aempi != b.mgid


34. Singleton & Factory Pattern?
Ans make private Construtor of a class and one static method through which you can create
   Class object.

35. Pass by value & Reference?
Java passes parameters to methods using pass by value semantics. That is, a copy of the value of each of the specified arguments to the method call is passed to the method as its parameters.
Note very clearly that a lot of people confuse the "reference" terminology with respect to Java's references to objects and pass by reference calling semantics. The fact is, in dealing with Java's references to objects, a copy of the reference's value is what is passed to the method -- it's passed by value. This is, for example, why you cannot mutate the (original, caller's) reference to the object from inside the called method.

36. When you will use Final?
Ans Final can be used at variable level and method
   (Method will not be overridden at base class at Varialble it will behave has constant)

37. Can Interface be Extended?
Ans YEs

38. what is difference betn Dom and SAX?
Ans In DOM Entire XML is Converted into Tree and Loaded into the Memory   
   Sax is an Event based Parser

39. LifeCycle of Thread?
Ans Start-running-dead

40. How many ways you can Implement Thread which one is good and when?
Ans 1. Implemented runnable Interface
   2. Extends Thread

41. Procedures & Triggers difference thier use?
Ans Trigger are used on Trigerring some Events it depends on the action to be occured.
   Procedure is what sequence of statement to execute.

42. Is it possible to write the method of same name of class name?
Ans Yes

43  loose coupling and tight coupling ?
Ans  


44. What is difference between HashTable and HashMap?
Ans Hashtable is Synchronised and HashMap is unsyncronnised.
   Hashmap allows null value as key where hashtable dosen't   

45  What if try without catch ?
Ans no problem but need to write Finally after try.


46. What is difference betn wait and notify ?
Ans wait will make thread to go into wait state for specified time or till it call notify.


47 What is Clonning and ClonnableInterface?


48 What is observer and Observable?

49 What is different betn HashSet and HashMAp?
Ans HashSet will not allow duplicate values where has Hashmap does.






public : Public class is visible in other packages, field is visible everywhere (class must be public too)

private : 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 :What you get by default ie, without any access modifier
(ie, public private or protected).It means that it is visible to all within a
particular package.

what class name of wait() and notify()

can we used static with synchronicated keyword and why?

Garbage Collections Interview Questions

Q1) Which part of the memory is involved in Garbage Collection? Stack or Heap? Ans) Heap

Q2)What is responsiblity of Garbage Collector? Ans) Garbage collector frees the memory occupied by the unreachable objects during the java program by deleting these unreachable objects. It ensures that the available memory will be used efficiently, but does not guarantee that there will be sufficient memory for the program to run.

Q3) Is garbage collector a dameon thread? Ans) Yes GC is a dameon thread. A dameon thread runs behind the application. It is started by JVM. The thread stops when all non-dameon threads stop.

Q4)Garbage Collector is controlled by whom? Ans) The JVM controls the Garbage Collector; it decides when to run the Garbage Collector. JVM runs the Garbage Collector when it realizes that the memory is running low, but this behavior of jvm can not be guaranteed. One can request the Garbage Collection to happen from within the java program but there is no guarantee that this request will be taken care of by jvm.

Q5) When does an object become eligible for garbage collection? Ans) An object becomes eligible for Garbage Collection when no live thread can access it.

Q6) What are the different ways to make an object eligible for Garbage Collection when it is no longer needed? Ans) 1. Set all available object references to null once the purpose of creating the object is served : public class GarbageCollnTest1 {    public static void main (String [] args){ String str = "Set the object ref to null"; //String object referenced by variable str is not eligible for GC yet str = null; /*String object referenced by variable str becomes eligible for GC */    } } 2. Make the reference variable to refer to another object : Decouple the reference variable from the object and set it refer to another object, so the object which it was referring to before reassigning is eligible for Garbage Collection. publc class GarbageCollnTest2 {    public static void main(String [] args){ String str1 = "Garbage collected after use"; String str2 = "Another String"; System.out.println(str1); //String object referred by str1 is not eligible for GC yet str1 = str2; /* Now the str1 variable referes to the String object "Another String" and the object "Garbage collected after use" is not referred by any variable and hence is eligible for GC */    } } 3) Creating Islands of Isolation : If you have two instance reference variables which are referring to the instances of the same class, and these two reference variables refer to each other and the objects referred by these reference variables do not have any other valid reference then these two objects are said to form an Island of Isolation and are eligible for Garbage Collection. public class GCTest3 { GCTest3 g;    public static void main(String [] str){ GCTest3 gc1 = new GCTest3(); GCTest3 gc2 = new GCTest3(); gc1.g = gc2; //gc1 refers to gc2 gc2.g = gc1; //gc2 refers to gc1 gc1 = null; gc2 = null; //gc1 and gc2 refer to each other and have no other valid //references //gc1 and gc2 form Island of Isolation //gc1 and gc2 are eligible for Garbage collection here    } }

Q7) Can the Garbage Collection be forced by any means? Ans) No. The Garbage Collection can not be forced, though there are few ways by which it can be requested there is no guarantee that these requests will be taken care of by JVM.

Q8) How can the Garbage Collection be requested? Ans) There are two ways in which we can request the jvm to execute the Garbage Collection. 1) The methods to perform the garbage collections are present in the Runtime class provided by java. The Runtime class is a Singleton for each java main program. The method getRuntime() returns a singleton instance of the Runtime class. The method gc() can be invoked using this instance of Runtime to request the garbage collection. 2) Call the System class System.gc() method which will request the jvm to perform GC.

Q9) What is the purpose of overriding finalize() method? Ans) The finalize() method should be overridden for an object to include the clean up code or to dispose of the system resources that should to be done before the object is garbage collected.

Q10) If an object becomes eligible for Garbage Collection and its finalize() method has been called and inside this method the object becomes accessible by a live thread of execution and is not garbage collected. Later at some point the same object becomes eligible for Garbage collection, will the finalize() method be called again? Ans) No

Q11) How many times does the garbage collector calls the finalize() method for an object? Ans) Only once.

Q12) What happens if an uncaught exception is thrown from during the execution of the finalize() method of an object? Ans) The exception will be ignored and the garbage collection (finalization) of that object terminates.

Q13) What are different ways to call garbage collector? Ans) Garbage collection can be invoked using System.gc() or Runtime.getRuntime().gc().

Q14) How to enable/disable call of finalize() method of exit of the application Ans) Runtime.getRuntime().runFinalizersOnExit(boolean value) . Passing the boolean value will either disable or enable the finalize() call.

What is Serialization?
Serializable is a marker interface.
Class needs to implement Serializable interface.
Implementing this interface will allow the object converted into bytestream and transfer over a network.


Other than Serialization what are the different approach to make object Serializable?
implement the Externalizable interface, which extends Serializable. By implementing Externalizable, a developer is responsible for implementing the writeExternal() and readExternal() methods. As a result, a developer has sole control over reading and writing the serialized objects.


What happens if the object to be serialized includes the references to other serializable objects?
If the object to be serialized includes the references to other objects whose class implements serializable then all those object’s state also will be saved as the part of the serialized state of the object in question



What happens if an object is serializable but it includes a reference to a non-serializable object?

Ans- If you try to serialize an object of a class which implements serializable, but the object includes a reference to an non-serializable class then a ‘NotSerializableException’ will be thrown at runtime.


Are the static variables saved as the part of serialization?
No. The static variables belong to the class and not to an object they are not the part of the state of the object so they are not saved as the part of serialized object.

What will be the value of transient variable after de-serialization?
The transient variable is not saved as the part of the state of the serailized variable, it’s value after de-serialization is it’s default value.

Does the order in which the value of the transient variables and the state of the object using the defaultWriteObject() method are saved during serialization matter?

Ans) Yes.  As while restoring the object’s state the transient variables and the serializable variables that are stored must be restored in the same order in which they were saved.


Q12) How can one customize the Serialization process? or What is the purpose of implementing the writeObject() and readObject() method?

Ans) When you want to store the transient variables state as a part of the serialized object at the time of serialization the class must implement the following methods –

private void wrtiteObject(ObjectOutputStream outStream)
{
//code to save the transient variables state as a part of serialized object
}
private void readObject(ObjectInputStream inStream)
{
//code to read the transient variables state and assign it to the de-serialized object
}

e.g.

public class TestCustomizedSerialization implements Serializable{

   private static final long serialVersionUID =-22L;
   private String noOfSerVar;
   transient private int noOfTranVar;

   TestCustomizedSerialization(int noOfTranVar, String noOfSerVar) {
       this.noOfTranVar = noOfTranVar;
       this.noOfSerVar = noOfSerVar;
   }

   private void writeObject(ObjectOutputStream os) {

    try {
    os.defaultWriteObject();
    os.writeInt(noOfTranVar);
    } catch (Exception e) { e.printStackTrace(); }
    }

    private void readObject(ObjectInputStream is) {
    try {
    is.defaultReadObject();
    int noOfTransients = (is.readInt());
    } catch (Exception e) {
        e.printStackTrace(); }
    }

    public int getNoOfTranVar() {
       return noOfTranVar;
   }
   
}

The value of transient variable ‘noOfTranVar’ is saved as part of the serialized object manually by implementing writeObject() and restored by implementing readObject().
The normal serializable variables are saved and restored by calling defaultWriteObject() and defaultReadObject()respectively. These methods perform the normal serialization and de-sirialization process for the object to be saved or restored respectively.

Q13) If a class is serializable but its superclass in not , what will be the state of the instance variables inherited  from super class after deserialization?

Ans) The values of the instance variables inherited from superclass will be reset to the values they were given during the original construction of the object as the non-serializable super-class constructor will run.

E.g.
public class ParentNonSerializable {
   int noOfWheels;
   
   ParentNonSerializable(){
       this.noOfWheels = 4;
   }
   
}



public class ChildSerializable extends ParentNonSerializable implements Serializable {
  
   private static final long serialVersionUID = 1L;
   String color;



   ChildSerializable() {
       this.noOfWheels = 8;
       this.color = "blue";
   }
}



public class SubSerialSuperNotSerial {

   public static void main(String [] args) {

       ChildSerializable c = new ChildSerializable();
       System.out.println("Before : - " + c.noOfWheels + " "+ c.color);
       try {
       FileOutputStream fs = new FileOutputStream("superNotSerail.ser");
       ObjectOutputStream os = new ObjectOutputStream(fs);
       os.writeObject(c);
       os.close();
       } catch (Exception e) { e.printStackTrace(); }

       try {
       FileInputStream fis = new FileInputStream("superNotSerail.ser");
       ObjectInputStream ois = new ObjectInputStream(fis);
       c = (ChildSerializable) ois.readObject();
       ois.close();
       } catch (Exception e) { e.printStackTrace(); }
       System.out.println("After :- " + c.noOfWheels + " "+ c.color);
       }

}

Result on executing above code –
Before : - 8 blue
After :- 4 blue

The instance variable ‘noOfWheels’ is inherited from superclass which is not serializable. Therefore while restoring it the non-serializable superclass constructor runs and its value is set to 8 and is not same as the value saved during serialization which is 4.

Q14) To serialize an array or a collection all the members of it must be serializable. True /False?

Ans) true.

Q1) What is an immutable class? Ans) Immutable class is a class which once created, it’s contents can not be changed. Immutable objects are the objects whose state can not be changed once constructed. e.g. String class

Q2) How to create an immutable class? Ans) To create an immutable class following steps should be followed: Create a final class. Set the values of properties using constructor only. Make the properties of the class final and private Do not provide any setters for these properties. If the instance fields include references to mutable objects, don't allow those objects to be changed: Don't provide methods that modify the mutable objects. Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods. E.g. public final class FinalPersonClass {       private final String name;       private final int age;             public FinalPersonClass(final String name, final int age) {             super();             this.name = name;             this.age = age;       }       public int getAge() {             return age;       }       public String getName() {             return name;       }       }

Q3) Immutable objects are automatically thread-safe –true/false? Ans) True. Since the state of the immutable objects can not be changed once they are created they are automatically synchronized/thread-safe.

Q4) Which classes in java are immutable? Ans) All wrapper classes in java.lang are immutable – String, Integer, Boolean, Character, Byte, Short, Long, Float, Double, BigDecimal, BigInteger

Q5) What are the advantages of immutability? Ans) The advantages are: 1) Immutable objects are automatically thread-safe, the overhead caused due to use of synchronisation is avoided. 2) Once created the state of the immutable object can not be changed so there is no possibility of them getting into an inconsistent state. 3) The references to the immutable objects can be easily shared or cached without having to copy or clone them as there state can not be changed ever after construction.   4) The best use of the immutable objects is as the keys of a map.

Q1) What is an Exception? Ans) The exception is said to be thrown whenever an exceptional event occurs in java which signals that something is not correct with the code written and may give unexpected result. An exceptional event is a occurrence of condition which alters the normal program flow. Exceptional handler is the code that does something about the exception.

Q2) Exceptions are defined in which java package? Ans)All the exceptions are subclasses of java.lang.Exception

Q3) How are the exceptions handled in java? Ans)When an exception occurs the execution of the program is transferred to an appropriate exception handler.The try-catch-finally block is used to handle the exception. The code in which the exception may occur is enclosed in a try block, also called as a guarded region. The catch clause matches a specific exception to a block of code which handles that exception. And the clean up code which needs to be executed no matter the exception occurs or not is put inside the finally block

Q4) Explain the exception hierarchy in java. Ans) The hierarchy is as follows: Throwable is a parent class off all Exception classes. They are two types of Exceptions: Checked exceptions and UncheckedExceptions. Both type of exceptions extends Exception class.

Q5) What is Runtime Exception or unchecked exception? Ans) Runtime exceptions represent problems that are the result of a programming problem. Such problems include arithmetic exceptions, such as dividing by zero; pointer exceptions, such as trying to access an object through a null reference; and indexing exceptions, such as attempting to access an array element through an index that is too large or too small. Runtime exceptions need not be explicitly caught in try catch block as it can occur anywhere in a program, and in a typical one they can be very numerous. Having to add runtime exceptions in every method declaration would reduce a program's clarity. Thus, the compiler does not require that you catch or specify runtime exceptions (although you can). The solution to rectify is to correct the programming logic where the exception has occurred or provide a check.

Q6) What is checked exception? Ans) Checked exception are the exceptions which forces the programmer to catch them explicitly in try-catch block. It is a subClass of Exception. Example: IOException.

Q7) What is difference between Error and Exception? Ans) An error is an irrecoverable condition occurring at runtime. Such as OutOfMemory error. These JVM errors and you can not repair them at runtime.Though error can be caught in catch block but the execution of application will come to a halt and is not recoverable. While exceptions are conditions that occur because of bad input etc. e.g. FileNotFoundException will be thrown if the specified file does not exist. Or a NullPointerException will take place if you try using a null reference. In most of the cases it is possible to recover from an exception (probably by giving user a feedback for entering proper values etc.)

Q8) What is difference between ClassNotFoundException and NoClassDefFoundError? Ans) A ClassNotFoundException is thrown when the reported class is not found by the ClassLoader in the CLASSPATH. It could also mean that the class in question is trying to be loaded from another class which was loaded in a parent classloader and hence the class from the child classloader is not visible. Consider if NoClassDefFoundError occurs which is something like java.lang.NoClassDefFoundError src/com/TestClass does not mean that the TestClass class is not in the CLASSPATH. It means that the class TestClass was found by the ClassLoader however when trying to load the class, it ran into an error reading the class definition. This typically happens when the class in question has static blocks or members which use a Class that's not found by the ClassLoader. So to find the culprit, view the source of the class in question (TestClass in this case) and look for code using static blocks or static members.

Q9) What is throw keyword? Ans) Throw keyword is used to throw the exception manually. It is mainly used when the program fails to satisfy the given condition and it wants to warn the application.The exception thrown should be subclass of Throwable.   public void parent(){   try{    child();   }catch(MyCustomException e){ }   }   public void child{   String iAmMandatory=null;    if(iAmMandatory == null){     throw (new MyCustomException("Throwing exception using throw keyword");    }   }

Q10) What is use of throws keyword? Ans) If the function is not capable of handling the exception then it can ask the calling method to handle it by simply putting the throws clause at the function declaration.   public void parent(){   try{    child();   }catch(MyCustomException e){ }   }   public void child throws MyCustomException{    //put some logic so that the exception occurs.   }

Q11) What are the possible combination to write try, catch finally block? Ans) 1) try{ //lines of code that may throw an exception }catch(Exception e){ //lines of code to handle the exception thrown in try block }finally{ //the clean code which is executed always no matter the exception occurs or not. } 2 try{ }finally{} 3 try{ }catch(Exception e){ //lines of code to handle the exception thrown in try block } The catch blocks must always follow the try block. If there are more than one catch blocks they all must follow each other without any block in between. The finally block must follow the catch block if one is present or if the catch block is absent the finally block must follow the try block.

Q12) How to create custom Exception? Ans) To create you own exception extend the Exception class or any of its subclasses. e.g. 1 class New1Exception extends Exception { } // this will create Checked Exception 2 class NewException extends IOExcpetion { } // this will create Checked exception 3 class NewException extends NullPonterExcpetion { } // this will create UnChecked exception

Q13) When to make a custom checked Exception or custom unchecked Exception? Ans) If an application can reasonably be expected to recover from an exception, make it a checked exception. If an application cannot do anything to recover from the exception, make it an unchecked exception.

Q14)What is StackOverflowError? Ans) The StackOverFlowError is an Error Object thorwn by the Runtime System when it Encounters that your application/code has ran out of the memory. It may occur in case of recursive methods or a large amount of data is fetched from the server and stored in some object. This error is generated by JVM. e.g. void swap(){ swap(); }

Q15) Why did the designers decide to force a method to specify all uncaught checked exceptions that can be thrown within its scope? Ans) Any Exception that can be thrown by a method is part of the method's public programming interface. Those who call a method must know about the exceptions that a method can throw so that they can decide what to do about them. These exceptions are as much a part of that method's programming interface as its parameters and return value.

Q16) Once the control switches to the catch block does it return back to the try block to execute the balance code? Ans) No. Once the control jumps to the catch block it never returns to the try block but it goes to finally block(if present).

Q17) Where is the clean up code like release of resources is put in try-catch-finally block and why? Ans) The code is put in a finally block because irrespective of try or catch block execution the control will flow to finally block. Typically finally block contains release of connections, closing of result set etc.

Q18) Is it valid to have a try block without catch or finally? Ans) NO. This will result in a compilation error. The try block must be followed by a catch or a finally block. It is legal to omit the either catch or the finally block but not both. e.g. The following code is illegal. try{ int i =0; } int a = 2; System.out.println(“a = “+a);

Q19) Is it valid to place some code in between try the catch/finally block that follows it? Ans) No. There should not be any line of code present between the try and the catch/finally block. e.g. The following code is wrong. try{} String str = “ABC”; System.out.println(“str = “+str); catch(Exception e){}

Q20) What happens if the exception is never caught and throws down the method stack? Ans) If the exception is not caught by any of the method in the method’s stack till you get to the main() method, the main method throws that exception and the JVM halts its execution.

Q21) How do you get the descriptive information about the Exception occurred during the program execution? Ans) All the exceptions inherit a method printStackTrace() from the Throwable class. This method prints the stack trace from where the exception occurred. It prints the most recently entered method first and continues down, printing the name of each method as it works its way down the call stack from the top.

Q22) Can you catch more than one exceptions in a single catch block? Ans)Yes. If the exception class specified in the catch clause has subclasses, any exception object that is a subclass of the specified Exception class will be caught by that single catch block. E.g.. try { // Some code here that can throw an IOException } catch (IOException e) { e.printStackTrace(); } The catch block above will catch IOException and all its subclasses e.g. FileNotFoundException etc.

Q23)Why is not considered as a good practice to write a single catchall handler to catch all the exceptions? Ans) You can write a single catch block to handle all the exceptions thrown during the program execution as follows : try { // code that can throw exception of any possible type }catch (Exception e) { e.printStackTrace(); } If you use the Superclass Exception in the catch block then you will not get the valuable information about each of the exception thrown during the execution, though you can find out the class of the exception occurred. Also it will reduce the readability of the code as the programmer will not understand what is the exact reason for putting the try-catch block.

Q24) What is exception matching? Ans) Exception matching is the process by which the the jvm finds out the matching catch block for the exception thrown from the list of catch blocks. When an exception is thrown, Java will try to find by looking at the available catch clauses in the top down manner. If it doesn't find one, it will search for a handler for a supertype of the exception. If it does not find a catch clause that matches a supertype for the exception, then the exception is propagated down the call stack. This process is called exception matching.

Q25) What happens if the handlers for the most specific exceptions is placed above the more general exceptions handler? Ans) Compilation fails. The catch block for handling the most specific exceptions must always be placed above the catch block written to handle the more general exceptions. e.g. The code below will not compile. 1 try { // code that can throw IOException or its subtypes } catch (IOException e) { // handles IOExceptions and its subtypes } catch (FileNotFoundException ex) { // handle FileNotFoundException only } The code below will compile successfully :- try { // code that can throw IOException or its subtypes } catch (FileNotFoundException ex) { // handles IOExceptions and its subtypes } catch (IOException e){ // handle FileNotFoundException only }

Q26) Does the order of the catch blocks matter if the Exceptions caught by them are not subtype or supertype of each other? Ans) No. If the exceptions are siblings in the Exception class’s hierarchy i.e. If one Exception class is not a subtype or supertype of the other, then the order in which their handlers(catch clauses) are placed does not matter.

Q27) What happens if a method does not throw an checked Exception directly but calls a method that does? What does 'Ducking' the exception mean? Ans) If a method does not throw an checked Exception directly but calls a method that throws an exception then the calling method must handle the throw exception or declare the exception in its throws clause. If the calling method does not handle and declares the exception, the exceptions is passed to the next method in the method stack. This is called as ducking the exception down the method stack. e.g. The code below will not compile as the getCar() method has not declared the CarNotFoundException which is thrown by the getColor () method. void getCar() { getColor(); } void getColor () { throw new CarNotFoundException(); } Fix for the above code is void getCar() throws CarNotFoundException { getColor(); } void getColor () { throw new CarNotFoundException(); }

Q28) Is an empty catch block legal? Ans) Yes you can leave the catch block without writing any actual code to handle the exception caught. e.g. The code below is legal but not appropriate, as in this case you will nt get any information about the exception thrown. try{ //code that may throw the FileNotFoundException }catch(FileNotFound eFnf){ //no code to handle the FileNotFound exception }

Q29)Can a catch block throw the exception caught by itself? Ans) Yes. This is called rethrowing of the exception by catch block. e.g. the catch block below catches the FileNotFound exception and rethrows it again. void checkEx() throws FileNotFoundException { try{ //code that may throw the FileNotFoundException }catch(FileNotFound eFnf){ throw FileNotFound(); } }

Q1) What is polymorphism? Ans) Polymorphism gives us the ultimate flexibility in extensibility. The abiltiy to define more than pne function with the same name is called Polymorphism. In java,c++ there are two type of polymorphism: compile time polymorphism (overloading) and runtime polymorphism (overriding). When you override methods, JVM determines the proper methods to call at the program’s run time, not at the compile time. Overriding occurs when a class method has the same name and signature as a method in parent class. Overloading occurs when several methods have same names with Overloading is determined at the compile time. Different method signature and different number or type of parameters. Same method signature but different number of parameters. Same method signature and same number of parameters but of different type Example of Overloading      int add(int a,int b)      float add(float a,int b)      float add(int a ,float b)      void add(float a)      int add(int a)      void add(int a)                 //error conflict with the method int add(int a) Example: Overloading Class BookDetails{             String title;             String publisher;             float price; setBook(String title){ } setBook(String title, String publisher){ } setBook(String title, String publisher,float price){ } } Example: Overriding class BookDetails{             String title; setBook(String title){ } } class ScienceBook{             setBook(String title){}                                             //overriding setBook(String title, String publisher,float price){ }  //overloading }

Q2) What is inheritance? Ans) Inheritance is the property which allows a Child class to inherit some properties from its parent class. In Java this is achieved by using extends keyword. Only properties with access modifier public and protected can be accessed in child class. public class Parent{ public String parentName; public int parentage; public String familyName; } public class Child extends Parent{ public String childName; public int childAge; public void printMyName(){ System.out.println(“ My name is “+ chidName+” “ +familyName) } } In above example the child has inherit its family name from the parent class just by inheriting the class.

Q3) What is multiple inheritance and does java support? Ans) If a child class inherits the property from multiple classes is known as multiple inheritance. Java does not allow to extend multiple classes but to overcome this problem it allows to implement multiple Interfaces.

Q4) What is abstraction? Ans) Abstraction is way of converting real world objects in terms of class. For example creating a class Vehicle and injecting properties into it. E.g public class Vehicle { public String colour; public String model; }

Q5) What is encapsulation? Ans) The encapsulation is achieved by combining the methods and attribute into a class. The class acts like a container encapsulating the properties. The users are exposed mainly public methods.The idea behind is to hide how thinigs work and just exposing the requests a user can do.

Q6) What is Association? Ans) Association is a relationship between two classes. In this relationship the object of one instance perform an action on behalf of the other class. The typical beahiour can be invoking the method of other class and using the member of the other class. public class MyMainClass{ public void init(){ new OtherClass.init(); } }

Q7) What is Aggregation? Ans) Aggregation has a relationship between two classes. In this relationship the object of one class is a member of the other class. Aggregation always insists for a direction. public class MyMainClass{ OtherClass otherClassObj = new OtherClass(); }

Q8) What is Composition? Ans) Composition is a special type of aggregation relationship with a difference that its the compulsion for the OtherClass object (in previous example) to exist for the existence of MyMainClass.

Q1) What is difference between ArrayList and vector? Ans: ) 1) Synchronization - ArrayList is not thread-safe whereas Vector is thread-safe. In Vector class each method like add(), get(int i) is surrounded with a synchronized block and thus making Vector class thread-safe. 2) Data growth - Internally, both the ArrayList and Vector hold onto their contents using an Array. When an element is inserted into an ArrayList or a Vector, the object will need to expand its internal array if it runs out of room. A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.

Q2) How can Arraylist be synchronized without using Vector? Ans) Arraylist can be synchronized using: Collection.synchronizedList(List list) Other collections can be synchronized: Collection.synchronizedMap(Map map) Collection.synchronizedCollection(Collection c)

Q3) If an Employee class is present and its objects are added in an arrayList. Now I want the list to be sorted on the basis of the employeeID of Employee class. What are the steps? Ans) 1) Implement Comparable interface for the Employee class and override the compareTo(Object obj) method in which compare the employeeID 2) Now call Collections.sort() method and pass list as an argument. Now consider that Employee class is a jar file. 1) Since Comparable interface cannot be implemented, create Comparator and override the compare(Object obj, Object obj1) method . 2) Call Collections.sort() on the list and pass comparator as an argument.

Q4)What is difference between HashMap and HashTable? Ans) Both collections implements Map. Both collections store value as key-value pairs. The key differences between the two are 1. Hashmap is not synchronized in nature but hshtable is. 2. Another difference is that iterator in the HashMap is fail-safe while the enumerator for the Hashtable isn't. Fail-safe - “if the Hashtable is structurally modified at any time after the iterator is created, in any way except through the iterator's own remove method, the iterator will throw a ConcurrentModificationException� 3. HashMap permits null values and only one null key, while Hashtable doesn't allow key or value as null.

Q5) What are the classes implementing List interface? Ans) There are three classes that implement List interface: 1) ArrayList : It is a resizable array implementation. The size of the ArrayList can be increased dynamically also operations like add,remove and get can be formed once the object is created. It also ensures that the data is retrieved in the manner it was stored. The ArrayList is not thread-safe. 2) Vector: It is thread-safe implementation of ArrayList. The methods are wrapped around a synchronized block. 3) LinkedList: the LinkedList also implements Queue interface and provide FIFO(First In First Out) operation for add operation. It is faster if than ArrayList if it performs insertion and deletion of elements from the middle of a list.

Q6) Which all classes implement Set interface? Ans) A Set is a collection that contains no duplicate elements. More formally, sets contain no pair of elements e1 and e2 such that e1.equals(e2), and at most one null element. HashSet,SortedSet and TreeSet are the commnly used class which implements Set interface. SortedSet - It is an interface which extends Set. A the name suggest , the interface allows the data to be iterated in the ascending order or sorted on the basis of Comparator or Comparable interface. All elements inserted into the interface must implement Comparable or Comparator interface. TreeSet - It is the implementation of SortedSet interface.This implementation provides guaranteed log(n) time cost for the basic operations (add, remove and contains). The class is not synchronized. HashSet: This class implements the Set interface, backed by a hash table (actually a HashMap instance). It makes no guarantees as to the iteration order of the set; in particular, it does not guarantee that the order will remain constant over time. This class permits the null element. This class offers constant time performance for the basic operations (add, remove, contains and size), assuming the hash function disperses the elements properly among the buckets

Q7) What is difference between List and a Set? Ans) 1) List can contain duplicate values but Set doesnt allow. Set allows only to unique elements. 2) List allows retrieval of data to be in same order in the way it is inserted but Set doesnt ensures the sequence in which data can be retrieved.(Except HashSet)

Q8) What is difference between Arrays and ArrayList ? Ans) Arrays are created of fix size whereas ArrayList is of not fix size. It means that once array is declared as : int [] intArray= new int[6]; intArray[7]   // will give ArraysOutOfBoundException. Also the size of array cannot be incremented or decremented. But with arrayList the size is variable. Once the array is created elements cannot be added or deleted from it. But with ArrayList the elements can be added and deleted at runtime. List list = new ArrayList(); list.add(1); list.add(3); list.remove(0) // will remove the element from the 1st location. ArrayList is one dimensional but array can be multidimensional.             int[][][] intArray= new int[3][2][1];   // 3 dimensional array     To create an array the size should be known or initalized to some value. If not initialized carefully there could me memory wastage. But arrayList is all about dynamic creation and there is no wastage of memory.

Q9) When to use ArrayList or LinkedList ? Ans)  Adding new elements is pretty fast for either type of list. For the ArrayList, doing  random lookup using "get" is fast, but for LinkedList, it's slow. It's slow because there's no efficient way to index into the middle of a linked list. When removing elements, using ArrayList is slow. This is because all remaining elements in the underlying array of Object instances must be shifted down for each remove operation. But here LinkedList is fast, because deletion can be done simply by changing a couple of links. So an ArrayList works best for cases where you're doing random access on the list, and a LinkedList works better if you're doing a lot of editing in the middle of the list. Source : Read More - from java.sun http://java.sun.com/developer/TechTips/1999/tt0809.html

Q10) Consider a scenario. If an ArrayList has to be iterate to read data only, what are the possible ways and which is the fastest? Ans) It can be done in two ways, using for loop or using iterator of ArrayList. The first option is faster than using iterator. Because value stored in arraylist is indexed access. So while accessing the value is accessed directly as per the index.

Q11) Now another question with respect to above question is if accessing through iterator is slow then why do we need it and when to use it. Ans) For loop does not allow the updation in the array(add or remove operation) inside the loop whereas Iterator does. Also Iterator can be used where there is no clue what type of collections will be used because all collections have iterator.

Q12) Which design pattern Iterator follows? Ans) It follows Iterator design pattern. Iterator Pattern is a type of behavioral pattern. The Iterator pattern is one, which allows you to navigate through a collection of data using a common interface without knowing about the underlying implementation. Iterator should be implemented as an interface. This allows the user to implement it anyway its easier for him/her to return data. The benefits of Iterator are about their strength to provide a common interface for iterating through collections without bothering about underlying implementation. Example of Iteration design pattern - Enumeration The class java.util.Enumeration is an example of the Iterator pattern. It represents and abstract means of iterating over a collection of elements in some sequential order without the client having to know the representation of the collection being iterated over. It can be used to provide a uniform interface for traversing collections of all kinds.

Q12) Is it better to have a HashMap with large number of records or n number of small hashMaps? Ans) It depends on the different scenario one is working on: 1) If the objects in the hashMap are same then there is no point in having different hashmap as the traverse time in a hashmap is invariant to the size of the Map. 2) If the objects are of different type like one of Person class , other of Animal class etc then also one can have single hashmap but different hashmap would score over it as it would have better readability.

Q13) Why is it preferred to declare: List list = new ArrayList(); instead of ArrayList = new ArrayList(); Ans) It is preferred because: If later on code needs to be changed from ArrayList to Vector then only at the declaration place we can do that. The most important one – If a function is declared such that it takes list. E.g void showDetails(List list); When the parameter is declared as List to the function it can be called by passing any subclass of List like ArrayList,Vector,LinkedList making the function more flexible

Q14) What is difference between iterator access and index access? Ans) Index based access allow access of the element directly on the basis of index. The cursor of the datastructure can directly goto the 'n' location and get the element. It doesnot traverse through n-1 elements. In Iterator based access, the cursor has to traverse through each element to get the desired element.So to reach the 'n'th element it need to traverse through n-1 elements. Insertion,updation or deletion will be faster for iterator based access if the operations are performed on elements present in between the datastructure. Insertion,updation or deletion will be faster for index based access if the operations are performed on elements present at last of the datastructure. Traversal or search in index based datastructure is faster. ArrayList is index access and LinkedList is iterator access.

Q15) How to sort list in reverse order? Ans) To sort the elements of the List in the reverse natural order of the strings, get a reverse Comparator from the Collections class with reverseOrder(). Then, pass the reverse Comparator to the sort() method. List list = new ArrayList(); Comparator comp = Collections.reverseOrder(); Collections.sort(list, comp)

Q16) Can a null element added to a Treeset or HashSet? Ans) A null element can be added only if the set contains one element because when a second element is added then as per set defination a check is made to check duplicate value and comparison with null element will throw NullPointerException. HashSet is based on hashMap and can contain null element.

Q17) How to sort list of strings - case insensitive? Ans) using Collections.sort(list, String.CASE_INSENSITIVE_ORDER);

Q18) How to make a List (ArrayList,Vector,LinkedList) read only? Ans) A list implemenation can be made read only using Collections.unmodifiableList(list). This method returns a new list. If a user tries to perform add operation on the new list; UnSupportedOperationException is thrown.

Q19) What is ConcurrentHashMap? Ans) A concurrentHashMap is thread-safe implementation of Map interface. In this class put and remove method are synchronized but not get method. This class is different from Hashtable in terms of locking; it means that hashtable use object level lock but this class uses bucket level lock thus having better performance.

Q20) Which is faster to iterate LinkedHashSet or LinkedList? Ans) LinkedList.

Q21) Which data structure HashSet implements Ans) HashSet implements hashmap internally to store the data. The data passed to hashset is stored as key in hashmap with null as value.

Q22) Arrange in the order of speed - HashMap,HashTable, Collections.synchronizedMap,concurrentHashmap Ans) HashMap is fastest, ConcurrentHashMap,Collections.synchronizedMap,HashTable.

Q23) What is identityHashMap? Ans) The IdentityHashMap uses == for equality checking instead of equals(). This can be used for both performance reasons, if you know that two different elements will never be equals and for preventing spoofing, where an object tries to imitate another.

Q24) What is WeakHashMap? Ans) A hashtable-based Map implementation with weak keys. An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use. More precisely, the presence of a mapping for a given key will not prevent the key from being discarded by the garbage collector, that is, made finalizable, finalized, and then reclaimed. When a key has been discarded its entry is effectively removed from the map, so this class behaves somewhat differently than other Map implementations.

Q1) What is a Thread? Ans) In Java, "thread" means two different things: An instance of class java.lang.Thread. A thread of execution. An instance of Thread is just…an object. Like any other object in Java, it has variables and methods, and lives and dies on the heap. But a thread of execution is an individual process (a "lightweight" process) that has its own call stack. In Java, there is one thread per call stack—or, to think of it in reverse, one call stack per thread. Even if you don't create any new threads in your program, threads are back there running. The main() method, that starts the whole ball rolling, runs in one thread, called (surprisingly) the main thread. If you looked at the main call stack (and you can, any time you get a stack trace from something that happens after main begins, but not within another thread), you'd see that main() is the first method on the stack— the method at the bottom. But as soon as you create a new thread, a new stack materializes and methods called from that thread run in a call stack that's separate from the main() call stack.

Q2) What is difference between thread and process? Ans) Differences between threads and processes are:- 1. Threads share the address space of the process that  created it; processes have their own address. 2. Threads have direct access to the data segment of its process; processes have their own copy of the data segment of the parent process. 3. Threads can directly communicate with other threads of its process; processes must use interprocess communication to communicate with sibling processes. 4. Threads have almost no overhead; processes have considerable overhead. 5. New threads are easily created; new processes require duplication of the parent process. 6. Threads can exercise considerable control over threads of the same process; processes can only exercise control over child processes. 7. Changes to the main thread (cancellation, priority change, etc.) may affect the behavior of the other threads of the process; changes to the parent process do not affect child processes.

Q3) What are the advantages or usage of threads? Ans)  Threads support concurrent operations. For example,  • Multiple requests by a client on a server can be handled as an individual client thread.  • Long computations or high-latency disk and network operations can be handled in the background without disturbing foreground computations or screen updates. Threads often result in simpler programs. • In sequential programming, updating multiple displays normally requires a big while-loop that performs small parts of each display update. Unfortunately, this loop basically simulates an operating system scheduler. In Java, each view can be assigned a thread to provide continuous updates. • Programs that need to respond to user-initiated events can set up service routines to handle the events without having to insert code in the main routine to look for these events. Threads provide a high degree of control. • Imagine launching a complex computation that occasionally takes longer than is satisfactory. A "watchdog" thread can be activated that will "kill" the computation if it becomes costly, perhaps in favor of an alternate, approximate solution. Note that sequential programs must muddy the computation with termination code, whereas, a Java program can use thread control to non-intrusively supervise any operation. Threaded applications exploit parallelism. • A computer with multiple CPUs can literally execute multiple threads on different functional units without having to simulating multi-tasking ("time sharing"). • On some computers, one CPU handles the display while another handles computations or database accesses, thus, providing extremely fast user interface response times.

Q4)What are the two ways of creating thread? Ans) There are two ways to create a new thread. 1)Extend the Thread class and override the run() method in your class. Create an instance of the subclass and invoke the start() method on it, which will create a new thread of execution. e.g. public class NewThread extends Thread{ public void run(){ // the code that has to be executed in a separate new thread goes here } public static void main(String [] args){ NewThread c = new NewThread(); c.start(); } } 2)Implements the Runnable interface.The class will have to implement the run() method in the Runnable interface. Create an instance of this class. Pass the reference of this instance to the Thread constructor a new thread of execution will be created. e.g. class public class NewThread implements Runnable{ public void run(){ // the code that has to be executed in a separate new thread goes here } public static void main(String [] args){ NewThread c = new NewThread(); Thread t = new Thread(c); t.start(); } }

Q5) What are the different states of a thread's lifecycle? Ans) The different states of threads are as follows: 1) New – When a thread is instantiated it is in New state until the start() method is called on the thread instance. In this state the thread is not considered to be alive. 2) Runnable – The thread enters into this state after the start method is called in the thread instance. The thread may enter into the Runnable state from Running state. In this state the thread is considered to be alive. 3) Running – When the thread scheduler picks up the thread from the Runnable thread’s pool, the thread starts running and the thread is said to be in Running state.  4) Waiting/Blocked/Sleeping – In these states the thread is said to be alive but not runnable. The thread switches to this state because of reasons like wait method called or sleep method has been called on the running thread or thread might be waiting for some i/o resource so blocked. 5)      Dead – When the thread finishes its execution i.e. the run() method execution completes, it is said to be in dead state. A dead state can not be started again. If a start() method is invoked on a dead thread a runtime exception will occur.

Q6) What is use of synchronized keyword? Ans) synchronized keyword can be applied to static/non-static methods or a block of code. Only one thread at a time can access synchronized methods and if there are multiple threads trying to access the same method then other threads have to wait for the execution of method by one thread. Synchronized keyword provides a lock on the object and thus prevents race condition. E.g. public void synchronized method(){}  public void synchronized staticmethod(){} public void myMethod(){             synchronized (this){             // synchronized keyword on block of  code             } }

Q7) What is the difference when the synchronized keyword is applied to a static method or to a non static method? Ans) When a synch non static method is called a lock is obtained on the object. When a synch static method is called a lock is obtained on the class and not on the object. The lock on the object and the lock on the class don’t interfere with each other. It means, a thread accessing a synch non static method, then the other thread can access the synch static method at the same time but can’t access the synch non static method.

Q8) What is a volatile keyword? Ans) In general each thread has its own copy of variable, such that one thread is not concerned with the value of same variable in the other thread. But sometime this may not be the case. Consider a scenario in which the count variable is holding the number of times a method is called for a given class irrespective of any thread calling, in this case irrespective of thread access the count has to be increased so the count variable is declared as volatile. The copy of volatile variable is stored in the main memory, so every time a thread access the variable even for reading purpose the local copy is updated each time from the main memory. The volatile variable also have performance issues.

Q9) What is the difference between yield() and sleep()? Ans)  yield() allows the current the thread to release its lock from the object and scheduler gives the lock of the object to the other thread with same priority.          sleep() allows the thread to go to sleep state for x milliseconds. When a thread goes into sleep state it doesn’t release the lock.

Q10) What is the difference between wait() and sleep()? Ans) 1) wait() is a method of Object class. sleep() is a method of Object class. 2) sleep() allows the thread to go to sleep state for x milliseconds. When a thread goes into sleep state it doesn’t release the lock. wait() allows thread to release the lock and goes to suspended state. The thread is only active when a notify() or notifAll() method is called for the same object.

Q11) What is difference between notify() and notfiyAll()? Ans) notify( ) wakes up the first thread that called wait( ) on the same object. notifyAll( ) wakes up all the threads that called wait( ) on the same object. The highest priority thread will run first.

Q12) What happens if a start method is not invoked and the run method is directly invoked? Ans) If a thread has been instantiated but not started its is said to be in new state. Unless until a start() method is invoked on the instance of the thread, it will not said to be alive. If you do not call a start() method on the newly created thread instance thread is not considered to be alive. If the start() method is not invoked and the run() method is directly called on the Thread instance, the code inside the run() method will not run in a separate new thread but it will start running in the existing thread.

Q13) What happens when start() is called? Ans) A new thread of execution with a new call stack starts. The state of thread changes from new to runnable. When the thread gets chance to execute its target run() method starts to run.

Q14) If code running is a thread creates a new thread what will be the initial priority of the newly created thread? Ans) When a code running in a thread creates a new thread object , the priority of the new thread is set equal to the priority of the thread which has created it.

Q15) When jvm starts up, which thread will be started up first? Ans) When jvm starts up the thread executing main method is started.

Q16) What are the daemon threads? Ans) Daemon thread are service provider threads run in the background,these not used to run the application code generally.When all user threads(non-daemon threads) complete their execution the jvm exit the application whatever may be the state of the daemon threads. Jvm does not wait for the daemon threads to complete their execution if all user threads have completed their execution. To create Daemon thread set the daemon value of Thread using setDaemon(boolean value) method. By default all the threads created by user are user thread. To check whether a thread is a Daemon thread or a user thread use isDaemon() method. Example of the Daemon thread is the Garbage Collector run by jvm to reclaim the unused memory by the application. The Garbage collector code runs in a Daemon thread which terminates as all the user threads are done with their execution.

Q17) What all constructors are present in the Thread class? Ans) Thread()  Thread(Runnable target) Thread(Runnable target, String name) Thread(String name)

Q18) Can the variables or classes be Synchronized? Ans) No. Only methods can be synchronized.

Q19) How many locks does an object have? Ans) Each object has only one lock.

Q20) Can a class have both Synchronized and non-synchronized methods? Ans) Yes a class can have both synchronized and non-synchronized methods.

Q1) If a class has a synchronised method and non-synchronised method, can multiple threads execute the non-synchronised methods? Ans) Yes. If a class has a synchronised and non-synchronised methods, multiple threads can access the non-synchronised methods.

Q2) If a thread goes to sleep does it hold the lock? Ans) Yes when a thread goes to sleep it does not release the lock.

Q3)Can a thread hold multiple locks at the same time? Ans) Yes. A thread can hold multiple locks at the same time. Once a thread acquires a lock and enters into the synchronized method / block, it may call another synchronized method and acquire a lock on another object.

Q4) Can a thread call multiple synchronized methods on the object of which it hold the lock? Ans) Yes. Once a thread acquires a lock in some object, it may call any other synchronized method of that same object using the lock that it already holds.

Q5) Can static methods be synchronized? Ans) Yes. As static methods are class methods and have only one copy of static data for the class, only one lock for the entire class is required. Every class in java is represented by java.lang.Class instance. The lock on this instance is used to synchronize the static methods.

Q6) Can two threads call two different static synchronized methods of the same class? Ans) No. The static synchronized methods of the same class always block each other as only one lock per class exists. So no two static synchronized methods can execute at the same time.

Q7)Does a static synchronized method block a non-static synchronized method? Ans)No As the thread executing the static synchronized method holds a lock on the class and the thread executing the non-satic synchronized method holds the lock on the object on which the method has been called, these two locks are different and these threads do not block each other.

Q8) Once a thread has been started can it be started again? Ans) No. Only a thread can be started only once in its lifetime. If you try starting a thread which has been already started once an IllegalThreadStateException is thrown, which is a runtime exception. A thread in runnable state or a dead thread can not be restarted.

Q9) When does deadlock occur and how to avoid it? Ans) When a locked object tries to access a locked object which is trying to access the first locked object. When the threads are waiting for each other to release the lock on a particular object, deadlock occurs .

Q10) What is a better way of creating multithreaded application? Extending Thread class or implementing Runnable? Ans) If a class is made to extend the thread class to have a multithreaded application then this subclass of Thread can not extend any other class and the required application will have to be added to this class as it can not be inherited from any other class. If a class is made to implement Runnable interface, then the class can extend other class or implement other interface.

Q11) Can the start() method of the Thread class be overridden? If yes should it be overridden? Ans) Yes the start() method can be overridden. But it should not be overridden as it’s implementation in thread class has the code to create a new executable thread and is specialised.

Q12) What are the methods of the thread class used to schedule the threads? Ans) The methods are as follows: public static void sleep(long millis) throws InterruptedException public static void yield() public final void join() throws InterruptedException public final void setPriority(int priority) public final void wait() throws InterruptedException public final void notify() public final void notifyAll()

Q13) Which thread related methods are available in Object class? Ans) The methods are: public final void wait() throws Interrupted exception public final void notify() public final void notifyAll()

Q14) Which thread related methods are available in Thread class? Ans) Methods which are mainly used : public static void sleep(long millis) throws Interrupted exception public static void yield() public final void join() throws Interrupted exception public final void setPriority(int priority) public void start() public void interrupt() public final void join() public void run() public void resume()

Q15) List the methods which when called the thread does not release the locks held? Ans) Following are the methods. notify() join() sleep() yield()

Q16) List the methods which when called on the object the thread releases the locks held on that object? Ans) wait()

Q17) Does each thread has its own thread stack? Ans) Yes each thread has its own call stack. For eg Thread t1 = new Thread(); Thread t2 = new Thread(); Thread t3 = t1; In the above example t1 and t3 will have the same stack and t2 will have its own independent stack.

Q18) What is thread starvation? Ans) In a multi-threaded environment thread starvation occurs if a low priority thread is not able to run or get a lock on the resoruce because of presence of many high priority threads. This is mainly possible by setting thread priorities inappropriately.

Q19) What is threadLocal variable? Ans) ThreadLocal is a class. If a variable is declared as threadLocal then each thread will have a its own copy of variable and would not interfere with the other's thread copy. Typical scenario to use this would be giving JDBc connection to each thread so that there is no conflict. ThreadLocal class by JAVA API public class ThreadLocal {   public Object get();   public void set(Object newValue);   public Object initialValue(); } Implementation of ThreadLocal public class ConnectionDispenser {   private static class ThreadLocalConnection extends ThreadLocal {     public Object initialValue() {       return DriverManager.getConnection(ConfigurationSingleton.getDbUrl());     }   }   private static ThreadLocalConnection conn = new ThreadLocalConnection();     public static Connection getConnection() {       return (Connection) conn.get();     }   }

Q1) What is an inner class? Ans) Inner class is a class defined inside other class and act like a member of the enclosing class.

Q2) What are the different types of inner classes? Ans) There are two main types of inner classes – Static member class Inner class Member class Anonymous class Local class

Q3) What is static member class? Ans) A static member class behaves much like an ordinary top-level class, except that it can access the static members of the class that contains it. The static nested class can be accessed as the other static members of the enclosing class without having an instance of the outer class. The static class can contain non-static and static members and methods. public class InnerClass {       static class StaticInner {             static int i = 9;             int no = 6;             private void method() {}             public void method1() {}             static void method2() {}             final void method3() {}       } }       The static inner class can be accessed from Outer Class in the following manner: InnerClass.StaticInner staticObj= new InnerClass. StaticInner (); No outer class instance is required to instantiate the nested static class because the static class is a static member of the enclosing class.

Q4) What are non static inner classes? Ans) The different type of static inner classes are: Non - static inner classes – classes associated with the object of the enclosing class. Member class - Classes declared outside a function (hence a "member") and not declared "static". The member class can be declared as public, private, protected, final and abstract. E.g. public class InnerClass { class MemberClass { public void method1() { } } } Method local class – The inner class declared inside the method is called method local inner class. Method local inner class can only be declared as final or abstract. Method local class can only access global variables or method local variables if declared as final public class InnerClass { int i = 9; public void method1() { final int k = 6; class MethodLocal { MethodLocal() { System.out.println(k + i); } } } } Anonymous inner class - These are local classes which are automatically declared and instantiated in the middle of an expression.  Also, like local classes, anonymous classes cannot be public, private, protected, or static. They can specify arguments to the constructor of the superclass, but cannot otherwise have a constructor. They can implement only one interface or extend a class. Anonymous class cannot define any static fields, methods, or classes, except for static final constants. Also, like local classes, anonymous classes cannot be public, private, protected, or static Some examples: public class MyFrame extends JFrame { JButton btn = new JButton(); MyFrame() { btn.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { } }); } } Anonymous class used with comparator List l = new ArrayList(); l.add(new Parent(2)); l.add(new Parent(3)); Collections.sort(l, new Comparator() { public int compare(Object o1, Object o2) { Parent prt1 = (Parent) o1; Parent prt2 = (Parent) o2; if (prt1.getAge() > prt2.getAge()) { return -1; }else if(prt1.getAge() return 1; } else { return 0; } } });

Q5) Does a static nested class have access to the enclosing class' non-static methods or instance variables? Ans) No .

Q6)What are the advantages of Inner classes? Ans) The embedding of inner class into the outer class in the case when the inner class is to be used only by one class i.e. the outer class makes the package more streamlined. Nesting the inner class code where it is used (inside the outer class) makes the code more readable and maintainable. The inner class shares a special relationship with the outer class i.e. the inner class has access to all members of the outer class and still have its own type is the main advantages of Inner class. Advantage of inner class is that they can be hidden from the other classes in the same package and still have the access to all the members (private also) of the enclosing class. So the outer class members which are going to be used by the inner class can be made private and the inner class members can be hidden from the classes in the same package. This increases the level of encapsulation. If a class A is written requires another class B for its own use, there are two ways to do this. One way is to write a separate class B or to write an inner class B inside class A. Advantage of writing the inner class B in the class A is you can avoid having a separate class. Inner classes are best used in the event handling mechanism and to implement the helper classes. The advantage of using inner class for event handling mechanism is that the use of if/else to select the component to be handled can be avoided. If inner classes are used each component gets its own event handler and each event handler implicitly knows the component it is working for. e.g. Button btn1 = new Button("Submit"); Btn.addActionListener(new ActionListener(){/br> Public void actionPerformed(ActionEvent ae){ submitClicked(); } } ); The advantage of using static nested class is that to instantiate a static nested class you need not create an instance of the enclosing class which reduces the number of objects the application creates at runtime.

Q7)What are disadvantages of using inner classes? Ans) 1. Using inner class increases the total number of classes being used by the application. For all the classes created by JVM and loaded in the memory, jvm has to perform some tasks like creating the object of type class. Jvm may have to perform some routine tasks for these extra classes created which may result slower performance if the application is using more number of inner classes. 2. Inner classes get limited support of ide/tools as compared to the top level classes, so working with the inner classes is sometimes annoying for the developer.

Q8) What are different types of anonymous classes? Ans 1) Plain old anonymous class type one– e.g. class superClass{          void doSomething() {                   System.out.println(“Doing something in the Super class”);          }  } class hasAnonymous{                superClass anon = new superClass(){                        void doSomething() {                                System.out.println(“Doing something in the Anonymous class”);                      }             }; Here anon is the reference which is of type superClass which is the class extended by the anonymous class i.e. superclass of the anonymous class. The method doSomething() is the super class method overridden by the anonymous class. 2) Plain old anonymous class type two – interface Eatable{        public void prepareSweets();  } class serveMeal{  Eatable food = new Eatable(){               public void prepareSweets(){ //come implementation code goes here }      }; }  food is reference variable of type Eatable interface which refers to the anonymous class which is the implementer of the interface Eatable. The anonymous implementer class of the interface Eatable implements its method prepareSweets() inside it. 3) Argument defined anonymous class – e.g. interface Vehicle {    void getNoOfWheels();  } class Car {        void getType(Vehical v) { } } class BeautifulCars {         void getTheBeautifilCar() {              Car c = new Car ();              c.getType (new Vehicle () {                           public void getNoOfWheels () {                                  System.out.println("It has four wheels");                           }              });         }  }  Anonymous class is defined as the argument of the method getTheBeautifilCar(), this anonymous class is the implementer of the interface Vehicle. The method of class Car getTheBeautifilCar() expects the argument as an object of type Vehicle. So first we create an object of Car referenced by the variable ‘c’. On this object of Car we call the method getTheBeautifilCar() and in the argument we create an anonymous class in place which is the implementer of interface Vehicle hence of type Vehicle.

Q9) If you compile a file containing inner class how many .class files are created and what are all of them accessible in usual way? Ans) If a inner class enclosed with an outer class is compiled then one .class file for each inner class an a .class file for the outer class is created. e.g. class EnclosingOuter {     class Inner{ }  }  If you compile the above code with command % javac EnclosingOuter.java Two files EnclosingOuter.class EnclosingOuter$Inner.class will be created. Though a separate inner class file is generated, the inner class file is not accessible in the usual way like, % java EnclosingOuter$Inner

Q10) How to access the inner class from code within the outer class? Ans) The inner class is instantiated only through the outer class instance. class EnclosingOuter { private int noInnerClass = 1; public void getNoOfInnerClasses(){            Inner in = new Inner(); System.out.println(“No Of Inner classes is : “+ in.getNoOfClassesFromOuter()); } class Inner{ public int getNoOfClassesFromOuter(){ return noInnerClass; } }