• Simple: Java Programming language is easy to learn. The Java syntax is based on C++ in which we can easily write the program.
• Portable: Java has a read-once-write-anywhere approach. We can run the Java program on any machine by converting the Java program (.java) to bytecode (.class).
• Platform Independent: Java doesn’t depend upon any other operating system to be executed and comes with its platform on which its code is executed.
• Secured: Java uses ByteCode and Exception handling which makes it more secured.
• Robust: Java uses strong memory management. The concepts such as Exception handling, Automatic garbage collection, etc. make it more robust.
• Architecture Neutral: Java is not dependent on the architecture. In C language, the size of the architecture (32 bit or 64 bit) varies that doesn’t exist in Java.
• Interpreted: Java uses (JIT) interpreter along with the compiler to execute the program.
• High Performance: Java is faster than other traditional programming languages because Java bytecode is “close” to native code but still a little bit slower than a compiled language (e.g., C++).
• Dynamic: Java Programming language is dynamic. It allows the dynamic loading of classes and loads on demand. It also sustains functions from its native languages, i.e., C and C++.

• Class(Method) Area: It stores per-class structures such as the runtime constant pool, method data, field, and the code for methods.
• Heap: It is the runtime data area in which allocated the memory to the objects
• Stack: Java Stack supplies frames. It carries local variables and partial results, and plays a part in method invocation and return. Each thread creates a private JVM stack. A new frame is made every time a method is invoked. A frame is destroyed when its method invocation finishes.
• Program Counter Register: PC (program counter) register includes the address of the JVM instruction currently being implemented.
• Native Method Stack: It includes all the native methods used in the application.

• Java is only a software-based platform whereas other platforms can be software-based platforms or hardware-based platforms.
• Java is directed on top of other hardware platforms whereas other platforms can only work on the hardware components.

• Bootstrap ClassLoader: it is the superclass of the Extension classloader as it loads the rt.jar file that includes all class files of Java Standard Edition like java.util package classes, java.lang package classes, java.io package classes, java.net package classes, java.sql package classes, etc.
• Extension ClassLoader: For Bootstrap it is the child classloader and parent classloader of the System classloader. It loads the jar files placed inside $JAVA_HOME/jre/lib/ext directory.
• System/Application ClassLoader: It loads the class files from the classpath. By default, the classpath is set to the existing directory. You can alter the classpath using “-cp” or “-classpath” switch. It is also called the Application classloader.

Yes, Java authorizes us to save our java file by .java only, after that we need to assemble it by javac .java and operate by java class name. For example:

//save by .java only

class A{

public static void main(String args[]){

System.out.println(“Hello java”);

}

}

//compile by javac .java

//run by java A

compile it by javac .java

run it by java A

• Public: Any classes, methods, or variables can be accessed under public.
• Protected: It can be accessed by the class or the sub-class of the same package.
• Default: Default is accessible in the set package only.
• Private: The class, methods, or variables mentioned as private can be called up within that class only.

• Packages evade the name clashes.
• The Package gives easier access control.
• Packages also use the hidden classes which are not visible outside.
• It easily locates the related classes.

• Follows the bottom-up approach in program design.
• Focus on data with methods to operate upon the object’s data
• Consist the concept like Encapsulation and abstraction which only show functionality to the user and hide the complexities.
• Implements the real-time approach such as inheritance, abstraction, etc.
• C++, Simula, Smalltalk, Python, C#, etc. are some examples of the object-oriented paradigm.

Core Java Interview Questions For Experienced

• Default Constructor: It is the one that doesn’t take any value. It is mainly used to set the instance variable with the default values. Default Constructor is also used for executing some important tasks on object creation. A default constructor is invoked indirectly by the compiler if there is no constructor mentioned in the class.
• Parameterized Constructor: It is the one that uses the given values to initialize the instance variables. Generally, the constructors which take the arguments are called parameterized constructors.

• A static method fits in the class better rather than the object.
• You do not require creating an object to call the static methods.
• A static method can manage and modify the value of the static variable.

Follow Simple Steps to apply in these MNC’s:

• Infosys Interview Process | Selection Criteria, Technical Questions
• TCS Interview Process - Complete Recruitment Guide, Tips
• SAP Interview Guide: SAP Labs Hiring Process, Tips, Questions
• HP Interview Guide, Application & Recruitment Process, Tips
• Adobe Hiring Process | Questions & Adobe’s Core Values
• Know All Companies Hiring Process Here

• The static method is not able to use non-static data members or directly call the non-static method.
• this and super are non-static so they cannot be used in a static context.

It is used to set the static data member and executed prior to the main method, at the time of classloading.

class A2{

static{System.out.println(“static block is invoked”);}

public static void main(String args[]){

System.out.println(“Hello main”);

}

}

Initially, Program compiles but at runtime, It shows an error “NoSuchMethodError.”

Know the Interview Criteria of these MNCs!!!

• Google Interview Preparation Guide
• Amazon Interview Preparation Guide
• Accenture Interview Preparation Guide
• Capgemini Interview Preparation Guide
• Cognizant Interview Preparation Guide

Core Java Interview Questions And Answers For Experienced

• this points to the current class instance variable.
• this can also implicitly invoke the current class method
• this() keyword can also invoke the current class constructor.
• In the method call, this keyword can be passed as an argument.
• In constructor call also this keyword can be passed as an argument
• this keyword can return to the current class instance.

Core Java Interview Questions For 3 Years Experience

No, this variable is not able to be assigned to any value as it always refers to the current class object and in Java, this is the final reference. The compiler will show an error if we try to do so. For example.

public class Test

{

public Test()

{

this = null;

System.out.println(“Test class constructor called”);

}

public static void main (String args[])

{

Test t = new Test();

}

}

Output

Test.java:5: error: cannot assign a value to final variable this

this = null;

^

1 error

this keyword is just a reference variable that points to the current class object. Nevertheless, it is useless to access static variables through objects, therefore, we don’t use this to refer to static members. For example:

public class Test

{

static int i = 10;

public Test ()

{

System.out.println(this.i);

}

public static void main (String args[])

{

Test t = new Test();

}

}

Output

10

Constructor chaining allows us to call one constructor from another constructor of the class w.r.t. the current class object. this keyword can be used to perform constructor chaining in the same class. Check the below-given example:

public class Employee

{

int id,age;

String name, address;

public Employee (int age)

{

this.age = age;

}

public Employee(int id, int age)

{

this(age);

this.id = id;

}

public Employee(int id, int age, String name, String address)

{

this(id, age);

this.name = name;

this.address = address;

}

public static void main (String args[])

{

Employee emp = new Employee(105, 22, “Vikas”, “Delhi”);

System.out.println(“ID: “+emp.id+” Name:“+emp.name+” age:“+emp.age+” address: “+emp.address);

}

}

Output

ID: 105 Name:Vikas age:22 address: Delhi

• this is a final variable so it cannot be allocated to any new value whereas the current class object can be modified.
• this can also be used in the synchronized block.

It is a mechanism through which a single object can acquire all the behavior and properties of another object of another class. Inheritance is used for Method Overriding and Code Reusability. The idea used behind inheritance is that you can make new classes that are made upon existing classes. When you come from an existing class, you can utilize methods and fields of the parent class and also add new methods and fields in your present class. It shows the IS-A relationship that is also called the parent-child relationship.

5 types of inheritance in Java are:

• Single-level inheritance
• Multi-level inheritance
• Multiple Inheritance
• Hierarchical Inheritance
• Hybrid Inheritance

Multiple inheritances are not supported in Java through the class.

It is basically a variable that always points to the immediate parent class object. When you make the subclass instance then an instance of the parent class is made implicitly which referred to the super keyword reference variable. The super() automatically becomes the class constructor by the compiler when there is no super or this keyword is used.

class Animal{

Animal(){System.out.println(“animal is created”);}

}

class Dog extends Animal{

Dog(){

System.out.println(“dog is created”);

}

}

class TestSuper4{

public static void main(String args[]){

Dog d=new Dog();

}

}

Output:

animal is created

dog is created

class Person

{

String name,address;

int age;

public Person(int age, String name, String address)

{

this.age = age;

this.name = name;

this.address = address;

}

}

class Employee extends Person

{

float salary;

public Employee(int age, String name, String address, float salary)

{

super(age,name,address);

this.salary = salary;

}

}

public class Test

{

public static void main (String args[])

{

Employee e = new Employee(22, “Mukesh”, “Delhi”, 90000);

System.out.println(“Name: “+e.name+” Salary: “+e.salary+” Age: “+e.age+” Address: “+e.address);

}

}

Output

Name: Mukesh Salary: 90000.0 Age: 22 Address: Delhi

• It is used to point to the immediate parent class instance variable.
• It can invoke the parent class method immediately.
• It is also used to invoke immediate parent class constructor.

You may also prepare:

• Networking Interview Questions
• TypeScript Interview Questions
• MVC Interview Questions
• CSS Interview Questions

Core Java Interview Questions For 5 Years Experience

• this keyword goes to the current class context whereas The super keyword goes to the parent class contexts.
• this keyword tells the difference between local and instance variables when it goes through the class constructor whereas the super keyword initializes the base class variables in the derived class constructor
• They are both super and this should be the first statement in the class constructor else the compiler shows an error.

No, because super() and this() should be the first statement in the class constructor.

Example:

public class Test{

Test()

{

super();

this();

System.out.println(“Test class object is created”);

}

public static void main(String []args){

Test t = new Test();

}

}

Output:

Test.java:5: error: call to this must be the first statement in the constructor

Object cloning is used to make a clone, an exact copy of an object. The Object class uses the clone() method to clone an object. By the object class java.lang.Cloneable interface needed to be implemented on those objects which are cloned. If the cloneable interface is not implement then, clone() method create CloneNotSupportedException.

protected Object clone() throws CloneNotSupportedException

Method overloading is the polymorphism method that permits you to generate multiple methods with the same name but dissimilar signatures. Through these ways, you can achieve method overloading.

• By Changing the number of arguments
• By changing the data type of arguments

It enhances the readability of the program and it is performed to work out the program quickly.

In Java programming, method overloading is not workable by changing the return type of the program because of avoiding ambiguity.

class Adder{

static int add(int a,int b){return a+b;}

static double add(int a,int b){return a+b;}

}

class TestOverloading3{

public static void main(String[] args){

System.out.println(Adder.add(11,11));//ambiguity

}}

Output:

Compile Time Error: method add(int, int) is already defined in class Adder

• The method and parent class must have the same name.
• The method and parent class must have the same signature.
• The method and parent classes must have an IS-A relationship between them.

• The private scope can be transformed to protected, public, or default.
• The protected scope can be transformed to public or default.
• The default can be transformed to public.
• The public will not be changed and always remain public.