Basic JAVA interview questions

Having covered a lot of topics in .NET, let’s shift our attention to some JAVA questions. In this post, we will cover a few basic JAVA interview questions to get started. We will advance in complexity in later posts.

SO, first, let’s start with constructors.

Question: What is the difference between constructors and other regular methods?

Constructors must have the same name as the class name and cannot return a value. The constructors are called only once per creation of an object while regular methods can be called many times.

Question: What happens if you do not provide a constructor?

Java does not actually require an explicit constructor in the class description. If you do not include a constructor, the Java compiler will create a default constructor in the byte code with an empty argument. If a class includes one or more explicit constructors, the java compiler does not create the default constructor.

Question: Can you call one constructor from another?

Yes, the key is to use the this() construct.

public Shape(int id) {
    this.id = id; // "this" means this object
}
    
public Shape(int id, String type) {
    this(id); // calls constructor public Shape(int id)
    this.type = type; // "this" means this object
}

Question: How can you invoke the base class constructor in the derived class?

You can use the super() syntax. Note that this has to be the first statement in the function.

public Circle(int id) {
    super(id); //must be the very first statement in the constructor.
}

Question: How can you invoke base class methods in the derived class?

To call a regular method in the base class use “super.myMethod( )”. This can be called at any line.

public class Circle extends Shape 
{
    public void setUp() 
    {
        super.initialize();
        // do circle stuff
    }
}

public void reset() throws Throwable
{
    try 
    {
        // Do stuff here to rest your object
    }
    catch (Throwable t) {}
    finally
    {
        super.reset(); //clean up your parent class. Unlike constructors super.regularMethod() can be called at any line.
    }
}

Question: Explain static initializers with an example.

When a class is loaded, all blocks that are declared static and don’t have function name (i.e. static initializers) are executed even before the constructors are executed. As the name suggests they are typically used to initialize static fields.

public class StaticInitializer 
{
    public static final int x = 5;
    public static final int y; 
    //note that since y is final, it can be initialized only once.
        
    //Static initializer block, which is executed only once when the class is loaded.
    static 
    {
        if(x == 5)
            y = 10;
        else
            y = 5;
    }
    
    //constructor is called only after static initializer block
    public StaticInitializer(){} 
}

The code above sets the value of x to 5 and y to 10.