Why the methods of the Math class are static? Its to reduce un-necessary object creation.

Generally utility class methods should be kept static. See if the methods of Math class are non static then you will have to create object of Math class every time and that object is of no use after method is called once. To reduce un necessary object creation and keep the garbage collector heap healthy method should be made static if they are utility methods.

Can we define an interface within an interface? Yes u can write interface within another interface. And if u want to implement inner interface u have to access it using outer_interface_name.inner_interface_name. eg. // abc.java interface abc { void show(); public interface xyz { void calc(); }}// InterfaceImpl.java public class InterfaceImpl implements abc.xyz { public void show() {System.out.println("Hi"); }public void calc(){} } What is the meaning of persistence? Persistence means 'to save'. In java, persistence is referred to saving the state of an object from memory to some other media (mostly permanent media such as hard disk, but it can be a database, a network stream etc. etc.). Hibernate is an Object to Relational mapping framework. It helps in persisting (or saving) and loading (a.k.a mapping) the state of objects in your application to a relational database management system. The reason it is so popular is because it is based on configuration files (also called as declarative programming). It generate all the boilerplate JDBC code for you, you just have to focus on the API's methods to persist the objects from your java programs. Is Java fully object oriented?

No... There is lot many reasons to say... Java supports OOP concepts partially... But not fully... The main aim of java is to avoid any complexity for programmers... So they avoided almost all the complexity from the OOP... Like multiple inheritance, friend functions, operator overloading... Etc...

Why interfaces cannot contain static methods whereas they can contain static variables? 1) Interface means, you can say that it is really incomplete.... that is the reason, you can not create the instances.... 2) In second point, the all methods in the interface are abstract method... Simply you can say, abstract methods are also the incomplete method. 3) And when the methods are incomplete, the class is also incomplete, so even for the abstract class which is partially incomplete, you can't create the object. Because it restricts the abstract methods to be called by object because they are abstract. 4) And you know very well, that, static methods do not need any object to be created to get called of. So directly they can be called as <classname>.<methodname>. 5) Now think, when the method is abstract (may be in abstract class or interface), and it is incomplete, and you invoke that method, then, how it can be used when it is incomplete???? So you can't use static. (When you use static with a method, you can call directly without creating an object). So you can't do it.

. Transient variable can't be final or static The modifier transient can be applied to field members of a class to turn off serialization on these field members. Every field marked as transient will not be serialized. You use the transient keyword to indicate to the Java virtual machine that the transient variable is not part of the persistent state of an object. Java classes often hold some globally relevant value in a static class variable. The static member fields belong to class and not to an individual instance. The concept of

serialization is concerned with the object's current state. Only data associated with a specific instance of a class is serialized, therefore static member fields are ignored during serialization (they are not serialized automatically), because they do not belong to the serialized instance, but to the class. To serialize data stored in a static variable one must provide class-specific serialization. Surprisingly, the java compiler does not complaint if you declare a static member field as transient. However, there is no point in declaring a static member field as transient, since transient means: "do not serialize and static fields would not be serialized anyway. On the other hand, an instance member field declared as final could also be transient, but if so, you would face a problem a little bit difficult to solve: As the field is transient, its state would not be serialized, it implies that, when you deserialize the object you would have to initialize the field manually, however, as it is declared final, the compiler would complaint about it. For instance, maybe you do not want to serialize your class' logger, then you declared it this way: private transient final Log log = LogFactory.getLog(EJBRefFactory.class); Now, when you deserialize the class your logger will be a null object, since it was transient. Then you should initialize the logger manually after serialization or during the serialization process. But you can't, because logger is a final member as well. How JVM performs Thread Synchronization? JVM associates a lock with an object or a class to achieve multithreading. A lock is like a token or privilege that only one thread can "possess" at any one time. When a thread wants to lock a particular object or class, it asks the JVM.JVM responds to thread with a lock maybe very soon, maybe later, or never. When the thread no longer needs the lock, it returns it to the JVM. If another thread has requested the same lock, the JVM passes the lock to that thread. If a thread has a lock, no other thread can access the locked data until the thread that owns the lock releases it. The JVM uses locks in conjunction with monitors. A monitor is basically a guardian in that it watches over a sequence of code, making sure only one thread at a time executes the code. Each monitor is associated with an object reference. It is the responsibility of monitor to watch an arriving thread must obtain a lock on the referenced object. When the thread leaves the block, it releases the lock on the associated object. A single thread is allowed to lock the same object multiple times. JVM maintains a count of the number of times the object has been locked. An unlocked object has a count of zero. When a thread acquires the lock for the first time, the count is incremented to one. Each time the thread acquires a lock on the same object, a count is incremented. Each time the thread releases the lock, the count is decremented. When the count reaches zero, the lock is released and made available to other threads.

In Java language terminology, the coordination of multiple threads that must access shared data is called synchronization. The language provides two built-in ways to synchronize access to data: with synchronized statements or synchronized methods. The JVM does not use any special opcodes to invoke or return from synchronized methods. When the JVM resolves the symbolic reference to a method, it determines whether the method is synchronized. If it is, the JVM acquires a lock before invoking the method. For an instance method, the JVM acquires the lock associated with the object upon which the method is being invoked. For a class method, it acquires the lock associated with the class to which the method belongs. After a synchronized method completes, whether it completes by returning or by throwing an exception, the lock is released. Two opcodes, monitorenter and monitorexit are used by JVM for accomplishing this task. When monitorenter is encountered by the Java virtual machine, it acquires the lock for the object referred to by objectref on the stack. If the thread already owns the lock for that object, a count is incremented. Each time monitorexit is executed for the thread on the object, the count is decremented. When the count reaches zero, the monitor is released. What is a class loader and what are its responsibilities? The Class loader is a subsystem of a JVM which is responsible, predominantly for loading classes and interfaces in the system. Apart from this, a class loader is responsible for the following activities: -Verification of imported types(classes and interfaces) -Allocating memory for class variables and initializing them to default values. Static fields for a class are created and these are set to standard default values but they are not explicitly initialized. The method tables are constructed for the class. -Resolving symbolic references from type to direct references The class loaders can be of two types: a bootstrap or primordial class loader and user defined class loaderEach JVM has a bootstrap class loader which loads trusted classes , including classes from Java API.JVM specs do not tell how to locate these classes and is left to implementation designers. A Java application with user defined class loader objects can customize class loading. These load untrustworthy classes and not an intrinsic part of JVM.They are written in Java, converted to class files and loaded into the JVM and installed like any other objects. . What is Early Binding? The assignment of types to variables and expressions at compilation time is known as 'Early Binding, it is also called 'static binding' and 'static typing'. ..

What is the difference between JVM and JRE? A Java Runtime Environment (JRE) is a prerequisite for running Java applications on any computer. A JRE contains a Java Virtual Machine (JVM), all standard, core java classes and runtime libraries. It does not contain any development tools such as compiler, debugger, etc. JDK (Java Development Kit) is a whole package required to Java Development which essentially contains JRE+JVM, and tools required to compile and debug, execute Java applications. Does a class inherit constructors from its superclass? . What is the difference between process and threads? A thread is part of a process; a process may contain several different threads. Two threads of the same process share a good deal of state and are not protected against one another, whereas two different processes share no state and are protected against one another. Two threads of the same process have different values of the program counter; different stacks (local variables); and different registers. The program counter, stack pointer, and registers are therefore saved in the thread table. Two threads share open files and memory allocation; therefore, file information and memory information (e.g. base/limit register or page table) is stored in the process table. Can an inner class be defined inside a method? Yes it can be defined inside a method and it can access data of the enclosing methods or a formal parameter if it is final. What is an anonymous class? It is a type of inner class with no name. Once defined an object can be created of that type as a parameter all in one line. it cannot have explicitly declared constructor. The compiler automatically provides an anonymous constructor for such class. An anonymous class is never abstract. An anonymous class is always an inner class; it is never static. An anonymous class is always implicitly final. What modifiers may be used with an inner class that is a member of an outer class? A (non-local) inner class may be declared as public, protected, private, static, final, or abstract. Why are wait(), notify(), and notifyAll() in the Object class?

Many new Java programmers ask this question when they're just starting out, and it's a good question. After all, these methods have something to do with threads, so why aren't they in the thread class? The answer is that Threads can use Objects to transmit messages from one thread to another, and these methods allow that to happen. A Thread calls wait() to say "I am waiting for a message to be sent to this object." Another thread can call notify() to say "I am sending a message to that object." The Object is therefore a conduit through which threads communicate without explicitly referencing each other. If the methods were in the Thread class, then two threads would need to have references to one another to communicate. Instead, all communicating threads just need to agree to use some specific shared resource. What is Composition and how it maps into a Java class A Composition is a tight Association and denotes "whole-part" relationship.So when an object is destroyed then all its constituents are also destroyed, these 'parts' have no meaning/sense in their lone existence from their 'whole'. The best example of Composition is a 'Human body' which is composed of two legs,two hands,two eyes,two ears and so on.During the lifetime of a human being,all organs make sense being part of whole,but once a human being is dead most of these parts are also dead,unless some of his body parts are not medically reused. Now come to map composition to Java world, the best example is garbage collection feature of the language.While garbage collecting objects, whole has the responsibility of preventing all its parts being garbage collected by holding some references to them. It is the responsibility of whole to protect references to its parts not being exposed to outside world.The only way to have true composition in Java is to never let references to internal objects escape their parent's scope. An example of Inner class as shown in the following code snippet may give you an idea how to implement Composition in Java. public class Human {public Human() {Brain brain = new Brain(); } private class Brain {.... ....

}}What is a Daemon thread? A ''daemon'' thread is one that is supposed to provide a general service in the background as long as the program is running, but is not part of the essence of the program. Thus, when all of the non daemon threads complete the program is terminated. Conversely, if there are any nondaemon threads still running the program doesn' t terminate. What is the difference between Serializable and Externalizable interface? java.io.Serializable interface is an empty interface with no methods and attributes.It is implemented by objects which are needed to be serialized and serves only to identify the semantics of being serializable. When process of serializing an object is to be controlled then Externalizable interface is used.The Externizable interface extends Serializable and adds two methods,writeExternal() and readExternal() which are automatically called during serialization and deserialization. Classes that require special handling during the serialization and deserialization process must implement special methods with these exact signatures: private void writeObject(java.io.ObjectOutputStream out) throws IOException private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException; What is memory leak? A memory leak occurs when all references (pointers) to a piece of allocated memory are overwritten, cleared, or pass out of scope. The result is that the program simply "forgets" about that particular piece of memory.Unfortunately , the operating environment (usually an OS) is not aware of the application's amnesia. That memory is treated by the outside world as though it still belongs to the application. The memory is therefore completely unavailable;it has "leaked". (In the worst case, the memory can become unavailable to all applications in the system, even if the application that created the leak is terminated. The memory can only be reclaimed by rebooting the system.) Explain StreamTokenizer? The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time. The parsing process is controlled by a table and a number of flags that can be set to various states. The stream tokenizer can recognize identifiers, numbers, quoted strings, and various comment styles. Each byte read from the input stream is regarded as a character in the range '\u0000' through '\u00FF'. The character value is used to look up five possible attributes of the character: white space, alphabetic, numeric, string quote, and comment character. Each character can have zero or more of these attributes. In addition, an instance has four flags. These flags indicate:

Whether line terminators are to be returned as tokens or treated as white space that merely separates tokens. Whether C-style comments are to be recognized and skipped. Whether C++-style comments are to be recognized and skipped. Whether the characters of identifiers are converted to lowercase. A typical application first constructs an instance of this class, sets up the syntax tables, and then repeatedly loops calling the nextToken method in each iteration of the loop until it returns the value TT_EOF. What is the purpose of Void class? - The Void class is an uninstantiable placeholder class to hold a reference to the Class object representing the primitive Java type void. Can an anonymous class implement an interface and extend a class at the same time? No, an anonymous class can either implement an interface or extend a class at a particular time but not both at the same time. Can protected or friendly features be accessed from different packages? No,when features are friendly or protected they can be accessed from all the classes in that package but not from classes in another package. How many ways can one write an infinite loop ? Personally I would recommend following ways to implement infinite loop in Java but their can be other ways like calling a method recursively , though I never tested that. - while (true) - for (;;) { } What is Exception ? An exception is an abnormal behavior existing during a normal execution of a program. For example: When writing to a file if there does not exist required file then an appropriate exception will be thrown by java code. What is a user-defined exception? For every project you implement you need to have a project dependent exception class so that objects of this type can be thrown so in order to cater this kind of requirement the need for user defined exception class is realized. for example: class MyException extends Exception { public MyException(){};

public MyException(String msg) { super(msg); } }What is the difference between Java class and bean? What differentiates Beans from typical Java classes is introspection. The tools that recognize predefined patterns in method signatures and class definitions can "look inside" a Bean to determine its properties and behavior. A Bean's state can be manipulated at the time it is being assembled as a part within a larger application. The application assembly is referred to as design time in contrast to run time. In order for this scheme to work, method signatures within Beans must follow a certain pattern in order for introspection tools to recognize how Beans can be manipulated, both at design time, and run time. How do you set Java library path programatically? Java library path can be set by choosing an option as:-Djava.library.path=your_path While setting the java.library.path property to "." instructs the Java virtual machine to search for native libraries in the current directory. And you execute your code as : java -Djava.library.path=. HelloWorld The "-D" command-line option sets a Java platform system property. But these values are 'read only' like many of the system properties, the value in java.library.path is just FYI and changing it doesn't actually change the behaviour of the JVM. If you want to load a library from a specific location, you can use System.load() instead with the full path to the library. What is a thread? A thread is most fundamental unit of a computer program which is under execution independent of other parts.A thread and a task are similar and often confused.An operating system executes a program by allocating it certain resources like memory,CPU cycles and when there are many a programs doing several things corresponding to several users requests.In such a scenario each program is viewed as a 'task' by OS for which it identifies an allocate resources. An OS treats each application e.g. Word Processor,spreadsheet,email client etc as a separate task , if a certain program initiates some parallel activity e.g. doing some IO operations,printing then a 'thread' will be created fro doing this job.