java

Some commonly asked Core Java interview questions.

What are the main concepts of OOPS?

Following are the important Oops concepts:

• Encapsulation hiding internal implementation details.Clients can access the object only through the public interface such as methods.
• Abstraction Once you implement encapsulation by hiding internal implementation details of the object you implement abstraction.Abstraction means defining public interface to access the object.
• Polymorphism Means same form different behavior. In the context of Object oriented programming it means the same function can behave differently depending on the
  passed arguments.
• Inheritence a new class can reuse the functionality of an existing class by deriving from an existing class.The new class acquires the methods and properties of the existing class.This is an example of is-a relationship.

What are different types of polymorphism in Java?

There are two types of polymorphism

• Runtime polymorphism Method overriding.Method to invoke is decided at runtime.
• compile time polymorphism Method overloading.Method to invoke is decided at compile time.

What is JIT compiler?

Compilation in Java happens in two phases:

• Java code to Bytecode
• Bytecode to machine code of CPU

JIT compiler compiles Bytecode to machine code at runtime.Since this compilation happens at runtime ,it is known as JIT(Just in time compilation).It is through Bytecode that Java is platform independent.Bytecode is not specific to any specific CPU so it can execute on different platforms.

What is JVM?

JVM is Java virtual machine.JVM converts the Bytecode to machine code.There is a separate JVM for every platform.

What is Constructor?

Constructor is like a normal method but has some differences from a normal method.Instead of invoking explicitly ,constructor is automatically called when an object of the class is created.It’s not required to define constructor in our class.If we don’t define a constructor then default constructor is created by Java.It initializes the variables with default values.A constructor is not inherited by the derived class.

How inheritence is implemented in Java?

inheritence is implemented in Java using the extends keyword.We define a subclass which extends a superclass as:

class sublcass extends superclass 
{ 
//class members,e.g methods and fields 
}

class which extends the parent class is called subclass while parent class is called super class.

What is generalization in Java?

generalization means extracting common attributes from two or more classes into a common super class.generalization in Java is implemented using inheritence.
For example common traits from employees of different departments such as employee number and company name can be extracted into a common super class.Different employee classes can then inherit from this employee super class.
Any behavior which can invoked on an object of super class can also be invoked on an object of child class.

What is association?

In association relationship classes depends upon each other but each class is independent.Each class can be instantiated independently.

What is an Interface?

Interface is just a contract which consists of method signatures.Interface doesn’t consist of implementation details. Implemetation is provided by the classes which implements the interface.Interface methods can be only public and abstract.The variables can be public,static or final.So Interface can consist of variables but just constants.

An interface is a description of a set of methods that conforming implementing classes must have.

Which class is the superclass of all the classes?

java.lang.Object is the super class of all the java classes

Does Java support multiple class inheritance?

Java does not support multiple class inheritance.A class in Java can inherit only from single class.

Which method is called first in Java application?

The main() method is called first in a Java application.Its signature is:

public static void main(String args[])

Can a single Java file define multiple classes?

A Java source file can contain multiple classes.But only single class in the source file can be public.

What is garbage collection?

Garbage collection is used to free the unused memory. By removing memory no longer being used by object references ,memory is made available for the program.

Follow on:

Following are some of the characteristics of lambda expression in Java 8.

1.It is a function which doesn’t have a name.But like other functions it has a :

• return type
• list of parameters
• body

2.lambda expression can be passed to other methods as parameters.This is a way to develop decoupled applications.
Since you can pass behaviour as a parameter using lambda expression at run time ,you are not coupling your application
to a fixed logic.This logic can be determined at runtime.

3.lambda expressions are easier to create than anonymous functions.

To create a lambda expression:

1.Create an interface with one abstract method called SayHello.Decorate the interface with annotation @FunctionalInterface.

@FunctionalInterface
interface ExampleInterface {
void SayHello(String data);
}

2. Declare a lambda expression as:
Write parameters inside paranthesis.You should write the same number of parameters as declared in the above interface.
(String message)

3.Write arrow “-> ” and on the right hand side write the body of the lambda expression.

(String message)->System.out.println("hello "+message);

4.Declare an object of the interface type and assign the lambda expression to it

ExampleInterface f=(String message)->System.out.println("hello "+message);

5.Call the method of the interface using the object declared above.

f.SayHello("Java");

The above example prints the output hello Java.
Following is the complete example.

public class HelloWorld
{
public static void main(String[] args)
{

ExampleInterface f=(String message)->System.out.println("hello "+message);
f.SayHello("Java");

}
}
@FunctionalInterface
interface ExampleInterface {
void SayHello(String data);
}

In the above example of Lambda expression we have implemented a functional interface.Functional interface is an interface which has only one method.We can use lambda expression to implement different functionalities.

For example to add two number we use the following the example

Calculate f=(a,b)-> System.out.println(a+b);;
f.Add(1,2);

interface Calculate {
void Add(int a,int b);
}

 

Follow on:

It is sometimes useful not to specify a value for a variable.If a class variable is unassigned then it has null value.In such scenario we can use Optional class in Java 8 for optional values.

Optional is a useful class if we want to specifying whether a variable will have some assigned value or not.We define such a variable as Optional type.
The difference between a normal variable and an optional variable is we don’t need to assign a null value to specify absence of value.If specify
absent value using the empty method of the Optional type.For example we can specify an empty value for an optional variable as:

Optional<Integer> optVar=Optional.empty();

Similarly we can specify a value for an optional variable as:

Integer sampleValue=1;
Optional<Integer> optVar=Optional.of(sampleValue);

Following is the complete example:

import java.util.Optional;

public class SampleClass {
public static void main(String args[]){
SampleClass obj = new SampleClass();
if(obj.Check())
System.out.println("value is present");
else
System.out.println("value not present for optional type");
}
Integer a=1;
Optional<Integer> opt=Optional.of(a);

public boolean Check()
{
System.out.println("going to check value");
if(opt.isPresent()) {
return true;
}
else
{
return false;
}

}
}

 

Follow on:

Generics helps reusability of code

Generics are one of the most useful features of Java.Generics allows re usability of code.The same generic type,such as class,can work with different data types.Before generics we defined a class which work with only
specific data type.for example if we declare a class as:

public class SampleClass{
Integer obj;
//operations for integer type
}

the above class works with only integer data type.If you want to implement operations for float data type then you need to implement another class for float type.So such implementations results in duplicate logic.

When we use generic class we define a single class which works with different data types.

public class SampleClass<T>{

public static void main(String []args){
System.out.println("Hello World");
SampleClass<Integer> obj1=new SampleClass<Integer>();
obj1.Set(1);
System.out.println(obj1.Get());
}

T obj;

void Set(T a) {
obj=a;
}
T Get() {
return obj;
}
}

Generics avoid  casting

Another problem which occurs is when we use a class such as araylist. We can store different types of objects in arraylist. But when we retrieve elements from arraylist then we need to use type conversion.

List list = new ArrayList();
list.add("1");
String s = (String) list.get(0);

If we use generic collection then casting is not required.Below code is same as the previous implementation but doesn’t need casting.

List<String> list = new ArrayList<String>();
list.add("1");
String s = list.get(0);

 

Follow on:

The java.io package is useful when you want to perform any type of input or output operation.It contains different classes for performing input and output operations in Java.Here we will see how to Create file in Java using File class.

It contains the File class for performing file and directory related input/output operations.

To create a new following steps could be used

1.Import the file class by using

import java.io.File;

2.Declare a variable to File type.Pass the path and the name of the file you want to create.

String path="exampleFile.txt";
File file= new File(path);

3.Create a new file by calling the createNewFile() method.This method returns boolean if the file is created and returns false if the file is not created.Also it throws the IOException if there is any exception.You should enclose the call to createNewFile() method in try catch block otherwise you will get compile time error.

try
{
if(file.createNewFile())
System.out.println("file created");
else
System.out.println("unable to create file");
}
catch(IOException e)
{
System.out.println("exception occured");
}

Complete example:

import java.io.File;
class FileExample{
 
String path="exampleFile.txt";
File file= new File(path);
try
{
if(file.createNewFile())
System.out.println("file created");
else
System.out.println("unable to create file");
}
catch(IOException e)
{
System.out.println("exception occured");
}
}

Follow on: