Java Programming

You use loops in Java when you want a set of actions to be repeated until a particular condition is met or for a certain number of times.

The different types of loops in Java are:

• For Loops
• Do-While Loops
• While Loops

An interface is a collection of methods that must be implemented by the implementing class.

An interface defines a contract regarding what a class must do, without saying anything about how the class will do it.

Interface can contain declaration of methods and variables.

implementing class must define all the methods declared in the interface

If a class implements an interface and does not implement all the methods then class itself must be declared as abstract

Variables in interface automatically become static and final variableof the implementing class

Members of interface are implicitly public, so need not be declared as public.

An interface must be implemented in class.

One first basic rule is that you should use the for loop when the number of iterations is known. For instance:

• The loop iterates over the elements of a collection.
• The loop iterates over a range of values which is known in advance at execution time.
• The object provides a way to iterate over its elements with a for statements (e.g files).

The while loop is the more general one because its loop condition is more flexible and can be more complicated than that of a for loop. The condition of a for loop is always the same and implicit in the construction. A for loop stops if there are no more elements in the collection to treat. For simple traversals or iterations over index ranges it is a good advice to use the for statement because it handles the iteration variable for you, so it is more secure than while where you have to handle the end of the iteration and the change of the iteration variable by yourself.

The while loop can take every boolean expression as condition and permits therefore more complex end conditions. It is also the better choice if the iteration variable does not change evently by the same step or if there are more than one iteration variable. Even if you can handle more than one iteration variable in a for statement, the collections from which to choose the values must have the same number of elements.

Note: In C 'for' and 'while' can be easily replaced by each other:

while (exp) stmt

for (;exp;) stmt

for (exp1;exp2;exp3) stmt

{ exp1; while (exp2) { stmt exp3}}

Thread.sleep(long milliseconds): The thread's sleep method sends the current thread into Non-Runnable state for the specified amount of time. But, this doesn't cause the thread to loose ownership of the acquired monitors. So, if the current thread is into a synchronized block/method, then no other thread will be able to enter that block/method.

The Sleep method throws 'InterruptedException' if another thread interrupts it.

There is another variant of the 'sleep()' method where it accepts two arguments - one, long milliseconds, and second, int nanoseconds. Simply put, this method causes the current thread to sleep for the specified number of milliseconds plus the specified number of nanoseconds. The second argument 'int nanoseconds' can acquire a value of the range 0-999999.

wait() method: The wait() method also sends the current thread into Non-Runnable state like the sleep() method. But, the difference between the two is that in case of 'wait()' the locks are released before going into Non-Runnable state, so that any other thread that is waiting on the object can use it (Unlike the Sleep method - This is the big difference) Another apparent difference is that 'wait()' is an instance method, while sleep() is a static method. The method 'wait()' should be called for an object only when the current thread has already acquired lock for that object. This causes the current thread to wait either another thread invokes the 'notify()' method or the 'notifyAll()' method for this object, or a specified amount of time has elapsed and after that the thread starts participating in thread scheduling process to acquire the monitor of the object to proceed further.

There are three variants of this method in the 'Object' class:-

public final void wait(long timeout)

public final void wait(long timeout, int nanoseconds)

public final void wait()

All the three methods throw InterruptedException & IllegalMonitorStateException. The first two may also throw IllegalArgumentException.

The wait() method causes the current thread to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. After the execution of this method invocation, the thread becomes disabled for any scheduling purposes and lies dormant until one of the following things happen:-

* Any other thread invokes 'notify()' method this object and the thread under consideration is arbitrarily chosen as the thread to be awakened. * Any other thread invokes 'notifyAll()' for this object. * Any other thread interrupts the thread under consideration. * The specified amount of time has elapsed (in case first two variants of wait() are used) After any of the four above mentioned events happens, the thread is removed from the wait set for this object and re-enabled for thread scheduling. It'll compete for the rights to synchronize on the object in an usual manner and it'll keep doing this until it acquires control on the object and gains all the synchronization claims on the object, which it had acquired at the time of 'wait()' invocation. This means that after the return from wait() method, the synchronization state of object and of the thread will be exactly the same as it was before the wait() invocation.

• Character or small integer
• Short Integer
• Integer
• Long integer
• Boolean
• Floating point numbers
• Double precision floating point number
• Long double precision floating point number
• Wide character

To get a better idea on C++ data types, see related links below.

No one can force garbage collector to free memory, A java object is subjected to garbage collection when it can not be reached by the program in which it is being used. Programmer can request for garbage collection by System.gc() but JVM doesn't guarantee that is will start immediately

Actually, the specific method for GC and how it will be run is dependent on the JVM implementation being used.

For instance, Sun (now Oracle)'s Hotspot JVM has several different GC designs, one of which (the RealTime engine) can be immediately triggered via a System.gc() call. Each type of GC will have different triggers and thresholds as to when it will be run, which allows the user to pick the GC option that they think will be least disruptive and most effective for their particular application.

You must read the JVM documentation for your particular VM to see what available GC options there are, how each GC method works, and what the various thresholds are.

Object Oriented programming is a superset of structured programming. Structured programming is as follows:

--Program start

var

var

var

function { ... }

function { ... }

function { ... }

main { ... }

--- Program End

You have units of code, which operate on variables, and are called in reference to those variables, to follow a structure acting on those variables.

Object oriented is as follows:

--- Program Start

object {

var

var

function { ... }

function { ... }

function { ... }

}

var

var

function { ... }

main { ... }

--- Program end

Variables can be objects, which have their own data and functions. Think like C and structures, except structures can have functions "in them" which operate specificly on their own data. Thus, instead of referencing a function (a block of code) and telling it to operate on a variableq you reference an object and tell it to perform an operation, most often on itself, specific to itself, using its own data. Instead of creating units of data to pass to functions which operate on them, you create objects and have them perform operations [on themselves].

Functions attached to objects don't need a specific name; rather than task_struct_sort_children(task) and acl_rules_struct_sort_children(task), you can have task and acl_rules with task->sort_children() and acl_rules->sort_children(), which have completely different specific function but the same logical function, and operate on the specific instance of the object.

structured oriented programming and object oriented programming have some features of similarities, but the distinction between the two is that the former relies to the GOTO statements thus the developer has a tendency to confuse while the latter is subgrouped from objects, classes, methods and hierarchies.