understanding core java concepts

The documents contain important Core

Java Topics and brief description of each

for easy understanding. The highlight of the

document is that it is designed in question

answer format .This is done keeping in

mind all doubts and concern related to the

key topics .This will also act as a handbook

to brush up your java knowledge before

going for client interview!

Understanding

Core Java

Concepts Summarizing Core Java Key

Topics

Afrina Alam Rahman

1

Prepared by Afrina Alam

Table of Contents Introduction ............................................................................................................................................ 2

Static ....................................................................................................................................................... 3

String ...................................................................................................................................................... 7

Collection .............................................................................................................................................. 10

Exception .............................................................................................................................................. 23

Memory Management........................................................................................................................... 28

Key Guidelines ....................................................................................................................................... 35

References ............................................................................................................................................ 47

2


Introduction

This document highlights key concepts and features of java programming language .From any java

programmer point of view ,the topics covered here we all know and are familiar with but do we really

understand it ? This document will help all java programmers to learn and understand the essential topics

for better coding .The document is designed in Question Answer format such that all question and

confusion related to understanding of the topic is highlighted and made it clear. The various topics

covered here are as follows:

Static

String

Collection

Exception

Memory Management

Generics

Key Guidelines

3


Static

Explain static and its usage?

In java world the static word is basically used as

o static blocks of code

o static variables

o static methods

Static blocks of code

Block of statement within a Java class that is enclosed in braces { } and preceded by the static

keyword is called as static block of code .These statements will be executed as soon as class is

loaded first time into the JVM .This in turn helps to initialize all static members , similar to the

work of constructors which initialize instance members. A Java Class can have any number of

such blocks and they can be written anywhere within the class body. During the runtime all

static blocks are called in the same order as they appear in the class.

Given a scenario, one class has a Static block along with Public static void main method

which one will get executed first?

Static block

How to handle Exceptions in static blocks?

In a normal scenario exception are taken care via Exception Class or handling it via try-catch

block .But the above two are not applicable in terms of static blocks so other options available

for exception handling within static block are as follows :

Throw Runtime Exception

Call System.exit(1)

Set Failure flag

Write a piece of code to print the Class Name of any class while loading the class ?

import java.lang.Class;

public class GetClassName

{

public GetClassName (){

System.out.println("Constructor Called");

}

public static void main(String args[])

{

static{

String className = this.getClass().getName();

System.out.println(“ Class name Before loading the class”+ className);

}

4


}

}

What are the advantages and dis-advanatges of a static block?

Advantages

• If you’re loading drivers and other items into the namespace. For ex, Class has a

static block where it registers the natives.

• If you need to do computation in order to initialize your static variables,you can

declare a static block which gets executed exactly once,when the class is first loaded.

• Security related issues or logging related tasks

DisAdvanatges

• There is a limitation of JVM that a static initializer block should not exceed 64K.

• You cannot throw Checked Exceptions.

• You cannot use this keyword since there is no instance.

• You shouldn’t try to access super since there is no such a thing for static blocks.

• You should not return anything from this block.

• Static blocks make testing a nightmare.

Static Variables

Any variable declared with static keyword is called static variables and popularly known as class

variables .This is because all instances share the same copy of the variable and we can directly

access these variables without creating an instance .Variables without static key word are called

as instance variables as each instance of the class has its own copy of the variable. Key

characteristics of static variables are below:

It is a variable which belongs to the class and not to object(instance)

Static variables are initialized only once , at the start of the execution . These variables

will be initialized first, before the initialization of any instance variables

A single copy to be shared by all instances of the class

A static variable can be accessed directly by the class name and doesn’t need any object

Syntax : <class-name>.<variable-name>

Java does not support global variables but can something closest to it can be implemented

and how ?

The closest to global variables can be implemented via static variables .This in turn will share the

same variable even if we create multiple objects of that class . That implies that the given

variable will reside in the same memory location irrespective of how many objects are created

.And on top we can declare this static variable to be final so that it has only one instance of a

variable that is shared among all objects.

Static Method

5


Any method declared with static keyword is called static and popularly known as class methods.

This is because all instances share the same copy of the method and can be used directly without

creating object . Methods without static key word are called as instance methods. Static methods

cannot access variables declared without static. Key characteristics of static methods are below:

It is a method which belongs to the class and not to the object(instance)

A static method can access only static data. It can not access non-static data (instance

variables)

A static method can call only other static methods and can not call a non-static method

from it.

A static method can be accessed directly by the class name and doesn’t need any object

Syntax : <class-name>.<method-name>

A static method cannot refer to “this” or “super” keywords in anyway.

What is the use of static methods in java?

When you want to be able to access the method without an instance of the class

If there is some code that can easily be shared by all the instance methods, extract that

code into a static method

If you are sure that the definition of the method will never be changed or overridden. As

static methods can not be overridden

What is Static Impact on method overriding?

Sub class Method Action Super Class Method

InstanceMethod() Overrides InstanceMethod()

InstanceMethod() Complies Error StaticMethod()

StaticMethod() Complies Error InstanceMethod()

StaticMethod() Hides StaticMethod()

Can a class be static ?

What does it mean to have a static inner class?

Only Inner class can be declared static and not the top class. Static inner classes imply that the

object of the inner class is not dependent upon the outer class object and can exist indepenently.

Nested classes are divided into two categories: static and non-static. Nested classes that are

declared static are simply called static nested classes. Non-static nested classes are called inner

casses.A static java inner class cannot have instances. A non-static java inner class can have

instances that belong to the outer class. Non static inner class cannot have static data member

and static member method whereas Static Inner class can have static and non static data member

and member method.

6


class OuterClass{

static class staticInnerClass{} // static-member class

class innerClass{} // non-static member class

}

class testClass{

public static void main(String st[]){

OuterClass obj = new OuterClass ();

OuterClass.innerClass obj1 = obj.new innerClass (); //obj is enclosing instance

//OuterClass.innerClass obj1 = new OuterClass ().new innerClass ();

OuterClass.staticInnerClass obj2= new OuterClass.staticInnerClass (); //No enclosing

}

}

Can we use ‘This’ moderator inside Static Method?

class Sub {

static int x = 0;

int y;

public void mehtod1() {

this.y = 10;

}

public static void method2() {

this.y = 10;

}

}

Above gives compile time error as "this" represents the object invoking the method. Static

methods are not bound to any object, they are class level methods, hence, "this" cannot be used.

Hence Java static methods cannot use the ‘this’ keyword.

7


String

Strings in java are designed as an object that represents a sequence of characters. String is read

only that implies once created the contents cannot be modified at any time.

What are the different ways to create a String in java ?

String s1=“Java String”;

String s2=new String();

String s3=new String(“Java String”);

String s4 =new String(s3);

Char data[]={ ‘j’, ‘a’, ‘v’, ‘a’)}; String s5 =new String(data);

Where string is stored on Heap or Stack in java?

A String in java is dealt as an object and since all objects resides over heap hence even string

object is on the heap. But in addition to it the variables we define for String is pointer to the

object and hence reside on stack.

What is the difference between String s = “Java”; and String s= new String(“Java”);

String str = new String(“Java”);

In the above case two objects will be created

One which will reside on heap

Other in String Constant Pool

Here str will always point to the heap object and not to the String Constant Pool.

String str = “Java”;

In the above case only one object will be created and that would reside in String Constant Pool

Here str will always point to the to the object in String Constant Pool.

In String Constant Pool to create objects always is not mandatory. At first stage JVM checks if

there is any object that exist in Pool with the same content, if the object is present there then it

will use the same else create new object. Hence the pool does not allow any creation of duplicate

objects .JVM does not allow to do any clean up by Garbage collector within the String Constant

Pool but as soon as the JVM shut down automatically everything gets flushed out from the pool.

The benefit of the second approach is in terms of memory utilization that in turn improves the

performance .Because we reduce object creation and as we know object creation is costly in java

Explain the concept of String objects as immutable with an example

8


String s1 = "Java";

String s2 = s1;

// s1 and s2 now refer to the same string - "Java".

In the above case even if we make any changes to string s1 it will never affect the s2 .Though

they refer to the same value “Java” but since they are immutable thus cannot be altered.

Now lets check if we do a change like this :

s1 = "Java Modified ";

System.out.println(s2); // still prints "Java"

Here we see the difference between mutating an object, and changing a reference. s2 still points

to the same object as we initially set s1 to point to. Setting s1 to "Java Modified" only changes

the reference, while the String object it originally referred to remains unchanged. That

summarized the first String “Java” will always exist .Hence by changing string s1 we do not

actually modify the string but create one more thereby signifying the concept of immutable .

Explain the difference between == and equals with respect to string in java with example

equals( ) method and the == operator perform two different operations.

The equals( ) method compares the characters inside a String object. It considers the content of

string for comparison

The == operator compares two object references to see whether they refer to the same instance. It

considers the memory space.

String s1 =new String("Java");

String s2 = new String(“Java”);

String s3=s1;

System.out.println("String s1”+s1);



System.out.println(" s1 equals s2" +s1.equals(s2));

System.out.println(" s1 == s2 " + (s1 == s2));

System.out.println(" s1 == s3 " + (s1 == s3));

Output of above program is

String s1:Java

String s2:Java

String s3:Java

s1 equals s2 :true

s1 == s2 :false

s1 == s3 :true

9


Memory reference of above String values

Reference

If new is not used to assign values to String object then all Strings with same literal values will

refer to the same object in memory .

String s4 = "Java";

String s5 = "Java";

System.out.println(" s4 equals s5:" +s4.equals(s5));

System.out.println(" s4 == s5 :" + (s4 == s5));

Output for above will be

s4 equals s5 : true

s4 == s5 : true

When JVM find two string object with the same content, in order to save memory, instead of

creating two new objects, they check whether the object already exist and if exits they just point

ot it .That implies if the string "Java" already created say s4 and when a new string is created

with the same word "Java" say s5 JVM detect that already exist this string and then did not create

a new object, JVM just make a reference the two objects to the same "Java", so s4 and s5 are

"pointing" to the same place in the memory, and s4==s5 are true.

S1

S2

S3

2nd Object reference in Memory

Java

1st Object reference in Memory

Java

10


Collection

What is Collection and Collections in java referred to ?

Collection is a base interface for most collection classes, whereas Collections is a utility class.

Collections class is a utility class having static methods for doing operations on objects of classes

which implement the Collection interface. For example, Collections has methods for finding the

max element in a Collection.

Collection is the root interface in the collection hierarchy. A collection represents a group of

objects, known as its elements. Some collections allow duplicate elements and others do not.

Some are ordered and others unordered

Why is collection important in java ?

The Java Collections API's provide Java developers with a set of classes and interfaces that

makes it easier to handle collections of objects. In a sense Collection's works a bit like arrays,

except their size can change dynamically, and they have more advanced behaviour than arrays.

What Is a Collections Framework?

A collections framework is nothing but an architecture for representing and manipulating

collections. All collections frameworks contain the following:

• Interfaces: These are abstract data types that represent collections. Interfaces allow

collections to be manipulated independently of the details of their representation.

• Implementations: These are the concrete implementations of the collection interfaces. In

essence, they are reusable data structures.

• Algorithms: These are the methods that perform useful computations, such as searching

and sorting, on objects that implement collection interfaces. The algorithms are said to be

polymorphic: that is, the same method can be used on many different implementations of

the appropriate collection interface

What are advantages of Collection Framework ?

The Java Collections Framework provides the following Advantages:

Reduces programming effort

Increases program speed and quality

Allows interoperability among unrelated APIs

Reduces effort to learn and to use new APIs

Reduces effort to design new APIs

Fosters software reuse

11


Explain all Core Collection Interface?

The core collection interfaces are:

• Collection — the root of the collection hierarchy. A collection represents a group of

objects known as its elements. The Collection interface is the least common denominator

that all collections implement and is used to pass collections around and to manipulate

them when maximum generality is desired. Some types of collections allow duplicate

elements, and others do not. Some are ordered and others are unordered. The Java

platform doesn't provide any direct implementations of this interface but provides

implementations of more specific subinterfaces, such as Set and List.

• Set — a collection that cannot contain duplicate elements. This interface models the

mathematical set abstraction and is used to represent sets, such as the cards comprising a

poker hand, the courses making up a student's schedule, or the processes running on a

machine.

• List — an ordered collection (sometimes called a sequence). Lists can contain duplicate

elements. The user of a List generally has precise control over where in the list each

element is inserted and can access elements by their integer index (position).

• Queue — a collection used to hold multiple elements prior to processing. Besides basic

Collection operations, a Queue provides additional insertion, extraction, and inspection

operations.

• Map — an object that maps keys to values. A Map cannot contain duplicate keys; each

key can map to at most one value. If you've used Hashtable, you're already familiar with

the basics of Map.

The last two core collection interfaces are merely sorted versions of Set and Map:

Collection

List Set

Sorted Set

Queue

Map

Sorted Map

12


• SortedSet — a Set that maintains its elements in ascending order. Several additional

operations are provided to take advantage of the ordering. Sorted sets are used for

naturally ordered sets, such as word lists and membership rolls.

• SortedMap — a Map that maintains its mappings in ascending key order. This is the

Map analog of SortedSet. Sorted maps are used for naturally ordered collections of

key/value pairs, such as dictionaries and telephone directories.

What do generics do in Collections?

The motivation for adding generics to the Java programming language stems from the lack of

information about a collection's element type, the need for developers to keep track of what type

of elements collections contain, and the need for casts all over the place. Using generics, a

collection is no longer treated as a list of Object references, but you would be able to

differentiate between a collection of references to Integers and

collection of references to Bytes. A collection with a generic type has a type parameter that

specifies the element type to be stored in the collection.

E.g., consider the following segment of code that creates a linked list and adds an element to the

list:

LinkedList list = new LinkedList();

list.add(new Integer(1));

Integer num = (Integer) list.get(0);

So, when an element is extracted from the list it must be cast. The casting is safe as it will be

checked at runtime, but if you cast to a type that is different from, and not a supertype of, the

extracted type then a runtime exception, ClassCastException will be thrown.

Using generic types, the previous segment of code can be written as follows:

LinkedList<Integer> list = new LinkedList<Integer>();

list.add(new Integer(1));

Integer num = list.get(0);

Here we say that LinkedList is a generic class that takes a type parameter, Integer in this case.

With generics, you achieve polymorphic behavior similar to the example above, but with strong

static typechecking; the compiler knows that the two lists are different because they contain

different elements, and these lists are guaranteed to contain only a homogeneous set of elements.

The sample code below is a translation of the previous example, using generics this time. As you

can see from comments in the code, all the errors are caught at compile time. Don't worry about

the syntax for now -- we'll cover that shortly.

13


Draw the hierarchical diagram of collection framework

Collection Interface

Queue

Linked List

Stack

Array List Vector HashSet Tree Set

Linked HashSet Concrete

Classes

14


Map Interface

Is there a collection interface above all the collection classes

Collection is a base interface for most collection classes, whereas Collections is a utility

class.Hence Collection is the root interface in the collection hierarchy. A collection represents a

group of objects, known as its elements. Some collections allow duplicate elements and others do

not. Some are ordered and others unordered. The SDK does not provide any direct

implementations of this interface: it provides implementations of more specific subinterfaces like

Set and List. This interface is typically used to pass collections around and manipulate them

where maximum generality is desired.

MAP

SortedMap

Abstarct

Classes AbstarctMap

HashMap TreeMap

Interfaces

LinkedHashMap Concrete

Classes

15


Explain Collections Framework and the business scenarios where each of them will be

used?

Collection

type Functionality Typical uses

List Essentially a variable-size

array;

You can usually add/remove

items at any arbitrary

position;

The order of the items is

well defined (i.e. you can

say what position a given

item goes in in the list).

Most cases where you just need to store or

iterate through a "bunch of things" and later

iterate through them.

Set Things can be "there or

not"— when you add items

to a set, there's no notion of

how many times the item

was added, and usually no

notion of ordering.

Remembering "which items you've

already processed", e.g. when doing a

web crawl;

Making other yes-no decisions about an

item, e.g. "is the item a word of

English", "is the item in the database?"

, "is the item in this category?" etc.

Map Stores an association or

mapping between "keys" and

"values"

Used in cases where you need to say "for a

given X, what is the Y"? It is often useful for

implementing in-memory caches or indexes.

For example:

For a given user ID, what is their

cached name/User object?

For a given IP address, what is the

cached country code?

For a given string, how many instances

have I seen?

Queue Like a list, but where you

only ever access the ends of

the list (typically, you add to

one end and remove from

the other).

Often used in managing tasks

performed by different threads in an

application (e.g. one thread receives

incomming connections and puts them

on a queue; other "worker" threads take

connections off the queue for

processing);

For traversing hierarchical

structures such as a filing system, or

in general where you need to remember

16


"what data to process next", whilst

also adding to that list of data;

Related to the previous point, queues

crop up in various algorithms, e.g.

build the encoding tree for Huffman

compression.

Advantage of using java.util.iterator as compared to the for loop for traversing collections

In the case of ArrayList the difference, like said, is minimal. Both options above are not thread-

safe and roughly equal in performance. The difference lies in the Iterator's remove() method

which allows to "safely" remove items while iterating. for loop can not (easily) remove the

element of the current iteration correctly .Generally , we can get the collection object in iterator

object using iterator also when there are no more entries to be fetched the loop automatically

closes.

How does ArrayList work internally

Arraylist.java file has an array internally If the array is full and you add an element, it creates a

new array and copies the entries over. If you insert in the middle, it shifts the entries down and

inserts.

There are performance problems with such a structure, which is why there's such a thing as

Linked List, which is more efficient for insert operations

How does LinkedList work internally

A LinkedList in Java works as collection of element linked to each other . If you use the official

Collections LinkedList then it will indeed be a a bunch of object connected to each other by

having a 'next' and sometimes 'previous'. It has a get(int index) method which is surprising

because it would not be very efficient as we would need to start at the beginning and count our

way up the list to find the indexth entry and this is not what LinkedLists are good at. The reason

it is there is because LinkedList implements the List interface. However, we should avoid using a

LinkedList when most of your access to it is through the get(int index) method as that would

clearly be most inefficient. We should use an ArrayList.

What is hashSet ?

A HashSet holds a set of objects, but in a way that it allows you to easily and quickly determine

whether an object is already in the set or not. It does so by internally managing an array and

storing the object using an index which is calculated from the hashcode of the object.

17


Difference between hashMap and hashSet

HashMap is not collection inteface where as HashSet is Collection interface.

HashMap class implements Map interface where as HashSet class implements Set

interface.

HashMap is prints the elements orderly where as HashSet has no order

Which container is better for the storage Arraylist/Linked list?

Both are similar, though slightly different in terms of goal and implementation. In a LinkedList,

each element is linked to its previous and next element making it easier to delete or insert in the

middle of the list. An ArrayList is more as its name subjects used as an array.Performance is

similar, though LinkedList is optimized when inserting elements before the end of the list, where

ArrayList is optimized when adding elements at the end. If you frequently add elements to the

beginning of the List or iterate over the List to delete elements from its interior, you should

consider using LinkedList. These operations require constant-time in a LinkedList and linear-

time in an ArrayList. But you pay a big price in performance. Positional access requires

lineartime in a LinkedList and constant-time in an ArrayList.

Difference between linkedhashmap and hashmap

Both implement the Map interface and offer mostly the same functionality. Both represent

mapping from unique keys to values, and therefore implement the Map interface The most

important difference is the order in which iteration through the entries will happen:

• HashMap is a map based on hashing of the keys. It supports O(1) get/put operations.

Keys must have consistent implementations of hashCode() and equals() for this to work.

• LinkedHashMap is very similar to HashMap, but it adds awareness to the order at which

items are added (or accessed), so the iteration order is the same as insertion order (or

access order, depending on construction parameters).

• HashMap makes absolutely not guarantees about the iteration order. It can (and will)

even change completely when new elements are added.

• LinkedHashMap will iterate in the order in which the entries were put into the map

• HASH MAP has pair values(keys,values) NO duplication key values unordered

unsortered it allows one null key and more than one null values HASH TABLE: same as

hash map it does not allows null keys and null values

• LINKED HASH MAP: It is ordered version of map implementation Based on linked list

and hashing data structures TREE MAP: Ordered and sortered version based on hashing

data structures

Difference between Hash Map and Tree Map

HashMap will not store the elements in order.Whereas TreeMap stores in order.so while

retrieving we will get in a particular order.But for HashMap we won't.

HashMap provides the implementation of Map Interface by using hashtable where as

TreeMap provides the implementation of Map Interface by using Tree.

18


HashMap does not guarntee any order TreeMap provides sorted order.

Difference between a vector and array?

The basic difference between those two are:

Vector and Arraylist are grownable or shinkable where are array is not.

Vector and Arraylist are implemented from List interface where as array is a primitive

data type

Vector is Synchrnized where as arraylist is not

For best performance better to use arraylist than vector

Difference between a hashmap and a hashtable?

A HashMap is unsynchronized whereas a Hashtable is synchronized. In other words,

Hashtable can only be manipulated by a single thread at a time, use it only in

multithreaded environment.

HashMap allows null values in both key and value whereas Hashtable doesn't allow that.

HashMap allows you to iterate over keys, values, or key-value pairs whereas a Hashtable

does not provide the third option

HashMap is the best if your program is not involved with synchronization concept.

HashMap is not synchronized and faster access.

HashpTable is synchronized and slower performace.

Explain Internal implementation of interfaces which extend Set

Set contains no duplicate elements i.e., no pair of elements e1 and e2 such that e1.equals(e2), and

at most one null element. But the question is how set maintains unique elements?. Internally set

maintains a Map when a Set (HashSet/Treeset/etc) is instantiated

Constructor of HashSet

public HashSet() {

map = new HashMap();

}

So HashSet creates an instance of HashMap when HashSet is instantiated, TreeSet creates an

instance of TreeMap when TreeSet is instantiated and so on. The keys in the map are the

elements you add to Set. Then what are values? Values are dummy objects. When you add an

element to the Set, the element will be added as key and "new Object()" (dummy Object

instance) will be added as value which is a dummay value. What will happen if you add a

duplicate object to Set? If the set already contains the element, the call to add method leaves the

set unchanged and returns false. If the set does not contain the element, the call to add method

adds the element and returns true.

19


HashSet:

HashSet is backed by a HashMap instance and hence it allows the null element. It makes no

guarantees as to the iteration order of the set; in particular, it does not guarantee that the order

will remain constant over time.

When do you use HashSet?

When you are looking for performance, use HashSet. Since this class uses the hash function

when retrieving the elements, it allows fast retrieval. This class offers constant time performance

for the basic operations add, remove, contains and size, assuming the hash function disperses the

elements properly among the buckets. Iterating over this set requires time proportional to the

sum of the HashSet instance's size (the number of elements) plus the "capacity" of the backing

HashMap instance the number of buckets. Thus, it's very important not to set the initial capacity

too high (or the load factor too low) if iteration performance is important

LinkedHashSet:

LinkedHashSet is backed by LinkedHashMap. So all the elements in LinkedHashSet are actually

the keys in the LinkedHashMap. It maintains a doubly-linked list running through all of its

entries. This linked list defines the iteration ordering, which is the order in which elements were

inserted into the set (insertion-order). This class provides all of the optional Set operations, and

permits null elements.

When do you use LinkedHashSet?

When you are looking to produce a copy of a set that has the same order as the original,

regardless of the original set's implementation without incurring the increased cost (associated

with TreeSet).

This technique is particularly useful if a module takes a set on input, copies it, and later returns

results whose order is determined by that of the copy. Like HashSet, it provides constant-time

performance for the basic operations add, contains and remove), assuming the hash function

disperses elements properly among the buckets. Performance is likely to be just slightly below

that of HashSet, due to the added expense of maintaining the linked list, with one exception:

Iteration over a LinkedHashSet requires time proportional to the size of the set, regardless of its

capacity. Iteration over a HashSet is likely to be more expensive, requiring time proportional to

its capacity A linked hash set has two parameters that affect its performance: initial capacity and

load factor. They are defined precisely as for HashSet. Note, however, that the penalty for

choosing an excessively high value for initial capacity is less severe for this class than for

HashSet, as iteration times for this class are unaffected by capacity

TreeSet:

20


TreeSet is backed by TreeMap instance and TreeSet wont permit null elements. As opposing to

HashSet, TreeSet provides a total ordering on its elements and especially when you need a sorted

order. The elements are ordered either by using their plain Comparable natural ordering (if you

dont pass any parameter for the TreeSet constructor) or by a Comparator typically provided at

sorted set creation time as a parameter to the constructor. All elements inserted into this set must

either implement the Comparable interface or atleast be accepted by the specified comparator. So

all such elements must be mutually comparable i.e., e1.compareTo(e2) (or

comparator.compare(e1, e2)) must not throw a ClassCastException.

When do you use TreeSet?

Its very well explained above that TreeSet will be used when the sorted order of inserted

elements is required.

What about the performance? The performance obviously will be low compared to HashSet. A

TreeSet may be accessed and traversed in either ascending or descending order. The

descendingSet method returns a view of the set with the senses of all relational and directional

methods inverted. The performance of ascending operations and views is likely to be faster than

that of descending ones.

What is a hashcode?

Any Java programmer must be familiar with the word hashcode but what does it actually implies

and where does it get used? In a brief perspective Hash code is a 32-bit integer that locates an

object in the memory. We all know java considers everything as an object and an any object

when loaded into memory must have it location and that is specified as hashcode .And hence the

root of all classes –Object has a method called int hashcode() that signifies the above. Since all

class is inherited fromt his root class Object hene the method hashcode() is available to all the

objects in java.

How will you make sure that key returns unique hashcode in hashmap?

The default hashCode() method uses the 32-bit internal Java Virtual Machine address of the

Object as its hashCode. However, if the Object is moved in memory during garbage collection,

the hashCode stays constant. This default hashCode is not very useful, since to look up an Object

in a HashMap, you need the exact same key Object by which the key/value pair was originally

filed. Normally, when you go to look up, you don’t have the original key Object itself, just some

data for a key. So, unless your key is a String, nearly always you will need to implement a

hashCode and equals method on your key class. Object.hashCode in a native method.

Explain equals method and its dependability on hash code ?

Let us consider two String object :

String str=”String Object”;

String str1=”String Object”;

21


Now let us compare them str.equals(str1); This return true as equal method compares the value

for string Object .

Now let us take two new object :

Person obj=new Person ();

Person obj1=new Person ();

Now let us compare them obj.equals(obj1); This return false as equal method compares the

hashcode for two Objects.

Hence to make comparison of two Objects more meaningful we should always override Equals

as well as hashcode methodas belwo

public class Person{

private String empName;

public Person(String name){

this. empName= name;

}

public boolean equals( Object obj ){

boolean flag = false;

Person perObj = (Person)obj;

if(perObj. empName .equals( empName))

flag = true;

return flag;

}

public int hashCode(){

return empName;

}

How does hashmap works

It has a number of "buckets" which it uses to store key-value pairs in. Each bucket has a unique

number - that's what identifies the bucket. When you put a key-value pair into the map, the

hashmap will look at the hash code of the key, and store the pair in the bucket of which the

identifier is the hash code of the key. For example: The hash code of the key is 235 -> the pair is

stored in bucket number 235. (Note that one bucket can store more then one key-value pair).

When you lookup a value in the hashmap, by giving it a key, it will first look at the hash code of

the key that you gave. The hashmap will then look into the corresponding bucket, and then it will

compare the key that you gave with the keys of all pairs in the bucket, by comparing them with

equals().

22


Now you can see how this is very efficient for looking up key-value pairs in a map: by the hash

code of the key the hashmap immediately knows in which bucket to look, so that it only has to

test against what's in that bucket.

Looking at the above mechanism, you can also see what requirements are necessary on the

hashCode() and equals() methods of keys:

•If two keys are the same (equals() returns true when you compare them), their

hashCode() method must return the same number. If keys violate this, then keys that are

equal might be stored in different buckets, and the hashmap would not be able to find

key-value pairs (because it's going to look in the same bucket).

•If two keys are different, then it doesn't matter if their hash codes are the same or not.

They will be stored in the same bucket, but the hashmap will use equals() to tell them

apart

23


Exception

What classes of exceptions may be caught by a catch clause?

A catch clause can catch any exception that may be assigned to the Throwable type. This

includes the Error and Exception types.

How can you customize your exception?

Create a custom exception class that will extends the Exception class, for example

class myException extends Exception{

public myException () { }

public myException(String message) {

super(message);

}

Usage :

try{

if(word.coantains(“ “)){

throw new myException();

}

}

Catch(myException ex){

……

}

Describe the different blocks involved in a typical exception handling scenario. what does

the "finally" block do?

try{

<code to be monitored for exceptions>

} catch (<ExceptionType1 <onjName>){

<handler if ExceptionType1 occurs>

24


} ….

}finally {

<code to be executed before the try blocks ends>

}

Finally:

A finally block is always executed, regardless of the cause of exit from the try block, or whether

any catch block was executed. Generally finally block is used for freeing resources, cleaning up,

closing connections etc. If the finally clock executes a control transfer statement such as a return

or a break statement, then this control

statement determines how the execution will proceed regardless of any return or control

statement present in the try or catch

What is the "throws" statement? when is it required?

Java allows you to throw exceptions (generate exceptions)

throw <exceptionObject>;

An exception thrown is always an object same as any other object except it extend Exception

Class or RuntimeException Class

What are the different types of exceptions, and examples

In Java, exceptions are objects. When you throw an exception, you throw an object. You can't

throw just any object as an exception, however -- only those objects whose classes descend from

Throwable.

Throwable serves as the base class for an entire family of classes, declared in java.lang, that your

program can instantiate and throw.

Throwable has two direct subclasses, Exception and Error.

Exceptions (members of the Exception family) are thrown to signal abnormal conditions that can

often be handled by some catcher, though it's possible they may not be caught and therefore

could result in a dead thread. Exception subclasses represent errors that a program can

reasonably recover from. Except for RuntimeException and its subclasses (see below), they

generally represent errors that a program will expect to occur in the normal course of duty

Example:

Division by Zero

Array out of Bound

RuntimeException is a further subclass of Exception. RuntimeException and its subclasses are

slightly different: they represent exceptions that a program shouldn't generally expect to occur,

but could potentially recover from. They represent what are likely to be programming errors

rather than errors due to invalid user input or a

25


badly configured environment.

Errors (members of the Error family) are usually thrown for more serious problems, such as

OutOfMemoryError, that may not be so easy to handle. In general, code you write should throw

only exceptions, not errors. Errors are usually thrown by the methods of the Java API, or by the

Java virtual machine itself. Error subclasses represent "serious" errors that a program generally

shouldn't expect to catch and recover from. These include conditions such as an expected class

file being missing, or an OutOfMemoryError.

Example:

Out of Memory

Hard Disk error

Exception Class Hierarchy

Throwable Error Linkage Error ,….

Virtual Machine Error, ..

Exception Class Not Found Exception

Clone Not Supported Exception

IllegalAccessException

InstantiationException

InterruptedException

IOException EOFException

FileNotFoundException

…

RunTimeException ArithemticException

ArrayStoreException

IllegalArgumentException

(IllegalThreadStateException &

NumberFormatException as subclass)

IllegalMonitorStateException

IndexOutOFBoundException

NegativeArraySizeException

NullPointerException……

What are Checked/unchecked exceptions?

Unchecked exceptions :

• Represent defects in the program (bugs) - often invalid arguments passed to a non-private

method. To quote from The Java Programming Language, by Gosling, Arnold, and

Holmes : "Unchecked runtime exceptions represent conditions that, generally speaking,

reflect errors in your program's logic and cannot be reasonably recovered from at run

time."

• Are subclasses of RuntimeException, and are usually implemented using

IllegalArgumentException,NullPointerException, or IllegalStateException

26


• A method is not obliged to establish a policy for the unchecked exceptions thrown by its

implementation (and they almost always do not do so)

Checked exceptions :

• Represent invalid conditions in areas outside the immediate control of the program

(invalid user input,database problems, network outages, absent files)

• Are subclasses of Exception

• A method is obliged to establish a policy for all checked exceptions thrown by its

implementation (either pass the checked exception further up the stack, or handle it

somehow) It is somewhat confusing, but note as well that RuntimeException (unchecked)

is itself a subclass of Exception (checked).

"What are Runtime Exceptions?

Generally RuntimeExceptions are exceptions that can be prevented programmatically. E.g

NullPointerException, ArrayIndexOutOfBoundException. If you check for null before calling

any method, NullPointerException would never occur. Similarly

ArrayIndexOutOfBoundException would never occur if you check the index first.

RuntimeException are not checked by the compiler, so it is clean code.

What is an Error?"

Errors (members of the Error family) are usually thrown for more serious problems, such as

OutOfMemoryError, that may not be so easy to handle. In general, code you write should throw

only exceptions, not errors. Errors are usually thrown by the methods of the Java API, or by the

Java virtual machine itself. Error subclasses represent "serious" errors that a program generally

shouldn't expect to catch and recover from. These include conditions such as an expected class

file being missing, or an OutOfMemoryError.

Example:

Out of Memory

Hard Disk error

Can a method return an exception

Yes itcan return exceptions since they descend from Object class and are a type of Object.

public class Test {

public static void main(String[] args) {

System.out.println(System.getProperty("user.dir"));

Exception ex = test();

System.out.println(ex.getMessage());

}

static Exception test() {

return new IndexOutOfBoundsException("Returning Exception!!!");

}

}

27


Can a subclass throw a narrower Exception ?

An overriding method can throw any uncheck exceptions, regardless of whether the overridden

method throws exceptions or not. However the overriding method should not throw checked

exceptions that are new or broader than the ones declared by the overridden method. The

overriding method can throw narrower or fewer exceptions than the overridden method

28


Memory Management

What you know about Garbage collector in Java?

In the Java programming language, dynamic allocation of objects is achieved using the new

operator. An object once created uses some memory and the memory remains allocated till there

are references for the use of the object. When there are no references for an object, it is assumed

to be no longer needed and the memory occupied by the object can be reclaimed.There is no

explicit need to destroy an object as java handles the de-allocation automatically. The technique

that accomplishes this is known as Garbage Collection.Programs that do not de-allocate

memory can eventually crash when there is no memory left in the system to allocate. These

programs are said to have memory leaks

In Java,Garbage collection happens automatically during the lifetime of a java program,

eliminating the need to de-allocate memory and avoiding memory leaks.

Garbage mechanism in java

class GarabageTestObject{

private int a;

private int b;

public void setMethod(int c,int d){

a=c;

b=d;

}

public void showMethod(){

System.out.println("Value of a = "+a);

System.out.println("Value of a = "+b);

}

public static void main(String args[]){

GarabageTestObject firstObj = new GarabageTestObject ();

GarabageTestObject secondObj = new GarabageTestObject ();

firstObj.setMethod(1,2);

secondObj.setMethod(3,4);

29


firstObj.showMethod();

secondObj.showMethod();

}

}

Now let us see what happens in the memory after we run the above program :

Two Object with values a=1,b=2 and a=3 ,b=4 are created with two reference variables firstObj

and secondObj created

Heap Memory

a=1 a=3

b=2 b=4

Now lets us add few lines to the above code:

GarabageTestObject thirdObj;

thirdObj = secondObj;

thirdObj.showMethod();

Now we see two reference variables secondObj and thirdObj are pointing to the same object

a=3,b=4.

Heap Memory

a=1 a=3

b=2 b=4

firstObj secondObj

firstObj secondObj thirdObj

30


Now let us make the below changes in above code

secondObj =null;


We see secondObj becomes null but the reference thirdObj still exist and hence the object is not

eligible for garabge collection

Heap Memory

a=1 a=3

b=2 b=4

Now let us add following lines of code to the above code

thirdObj =null;


Now to the second object no reference variables are pointing and hence become eligible

candidate for garbage collection.

Heap Memory

a=1 a=3

b=2 b=4

Note :

If you want to make your object eligible for Garbage Collection , assign its reference

variable to null.

Primitive types are not objects. They cannot be assigned null.

firstObj secondObj

thirdObj

Pointing to null

firstObj secondObj thirdObj

31


Which part of the memory is involved in Garbage Collection? Stack or Heap?

Heap

What is responsiblity of Garbage Collector?

Garbage collector frees the memory occupied by the unreachable objects during the java

program by deleting these unreachable objects.It ensures that the available memory will be used

efficiently, but does not guarantee that there will be sufficient memory for the program to run.

Is garbage collector a dameon thread?

Yes GC is a dameon thread. A dameon thread runs behind the application. It is started by JVM.

The thread stops when all non-dameon threads stop.

Garbage Collector is controlled by whom?

The JVM controls the Garbage Collector; it decides when to run the Garbage Collector. JVM

runs the Garbage Collector when it realizes that the memory is running low, but this behavior of

jvm can not be guaranteed.One can request the Garbage Collection to happen from within the

java program but there is no guarantee that this request will be taken care of by jvm.

When does an object become eligible for garbage collection?

An object becomes eligible for Garbage Collection when no live thread can access it.

What are the different ways to make an object eligible for Garbage Collection when it is no

longer needed?

a. Set all available object references to null once the purpose of creating the object is served :

public class GarbageCollnTest1 {

public static void main (String [] args){

String str = "Set the object ref to null";

//String object referenced by variable str is not eligible for GC yet

str = null;

/*String object referenced by variable str becomes eligible for GC */

}

}

32


b. Make the reference variable to refer to another object : Decouple the reference variable from

the object and set it refer to another object, so the object which it was referring to before

reassigning is eligible for Garbage Collection.

publc class GarbageCollnTest2 {

public static void main(String [] args){

String str1 = "Garbage collected after use";

String str2 = "Another String";

System.out.println(str1);

//String object referred by str1 is not eligible for GC yet

str1 = str2;

/* Now the str1 variable referes to the String object "Another String" and the object "Garbage

collected after use" is not referred by any variable and hence is eligible for GC */

}

}

c. Creating Islands of Isolation : If you have two instance reference variables which are

referring to the instances of the same class, and these two reference variables refer to each

other and the objects referred by these reference variables do not have any other valid

reference then these two objects are said to form an Island of Isolation and are eligible for

Garbage Collection.

public class GCTest3 {

GCTest3 g;

public static void main(String [] str){

GCTest3 gc1 = new GCTest3();

GCTest3 gc2 = new GCTest3();

gc1.g = gc2; //gc1 refers to gc2

gc2.g = gc1; //gc2 refers to gc1

gc1 = null;

gc2 = null;

//gc1 and gc2 refer to each other and have no other valid //references

//gc1 and gc2 form Island of Isolation

//gc1 and gc2 are eligible for Garbage collection here

}

}

33


Can the Garbage Collection be forced by any means?

No. The Garbage Collection can not be forced, though there are few ways by which it can be

requested there is no guarantee that these requests will be taken care of by JVM.

What is the purpose of overriding finalize() method?

The finalize() method should be overridden for an object to include the clean up code or to

dispose of the system resources that should to be done before the object is garbage collected.

If an object becomes eligible for Garbage Collection and its finalize() method has been

called and inside this method the object becomes accessible by a live thread of execution

and is not garbage collected. Later at some point the same object becomes eligible for

Garbage collection, will the finalize() method be called again?

No

How many times does the garbage collector calls the finalize() method for an object?

Only once.

What happens if an uncaught exception is thrown from during the execution of the

finalize() method of an object?

The exception will be ignored and the garbage collection (finalization) of that object terminates.

What are different ways to call garbage collector?

Garbage collection can be invoked using System.gc() or Runtime.getRuntime().gc().

What is Garbage collection algorithms

Any garbage collection algorithm must do two basic things.

First, it must detect garbage objects.

Second, it must reclaim the heap space used by the garbage objects and make it available to the

program.

Garbage detection is ordinarily accomplished by defining a set of roots and determining

reachability from the roots. An object is reachable if there is some path of references from the

roots by which the executing program can access the object. The roots are always accessible to

the program. Any objects that are reachable from the roots are considered live. Objects that are

not reachable are considered garbage, because they can no longer affect the future course of

program execution.

34


How does the Garbage Collector know what resource to de-allocate?

An object typically goes through most of the following states between the time it is allocated and

the time its resources are finally returned to the system for reuse.

1. Created 2. In use (strongly reachable) : Objects that are held by at least one strong reference are

considered to be in use

3. Invisible : An object is in the invisible state when there are no longer any strong

references that are accessible to the program, even though there might still be references.

public void run() {

try {

Object foo = new Object();

foo.doSomething();

} catch (Exception e) {

// whatever

}

while (true) { // do stuff } // loop forever

}

the object foo falls out of scope when the try block finishes

4. Unreachable : An object enters an unreachable state when no more strong references to

it exist. When an object is unreachable, it is a candidate for collection

5. Collected : An object is in the collected state when the garbage collector has recognized

an object as unreachable and readies it for final processing as a precursor to deallocation.

If the object has a finalize method, then it is marked for finalization. If it does not have a

finalizer then it moves straight to the finalized state.

6. Finalized : An object is in the finalized state if it is still unreachable after its finalize

method, if any, has been run. A finalized object is awaiting deallocation

7. Deallocated : The deallocated state is the final step in garbage collection. If an object is

still unreachable after all the above work has occurred, then it is a candidate for

deallocation. Again, when and how deallocation occurs is up to the JVM.

What is the impact of the GC on Performance of apps?

GC is automatic in Java and it is low priority task and it runs when there are CPU cycles

available or JVM runs short of memory .But If JVM runs short on memory GC runs

continuously till memory is available , this takes almost 5-15 % of CPU.Two techniques to

reduce GC:

a. Write applications that reuse existing objects [reduce the overheads of creating and

destroying objects but extra work on programmer ‘coz values will need to be reinitialized

prior to use]

b. Use appropriate objects that meet requiremtns [For example for string concatenation use

String Buffer instead of String else every time new string object will be created ]

35


Key Guidelines

What are the best practice for java programming

Best Practices to improve Java program are as follows :

Avoiding garbage Collection:

GC is automatic in Java and it is low priority task and it runs when there are CPU cycles

available or JVM runs short of memory .But If JVM runs short on memory GC runs

continuously till memory is available , this takes almost 5-15 % of CPU.Two techniques

to reduce GC:

a. Write applications that reuse existing objects [reduce the overheads of creating

and destroying objects but extra work on programmer ‘coz values will need to be

reinitialized prior to use]

b. Use appropriate objects that meet requiremtns [For example for string

concatenation use String Buffer instead of String else every time new string object

will be created ]

Loop Optimization :

Java programs spends maximum time in loop hence we must optimize them

a. Avoid using method call for termination of loop

String str=”sdsdsddssdsddffd”;

for(j=0;j<str.length;j++) { ----------------------------Avoid

int len=str.length;

for(j=0;j<len;j++) { -------------------------------Use instead

b. Changing the Loop to backwards.JVM is optimized to compare to integers

between -1 and +5.So re writing a loop to compare against 0 will produce faster

loops

for(int j=len-1;j>=0’j--) { -----------------------------Better

c. Once processing requirement of loop has completed use break to terminate the

loop .This saves JVM from iterating through loop and evaluating termination

criteria .

d. Using local variables within loop requires less processing than instance variables

as it is a part of object .

Data Structures :

Data structure usage is more common with collection , hence most care should be taken

what collection to be used and where

a. HashSet is faster than TreeSet as TreeSet provides iteration of keys in order

b. Implementation of sets are slower than all other collection hence careful

considerations should be given prior to use.

c. HasTable and HashMap are faster than TreeMap as TreeMap provides iteration of

keys in order

d. Among ArrayList ,Vector, Stack and LinkedList , ArrayList is fastest of the list

classes with Vector and Stack being equal .Vector is slow because it uses

synchronization.Stack uses additional method to for push & pop entries.

e. Arrays provides fastest data structure for storing data.

36


f. Proper sizing of the collection object is very important with respect to

performance .For eg if number of elements exceed capacity of HashTable

program will end up with multiple nodes that reduces HashTable’s efficiency , in

addition a larger hashcode will ensure more even distribution within Hashtable &

that improves performance

Synchronization :

Java allows multithreading so that independent operations can overlap . Excessive

synchronization defeats the performance improvements mad possible by multithreading

.Hence design your applications to use minimum amount of synchronization .As

Synchronization involves two major costs :

a. Overheads associated with management of locks by JVM .

b. Defeats the purpose of building multi threaded applications that provide better

performance through parallelism where threads end up waiting up on

synchronized process.

Exception Handling :

a. Simple performance improvement is achieved by placing try-catch block outside

any loops .

b. The other one throw a self defined exception

Explain use of final keyword in java.

A java variable can be declared using the keyword final. Then the final variable can be

assigned only once.

A variable that is declared as final and not initialized is called a blank final variable. A blank

final variable forces the constructors to initialise it.

Java classes declared as final cannot be extended. Restricting inheritance!

Methods declared as final cannot be overridden. In methods private is equal to final, but in

variables it is not.

final parameters – values of the parameters cannot be changed after initialization. Do a small

java exercise to find out the implications of final parameters in method overriding.

Java local classes can only reference local variables and parameters that are declared as final.

A visible advantage of declaring a java variable as static final is, the compiled java class

results in faster performance.

‘final’ should not be called as constants. Because when an array is declared as final, the state of

the object stored in the array can be modified. You need to make it immutable in order not to

allow modifcations. In general context constants will not allow to modify. In C++, an array

declared as const will not allow the above scenario but java allows. So java’s final is not the

general constant used across in computer languages.

A variable that is declared static final is closer to constants in general software terminology. You

must instantiate the variable when you declare it static final.

37


Definition as per java language specification (third edition) – 4.12.4 is “A final variable may

only be assigned to onceJava language specification tries to redefine the meaning of constant in

the following way!

We call a variable, of primitive type or type String, that is final and initialized with a compile-

time constant expression a constant variable. Whether a variable is a constant variable or not may

have implications with respect to class initialization ,binary compatibility and definite

assignment

Static binding vs. Dynamic binding - how can you have dynamic/ static binding in Java?

Dynamic binding is runtime polymorphism and static binding is compile time polymorphism

right

Dynamic binding example would be overriding (Methods are invoked based on object of a class)

Static binding example would be overloading (Methods are invoked based on reference type of a

class)

Dynamic binding means the runtime finds the type of an object (probably from its Class<T>

object) and uses that type to look for the types of methods invoked. As imply, that applies to

overridden class members. And the only kind of class member you can override is an instance

method.

Static binding means the compiler finds the type of an object from the declaration of its reference

and uses that type to look for the types of members. That applies to non-overridden class

members, ie static fields and methods.

Dynamic Binding

In Java, we can assign derived class object to a base class variable. For example, if you have a

class named Vehicle from which you derived the class Car,

Vehicle myVehicle = new Car();

The variable on the left is an object of class Vehicle, but the object on the right is type Car. It

will compile and run successfully but reverse is not possible.

If the Car class has a method that is the same as a method in the Vehicle, then the method in the

derived Car class will be called.

For instance, if both classes define a method called show(), and you do this:

myVehicle.show();

In this case,the method of show() in the Car class will be called.Even though you are using an

Vehicle variable type to call the method show(), the method of show() in the method of Vehicle

class won’t be executed. Instead, it is the method of show() in the Car class that will be executed.

38


The type of the object that is assigned to the Vehicle variable determines the method that is

called. So, when the compiler scans the program and sees a statement like this:

myVehicle.show();

It knows that myVehicle is of type Vehicle, but the compiler also knows that myVehicle can be a

reference to any class derived from Vehicle. Therefore, the compiler doesn’t know what version

of show() that statement is calling. It’s not until the assignment:


After executing the method of show() is determined. Since the assignment doesn’t occur until

runtime, it’s not until runtime that the correct method of show() is known. That is known as

“dynamic binding” or “late binding”: it’s not until your program performs some operation at

runtime that the correct version of a method can be determined. In Java, most uses of inheritance

involve dynamic binding.

Static Binding

It occurs when the compiler determines the correct method called from superclass or subclass

something during compile time ,i.e. before the program is executed.

If both the Vehicle class and the Car class have a member variable with the same name, it’s the

base class version that is used.


Both the Vehicle and Car classes have a String member variable ‘type’, then if you do this:

String str = myVehicle.type;

The value of ‘type’ can be fully determined by the compiler. Because polymorphism is not

allowed for member variables, that statement is referring to the value of ‘type’ in the Vehicle

class–not the Car’s value for ‘type’. The result is: with member variables, it’s the type of the

variable (e.g. myVehicle) that determines which version is called–not the type of the object the

variable refers to (e.g. Car).

That means if both the Vehicle class and the Car class have a member variable with the same

name, it’s the base class version that is used.

When the compiler is able to find out the correct version of something during compilation, that is

known as “static binding or early binding”.

39


Difference between abstract class and interface, when to go abstract class ?

Java Abstract classes are used to declare common characteristics of subclasses. An abstract

class cannot be instantiated. It can only be used as a superclass for other classes that extend the

abstract class. Abstract classes are declared with the abstract keyword. Abstract classes are used

to provide a template or design for concrete subclasses down the inheritance tree.

Like any other class, an abstract class can contain fields that describe the characteristics and

methods that describe the actions that a class can perform. An abstract class can include methods

that contain no implementation. These are called abstract methods. The abstract method

declaration must then end with a semicolon rather than a block. If a class has any abstract

methods, whether declared or inherited, the entire class must be declared abstract. Abstract

methods are used to provide a template for the classes that inherit the abstract methods.

Abstract classes cannot be instantiated; they must be subclassed, and actual implementations

must be provided for the abstract methods. Any implementation specified can, of course, be

overridden by additional subclasses. An object must have an implementation for all of its

methods. You need to create a subclass that provides an implementation for the abstract method.

A big Disadvantage of using abstract classes is not able to use multiple inheritance. In the

sense, when a class extends an abstract class, it can’t extend any other class.

Interface In Java, this multiple inheritance problem is solved with a powerful construct called

interfaces. Interface can be used to define a generic template and then one or more abstract

classes to define partial implementations of the interface. Interfaces just specify the method

declaration (implicitly public and abstract) and can only contain fields (which are implicitly

public static final). Interface definition begins with a keyword interface. An interface like that of

an abstract class cannot be instantiated.

Multiple Inheritance is allowed when extending interfaces i.e. one interface can extend none, one

or more interfaces. Java does not support multiple inheritance, but it allows you to extend one

class and implement many interfaces.

If a class that implements an interface does not define all the methods of the interface, then it

must be declared abstract and the method definitions must be provided by the subclass that

extends the abstract class.

When a given interface method is invoked on a given reference, the behavior that results will be

appropriate to the class from which that particular object was instantiated. This is runtime

polymorphism based on interfaces and overridden methods

Differences

1. Abstract class is a class which contain one or more abstract methods, which has to be

implemented by sub classes. An abstract class can contain no abstract methods also i.e. abstract

class may contain concrete methods. A Java Interface can contain only method declarations and

public static final constants and doesn't contain their implementation. The classes which

implement the Interface must provide the method definition for all the methods present.

2. Abstract class definition begins with the keyword "abstract" keyword followed by Class

definition. An Interface definition begins with the keyword "interface".

40


3. Abstract classes are useful in a situation when some general methods should be implemented

and specialization behavior should be implemented by subclasses. Interfaces are useful in a

situation when all its properties need to be implemented by subclasses

4. All variables in an Interface are by default - public static final while an abstract class can have

instance variables.

5. An interface is also used in situations when a class needs to extend an other class apart from

the abstract class. In such situations its not possible to have multiple inheritance of classes. An

interface on the other hand can be used when it is required to implement one or more interfaces.

Abstract class does not support Multiple Inheritance whereas an Interface supports multiple

Inheritances.

6. An Interface can only have public members whereas an abstract class can contain private as

well as protected members.

7. A class implementing an interface must implement all of the methods defined in the interface,

while a class extending an abstract class need not implement any of the methods defined in the

abstract class.

8. The problem with an interface is, if you want to add a new feature (method) in its contract,

then you MUST implement those method in all of the classes which implement that interface.

However, in the case of an abstract class, the method can be simply implemented in the abstract

class and the same can be called by its subclass

9. Interfaces are slow as it requires extra indirection to to find corresponding method in in the

actual class. Abstract classes are fast

10.Interfaces are often used to describe the peripheral abilities of a class, and not its central

identity, E.g. an Automobile class might

implement the Recyclable interface, which could apply to many otherwise totally unrelated

objects.

Note: There is no difference between a fully abstract class (all methods declared as abstract and

all fields are public static final) and an interface.

Note: If the various objects are all of-a-kind, and share a common state and behavior, then tend

towards a common base class. If all they

share is a set of method signatures, then tend towards an interface.

Similarities:

Neither Abstract classes nor Interface can be instantiated.

41


Difference between overriding and overloading, significance of return type wrt the same.?

Overloading is having two methods with the same name but different parameter types in the

same class (different "signatures"). To overload, changing the return type is only not sufficient,

the (number or type of the) input parameters should change.

Overiding method redefines an existing method in a super class, to specify a new behavior in the

sub class. Return type, Parameter type, Parameter Number all must be same. Only body of

method can change.

What is the reason to make a constructor 'private'?

Yes, a constructor can be private. It can still be called within the class, or any enclosing class.

This is common for things like singletons

public class Singleton {

private static final Singleton instance = new Singleton();

private Singleton() {

// Prevent instantiation from the outside world (assuming this isn't a nested class)

}

public static Singleton getInstance() {

return instance;

}

}

Private constructors are also used to prevent any instantiation, if you have a utility class which

just has static methods

Advantages and disadvantages with Java - in terms of performance.

Advantages of JAVA

Java is simple: Java was designed to be easy to use and is therefore easy to write, compile,

debug, and learn than other programming languages. The reason that why Java is much simpler

than C++ is because Java uses automatic memory allocation and garbage collection where else

C++ requires the programmer to allocate memory and to collect garbage.

Java is object-oriented: Java is object-oriented because programming in Java is centered on

creating objects, manipulating objects, and making objects work together. This allows you to

create modular programs and reusable code.

Java is platform-independent: One of the most significant advantages of Java is its ability to

move easily from one computer system to another.

42


The ability to run the same program on many different systems is crucial to World Wide Web

software, and Java succeeds at this by being platform-independent at both the source and binary

levels.

Java is distributed: Distributed computing involves several computers on a network working

together. Java is designed to make distributed computing easy with the networking capability

that is inherently integrated into it.

Writing network programs in Java is like sending and receiving data to and from a file. For

example, the diagram below shows three programs running on three different systems,

communicating with each other to perform a joint task.

Java is interpreted: An interpreter is needed in order to run Java programs. The programs are

compiled into Java Virtual Machine code called bytecode.

The bytecode is machine independent and is able to run on any machine that has a Java

interpreter. With Java, the program need only be compiled once, and the bytecode generated by

the Java compiler can run on any platform.

Java is secure: Java is one of the first programming languages to consider security as part of its

design. The Java language, compiler, interpreter, and runtime environment were each developed

with security in mind.

Java is robust: Robust means reliable and no programming language can really assure reliability.

Java puts a lot of emphasis on early checking for possible errors, as Java compilers are able to

detect many problems that would first show up during execution time in other languages.

Java is multithreaded: Multithreaded is the capability for a program to perform several tasks

simultaneously within a program. In Java, multithreaded programming has been smoothly

integrated into it, while in other languages, operating system-specific procedures have to be

called in order to enable multithreading. Multithreading is a necessity in visual and network

programming.

Disadvantages of JAVA

Performance: Java can be perceived as significantly slower and more memory-consuming than

natively compiled languages such as C or C++.

Look and feel: The default look and feel of GUI applications written in Java using the Swing

toolkit is very different from native applications. It is possible to specify a different look and feel

through the pluggable look and feel system of Swing.

Single-paradigm language: Java is predominantly a single-paradigm language. However, with

the addition of static imports in Java 5.0 the procedural paradigm is better accommodated than in

earlier versions of Java.

43


How to write efficient program in Java

Write code that is as readable and maintainable as possible.

Have performance goals and benchmarks so you can always measure performance

Put effort into making your architecture perform; it's hard to change that later (compared

with changing implementation)

Think about performance more in terms of complexity of algorithms than "make it 10%

faster": a change from O(n^2) to O(n) is (generally) much more important. (It very much

depends on what the real world usage will be though - if you're only going to be dealing

with small values of n, the "theoretically better" algorithm can easily end up being slower

due to constant factors.)

Use a profiler to determine where your bottlenecks are

Only micro-optimise at the cost of readability when the profiler suggests it's worth doing.

Best Practices

Use shorthand for evaluating Boolean conditions.

Make classes final.

Use int instead of long.

Avoid garbage collection.

Use static variables for Strings.

Avoid the String(String) constructor.

Write efficient loops.

Optimize subexpressions.

Optimize division operations.

Avoid java.util.Enumeration.

Perform casts using instanceof.

Evaluate conditions using instanceof.

Avoid using StringBuffer.append (StringBuffer).

Avoid returning null.

Avoid passing null into methods.

Use caution when passing null into a constructor.

Use long for unique identifiers.

Exit applications correctly.

Print the stack trace.

Using local variables

Using shorthand for evaluating Boolean conditions

Making classes final

Using int instead of long

Avoiding garbage collection

Using static variables for Strings

Avoiding the String(String) constructor

Writing efficient loops

Optimizing subexpressions

Optimizing division operations

44


Avoiding java.util.Enumeration

Performing casts using instanceof

Evaluating conditions using instanceof

Avoiding StringBuffer.append (StringBuffer)

Avoiding returning null

Avoiding passing null into methods

Using caution when passing null into a constructor

Using longs for unique identifiers

Exiting applications correctly

Printing the stack trace

What is meant by Heap, Constant Pool and Stack?

Java has only two types of memory when it comes to JVM. Heap memory and Non-heap

memory. All the other memory jargons you hear are logical part of either of these two.

Heap Memory : Class instances and arrays are stored in heap memory. Heap memory is also

called as shared memory. As this is the place where multiple threads will share the same data

Non-heap Memory: It comprises of ‘Method Area’ and other memory required for internal

processing. It stores per-class structures, code for methods and constructors. Per-class structure

means runtime constants and static fields

Memory Pool : Memory pools are created by JVM memory managers during runtime. Memory

pool may belong to either heap or non-heap memory.

Runtime Constant Pool : A run time constant pool is a per-class or per-interface run time

representation of the constant_pool table in a class file. Each runtime constant pool is allocated

from the Java virtual machine’s method area.

Java Stacks or Frames : Java stacks are created private to a thread. Every thread will have a

program counter (PC) and a java stack. PC will use the java stack to store the intermediate

values, dynamic linking, return values for methods and dispatch exceptions. This is used in the

place of registers

Where are objects stored in memory? Where are the local variables used in the instance

methods stored?

When Each time an object is created in java it goes to area of memory known as heap.

The primitive variables like int and double are allocated in the stack If they are local method

variables.

45


The primitive variables like int and double are allocated in the heap if they are member variables

like fields of a class

In a multi-threaded application each thread will have its own stack but will share the same heap.

This is why care should be taken in your code to avoid any concurrent access issue in the heap

space. The stack is thread-safe because each thread will have its own stack, but the heap is not

thread safe unless guarded with synchronization through your code

How can you have memory leaks in Java

An object is only counted as being unused when it is no longer referenced. And only objects

which are unused will be recycled by the garbage collector. But there may be an object which is

referenced yet not in use. Under such circumstances the GC cannot recycle that object. If the

programming is not careful and there are many such objects, in that case there can be a

considerable memory leak.

Few examples are below :

Static field holding object reference [esp final field]

class MemorableClass {

static final ArrayList list = new ArrayList(100);

}

(Unclosed) open streams ( file , network etc..)

try {

BufferedReader br = new BufferedReader(new FileReader(inputFile));

...

...


e.printStacktrace();

}

Unclosed connections

try {

Connection conn = ConnectionFactory.getConnection();

...

...


e.printStacktrace();

}

46


How can you make a class immutable ?

Do not provide any methods such as setters or any methods that may alter the properties

of that object. If you do, make sure they return a new instance of your object.

All properties and methods of that object are to be marked as final. Marking the methods

as final is extremely important. We don’t want anyone carelessly overridding our

functions that may compromise our immutable behavior.

All properties of that object are to be marked as private.

47


References

http://www.tutorialspoint.com/java

http://www.javabeginner.com/

http://docs.oracle.com/javase/1.5.0/docs/api/java

http://www.tutorialspoint.com/java

http://www.javabeginner.com/

http://docs.oracle.com/javase/1.5.0/docs/api/java

understanding core java concepts

Documents