Ayupp Google Ads

Rule to crack any beginner’s java interview 1

Java is a language which is extensively used across the globe. Java is extensively used almost across all the companies across the world, in some form of another and it is extensively used by developers to develop application using java.

There has been a huge demand for java developers across the IT market, across the world. So how can we land our self a job in java? Below are the set of important questions faced by most of the interviewers with some short and  quick answers.

  1. Related to exception handling: What is the difference between Throw and Throws in Java
  2. What is the Difference between JDK and JRE?

The “JDK” is the Java Development Kit. I.e., the JDK is bundle of software that you can use to develop Java based software.

The “JRE” is the Java Runtime Environment. I.e., the JRE is an implementation of the Java Virtual Machine which actually executes Java programs.

Typically, each JDK contains one (or more) JRE’s along with the various development tools like the Java source compilers, bundling and deployment tools, debuggers, development libraries, etc.

  1. What does the ‘static’ keyword mean?

Static variable is associated with a class and not objects of that class. For example:

public class ExplainStatic {

      public static String name = "Look I am a static variable";


We have another class where-in we intend to access this static variable just defined.

public class Application {

        public static void main(String[] args) {




  1. What are the Data Types supported by Java? What is Autoboxing and Unboxing?

Most commonly asked, The eight Primitive Data types supported by Java are:

  • Byte: 8-bit signed two’s complement integer. It has a minimum value of -128 and a maximum value of 127 (inclusive)
  • Short: 16-bit signed two’s complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive).
  • Int: 32-bit signed two’s complement integer. It has a minimum value of -2,147,483,648 and a maximum value of 2,147,483,647 (inclusive)
  • Long: 64-bit signed two’s complement integer. It has a minimum value of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807 (inclusive)
  • Double
  • Float

Unboxing: The automatic transformation of wrapper types into their primitive equivalent is known as Unboxing.

Autoboxing: The Java compiler brings about an automatic transformatio n of primitive type (int, float, double etc.) into their object equivalents or wrapper type (Integer, Float, Double,etc) for the ease of compilation.

  1. What is the difference between STRINGBUFFER and STRING?

String object is immutable. i.e , the value stored in the String object cannot be changed. Consider the following code snippet:

String myString = “Hello”;

myString = myString + ” Master”;

When you print the contents of myString the output will be “Hello Master”. Although we made use of the same object (myString), internally a new object was created in the process. That’s a performance issue.

StringBuffer/StringBuilder objects are mutable: StringBuffer/StringBuilder objects are mutable; we can make changes to the value stored in the object. What this effectively means is that string operations such as append would be more efficient if performed using StringBuffer/StringBuilder objects than String objects.

String str = “Be Happy With Your job.''

str += “Because Increments are a myth";

StringBuffer strbuf = new StringBuffer();



The Output of the code snippet would be: Be Happy with Your job. Because Increments are a myth.

  1. What is Function OverRiding and OverLoading in Java?

OverRiding: An override is a type of function which occurs in a class which inherits from another class. An override function “replaces” a function inherited from the base class, but does so in such a way that it is called even when an instance of its class is pretending to be a different type through polymorphism. That probably was a little over the top. The code snippet below should explain things better.

public class Car {

public static void main (String [] args) {

Car a = new Car();

Car b = new Ferrari(); //Car ref, but a Ferrari object

a.start(); // Runs the Car version of start()

b.start(); // Runs the Ferrari version of start()



class Car {

public void start() {

System.out.println("This is a Generic start to any Car");



class Ferrari extends Car {

public void start() {

System.out.println("Lets start the Ferrari and go out for a cool Party.");



OverLoading: Overloading is the action of defining multiple methods with the same name, but with different parameters. It is unrelated to either overriding or polymorphism. Functions in Java could be overloaded by two mechanisms ideally:

  • Varying the number of arguments.
  • Varying the Data Type.

class CalculateArea{

      void Area(int length){System.out.println(length*2);}

      void Area(int length , int width){System.out.println(length*width);}


      public static void main(String args[]){

      CalculateArea obj=new CalculateArea();

      obj.Area(10);   // Area of a Square

      obj.Area(20,20);  // Area of a Rectangle




  1. What is Constructors, Constructor Overloading in Java and Copy-Constructor?

Constructors form the basics of OOPs, for starters.

Constructor: The sole purpose of having Constructors is to create an instance of a class. They are invoked while creating an object of a class. Here are a few salient features of Java Constructors:

  • Constructors can be public, private, or protected.
  • They must have the same name as the class itself.
  • If a constructor with arguments has been defined in a class, you can no longer use a default no-argument constructor – you have to write one.
  • They are called only once when the class is being instantiated.
  • They do not return a value and you do not have to specify the keyword void.
  • If you do not create a constructor for the class, Java helps you by using a so called default no-argument constructor.

public class Boss{

     String name; 


     Boss(String input) { //This is the constructor

        name = "Our Boss is also known as : " + input;



public static void main(String args[]) {

     Boss p1 = new Boss("Super-Man");



Constructor overloading: passing different number and type of variables as arguments all of which are private variables of the class. Example snippet could be as follows:

public class Boss{

   String name; 

   Boss(String input) { //This is the constructor

        name = "Our Boss is also known as : " + input;


   Boss() {

        name = "Our Boss is a nice man. We don’t call him names.”;


public static void main(String args[]) {

      Boss p1 = new Boss("Super-Man");

      Boss p2 = new Boss();



Copy Constructor: A copy constructor is a type of constructor which constructs the object of the class from another object of the same class. The copy constructor accepts a reference to its own class as a parameter.

Note: Java Doesn’t support Copy Constructor. Nevertheless folks from C/C++ background often get confused when asked about Java Copy Constructors.

  1. What is Java Exception Handling? What is the difference between Errors, Unchecked Exception and Checked Exception?

Anything that’s not Normal is an exception. Exceptions are the customary way in Java to indicate to a calling method that an abnormal condition has occurred.

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. Here’s a hierarchical Exception class structure:

  • An Unchecked Exception inherits from RuntimeException (which extends from Exception). The JVM treats RuntimeException differently as there is no requirement for the application-code to deal with them explicitly.
  • A Checked Exception inherits from the Exception-class. The client code has to handle the checked exceptions either in a try-catch clause or has to be thrown for the Super class to catch the same. A Checked Exception thrown by a lower class (sub-class) enforces a contract on the invoking class (super-class) to catch or throw it.
  • Errors (members of the Error family) are usually thrown for more serious problems, such as OutOfMemoryError (OOM), that may not be so easy to handle.

 Exception handling needs special attention while designing large applications. So we would suggest you to spend some time brushing up your Java skills.

  1. What is the difference between Throw and Throws in Java Exception Handling

Throws: A throws clause lists the types of exceptions that a method might throw, thereby warning the invoking method – ‘Dude. You need to handle this list of exceptions I might throw.’ Except those of type Error or RuntimeException, all other Exceptions or any of their subclasses, must be declared in the throws clause, if the method in question doesn’t implement a try…catch block. It is therefore the onus of the next-on-top method to take care of the mess.

public void myMethod() throws PRException


This means the super function calling the function should be equipped to handle this exception.

public void Callee()




}catch(PRException ex)


...handle Exception....



Using the Throw: If the user wants to throw an explicit Exception, often customized, we use the Throw. The Throw clause can be used in any part of code where you feel a specific exception needs to be thrown to the calling method.


if(age>100){throw new AgeBarException(); //Customized ExceptioN




}catch(AgeBarException ex){

...handle Exception.....


  1. What is the Difference between byte stream and Character streams?

Every Java Programmer deals with File Operations. To generate User reports, send attachments through mails and spill out data files from Java programs. And a sound knowledge on File Operation becomes even more important while dealing with Java questions.

byte stream : For reading and writing binary data, byte stream is incorporated. Programs use byte streams to perform byte input and output.

  • Performing InputStream operations or OutputStream operations means generally having a loop that reads the input stream and writes the output stream one byte at a time.
  • You can use buffered I/O streams for an overhead reduction (overhead generated by each such request often triggers disk access, network activity, or some other operation that is relatively expensive).

Character streams: Character streams work with the characters rather than the byte. In Java, characters are stored by following the Unicode (allows a unique number for every character) conventions. In such kind of storage, characters become the platform independent, program independent, language independent.

  1. What are FileInputStream and FileOutputStream ? Explain with an example to read and write into files.

FileInputStream : It contains the input byte from a file and implements an input stream.

FileOutputStream : It uses for writing data to a file and also implements an output stream.

public class FileHandling {

public static void main(String [ ] args) throws IOException


FileInputStream inputStream = new FileInputStream ("Input.txt") ;

FileOutputStream outputStream = new FileOutputStream("Output.txt",true) ;


byte[] buffer = new byte[1024];

//For larger files we specify a buffer size which defines the chunks size for data

int bytesRead;

while ((bytesRead = inputStream.read(buffer)) != -1)

        outputStream.write(buffer, 0, bytesRead);

inputStream.close() ;

outputStream.close() ;



  1. What is the difference between ArrayList and LinkedList ?

Please pay special attention as this is probably one of the most widely asked interview questions.

We aren’t going to state the properties of each in this question. What we are looking for are the differences. The prime areas where the two stand apart are as follows :



Random access.

Sequential access.The control traverses from the first node to reach the indexed node.

Only objects can be added.

The LinkedList is implemented using nodes linked to each other. Each node contains a previous node link, next node link, and value, which contains the actual data

  1. Explain the difference between ITERATOR AND ENUMERATION INTERFACE with example.
  • Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics.
  • Iterator actually adds one method that Enumeration doesn’t have: remove ().

Whereas in case of Enumeration:

  1. What is the use of the ‘SimpleDateFormat’ and how can you use it to display the current system date in ‘yyyy/MM/DD HH:mm:ss’ format?

SimpleDateFormat is one such concrete class which is widely used by Java developers for parsing and formatting of dates. This is also used to convert Dates to String and vice-versa.

Literally every Enterprise level Java Application invariably uses the SimpleDateFormat for handling user dates. We ofcourse aren’t expecting Java interviewees to be absolutely spectacular with the syntaxes. But a basic know-how of this class is mandatory.


public class CurrentSystemDate {

public static void main(String[] args) {

        SimpleDateFormat sysForm = new SimpleDateFormat("yyyy/MM/DD HH:mm:ss");

        Date curdate= new Date();




The best way to brush up your Java knowledge is to open up an eclipse and write loads of codes and sample programs. Get into the habit of remembering syntaxes and applying the best coding standards possible.