The Way Java Works

The goal is to write one application (in this example, an interactive party Invitation) and
have it work on whatever device your friends have.

Source file  Compiler  Java Byte code file  Interpreted by any machine having

JVM  Produce Output file.

What You'll Do In Java

You'll type a source code file, compile It using the Javac complier, then run the complied
byte code on a Java virtual machine.

A Brief History of Java

Java 1.02 ======== 250 classes, Slow, Applets were the big things
Java 1.1 ========= 500 classes, Little Faster, Better GUI
Java 2 ========= 2300 classes, Versions 1.1 – 1.4, much faster, powerful,
J2SE-J2ME-J2EE, popular for web and mobile application.
Java 5 ========= 3500 classes, Version 1.5 and up, more faster, powerful, easier
for programmers and features from other languages added.

Anatomy of Class
public class MyFirstClass
{
public static void main (String args[])
{
System.out.println(“Hi Boss…!!”);
}
}

Running a Java Program

Running a java program means telling JVM to load the compiler generated java byte code
file (.class) file and then start executing its main method till all the code in main is finished.

Q) Why does everything have to be in a class?

A: Java is an object-oriented (00) language. It's not like the old days when you had steam
driven compliers and wrote one monolithic source file with a pile of procedure.
What is the Difference between a Class &
Object?
Class is a mould / template which tells JVM how to make an object of particular type. For
example you can have Button Class to create n no.of button objects and each button
object might have its own color, size , features.

Notes:-
• A Java application is nothing but objects calling other objects.
• The purpose of main() method is to launch the java application.
• The ‘instance variables’ are class variables.
• The ‘local variables’ are method variables.

Garbage Collection:
Each time object is created, it goes into HEAP MEMORY. When system is running out of
memory, JVM runs garbage collector which removes unreachable objects and free up
memory space.

Notes:
• myObj.bark() == means use the object referenced by myObj variable to invoke
the bark method.
• Difference between INSTANCE VARIABLE and LOCAL VARIABLE is that local
variables do not get default value. They must be initialized b4 its use.

Inheritance:
Somethinf will come here…

Polymorphism:
* Why we need abstract classes?
Ans: While doing Inheritance we need certain classes, such as Animal class which is
extended by child classes such as Tiger, Deer, Hippopotamus, etc. Here we need objects
of Tiger, Deer, Hippopotamus; but object of Animal Class isn’t required. To prevent such
classes from being instantiated we need to make these classes Abstract. By writing
keyword abstract .
Declarating class Animal As Abstract :

abstract class Canine extends Animal {

public void roam() { }
}

* What is concrete class?

Ans: A class which is not abstract is a concrete class.

* Why we need abstract methods?

Ans: All abstract methods must be overridden. Abstract methods do not contain body. A
class must be marked as abstract if it has any abstract method. Now why we need abstract
method, we need an abstract method for Polymorphism. That means the first concrete
class in the Inheritance tree must implement all the abstract methods. Here implement
means must provide body to methods.

* Why we use instance of operator?

Ans: We use instanceof operator to check the particular object for its instance.
if (o instanceof Dog) {
Dog d = (Dog) o;
}

Using this, ClassCastException can be avoided.

* Why multiple inheritances are not allowed in Java?

Ans: To avoid the problem of Deadly Diamond of Death, multiple inheritance is not
allowed. Which method of two parent classes (multiple parent classes in multiple
inheritance) will run, is a problem.

* Why we need interfaces?

Ans: Interfaces solves the problem of Deadly Diamond of Death introduced by the
multiple inheritance. The Interface gives the benefit of the multiple inheritance. All the
methods of interface are abstract so that the the first concrete subclass implements the
method and that’s why at runtime JVM is not confused which method to run.
Interface is 100% abstract class.

* When to make a class, sub-class, abstract class and interface?

Ans: Class, when your class doesn’t extend anything and it does not pass IS-A test.
Sub-Class, when you make more specific version of a class by adding / overriding
behavior of the class. Abstract Class, when you need to prevent the class from being
instantiated and it is a template kind of thing for subclasses containing some
implementation code that group of subclasses can use. Interface, when you need to
define the role of the class. (in case of multiple inheritance).
Static Modifier:
* Why static method cannot access non-static instance variables?
Ans: The static method does not know which instance’s variable value to use as there
may be many instance variables on the heap. As a result static methods cannot use non-
static methods also.

* Why we need static variables?

Ans: Static Variables has same value for all instances of the class i.e. 1 value per class.

* When the class is loaded?

Ans: Class is loaded when new instance of the class is created for the first time or static
method / variable is used. Then JVM loads the class. Static variables are initialized
when the class is loaded.

* Keyword final when used for variable, method and class?

Ans: Final Variable, means its value cannot be changed. Final Method, means it cannot
be overridden. Final Class means, it cannot be extended.

Exception
* What are checked and unchecked exceptions?
Ans:

* What is the difference between throw and throws?

Ans:

* If you don’t want to handle the exception, what will you do?
Ans: Exception works on HANDLE or DECLARE concept. If you don’t want to handle
the exception, you can duck it by declaring it. The method with a risky code THROWS
exception and its calling method will follow HANDLE or DECLARE law. It goes till
main () method, if that too doesn’t handle it and duck it by declaring then it will go to
JVM and JVM will shut down.
Object Synchronization
* Why we need to save Objects?
Ans: Objects have state and behavior. Sometimes we need to save the state of java
program. For example Java game, etc. there you need to save Objects.

* How to save the state of Java program?

Ans:

Servlets
* What is web server?
Ans: It is a computer program that delivers (serves) the content like web pages using
HTTP over web. It can be a computer or virtual machine running the program. Popular
web servers are Apache, Microsoft’s Internet Information Server, Google’s GWS
(Google Web Server).

* What is application server?

Ans: It is software platform that delivers applications to the client computers or devices.
It has components accessible to developer through API. It is used to generate dynamic
pages, clustering, load balancing, etc. Popular application servers are Tomcat(Apache),
JBoss(Red Hat), Weblogic(Oracle), Webspher Application Server(WAS), etc.

* What is Servlet?
Ans: It is a java program that generates dynamic content and interacts with web clients
using request-response paradigm. We need servlets because, they inherits security from
web container, they maintain session for end-user, enhance server performance by
preventing frequent disk access.

* What does web container do?

Ans: It does,
1. LOAD the Servlet class
2. INSTANTIATES the Servlet
3. INITIALIZES the Servlet instance
4. PASSES request to the Servlet instance
5. SENDS response.
* What is HTTP? Give difference between stateless & stateful protocol.
Ans: It is a application layer protocol, used to exchange information in request-response
form. HTTPS is another URI scheme which tells browser to use added encryption layer
of SSL to protect traffic.

The difference is in the nature of the connection they define between a client and a
server.Telnet and FTP, for example are stateful protocols

The client connects to the server, conducts a series of operations via that conneciton, and
then disconnects.Then server can associate all of the requests together and knows that thy
all came from the same user.

In internet jargon, the server associates a state with the connection

-it remembers who the user is, and what it is that they are doing.For example, when u
FTP to mama, u as a client request a file for download, the FTP(mama) server can
associate the request with previous ones and work out which file u requested,like
sometimes it pops messages saying,"do u want to overwrite? or modify changes".It also
creates a log file which u can easily view with the ws_ftp program.

HTTP , on the other hand is a Stateless Protocol.It is concerned with requests and
responses,which are simple,isolated transactions.This is perfect for simple web browsing,
where each request typically results in a file(an HTML document or a GIF image etc)
being sent back to the client.The server does not need to know whether a series of
requests come from the same, or from different clients, or whether those requests are
related or distinct

* Illustrate working of Servlet?

Ans: 1. Receives request from the client
2. Extract information from the request
3. Do the content generation or performs business logic
4. Send response to client / forward request to another Servlet / JSP

* Give differences between GET and POST methods?

Ans: 1. In GET, user entered information is appended in URL; in POST user entered
information is sent in message body and not shown in URL.
2. GET can send limited data (equal to RAM of server) but POST can send
unlimited data.

* Why we need deployment descriptor?

Ans: It directs the deployment tools and contains information such as Servlet name,
display name, Servlet class, URL mappings, welcome files, etc.

* How to access Servlet?

Ans: [protocol]://[ip address]:[port no]/ [web context root name ]/[web resource name in
welcome-file] eg http://localhost:9080/GTSRAH/logon.jsp

* What is Session management?

Ans: Mechanism to maintain client’s state across multiple request from same user or
browser over a period of time. Use HTTPSession interface for that.
HttpSession ses = req.getSession(); // get a session obj
Req.getRemoteAddress();// get clients ip
Req.getRemotehost();// get clients hostname
Req.getServername();//get server name
Req.getServerPort();// returns server port tomcat 8080, rad 9080

* What do response.setContentType() do?

Ans: tells the browser the type of response it will get.

* What is life cycle of Servlet?

Ans: 1. Container loads the Servlet
2. Container calls init method
3. On each req, new thread is created and calls service() method,
4. service() method checks for Http method and depending on that calls doGet()
or doPost()

Collection

1. Enumeration:

* What is the use of Enumeration Interface ?

Ans: Its methods(hasMoreElements(), nextElement()) are used to enumerate through the
elements of Vector, keys of HashTable, values in HashTable.

Vector vector = new Vector();

vector.add("vect1");
vector.add("vect2");
Enumeration e = vector.elements();
while (e.hasMoreElements()){
System.out.println("enumeration : "+e.nextElement());
}

Note: This functionality has been duplicated by iterator interface with an added remove
operation and shorter method names.
2. Iterator:

* What is difference between Iterator and Enumeration?

Ans: Iterator has improved names for methods(hasNext(), next()). Functionality is same
but Iterator has extra remove() method to remove elements from the collection during
iteration.

ArrayList arrayList = new ArrayList();

arrayList.add("mahesh");
arrayList.add("yogesh");
arrayList.add("arpan");
arrayList.add("narayan");

Iterator iterator = arrayList.iterator();

while(iterator.hasNext()){
System.out.println("Arraylist contain : "+iterator.next());
}
iterator.remove();

The remove () method removes the last element returned by the iterator.

3. ListIterator:

* What is difference between Iterator and ListIterator interface?

Ans: ListIterator extends Iterator and allows bi-directional traversal in the List. In the
List of n, there are n+ 1 valid index. In Iterator you can only remove but in ListIterator
you can add elements to the Collection.

Forward Direction : hasNext(), next(), nextIndex()

Reverse Direction: hasPrevious(), previous(), previousIndex()

System.out.println("ArrayList : "+arrayList); // [mahesh,yogesh,arpan]

ListIterator listIterator = arrayList.listIterator();

// get nextIndex and previousIndex

System.out.println("ListIterator's nextIndex:
"+listIterator.nextIndex());
System.out.println("ListIterator's previousIndex() :
"+listIterator.previousIndex());

// add element to ListIterator

listIterator.add("Added element");
System.out.println("arrayList after adding element to ListIterator :
"+arrayList);
System.out.println("ListIterator's element in forward direction : ");
while(listIterator.hasNext()){
System.out.println(listIterator.next());
System.out.println(listIterator.nextIndex());
}
System.out.println("ListIterator's element in reverse direction : ");
while(listIterator.hasPrevious()){
System.out.println(listIterator.previous());
}

4. List:

* Explain List Interface?

Ans: The List interface extends Collection and declares the behavior of a collection that
stores a sequence of elements. Elements can be inserted or accessed by their position
in the list, using a zero-based index. A list may contain duplicate elements.

* What is the use of List?

Ans: List interface is ordered Collection and allows duplicate entries. The List interface
provides methods for positional access to list elements, to search specified object, to
insert and remove elements in the List.

* Explain Set interface?

Ans: Set interface extends Collection and declares the behavior of collection that does
not allow duplicate elements.

* Explain SortedSet interface?

Ans: SortedSet extends Set interface and declares the behavior of Set sorted in ascending
order.

* Explain ArrayList class?

Ans: ArrayList supports dynamic arrays that can grow as needed. In Java, standard arrays
are of a fixed length. After arrays are created, they cannot grow or shrink, which means
that you must know in advance how many elements an array will hold. But, sometimes,
you may not know until run time precisely how large of an array you need. To handle
this situation, the collections framework defines ArrayList.
* How to increase / decrease the capacity of ArrayList?
Ans: Although the capacity of an ArrayList object increases automatically as objects are
stored in it, you can increase the capacity of an ArrayList object manually by calling
ensureCapacity( ). You might want to do this if you know in advance that you will be
storing many more items in the collection that it can currently hold. By increasing its
capacity once, at the start, you can prevent several reallocations later. Because
reallocations are costly in terms of time, preventing unnecessary ones improves
performance. The signature for ensureCapacity( ) is shown here:

void ensureCapacity(int cap)

Here, cap is the new capacity. Conversely, if you want to reduce the size of the array that
underlies an ArrayList object so that it is precisely as large as the number of items that it
is currently holding, call trimToSize( ), shown here:

void trimToSize( )

* What is the difference between ArrayList and Vector?

Ans: 1) Arraylist is not synchronized while Vector is.
2) Arraylist has no default size while Vector has a default size of 10.

Note: Methods in Vector are synchronised which means they are thread-safe and thus
preclude access to the Vector elements by concurrent threads.But this imposes additional
overhead on the JVM as it has to acquire and release locks on the vector objects under
consideration.

This is not possible in ArrayList since those methods are not synchronised and hence are
faster in performance.

Use Vector only if it will be accessed by multiple threads at a time else ArrayList is
always better.

5. LinkedList:

* What is the difference between LinkedList and ArrayList?

Ans: ArrayList is RandomAccess and LinkedList is SequentialAccess. Removing /
Inserting elements in the middle of array is costly, in that case we can use LinkedList.
Insertion in Arraylist is costly because Array stores object in consecutive location while
LinkedList stores objects as a separate link. All LinkedList are doubly linked list.

ArrayList arrayList2 = new ArrayList();

arrayList2.add("first");
arrayList2.add("second");
arrayList2.add("third");
arrayList2.add("fourth");
 arrayList2.add("fifth");
arrayList2.add("sixth");

LinkedList linkedList2 = new LinkedList(arrayList2);

ListIterator listIterator2 = linkedList2.listIterator();
System.out.println("LinkedList2 with ListIterator2 in
forward direction : ");
while(listIterator2.hasNext()){
System.out.println(listIterator2.next());
}
System.out.println("LinkedList2 with ListIterator2 in
reverse direction : ");
while(listIterator2.hasPrevious()){
System.out.println(listIterator2.previous());
}

System.out.println("***************************************************
******************");
System.out.println("");
System.out.println("Remove elements from 2-4");

linkedList2.subList(2, 5).clear();
System.out.println("Now linkedList2 :");
listIterator2 = linkedList2.listIterator();
while(listIterator2.hasNext()){
System.out.println(listIterator2.next());
}

The linkedList2.subList(int fromIndex, intToIndex) gives view of elements ranging from

fromindex(inclusive) and toindex(exclusive).

* Explain HashSet class?

Ans: HashSet extends AbstractSet and implements the Set interface. It creates a
collection that uses a hash table for storage. As most readers likely know, a hash table
stores information by using a mechanism called hashing. In hashing, the informational
content of a key is used to determine a unique value, called its hash code. The hash code
is then used as the index at which the data associated with the key is stored. The
transformation of the key into its hash code is performed automatically—you never see
the hash code itself. Also, your code can’t directly index the hash table. The advantage
of hashing is that it allows the execution time of basic operations, such as add( ),
contains( ), remove( ), and size( ), to remain constant even for large sets.
* What is LinkedHashSet?
Ans: Java 2, version 1.4 adds the LinkedHashSet class. This class extends HashSet, but
adds no members of its own. LinkedHashSet maintains a linked list of the entries in the
set, in the order in which they were inserted. This allows insertion-order iteration over the
set. That is, when cycling through a LinkedHashSet using an iterator, the elements will
be returned in the order in which they were inserted. This is also the order in which
they are contained in the string returned by toString( ) when called on a LinkedHashSet
object. To see the effect of LinkedHashSet, try substituting LinkedHashSet For HashSet
in the preceding program. The output will be
[B, A, D, E, C, F]
which is the order in which the elements were inserted.

* Explain TreeSet class?

Ans: TreeSet provides an implementation of the Set interface that uses a tree for storage.
Objects are stored in sorted, ascending order. Access and retrieval times are quite fast,
which makes TreeSet an excellent choice when storing large amounts of sorted
information that must be found quickly.

* Explain storing User Defined classes in Collection?

Ans: Of course, collections are not limited to the storage of built-in objects. Quite the
contrary. The power of collections is that they can store any type of object, including
objects of classes that you create.

6. Map:

* What is Map?
Ans: Map is interface used to map keys to values. No duplicate keys allowed. Each key
can point to at most one value. Values can be duplicated.

* What is the difference between HashMap and HashTable?

Ans: Hashmap is not synchronised and allows null for key and values where as Hashtable
is synchronised and does not allow null values. The elements may not be in an order in
the case of hashmap.

* What is the difference between HashMap and HashSet?

Ans: HashMap contains mapping between key-value pair, but HashSet has only values.
HashMap and HashSet contains unordered list of values. TreeMap and TreeSet contains
ordered list of values.

* Explain the scenarios when to use which collection and why?

Ans:
* Map is NOT a Collection, Explain?
Ans: Maps revolve around two basic operations: get( ) and put( ). To put a value into a
map, use put( ), specifying the key and the value. To obtain a value, call get( ), passing
the key as an argument. The value is returned. As mentioned earlier, maps are not
collections because they do not implement the Collection interface, but you can obtain a
collection-view of a map. To do this, you can use the entrySet( ) method. It returns a Set
that contains the elements in the map.

To obtain a collection-view of the keys, use keySet( ). To get a collection-view of the

values, use values( ). Collection-views are the means by which maps are integrated
into the collections framework.

* Explain HashMap class?

Ans: The HashMap class uses a hash table to implement the Map interface. This allows
the execution time of basic operations, such as get( ) and put( ), to remain constant even
for large sets. Order of insertion and iteration is not guaranteed.

* Explain Treemap class?

Ans: The TreeMap class implements the Map interface by using a tree. A TreeMap
provides an efficient means of storing key/value pairs in sorted order, and allows rapid
retrieval. You should note that, unlike a hash map, a tree map guarantees that its
elements will be sorted in ascending key order.

* Explain Comparator interface?

Ans: Both TreeSet and TreeMap store elements in sorted order. However, it is the
comparator that defines precisely what “sorted order” means. By default, these classes
store their elements by using what Java refers to as “natural ordering,” which is
usually the ordering that you would expect. (A before B, 1 before 2, and so forth.) If
you want to order elements a different way, then specify a Comparator object when
you construct the set or map. Doing so gives you the ability to govern precisely how
elements are stored within sorted collections and maps.

The Comparator interface defines two methods: compare( ) and equals( ). The
compare( ) method, shown here, compares two elements for order:
int compare(Object obj1, Object obj2) obj1 and obj2 are the objects to be compared. This
method returns zero if the objects are equal. It returns a positive value if obj1 is greater
than obj2. Otherwise, a negative value is returned. The method can throw a
ClassCastException if the types of the objects are not compatible for comparison. By
overriding compare( ), you can alter the way that objects are ordered. For example, to sort
in reverse order, you can create a comparator that reverses the outcome of a comparison.
The equals( ) method, shown here, tests whether an object equals the invoking
comparator: boolean equals(Object obj)
obj is the object to be tested for equality. The method returns true if obj and the
invoking object are both Comparator objects and use the same ordering. Otherwise, it
returns false. Overriding equals( ) is unnecessary, and most simple comparators will
not do so.
* Explain Properties class?
Ans: Properties is a subclass of Hashtable. It is used to maintain lists of values in which
the key is a String and the value is also a String. The Properties class is used by many
other Java classes. For example, it is the type of object returned by
System.getProperties( ) when obtaining environmental values.

* StringTokenizer, explain?
Ans: StringTokenizer implements Enumeration interface which helps to enumerate
through tokens.

Java.lang.io
1. BufferedInputStream:

* What is the difference between BufferedInputStream and BufferedReader?

Ans: BufferedInputStream works on byte streams, BufferedReader works on character
streams.

* What are Buffered Streams?

Ans:

Exceptions
* Try, Catch, Throw, Throws, Finally what is the purpose of theses words and how
to use these words?
Ans:
1. Try: code capable of generating exception is written within try block.
2. Catch: On exception, it is handled here in rational manner.
3. Throw: To manually throw an exception throw is used.
4. Throws: Any exception that is thrown out of a method must be specified by
throws
5. Finally: code that must be run irrespective of exception is written in finally
block.

* If Default Handler is provided to handle exception, why should programmer

handle the exception?
Ans: 1. It allows to fix the error. 2. It prevents the program from abrupt terminating.

* Explain how throw statement works?

Ans: The flow of execution stops immediately after the throw statement; any subsequent
statements are not executed. The nearest enclosing try block is inspected to see if it has
a catch statement that matches the type of the exception. If it does find a match, control
is transferred to that statement. If not, then the next enclosing try statement is
inspected, and so on. If no matching catch is found, then the default exception handler
halts the program and prints the stack trace.

public class TestThrow {

/**
* TestThrow class demonstrate throw statement in java to throw
exception manually.
* @param args
*/

static double demo(int a, int b) throws MyArithmeticException{

if(b==0){
throw new MyArithmeticException("can't divide by zero...");
}
return (a/b);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int a=100, b=0, c=20;
double res=0.0;
System.out.println("a="+a+"\t b="+b+"\t c="+c);
try{
res=demo(a,b);
System.out.println("Result: "+res);
}catch(MyArithmeticException myArithmeticException){
System.out.println("Arithmatic: "+myArithmeticException);
}
}

}
class MyArithmeticException extends Exception{
MyArithmeticException(String str) {
super(str);
}
}

/* Output
* when divider is not zero ==>
* a=100 b=0 c=20
* Result: 5.0
*
* when divider is zero ==>
* a=100 b=0 c=20
* Arithmatic: myException.MyArithmeticException: can't divide by zero..
 */

* Explain how throws statement work?

Ans: If a method is capable of causing an exception that it does not handle, it must
specify this behavior so that callers of the method can guard themselves against that
exception. You do this by including a throws clause in the method’s declaration. A
throws clause lists the types of exceptions that a method might throw. This is necessary
for all exceptions, except those of type Error or RuntimeException, or any of their
subclasses.

Example:
// This is now correct.
class ThrowsDemo {

static void throwOne() throws IllegalAccessException {

System.out.println("Inside throwOne.");
throw new IllegalAccessException("demo");

public static void main(String args[]) {

try {
throwOne();
} catch (IllegalAccessException e) {
System.out.println("Caught " + e);
}
}
}

Here is the output generated by running this example program:

inside throwOne
caught java.lang.IllegalAccessException: demo

* Explain how finally works?

Ans: finally creates a block of code that will be executed after a try/catch block has
completed and before the code following the try/catch block. The finally block will
execute whether or not an exception is thrown. If an exception is thrown, the finally
block will execute even if no catch statement matches the exception. Any time a
method is about to return to the caller from inside a try/catch block, via an uncaught
exception or an explicit return statement, the finally clause is also executed just before
the method returns. This can be useful for closing file handles and freeing up any other
resources that might have been allocated at the beginning of a method with the intent
of disposing of them before returning. The finally clause is optional. However, each try
statement requires at least one catch or a finally clause.
* What are checked and unchecked exceptions?
Ans: Unchecked Exceptions, compiler doesn’t bother to see if a method handles or
throws these exceptions. Mostly these are subclasses of RuntimeException.
Checked Exceptions, needs to be handled using try-catch or declared in method’s throws
list.

Unchecked Exceptions Checked Exceptions

ArithmaticException ClassNotFoundException
ArraiIndexOutOfBoundsException NoSuchFieldException
ClassCastException NoSuchMethodException
IllegalArgumentException IllegalAccessException
NullPointerException

String
* State the difference between equals () and == operators?
Ans: It is important to understand that the equals( ) method and the == operator perform
two different operations. As just explained, the equals( ) method compares the
characters inside a String object. The == operator compares two object references to
see whether they refer to the same instance.

Examples:
// equals() vs ==

class EqualsNotEqualTo {
public static void main(String args[]) {
String s1 = "Hello";
String s2 = new String(s1);
System.out.println(s1 + " equals " + s2 + " -> " +
s1.equals(s2));
System.out.println(s1 + " == " + s2 + " -> " + (s1 == s2));
}
}

Output:
Hello equals Hello -> true
Hello == Hello -> false

* Explain Difference between String and StringBuffer?

Ans: As you know, String represents fixed-length, immutable character sequences. In
contrast, StringBuffer represents growable and writeable character sequences.

* Explain Runtime class?

Ans: The Runtime class encapsulates the run-time environment. You cannot instantiate a
Runtime object. However, you can get a reference to the current Runtime object by
calling the static method Runtime.getRuntime( ). Once you obtain a reference to the
current Runtime object, you can call several methods that control the state and
behavior of the Java Virtual Machine. Applets and other untrusted code typically
cannot call any of the Runtime methods without raising a SecurityException.

To run garbage collection, Runtime.getRuntime().gc();

* Explain System class?

Ans: The System class holds a collection of static methods and variables. The standard
input, output, and error output of the Java run time are stored in the in, out, and err
variables.

* Explain class loader?

Ans: The abstract class ClassLoader defines how classes are loaded. Your application
can create subclasses that extend ClassLoader, implementing its methods. Doing so
allows you to load classes in some way other than the way they are normally loaded by
the Java run-time system.