The Bytecode

No, constructors cannot be final.

Abstract classes are similar to interfaces. You cannot instantiate them, and they may contain a mix of methods declared with or without an implementation. However, with abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods. With interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public. In addition, you can extend only one class, whether or not it is abstract, whereas you can implement any number of interfaces.
http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html

Constructors must have the same name as the class and can not return a value. They are only called once while regular methods could be called many times.

Yes. Use this() syntax.

If a subclass provides a specific implementation of a method that is already provided by its parent class, it is known as Method Overriding. It is used for run-time polymorphism and to provide the specific implementation of the method.

Each field and method has an access level: • private: accessible only in this class • (package): accessible only in this package • protected: accessible only in this package and in all subclasses of this class • public: accessible everywhere this class is available Similarly, each class has one of two possible access levels: • (package): class objects can only be declared and manipulated by code in this package • public: class objects can be declared and manipulated by code in any package

Synchronized blocks place locks for shorter periods than synchronized methods.

You can't force GC, but could request it by calling System.gc(). JVM does not guarantee that GC will be started immediately.

If you assign a superclass object to a variable of a subclass's data type, you need to do explicit casting. For example: Object a; Customer b; b = (Customer) a; When you assign a subclass to a variable having a supeclass type, the casting is performed automatically.

Wrapper class is wrapper around a primitive data type. An instance of a wrapper class contains, or wraps, a primitive value of the corresponding type. Following table lists the primitive types and the corresponding wrapper classes:
Primitive Wrapper
boolean java.lang.Boolean
byte java.lang.Byte
char java.lang.Character
double java.lang.Double
float java.lang.Float
int java.lang.Integer
long java.lang.Long
short java.lang.Short
void java.lang.Void

Thread.sleep() causes the current thread to suspend execution for a specified period. However, these sleep times are not guaranteed to be precise, because they are limited by the facilities provided by the underlying OS.
Object.wait() causes the current thread to wait until either another thread invokes the notify() method or the notifyAll() method for this object, or a specified amount of time has elapsed.

"The Thread.sleep method is not guaranteed to be precise so it may not be exactly the specified duration. Also, sleep can end early if the thread is interrupted. I think it would be more correct to say sleep suspends execution at least the specified time unless interrupted and wait suspends up to the specified time." Brooks Hagenow

Java Vector class is internally synchronized and ArrayList is not.

Yes. We can add a main() method to the applet.

I'd use the method equals() to compare the values of the Strings and the == to check if two variables point at the same instance of a String object.

Yes, it does. The FileNoFoundException is inherited from the IOException. Exception's subclasses have to be caught first.

It's possible if these variables are final.

A single ampersand here would lead to a NullPointerException.

Stacks works by last-in-first-out rule (LIFO), while queues use the FIFO rule.

StringBuffer is faster and more memory efficient than String for concatenation.

Use the following syntax: super.myMethod(); To call a constructor of the superclass, just write super(); in the first line of the subclass's constructor.

A collection is a group of objects. java.util package provides important types of collections. There are two fundamental types of collections they are Collection and Map. Collection types hold a group of objects, Eg. Lists and Sets where as Map types hold group of objects as key, value pairs Eg. HashMap and Hashtable.

Sometimes. But your class may be a descendent of another class and in this case the interface is your only option.

StringBuffer is synchronized whereas StringBuilder is not synchronized.

Collection is an interface whereas Collections is a class. Collection interface provides normal functionality of data structure to List, Set and Queue. But, Collections class is to sort and synchronize collection elements.

Deadlock is a situation when two threads are waiting on each other to release a resource. Each thread waiting for a resource which is held by the other waiting thread.

hashCode() method.

ArrayList

Have this class implement Cloneable interface and call its method clone().

You do not need to specify any access level, and Java will use a default package access level.

When i want child class to implement the behavior of the method.

Yes, We can call a abstract method from a Non abstract method in a Java abstract class.

Checked exceptions must be caught using try .. catch() block or we should be declared using 'throws' clause. If you don't, compilation of the program will fail. However unchecked exceptions let the program compile but might cause a run-time exception after compilation.

In some types of applications you have to write the code to serialize objects, but in many cases serialization is performed behind the scenes by various server-side containers. These are some of the typical uses of serialization:
• To persist data for future use.
• To send data to a remote computer using such client/server Java technologies as RMI or socket programming.
• To "flatten" an object into array of bytes in memory.
• To exchange data between applets and servlets.
• To store user session in Web applications.
• To activate/passivate enterprise java beans.
• To send objects between the servers in a cluster.

There are two ways to create new kinds of threads:
- Define a new class that extends the Thread class
- Define a new class that implements the Runnable interface, and pass an object of that class to a Thread's constructor.
- An advantage of the second approach is that the new class can be a subclass of any class, not just of the Thread class.