Core Java Interview Questions and Answers

JDK (Java Development Kit) is a development purpose and it includes execution environment also. But JVM is purely a run time environment and hence you will not be able to compile your source files using a JVM.

• Abstraction
• Polymorphism
• Inheritance
• Encapsulation

Polymorphism is briefly described as “one interface, many implementations.” Polymorphism is a characteristic of being able to assign a different meaning or usage to something in different contexts – specifically, to allow an entity such as a variable, a function, or an object to have more than one form.

An Inner class is a class which is nested within another class. An Inner class has access rights for the class which is nesting it and it can access all variables and methods defined in the outer class.

A sub-class is a class which inherits from another class called super class. Sub-class can access all public and protected methods and fields of its super class.

In Java, access specifiers are the keywords used before a class name which defines the access scope. The types of access specifiers for classes are:

• Public: Class,Method,Field is accessible from anywhere.
• Protected:Method,Field can be accessed from the same class to which they belong or from the sub-classes,and from the class of same package,but not from outside.
• Default: Method,Field,class can be accessed only from the same package and not from outside of its native package.
• Private: Method,Field can be accessed from the same class to which they belong.

When there is a requirement to share a method or a variable between multiple objects of a class instead of creating separate copies for each object, we use static keyword to make a method or variable shared for all objects.

No

Yes, derived classes still can override the overloaded methods. Polymorphism can still happen. Compiler wills not binding the method calls since it is overloaded, because it might be overridden now or in the future.

Encapsulation is a concept in Object Oriented Programming for combining properties and methods in a single unit.

Encapsulation helps programmers to follow a modular approach for software development as each object has its own set of methods and variables and serves its functions independent of other objects. Encapsulation also serves data hiding purpose.

A singleton class in java can have only one instance and hence all its methods and variables belong to just one instance. Singleton class concept is useful for the situations when there is a need to limit the number of objects for a class.

The best example of singleton usage scenario is when there is a limit of having only one connection to a database due to some driver limitations or because of any licensing issues.

It is a thread that does not prevent the JVM from exiting when the program finishes but the thread is still running. An example for a daemon thread is the garbage collection.

Looping is used in programming to execute a statement or a block of statement repeatedly. There are three types of loops in Java:

For Loops

For loops are used in java to execute statements repeatedly for a given number of times. For loops are used when number of times to execute the statements is known to programmer.

While Loops

While loop is used when certain statements need to be executed repeatedly until a condition is fulfilled. In while loops, condition is checked first before execution of statements.

Do While Loops

Do While Loop is same as while loop with only difference that condition is checked after execution of block of statements. Hence in case of do while loop, statements are executed at least once.

Deadlock describes a situation where two or more threads are blocked forever, waiting for each other.

An infinite loop runs without any condition and runs infinitely. An infinite loop can be broken by defining any breaking logic in the body of the statement blocks.

Infinite loop is declared as follows:

For (;;)

{

// Statements to execute

// Add any loop breaking logic

}

break and continue are two important keywords used in Loops. When a break keyword is used in a loop, loop is broken instantly while when continue keyword is used, current iteration is broken and loop continues with next iteration.

In below example, Loop is broken when counter reaches 4.

For (counter=0;counter

System.out.println(counter);

If (counter==4) {

Break;}

}

In the below example when counter reaches 4, loop jumps tonext iteration and any statements after the continue keyword are skipped for current iteration.

For (counter=0;counter

System.out.println(counter);

If (counter==4) {

continue;

}

System.outprintln("This will not get printed when counter is 4");

}

In java, float takes 4 bytes in memory while Double takes 8 bytes in memory. Float is single precision floating point decimal number while Double is double precision decimal number.

javac produces the java byte code from *.java file. It is the intermediate representation of your source code that contains instructi

In java, a constant is declared using the keyword Final. Value can be assigned only once and after assignment, value of a constant can’t be changed.

In below example, a constant with the name const_val is declared and assigned avalue:

Private Final int const_val=100

When a method is declared as final,it can NOT  be overridden by the subclasses.This method are faster than any other method,because they are resolved at complied time.

When a class is declares as final,it cannot be subclassed. Example String,Integer and other wrapper classes.

Ternary operator, also called conditional operator is used to decide which value to assign to a variable based on a Boolean value evaluation. It’s denoted as?

In the below example, if rank is 1, status is assigned a value of “Done” else “Pending”.

public class conditionTest {

public static void main(string args[]) {

String status;

int rank;

status= (rank == 1) ? "Done": "Pending";

}

}

In java, operators can be classified in following six types:

Arithmetic Operators

Used for arithmetic calculations. Example are +,-,*,/,%,++,–

Relational Operators

Used for relational comparison. E.g. ==,!=, >,<,<=,>=

Bitwise operators

Used for bit by bit operations. E.g. &,|,^,~

Logical Operators

Used for logical comparisons. E.g. &&,||,!

Assignment Operators

Used for assigning values to variables. E.g. =,+=,-=,*=,/=

In a switch statement, default case is executed when no other switch condition matches. Default case is an optional case.

It can be declared only once all other switch cases have been coded.

In the below example, when score is not 1 or 2, default case is used.

public class switchExample {

int score=4;

public static void main(String args[]) {

switch (score) {

case 1:

System.out.println("Score is 1");

break;

case 2:

system.out.println("Score is 2");

break;

default:

System.out.println("Default Case");

}

}

}

java.lang.object

In java, main() method can’t return any data and hence, it’s always declared with a void return type.

In Java, package is a collection of classes and interfaces which are bundled together as they are related to each other. Use of packages helps developers to modularize the code and group the code for proper re-use. Once code has been packaged in Packages, it can be imported in other classes and used.

Yes we can create an abstract class by using abstract keyword before class name even if it doesn’t have any abstract method. However, if a class has even one abstract method, it must be declared as abstract otherwise it will give an error.

Heap memory is used by all the parts of the application. Whenever an object is created, it’s always stored in the Heap space and stack memory contains the reference to it. Memory management is more complex in Heap memory because it’s used globally.

Stack memory is used only by one thread of execution. Stack memory only contains local primitive variables and reference variables to objects in heap space. Memory management in the stack is done in LIFO manner

The primary difference between an abstract class and interface is that an interface can only possess declaration of public static methods with no concrete implementation while an abstract class can have members with any access specifiers (public, private etc) with or without concrete implementation.

Another key difference in the use of abstract classes and interfaces is that a class which implements an interface must implement all the methods of the interface while a class which inherits from an abstract class doesn’t require implementation of all the methods of its super class.

A class can implement multiple interfaces but it can extend only one abstract class.

Interfaces are slower in performance as compared to abstract classes as extra indirections are required for interfaces. Another key factor for developers to take into consideration is that any class can extend only one abstract class while a class can implement many interfaces.

Use of interfaces also puts an extra burden on the developers as any time an interface is implemented in a class; developer is forced to implement each and every method of interface.

In java, when a package is imported, its sub-packages aren’t imported and developer needs to import them separately if required.

For example, if a developer imports a package university.*, all classes in the package named university are loaded but no classes from the sub-package are loaded. To load the classes from its sub-package ( say department), developer has to import it explicitly as follows:

Import university.department.*

In java, main method must be public static in order to run any application correctly. If main method is declared as private, developer won’t get any compilation error however, it will not get executed and will give a runtime error.

In java, we can pass argument to a function only by value and not by reference.

In java, to convert an object into byte stream by serialization, an interface with the name Serializable is implemented by the class. All objects of a class implementing serializable interface get serialized and their state is saved in byte stream.

Serialization is used when data needs to be transmitted over the network. Using serialization, object’s state is saved and converted into byte stream. The byte stream is transferred over the network and the object is re-created at destination.

Try blocking needs to be followed by either Catch block or finally block or both. Any exception thrown from try block needs to be either caught in the catch block or else any specific tasks to be performed before code abortion are put in the Finally block.

If an exception is raised in Try block, control passes to catch block if it exists otherwise to finally block. Finally block is always executed when an exception occurs and the only way to avoid execution of any statements in Finally block is by aborting the code forcibly by writing following line of code at the end of try block:

System.exit(0);

The constructor of a class is invoked every time an object is created with new keyword.

For example, in the following class two objects are created using new keyword and hence, constructor is invoked two times.

public class const_example {

const_example() {

System.out.println("Inside constructor");

}

Public static void main(String args[]) {

const_example c1=new const_example();

const_example c2=new const_example();

}

}

		

Yes, a class can have multiple constructors with different parameters. Which constructor gets used for object creation depends on the arguments passed while creating the objects.

Super keyword can be used to access super class method when you have overridden the method in the child class.

We cannot override static methods. Static methods belong to a class and not to individual objects and are resolved at the time of compilation . Even if we try to override static method, we will not get an compilation error, nor the impact of overriding when running the code.

In the below example, what will be the output?

public class superclass {

public void displayResult() {

System.out.println("Printing from superclass");

}

}

public class subclass extends superclass {

public void displayResult() {

System.out.println("Displaying from subClass");

super.displayResult();

}

public static void main(String args[]) {

subclass obj=new subclass();

obj.displayResult();

}

}

Output will be:

Displaying from subclass

Displaying from superclass

String is not a primitive data type in java. When a string is created in java, it’s actually an object of Java.Lang.String class that gets created. After creation of this string object, all built-in methods of String class can be used on the string object.