What happens if an exception is not caught
An uncaught exception results in the uncaughtException() method of the thread’s ThreadGroup being invoked, which eventually results in the termination of the program in which it is thrown.
What happens if a try-catch-finally statement does not have a catch clause to handle an exception that is thrown within the body of the try statement
The exception propagates up to the next higher level try-catch statement (if any) or results in the program’s termination.
What is the catch or declare rule for method declarations
If a checked exception may be thrown within the body of a method, the method must either catch the exception or declare it in its throws clause.
How can a sub-class of Serializable super class avoid serialization? If serializable interface is implemented by the super class of a class, how can the serialization of the class be avoided
In Java, if the super class of a class is implementing Serializable interface, it means that it is already serializable. Since, an interface cannot be unimplemented, it is not possible to make a class non-serializable. However, the serialization of a new class can be avoided. For this, writeObject () and readObject() methods should be implemented in your class so that a Not Serializable Exception can be thrown by these methods. And, this can be done by customizing the Java Serialization process. Below the code that demonstrates it
class MySubClass extends SomeSerializableSuperClass {
private void writeObject(java.io.ObjectOutputStream out)
throws IOException {
throw new NotSerializableException(“Can not serialize this class”);
}
private void readObject(java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException {
throw new NotSerializableException(“Can not serialize this class”);
}
private void readObjectNoData()
throws ObjectStreamException; {
throw new NotSerializableException(“Can not serialize this class”);
}
}
How will you handle the checked exceptions ?
: You can provide a try/catch block to handle it. OR
Make sure method declaration includes a throws clause that informs the calling
method an exception might be thrown from this particular method
When you extend a class and override a method, can this new method throw
exceptions other than those that were declared by the original method
No it cannot throw, except for the subclasses of those exceptions
In what sequence does the finally block gets executed
: If you put finally after a try block without a matching catch block then it will be
executed after the try block
If it is placed after the catch block and there is no exception then also it will be
executed after the try block
If there is an exception and it is handled by the catch block then it will be executed
after the catch block
What are the common data structures, and where would you use them? How you would go about implementing your own List, Set, and Map
Many leave out Trees and Graphs. Trees and Graphs are very useful data structures as well.Whilst it is not recommended to write your own implementation when Java provides proven and tested implementations, the interviewer is testing your understanding on data structures. My book entitled “Core Java Career Essentials” covers this in more detail with diagrams, examples, and code.
Here are the common data structures.
Arrays are the most commonly used data structure. Arrays are of fixed size, indexed, and all containing elements are of the same type (i.e. a homogenous collection). For example, storing employee details just read from the database as EmployeeDetail[ ], converting and storing a string as a byte array for further manipulation or processing, etc. Wrap an array in a class to protect it from being inadvertently altered. This would be true for other data structures as well.
Lists are known as arrays that can grow. These data structures are generally backed by a fixed sized array and they re-size themselves as necessary. A list can have duplicateelements. For example, adding new line items to an order that stores its line items as a list, removing all expired products from a list of products, etc. Initialize them with an appropriate initial size to minimize the number of re-sizes
Sets are like lists but they do not hold duplicate elements. Sets can be used when you have a requirement to store unique elements.
Stacks allow access to only one data item, which is the last item inserted (i.e. Last In First Out – LIFO). If you remove this item, you can access the next-to-last item inserted, and so on. The LIFO is achieved through restricting access only via methods like peek( ), push( ), and pop( ). This is useful in many programing situations like parsing mathematical expressions like (4+2) * 3, storing methods and exceptions in the order they occur, checking your source code to see if the brackets and braces are balanced properly, etc.
The LIFO access mechanism used by a stack has many practical uses. For example, Evaluation of expressions / syntax Parsing, validating and parsing XML, undo sequence in a text editor, pages visited history in a web browser, etc. Java interview questions and answers on stack data structure.
Queues are somewhat like a stack, except that in a queue the first item inserted is the first to be removed (i.e. First In First Out – FIFO). The FIFO is achieved through restricting access only via methods like peek( ), offer( ), and poll( ). For example, waiting in a line for a bus, a queue at the bank or super market teller, etc.
LinkedLists are data structures made of nodes, where each node contains data and a reference to the next node, and possibly to the previous node as well for a doubly linked list. For example, a stack or queue can be implemented with a linked list or a doubly linked list because you can insert and delete at both ends. There would also be other situations where data will be frequently inserted and deleted from the middle. The Apache library provides a TreeListimplementation, which is a good replacement for a LinkedList as it performs much better than a LinkedList at the expense of using a little more memory. This means a LinkedList is rarely a good choice of implementation.
ArrayList is a good general purpose list implementation. An ArrayList is faster than a TreeList for most operations except inserting and removing in the middle of the list. A TreeList implementation utilizes a tree structure internally to ensure that all insertions and removals are O(log n). This provides much faster performance than both an ArrayList and a LinkedListwhere elements are inserted and removed repeatedly from anywhere.
class Link
{
private int id; // data
private String name; // data
private Link next; // reference to next link
}
HashMaps are amortized constant-time access data structures that map keys to values. This data structure is backed by an array. It uses a hashing functionality to identify a location, and some type of collision detection algorithm is used to handle values that hash to the same location. For example, storing employee records with employee number as the key, storing name/value pairs read from a properties file, etc. Initialize them with an appropriate initial size to minimize the number of re-sizes.
Trees are the data structures that contain nodes with optional data elements and one or more child elements, and possibly each child element references the parent element to represent a hierarchical or ordered set of data elements. For example, a hierarchy of employees in an organization, storing the XML data as a hierarchy, etc. If every node in a tree can have utmost 2 children, the tree is called a binary tree. The binary trees are very common because the shape of a binary tree makes it easy to search and insert data. The edges in a tree represent quick ways to navigate from node to node.
list.
Java does not provide an implementation for this but it can be easily implemented as shown below. Just make a class Node with an ArrayList holding links to other Nodes.
package bigo;
import java.util.ArrayList;
import java.util.List;
public class Node {
private String name;
private List<node> children = new ArrayList<node>( );
private Node parent;
public Node getParent( ) {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
public Node(String name) {
this.name = name;
}
public void addChild(Node child) {
children.add(child);
}
public void removeChild(Node child) {
children.remove(child);
}
public String toString( ) {
return name;
}
}
Graphs are data structures that represent arbitrary relationships between members of any data sets that can be represented as networks of nodes and edges. A tree structure is essentially a more organized graph where each node can only have one parent node. Unlike a tree, a graph’s shape is dictated by a physical or abstract problem. For example,nodes (or vertices) in a graph may represent cities, while edges may represent airline flight routes between the cities.
To make a Java graph class, you will have to work out the way in which the information can be stored and accessed. A graph will be using some of the data structures mentioned above. The Java API does not provide an implementation for this. But there are a number of third party libraries like JUNG, JGraphT, and JDSL (does not seem to support generics).The book “Core Java Career Essentials” covers working examples using Java.
What is the importance of init() method in Servlet?
The init method is designed to be called only once. It is called when the servlet is first created, and not called again for each user request. So, it is used for one-time initializations, just as with the init method of applets.
The servlet is normally created when a user first invokes a URL corresponding to the servlet, but you can also specify that the servlet be loaded when the server is first started.
When a user invokes a servlet, a single instance of each servlet gets created, with each user request resulting in a new thread that is handed off to doGet or doPost as appropriate. The init() method simply creates or loads some data that will be used throughout the life of the servlet.
The init method definition looks like this:
public void init() throws ServletException
{
// Initialization code…
}
How to find the load location of a Java class file at run-time
There are two ways to find it:
Using Classloader
Below code snippet can be used to find the location of java class
com.fromdev.MyClass
this.getClass().getClassLoader().getResource(“com/fromdev/MyClass.class”)
Using Protection Domain
We can use this to find the exact location a jar file containing the class JVM is using
clazz.getProtectionDomain().getCodeSource().getLocation()
How Java handles Two classes with same name in classpath
If I have two classes with same name say MyClass.java in two different jar in my classpath which one will be picked up by JVM , is there anyway I can suggest JVM to pick a specific one ?
Java interpreter loads classes based on the order they are specified in the CLASSPATH variable.
For example, lets say this is your classpath variable value
C:ProjectDir1;C:ProjectDir2
The Java interpreter will first look for MyClass class in the directory C:ProjectDir1. Only if it doesn’t find it in that directory it will look in the C:ProjectDir2 directory.
How to Add A Jar File To Java Load Path At Run Time
This can done by use of URLClassloader. A sample implementation of this code is shown below
import java.net.URL;
import java.net.URLClassLoader;
public class SimpleJarLoader {
public static void main(String args[]) {
if (args.length < 2) {
System.out.println(“Usage: [Class name] [Jar Path]”);
return;
}
try {
System.out.println(“Trying to load the class…”);
Class.forName(args[0]);
} catch (Exception ex) {
System.out.println(“Not able to load class…” + args[0]);
}
try {
String url = “jar:file:/” + args[1] + “!/”;
URL urls[] = { new URL(url) };
URLClassLoader cl = new URLClassLoader(urls,
SimpleJarLoader.class.getClassLoader());
System.out.println(“Looking into jar… ” + url);
cl.loadClass(args[0]);
System.out.println(“Woohoo….I found it”);
} catch (Exception ex) {
System.out.println(“Oops…Still cant find the jar”);
ex.printStackTrace();
}
}
}
You can run this code by below command. (Make sure to use forward slash “/” as directory separator.)
java SimpleJarLoader org.springframework.core.SpringVersion C:/spring.jar
The output is like this
Trying to load the class…
Not able to load class…org.springframework.core.SpringVersion
Looking into jar… jar:file:/C:/spring.jar!/
Woohoo….I found it
Is it legal for the extending class which overrides a method which throws an exception, not o throw in the overridden class
Yes it is perfectly legal