Java interview questions and answers for freshers and experienced

JVM stands for Java Virtual Machine. Its an abstract computer or virtual computer which runs the compiled java programs. Actually JVM is a software implementation which stands on the top of the real hardware platform and operating system. It provides abstraction between the compiled java program and the hardware and operating system. So the compiled program does not have to worry about what hardware and operating system he has to run in, its all handled by the JVM and thus attaining portability. All Java programs are compiled in to bytecodes. JVM can only understand and execute Java bytecodes. we can visualize Java bytecodes as machine language for JVM. Java compiler takes the .java files and compiles it to a bytecode file with .class file extension. Compiler generates one class file for one source file.

advertisements

When JVM compiles the class file he does not compile the full class file in one shot. Compilation is done on function basis or file basis. Advantage gained from this is that heavy parsing of original source code is avoided. Depending on need basis the compilation is done. This typ of compilation is termed as JIT or Just-in- Time compilation.

nheritance is implemented by using EXTEND” keyword.

Polymorphism is the capability of an action or method to do different things based on the object that it is acting upon. There are two types of polymorphism:-
Method Polymorphism through overloading.
Object polymorphism by inheritance / interfaces.

Packages group related classes and interfaces together and thus avoiding any name conflicts. From OOPs point of view packages are useful for grouping related classes together. Classes are group together in a package using package” keyword.

instanceof ” keyword is used to check what is the type of object. F

There may be times when we want to call subroutines which are written in some other language other than Java like C++, VB6 etc.

Garbage collection is the process of automatically freeing objects that are no longer referenced by the program. This frees the programmer from having to keep track of when to free allocated memory, thereby preventing many potential bugs. Thus making programmers more productive as they can now put more effort in coding rather than worrying about memory management.

The only disadvantage of garbage collector is it adds overheads. Because the JVM (Java virtual machine) has to keep a constant track of the objects which are not referenced and then free these unreferenced objects on fly. This whole process has a slight impact on the application performance. But garbage collector has a good algorithm and it runs in its own thread thus having a least impact on the application performance but still it has some impact.

Garbage collector can be run forcibly using System.gc()” or Runtime.gc()”

javap disassembles compiled Java files and spits out representation of the Java program. This is a useful option when the original source code is not available.

Applets are small applications that are accessed from web server automatically installed, and run from the browser. Once an applet arrives on the client it has limited access to resources thus ensuring security for the end user. An applet is controlled by the software that runs it. Usually, the underlying software is a browser, but it can also be applet viewer. If you run the applet source code from eclipse it runs inside an applet viewer. All applets should inherit from applet class.
Below are sequences of events which occur in applet:-
The init Method: The init method is called when the applet is first loaded. Init method can be used to initialize color, fonts or any type of one type operation needed for the applet.
The start Method: The start method is called when user visits a browser with an applet on it. In start method applet spawns a thread in which it runs the paint method.
paint() is called every time when applet has to re-display everything. paint() event can occur due to various reasons some of the reasons are :-.

Applet classes are located in " java.applet "package.

System.arraycopy(myOldArray, 0, myNewArray, 0, length);+

There are six interfaces and come under two different inheritance group one which comes under the collection interface root and the other in the map interface root.

Collection
Its the base of all collection classes. It provides a unified way to manipulate collection objects. Collection has group of object called as elements. These elements can be accessed and manipulated using Iterator. List
In List interface the elements are arranged sequentially. Elements can be inserted in to any location and you can also insert duplicate elements. In order to access the elements you need to use the ListIterator”. Using ListIterator” you can move back and forth which makes it unique as compared to other iterators.
Set
It represents a collection but no duplicates are allowed in this case.
SortedSet
It extends the Set interface and sorts the set in ascending order.
Map
Map stores association between keys and value pairs. So given a key you can easily find the value. One thing important to note is they do not implement iterable interface. But yes you can obtain a collection view of the map which allows you loop using for loop.
SortedMap
t Extends Map so that the keys are maintained in ascending order.

Vector / HashTable are synchronized which means they are thread safe. Cost of thread safe is performance degradation. So if you are sure that you are not dealing with huge number of threads then you should use ArrayList / HashMap.But yes you can still
synchronize List and Maps using Collections provided methods :-
List OurList = Collections.synchronizedList (OurList);
Map OurMap = Collections.synchronizedMap (OurMap);

StringBuffer is a peer class of String that provides almost all functionality of strings. String represents fixed-length, immutable character sequences. Comparatively StringBuffer represents mutable, growable and writeable character sequences. But StringBuffer does not create new instances as string so its more efficient when it comes to intensive concatenation operation.

Javadoc parses comments in JAVA source files and produced HTML pages for the same. Below is the syntax for the same javadoc [ options ] [ packagenames ] [ sourcefiles ] [ @files ] Arguments can be in any order. Options Command-line options that is doctitle, windowtitle, header, bottom etc
Packagenames: -
A series of names of packages, separated by spaces, such as java.lang java.lang.reflect java.awt. You must separately specify each package you want to document. Javadoc uses -sourcepath to look for these package names. Javadoc does not recursively traverse subpackages.
sourcefiles :-
A series of source file names, separated by spaces, each of which can begin with a path and contain a wildcard such as asterisk (*). The path that precedes the source file name determines where javadoc will look for it. (Javadoc does not use -sourcepath to look for these source file names.)
@files: - One or more files that contain packagenames and sourcefiles in any order, one name per line.

In one of our old JAVA projects we had an inheritance depth of five. Believe us we never liked that code. Its bad to have a huge inheritance depth. A maintainable inheritance depth should be maximum 5. Anything above that is horrible. There is no limit as such specified anywhere that there is some limit on the inheritance sub classing . But depending on environments you will get stack over flow error.