What is Object-Oriented Programming (OOP) in Java?

Main Features of Object-Oriented Programming (OOP)

Object-Oriented Programming (OOP) is a programming paradigm that organizes software design around data, or objects, rather than functions and logic. The key features of OOP help make the development process more modular, reusable, and easier to maintain.

Encapsulation is the concept of bundling the data (variables) and the methods (functions) that operate on the data into a single unit, called a class. It also helps in restricting access to certain components of the object to protect the data from unauthorized access and modification.

• Encapsulation is achieved through access modifiers like private, protected, and public.
• Example: Hide internal implementation details and provide getter and setter methods to access and modify the data.

Abstraction is the concept of hiding the complex implementation details and showing only the essential features of an object. It allows you to focus on what an object does rather than how it does it.

• Abstract classes and interfaces are used to achieve abstraction in OOP.
• Example: An abstract class or interface defines a template, and concrete classes provide the implementation.

Inheritance is a mechanism where a new class inherits the properties and behaviors (methods) of an existing class. It helps in reusing code, extending functionality, and creating a hierarchical class structure.

• Through inheritance, a subclass can access the members (fields and methods) of its superclass.
• Example: A Dog class can inherit from an Animal class and gain its characteristics and behavior.

Polymorphism means "many forms." It allows objects to be treated as instances of their parent class, but the actual method that gets executed is determined by the object's actual class (at runtime in the case of dynamic polymorphism).

• Polymorphism can be achieved through method overriding (runtime polymorphism) and method overloading (compile-time polymorphism).
• Example: A Shape class can have a method draw(), which is overridden in subclasses like Circle and Rectangle to provide specific implementations.

An object is an instance of a class. It holds real values for the variables defined in the class and can perform actions (methods) defined by the class. Objects are the basic units of OOP.

• Objects represent real-world entities and encapsulate state and behavior.
• Example: A Car object might have attributes like color and model, and behaviors like start() and stop().

• Encapsulation: Bundling data and methods and restricting access to internal details.
• Abstraction: Hiding complex details and showing only the essential features.
• Inheritance: Creating a new class from an existing class to reuse code.
• Polymorphism: Allowing objects to take many forms through method overriding and overloading.

What is encapsulation in Java?

Explain inheritance in Java with an example.

What is polymorphism in Java?

What is abstraction, and how is it achieved in Java?

Explain the difference between an abstract class and an interface.

          abstract class Animal {
              abstract void makeSound();
              void eat() {
                  System.out.println("Eating...");
              }
          }
          

          interface Animal {
              void makeSound();
              default void eat() {
                  System.out.println("Eating...");
              }
          }
          

• A class can implement multiple interfaces but can extend only one abstract class.
• Interfaces support default and static methods from Java 8 onwards.

How does Java implement multiple inheritance?

Answer: Java implements multiple inheritance through interfaces.
A class can implement multiple interfaces, thus inheriting behavior from all of them.
This avoids the "diamond problem" caused by ambiguity in multiple inheritance.

      interface InterfaceA {
          void methodA();
      }
      
      interface InterfaceB {
          void methodB();
      }
      
      class MultiInheritanceClass implements InterfaceA, InterfaceB {
          public void methodA() {
              System.out.println("Method A from InterfaceA");
          }
      
          public void methodB() {
              System.out.println("Method B from InterfaceB");
          }
      }
      
      public class Test {
          public static void main(String[] args) {
              MultiInheritanceClass obj = new MultiInheritanceClass();
              obj.methodA();
              obj.methodB();
          }
      }
        

Can a class be declared as both `abstract` and `final`?

Answer: No, a class cannot be both abstract and final because an abstract class is meant to be extended, whereas a final class cannot be extended.

What is a constructor, and what are its types?

Answer: A constructor is a special method used to initialize objects. Types:

• Default Constructor: No arguments.
• Parameterized Constructor: Takes arguments to initialize fields.

What is the role of the `super` keyword in Java?

Answer: The super keyword is used to refer to the immediate parent class. It can be used to call the parent class constructor or methods.

class Animal {
      void eat() {
          System.out.println("Animal eats.");
      }
  }
  
  class Dog extends Animal {
      void eat() {
          super.eat();
          System.out.println("Dog eats.");
      }
  }
  

Explain the concept of method overloading and method overriding.

      class Calculator {
          // Overloaded methods
          int add(int a, int b) {
              return a + b;
          }
      
          double add(double a, double b) {
              return a + b;
          }
      
          int add(int a, int b, int c) {
              return a + b + c;
          }
      }
      
      public class OverloadingExample {
          public static void main(String[] args) {
              Calculator calc = new Calculator();
              System.out.println(calc.add(2, 3));        // Calls int add(int, int)
              System.out.println(calc.add(2.5, 3.5));   // Calls double add(double, double)
              System.out.println(calc.add(1, 2, 3));    // Calls int add(int, int, int)
          }
      }
        

      class Parent {
          void display() {
              System.out.println("Display from Parent");
          }
      }
      
      class Child extends Parent {
          @Override
          void display() {
              System.out.println("Display from Child");
          }
      }
      
      public class OverridingExample {
          public static void main(String[] args) {
              Parent obj = new Child(); // Upcasting
              obj.display(); // Calls Child's overridden method
          }
      }
        

Can we overload a static method in Java?

Yes, you can overload a static method in Java. You can declare as many static methods of the same name as you wish provided all of them have different method signatures.

      class Calculator {
          // Static method to add two integers
          static int add(int a, int b) {
              return a + b;
          }
      
          // Static method to add three integers
          static int add(int a, int b, int c) {
              return a + b + c;
          }
      
          // Static method to add two double values
          static double add(double a, double b) {
              return a + b;
          }
      }
      
      public class StaticMethodOverloadingDemo {
          public static void main(String[] args) {
              // Calling overloaded static methods
              System.out.println(Calculator.add(10, 20));           // Calls method with two integers
              System.out.println(Calculator.add(10, 20, 30));       // Calls method with three integers
              System.out.println(Calculator.add(10.5, 20.5));       // Calls method with two doubles
          }
      }
          

      30
      60
      31.0
    

Can you override a static method in Java?

No, static methods cannot be overridden in Java. Instead, if a static method is defined in both the parent and child classes with the same name and parameters, it is known as method hiding. The method called depends on the reference type, not the object type.

• Static methods are associated with the class, not instances of the class.
• During method hiding, the method of the reference type (class type) is invoked, not the runtime object.

      class Parent {
          static void staticMethod() {
              System.out.println("Static method in Parent");
          }
      }
      
      class Child extends Parent {
          static void staticMethod() {
              System.out.println("Static method in Child");
          }
      }
      
      public class StaticMethodTest {
          public static void main(String[] args) {
              Parent parent = new Parent();
              Parent childAsParent = new Child();
              Child child = new Child();
              
              parent.staticMethod();           // Outputs: Static method in Parent
              childAsParent.staticMethod();    // Outputs: Static method in Parent (method hiding)
              child.staticMethod();            // Outputs: Static method in Child
          }
      }
        

Key Points:

• Static methods are resolved at compile time, not runtime.
• Overriding applies only to instance methods, not static methods.
• Access modifiers can be changed in hiding, but the method signature should remain the same.

Can we prevent overriding a method without using the final modifier?

Yes, you can prevent the method overriding in Java without using the final modifier. In fact, there are several ways to accomplish it e.g. you can mark the method as private or static, those cannot be overridden.

Can we override a private method in Java?

No, you cannot. Since the private method is only accessible and visible inside the class they are declared, it's not possible to override them in subclasses. Though, you can override them inside the inner class as they are accessible there.

Can We Change the Return Type of a Method to a Subclass While Overriding?

Yes, in Java, we can change the return type of a method to a subclass while overriding the method. This feature is called covariant return type.

Covariant return type allows a subclass to override a method and return a type that is a subclass of the original method's return type in the parent class. It is a feature introduced in Java 5 that enhances flexibility and reusability while preserving method signatures and behavior.

class Animal {
  // Method returning an Animal object
  Animal getAnimal() {
      return new Animal();
  }
}

class Dog extends Animal {
  // Overriding the method with a covariant return type (returning Dog)
  @Override
  Dog getAnimal() {
      return new Dog();
  }
}

public class CovariantReturnTypeDemo {
  public static void main(String[] args) {
      Animal animal = new Animal();
      Animal anotherAnimal = animal.getAnimal(); // Returns an Animal object

      Dog dog = new Dog();
      Dog anotherDog = dog.getAnimal(); // Returns a Dog object, covariant return type
  }
}
  

No output, but the types are correct:
- animal.getAnimal() returns Animal
- dog.getAnimal() returns Dog
  

• The class Animal has a method getAnimal() that returns an Animal object.
• The class Dog overrides the getAnimal() method and returns a Dog object, which is a subclass of Animal.
• This demonstrates the concept of covariant return types in method overriding. The method in the subclass (Dog) returns a more specific type than the superclass (Animal).

• It allows more specific return types in overridden methods, improving the flexibility and usability of class hierarchies.
• Helps to avoid unnecessary casting when working with object-oriented designs.

• The return type must be a subtype of the return type declared in the parent class method.
• Covariant return type can only be used in overriding methods, not overloaded methods.

What is an inner class, and why is it used?

Answer: An inner class in Java is a class that is defined within another class. Inner classes are used to logically group classes that are only used in one place, improve encapsulation, and make the code more readable and maintainable.

Types of Inner Classes:

• Member Inner Class: A non-static inner class that is a member of the outer class.
• Static Nested Class: A static class defined inside another class.
• Local Inner Class: A class defined within a method.
• Anonymous Inner Class: A class without a name, usually used to provide a quick implementation of an interface or abstract class.

Example: Member Inner Class

      class OuterClass {
          private String message = "Hello from Outer Class!";
          
          class InnerClass {
              void displayMessage() {
                  System.out.println(message); // Accessing private member of the outer class
              }
          }
      }
      
      public class InnerClassExample {
          public static void main(String[] args) {
              OuterClass outer = new OuterClass();
              OuterClass.InnerClass inner = outer.new InnerClass();
              inner.displayMessage();
          }
      }
        

Why Use Inner Classes?

• Improves code readability by logically grouping related classes.
• Provides better encapsulation since inner classes can access private members of the outer class.
• Enables creating more compact code, such as with anonymous inner classes for event handling or short-lived implementations.

What is the difference between `this` and `super` keywords?

Answer:

• this: Refers to the current object.
• super: Refers to the parent class object.

How Do You Call a Superclass Version of an Overriding Method in a Subclass?

In Java, when a method in a subclass overrides a method in its superclass, you can call the superclass version of the method using the super keyword. The super keyword allows access to the superclass's methods and constructors.

class Animal {
  // Method in the superclass
  void sound() {
      System.out.println("Animal makes a sound");
  }
}

class Dog extends Animal {
  // Overriding the sound method
  @Override
  void sound() {
      System.out.println("Dog barks");
      
      // Calling the superclass version of the sound method
      super.sound();
  }
}

public class SuperclassMethodCallDemo {
  public static void main(String[] args) {
      Dog dog = new Dog();
      dog.sound();  // Calls the overridden method in Dog class
  }
}
  

Dog barks
Animal makes a sound
  

• You can only call the superclass method from the subclass if the method is not marked as private in the superclass.
• super can only refer to the immediate superclass, and not any class higher in the hierarchy.

How do you achieve immutability in Java?

Answer: Create a class with:

• Private final fields.
• A constructor to initialize fields.
• No setter methods.

final class Immutable {
      private final String name;
  
      Immutable(String name) {
          this.name = name;
      }
  
      public String getName() {
          return name;
      }
  }
  

What is a sealed class in Java?

Answer: A sealed class in Java restricts the inheritance of the class to a specific set of classes. It is a way to restrict the subclassing of a class, ensuring that only a designated set of classes can inherit it. Sealed classes are introduced in Java 16.

Key Features:

• Used to define a base class that only a specific set of classes can extend.
• Enhances code security and predictability by limiting which classes can extend a sealed class.

Example:

      sealed class Shape permits Circle, Rectangle {
          double area;
      
          Shape(double area) {
              this.area = area;
          }
      
          abstract double calculateArea();
      }
      
      final class Circle extends Shape {
          Circle(double area) {
              super(area);
          }
      
          @Override
          double calculateArea() {
              return Math.PI * area * area;
          }
      }
      
      final class Rectangle extends Shape {
          double length, width;
      
          Rectangle(double area, double length, double width) {
              super(area);
              this.length = length;
              this.width = width;
          }
      
          @Override
          double calculateArea() {
              return length * width;
          }
      }
      
      public class SealedClassExample {
          public static void main(String[] args) {
              Shape circle = new Circle(10.0);
              Shape rectangle = new Rectangle(20.0, 5.0, 4.0);
              
              System.out.println("Circle Area: " + circle.calculateArea());
              System.out.println("Rectangle Area: " + rectangle.calculateArea());
          }
      }
        

Why Use Sealed Classes?

• Provides greater control over what can be a subclass, improving maintainability and readability.
• Enhances security by limiting the types of classes that can extend a sealed class.
• Useful in domain modeling to represent closed hierarchies.

What is the method of hiding in Java?

When you declare two static methods with the same name and signature in both superclass and subclass then they hide each other i.e. a call to the method in the subclass will call the static method declared in that class and a call to the same method is superclass is resolved to the static method declared in the super-class.

Can we make a class both final and abstract at the same time?

No, you cannot apply both final and abstract keywords to the class at the same time because they are exactly the opposite of each other. A final class in Java cannot be extended and you cannot use an abstract class without extending and making it a concrete class. As per Java specification, the compiler will throw an error if you try to make a class abstract and final at the same time.

Can a class extend more than one class in Java?

No, a class can only extend another class because Java doesn't support multiple inheritances but yes, it can implement multiple interfaces.

Can an interface extend another interface?

Answer: Yes, an interface can extend another interface. This allows a child interface to inherit methods from the parent interface.

What is the `instanceof` keyword?

Answer: The instanceof keyword is used to test whether an object is an instance of a specific class or subclass.

What is the purpose of the `default` methods in interfaces?

Answer: Default methods, introduced in Java 8, allow adding new methods to interfaces without breaking existing implementations.

Explain the use of functional interfaces in Java 8.

Answer: A functional interface is an interface with a single abstract method. It is used in lambda expressions and method references. Example: Runnable, Predicate.

How does Java handle object cloning?

Answer: Java provides cloning using the clone() method of the Object class. A class must implement Cloneable to use it.

What is composition in OOP?

Answer: Composition is a design principle where a class contains objects of other classes to achieve reusability.

Explain dependency injection.

Answer: Dependency Injection is a design pattern where objects are provided their dependencies instead of creating them internally, promoting loose coupling.

What are default constructors?

Answer: A default constructor is provided by Java if no constructor is explicitly defined. It initializes objects with default values.

Can you explain the concept of method hiding?

Answer: Method hiding occurs when a static method in a subclass has the same name and signature as one in its superclass. The method is hidden, not overridden.

What are the SOLID principles?

Answer: SOLID principles are design principles for maintainable software:

• Single Responsibility
• Open/Closed
• Liskov Substitution
• Interface Segregation
• Dependency Inversion

What is the difference between aggregation and composition?

Answer:

• Aggregation: A weak relationship where the lifecycle of the contained object is independent.
• Composition: A strong relationship where the contained object's lifecycle is dependent.

What is the difference between method overloading and method overriding?

Method overloading occurs when you have multiple methods with the same name but different parameter lists (either by number, type, or both) in the same class. It is a form of compile-time polymorphism. Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass, and it is a form of runtime polymorphism.

What happens if you override a method and change the return type to a different type, which is not a subclass of the original return type?

Java does not allow overriding a method with a return type that is not a subclass of the original return type. The return type in the overriding method must either be the same as the return type in the superclass method or a subtype of it (covariant return type). If you attempt to do so, a compilation error will occur.

Can a constructor be inherited?

No, constructors are not inherited in Java. Although a subclass can call a superclass constructor using the super keyword, it cannot directly inherit the constructor from the superclass. The subclass can only inherit the behavior of the superclass via method inheritance, not constructors.

Can we call a constructor from a static method in Java?

Yes, you can call a constructor from a static method in Java, but you cannot directly call a constructor using this() in a static context (since this refers to an instance). However, you can create an object inside a static method using new and invoke the constructor to initialize the object.