Java Constructors and Inheritance

What is the purpose of a constructor in Java?

If a class does not define any constructors, what happens when an object of that class is created?

Consider the following Java statement: obj = new MyClass();. Which part of this statement allocates memory for the new object?

In the statement objA = new A();, after memory allocation, what does A() do?

What is the implicit return type of a class's constructor?

Which of the following statements about constructors is NOT true?

Which keyword is used to establish an inheritance relationship between a subclass and a superclass in Java?

What is the key difference between a non-parameterized constructor and a parameterized constructor?

In the context of inheritance, what does it mean for a class to follow an 'IS-A' relationship?

What is the primary difference between a superclass and a subclass in an inheritance hierarchy?

Why are private members of a class not accessible from outside the class?

If a subclass overrides a method from its superclass, which version of the method is executed when called on an object of the subclass?

Consider a scenario where you have an Animal class and a Dog class that extends Animal. If you create an Animal reference that points to a Dog object, what methods can you call using this reference?

What happens when you try to access a private attribute of the superclass directly from a subclass?

You have a class Vehicle with a method startEngine(). A Car class extends Vehicle and overrides startEngine() to include additional car-specific startup procedures. If you have a Vehicle reference pointing to a Car object and call startEngine(), what happens?

Consider the Animal, Mammal, and Dog class hierarchy. Which class would be most suitable to define a general eat() method that applies to all animals?

What is the primary purpose of the super() keyword when used as the first statement within a subclass constructor?

If a class has multiple constructors with different parameters, how does the compiler determine which constructor to call when creating an object?

In the context of inheritance, what does the super keyword allow a subclass to access?

Consider a scenario where a subclass overrides a method from its superclass and needs to call the superclass's implementation of that method. How can this be achieved?

What is the term for having multiple constructors within the same class, each with a unique parameter list?

If a subclass constructor does not explicitly call super(), what constructor will be invoked in the superclass?

In a method, what is the purpose of super(arg1, arg2, ... argn)?

When local variables in a constructor have the same name as instance variables, what keyword is used to differentiate between them and ensure proper initialization of the instance variables?

Why do instance variables sometimes not receive values from local variables with the same name within a constructor, even when an assignment is attempted?

What is the primary purpose of the this keyword in the context of instance variables and local variables within a class constructor?

Consider a class Animal with an instance variable name and a constructor Animal(String name). Without using the this keyword, how would the constructor likely behave if it included the line name = name;?

In a class Dog, if you have an instance variable breed and local variable breed in the constructor, how do you explicitly refer to the instance variable breed?

Within a method, what does the this keyword represent?

Consider the following code snippet:

class Example {
    int value;

    Example(int value) {
        value = value;  // Line X
    }
}

What is the likely outcome of Line X?

In object-oriented programming, what problem does the this keyword specifically solve regarding variable scope?

What happens if the this keyword is not used to differentiate between an instance variable and a local variable with the same name in a constructor?

When a local variable and an instance variable share the same name within a class, how can you specifically refer to the instance variable?

What is the primary purpose of using this() within a constructor?

In Java, how are arguments passed to a method?

Consider a Student class with attributes like rollNbr and name. If you pass a Student object to a method and modify the name attribute inside the method, what happens to the original Student object's name?

A Marksheet class has a calculateGrade() method, and a separate class passes a primitive integer representing a student's score to it. If the calculateGrade() method modifies this integer, what effect does it have on the original integer variable in the calling method?

In the context of parameter passing in Java, what is the key difference in how primitive types and objects are handled?

A calculateGrade() method in a Marksheet class is overloaded to accept either individual course marks or a Student object. How does overloading the method to accept a Student object improve the design?

Consider a scenario where the calculateGrade() method in the Marksheet class takes a Student object as input. Inside this method, a new Marksheet object is created and the grade is calculated based on the student's marks. If the printMarksheet() method is invoked on this new Marksheet object, what is the scope and visibility of the calculated grade?

When should you prefer passing an object as an argument to a method instead of passing primitive data types?

What is the purpose of the final keyword when applied to a variable in Java?

When a variable is declared as final, when must it be initialized?

What happens if you try to override a method that is declared as final in a superclass?

What is the primary benefit of declaring a method as final?

What is the effect of declaring a class as final in Java?

Why might you declare a class as final?

Consider a scenario where you have a Shape class with a calculateArea() method. If you want to ensure that subclasses like Circle and Square do not modify the basic area calculation logic defined in Shape, how should you declare the calculateArea() method in the Shape class?

IS-A Relationship

Superclass

Subclass

Extends Keyword

Method Overriding

Sound() Method Overriding

Private Attribute

Accessing Private Members

Private Class Members

Instantiating a Class

Object Creation Steps

Constructor

Constructor Characteristics

Constructor Chaining

Default Constructor

Parameterized Constructor

Constructor Overloading

super Keyword

super() in Constructor

super.method()

super.variable

this Keyword

this.variable

Local Variable

Instance Variable

Naming Conflict (Variable Hiding)

Local Variable Hiding Instance Variable

Using this to avoid hiding

Purpose of this Keyword

this Keyword in a Method

What is the 'this' keyword?

What is 'this()'?

What is Call by Value?

How does Java pass parameters?

How are Objects passed in Java?

What is the 'Student' class?

What is the 'Marksheet' class?

What is method overloading?

Object Argument in Method

Final Keyword

Final Variable

Final Variable Initialization

Final Method

Final Class

Types of Final Variables

Naming Final Variables