CAI710-M2-Q1

Which of the following best describes the “is-a” relationship in Java inheritance?

• A subclass is part of a superclass.

• A subclass contains a superclass.

• A subclass is an extension of a superclass.

• A superclass is dependent on a subclass.

• A superclass cannot share attributes with its subclass.

In a software model, a 'Professor' class inherits from a 'Person' class. Which of the following best explains why this inheritance relationship is valid?

• The 'Person' class is a sub-type of 'Professor'

• The 'Professor' class is a specialized object.

• A 'Professor' has a 'Person'.

• A 'Professor' is a type of 'Person', so it can reuse common attributes and behaviors.

• Both 'Professor' and 'Person' are classes in the same system.

If we have the classes Car and Vehicle, and Car extends Vehicle, which statement correctly explains the relationship?

• A Car is-a Vehicle.

• A Vehicle is-a Car.

• A Car contains a Vehicle.

• A Vehicle cannot be a superclass of Car.

• A Car and Vehicle are unrelated.

When a subclass constructor does not explicitly call a superclass constructor using super(), what action does the Java compiler automatically take?

• It calls all available constructors in the superclass to ensure proper initialization.

• It throws a compile-time error because the superclass constructor must be explicitly called.

• It automatically calls the no-argument constructor of the superclass.

• It throws a runtime error because the superclass was not initialized.

• It initializes the subclass but skips the initialization of the superclass.

If a superclass defines only parameterized constructors and no default (no-argument) constructor, what happens when the subclass does not explicitly call super(parameters)?

• The compiler automatically inserts a call to the parameterized constructor.

• The compiler automatically creates a default constructor in the superclass.

• Compilation error because no suitable super() is available.

• The subclass constructor executes successfully without initializing superclass variables.

• The JVM provides default values to superclass attributes automatically.

In a scenario where a `Cat` subclass has a constructor `Cat()` and its `Animal` superclass has two constructors: `Animal()` and `Animal(String breed)`, what happens if `Cat()` does not explicitly call `super()`?

• A compile-time error will occur.

• The program will crash at runtime due to an unhandled exception.

• The `Animal(String breed)` constructor will be called automatically.

• The `Animal()` constructor will be called automatically.

• The subclass constructor will run, but the superclass will not be initialized.

What does method overriding mean in Java?

• Writing multiple methods with the same name but different parameter lists in the same class.

• Defining a method in a subclass with the same signature as a method in the superclass.

• Preventing a subclass from accessing superclass methods.

• Using a constructor in the subclass instead of the superclass method.

• Changing the return type of a method in the subclass.

Why is method overriding useful in inheritance?

• It lets a subclass inherit attributes from a superclass.

• It allows a subclass to completely hide a superclass's method.

• It changes the method's return type to a different data type in the subclass.

• It is a requirement for all subclasses to have an override of every method in the superclass.

• It allows a subclass to provide a specific implementation for a behavior that is already defined in its general superclass.

In a scenario where a 'Dog' subclass inherits from an 'Animal' superclass, which of the following is an example of method overriding?

• The `Dog` class has a new method called `fetch()`, which the `Animal` class does not have.

• The `Animal` class has a `makeSound()` method, and the `Dog` class has a `makeSound(String noise)` method.

• The `Animal` class has a public `eat()` method, and the `Dog` class has a private `eat()` method.

• The `Animal` class has a `makeSound()` method, and the `Dog` class also has a `makeSound()` method that prints "Woof!".

• A new class called `Poodle` is created, which inherits from `Dog`.

Which scenario best demonstrates practical use of polymorphism?

• Storing different types of objects (Student, Teacher, Staff) all as Person in an ArrayList<Person>.

• Declaring the same variable name in two different methods.

• Creating multiple constructors in the same class.

• Using final keyword to prevent inheritance.
  
  

• Declaring static methods with the same name in two classes.