Java Interview Questions on Class, Constructors, and Instance variables

A class in Java is essentially a blueprint from which individual objects are created. It defines a type of data, encapsulating both the data itself (in the form of fields, also known as attributes or properties) and operations on the data (in the form of methods, also known as functions or procedures). The purpose of a class is to specify the structure and behavior of objects by defining their attributes and what operations can be performed on them.

Example

public class Animal {
    String name; // Field

    public void makeSound() { // Method
        System.out.println("Some sound");
    }
}

Encapsulation is a fundamental concept in object-oriented programming that involves wrapping the data (attributes) and the code (methods) that operates on the data into a single unit, known as a class, and restricting access to some of the object’s components.

This is usually done by making attributes private and providing public getters and setters to access and modify the values of these attributes. Encapsulation helps to protect the integrity of the data and hides the implementation details from the user.

public class Account {
    private double balance; // Encapsulated attribute
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

A class in Java is defined with the class keyword, followed by the class name and a pair of curly braces that enclose the definitions of fields and methods.

Example

public class Animal {
    String species; // Field
    public void eat() { // Method
        System.out.println("This animal is eating.");
    }
}

• Instance Variables: These variables belong to an instance of a class, meaning that each object has its own copy of the instance variables. They describe the attributes or state of a particular object.
• Class Variables: Also known as static variables, they are declared with the static keyword and shared among all instances of the class. There is only one copy of a class variable, and it belongs to the class itself rather than any object.

public class Bicycle {
    int gear = 1; // Instance variable
    static int numberOfBicycles = 0; // Class variable
}

No, Java does not support multiple inheritance for classes to avoid the complexity and ambiguity related to the diamond problem. However, a class can implement multiple interfaces, which is Java’s way to achieve polymorphism and code reuse.

The public access modifier makes the class accessible from any other class in the program, regardless of the package it belongs to. It’s essential for creating instances of the class in different parts of the program or using its methods and attributes across various classes.

Example:

public class PublicClass {
    // This class can be accessed from any other class
}

A class is declared as final by prefixing the class definition with the final keyword. Making a class final prevents it from being subclassed.

Example:

public final class ImmutableClass {
    // Cannot be extended
}

The static keyword indicates that a particular field or method belongs to the class, rather than instances of the class. Static methods and variables can be accessed directly by the class name without creating an instance of the class.

Example

public class MathUtility {
    public static int add(int a, int b) {
        return a + b;
    }
}
// Access static method
int sum = MathUtility.add(5, 3);

Abstraction in Java can be achieved using abstract classes. An abstract class cannot be instantiated on its own and may contain abstract methods without an implementation. Subclasses must provide implementations for abstract methods, making abstraction a way to define a template for a group of subclasses.

Example:

public abstract class Shape {
    abstract void draw();
}

public class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

In Java, a source file (a file with a .java extension) can contain one public class and multiple non-public classes. The name of the source file must match the name of the public class it contains. This convention simplifies the organization of code and helps in easily locating class definitions within a project.

Example:

Filename: Main.java

public class Main {
    // This is the main public class
}

class Helper {
    // This is a non-public class
}

A constructor in Java is a special type of method used to initialize objects. It has the same name as the class in which it is declared and does not have a return type, not even void. Constructors are called automatically at the time of object creation.

Example

public class MyClass {
    int x;
    
    // Constructor for MyClass
    public MyClass() {
        x = 5;
    }
}

The purpose of a constructor is to initialize the newly created object before it is used. Constructors establish a way to set an object’s initial state, or to perform any setup steps necessary for the object to be ready for use immediately after it is created.

Example:

public class Book {
    String title;
    
    // Constructor initializes the title of the book
    public Book(String bookTitle) {
        title = bookTitle;
    }
}

The key differences between a constructor and a regular method are:

• Name and Return Type: A constructor must have the same name as the class and cannot have a return type, not even void, whereas a regular method can have any name and must have a return type.
• Initialization vs Operation: Constructors are used for initializing new objects, while regular methods perform operations on objects.
• Automatic Invocation: Constructors are called automatically when a new instance of a class is created, whereas regular methods must be explicitly called.

Example of a method:

public class MyClass {
    int x;
    
    // Constructor
    public MyClass() {
        x = 5;
    }
    
    // Regular method
    public void setX(int newValue) {
        x = newValue;
    }
}

If a class does not explicitly define any constructors, Java automatically provides a default constructor that initializes the object with default values (null for objects, 0 for numeric types, false for boolean, etc.). This default constructor is no-arg (parameterless) and public.

Implicit default constructor example:

public class MyClass {
    // No constructor defined
    int x;
}
// Java implicitly defines a default constructor for MyClass.

Yes, constructors can be overloaded in Java, which means you can have multiple constructors in a class with different parameter lists (different number of parameters or types of parameters).

Example:

public class Box {
    double width, height, depth;
    
    // No-arg constructor
    public Box() {
        width = height = depth = 0;
    }
    
    // Constructor with one parameter
    public Box(double len) {
        width = height = depth = len;
    }
    
    // Constructor with three parameters
    public Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }
}

The this keyword in a constructor refers to the current object, the object being constructed. It is used to resolve naming conflicts between instance variables and parameters and to call other constructors in the same class.

Example:

public class Point {
    int x, y;
    
    // Constructor using 'this' to differentiate between instance variables and parameters
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

A parameterless constructor is created by defining a constructor that does not take any arguments.

Example:

public class MyClass {
    int x;
    
    // Parameterless constructor
    public MyClass() {
        x = 10;
    }
}

A default constructor is a no-argument constructor automatically provided by Java if no constructors are explicitly defined in the class. It initializes the object with default values.

Example of implicit use:

public class MyClass {
    // No constructor is defined here, so Java provides a default constructor.
}

Yes, a constructor can be made private. This is typically done in certain design patterns, like Singleton, to restrict instantiation of the class from outside the class.

Singleton example:

public class Singleton {
    private static Singleton instance;
    
    // Private constructor
    private Singleton() {}
    
    // Public method to get the instance
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

To call a superclass constructor from a subclass constructor, use the super keyword followed by arguments matching the superclass constructor you want to call.

Example

public class Parent {
    Parent() {
        System.out.println("Parent Constructor");
    }
}

public class Child extends Parent {
    Child() {
        super(); // Calls the constructor of the Parent class
        System.out.println("Child Constructor");
    }
}

Instance variables, also known as instance fields, are variables declared within a class but outside any method, constructor, or block. Unlike static variables, instance variables are unique to each instance (or object) of a class. They represent the state or attributes of an object and can have different values for different objects of the same class.

Example

public class Car {
    // Instance variable
    String color;

    // Constructor
    public Car(String color) {
        this.color = color;
    }
}

To declare an instance variable in a Java class, you specify the data type followed by the variable name. The declaration is done outside any method, constructor, or block within the class.

Example

public class Student {
    // Instance variable declaration
    int age;
}

Instance Variables: These are declared in a class outside any method, constructor, or block. Instance variables can be accessed by all methods, constructors, and blocks in the class. They have a scope throughout the class and are unique to each instance of the class.

Local Variables: These are declared within a method, constructor, or block and can only be accessed within that method, constructor, or block. Local variables do not have a default value and must be initialized before use. They are not related to instances of the class.

Example:

public class Person {
    // Instance variable
    String name; // Can be used by all methods in the class
    
    public void setName(String newName) {
        // Local variable
        String oldName = this.name; // Only accessible within this method
        this.name = newName;
    }
}

In this example, name is an instance variable, while oldName is a local variable.

If an instance variable is not explicitly initialized, it is given a default value by the JVM. The default values are as follows:

• byte, short, int, long default to 0
• float, double default to 0.0
• char defaults to \u0000 (null character)
• boolean defaults to false
• Object references default to null

Example:

public class DefaultValueExample {
    int number;
    boolean isValid;
    String name;
    
    // number will be 0, isValid will be false, name will be null
}

Inside a class, instance variables can be accessed directly by their names in methods, constructors, and initialization blocks. If a local variable or parameter has the same name as an instance variable, the instance variable can be accessed using this keyword to distinguish it.

Example:

public class Employee {
    String name;
    
    public void updateName(String name) {
        // Accessing the instance variable 'name' using 'this' keyword
        this.name = name;
    }
}

The scope of an instance variable extends throughout the class in which it is declared. This means it can be accessed by all methods, constructors, and blocks within the class. However, it cannot be accessed directly from outside the class unless it is public or accessed through methods (getters/setters).

Definition: Getter and setter methods are public methods that provide access to and control over the values of private instance variables. A getter method returns the value of an instance variable, while a setter method sets or updates the value of an instance variable.

Purpose: They are used to encapsulate the instance variables, making a class’s public interface more flexible and safe from direct access by external code, which helps in maintaining the integrity of the data.

Example:

public class Person {
    private String name;

    // Getter
    public String getName() {
        return name;
    }

    // Setter
    public void setName(String name) {
        this.name = name;
    }
}

To make an instance variable final, you prepend the final keyword to its declaration. A final instance variable can be assigned only once, either at the point of declaration or within the constructor. After assignment, its value cannot be changed.

Example:

public class Circle {
    final double radius;

    public Circle(double radius) {
        this.radius = radius; // Final variable can be initialized in the constructor
    }
}

No, you cannot use the static keyword with an instance variable. Using static makes a variable a class variable, not an instance variable. Static variables are shared among all instances of a class, while instance variables have their own separate value for each instance.

To ensure that a variable is shared across all instances of a class, you should declare the variable as static. This makes it a class variable (or static field), meaning it is shared among all instances of the class, and changing its value in one instance will change it for all instances.

Example

public class Counter {
    static int count = 0; // Shared across all instances

    public void increment() {
        count++; // Incrementing the shared count for all instances
    }
}

In this example, count is a static variable shared by all instances of the Counter class.