Java Ch9

Superclass methods with private access cannot be called from subclasses. The private access modifier restricts access to only within the same class, so subclasses cannot access these methods.

Inheritance allows for code reuse by creating a new class that inherits the properties and methods of an existing class. This avoids duplicating code by allowing the new class to inherit the functionality of the existing class. On the other hand, the "copy-and-paste" approach involves manually copying and pasting code from one place to another, which can lead to code duplication and make maintenance and updates more difficult. Therefore, using inheritance instead of the "copy-and-paste" approach is recommended to avoid duplicating code.

Every class in Java, except Object, extends an existing class. The Object class is the root of the class hierarchy in Java and serves as the base class for all other classes. This means that all other classes directly or indirectly inherit from the Object class. Therefore, the correct answer is b. Object.

All subclasses of a superclass inherit the protected instance variables and methods of that superclass. Protected members are accessible within the same package and also by subclasses of the superclass, regardless of the package they are in. This allows subclasses to access and use the protected members inherited from the superclass. Private instance variables and methods are not inherited by subclasses, as they are only accessible within the class they are declared in. Private constructors are also not inherited, as constructors are not inherited at all.

The relationship between a sailboat and a tugboat is not a superclass/subclass relationship because they are not related in terms of inheritance or specialization. A superclass/subclass relationship implies that one class is a more specific version or specialization of another class. In this case, a sailboat and a tugboat are different types of boats with different purposes and characteristics, rather than one being a specialized version of the other.

The keyword "super" allows a subclass to access a superclass method even when the subclass has overridden the superclass method. By using "super" keyword, the subclass can invoke the superclass method and perform additional operations or modifications on it. This is useful when the subclass wants to extend the functionality of the superclass method without completely overriding it.

Overriding a method means providing a different implementation of a method in a subclass, while keeping the same method signature as the method in the superclass. In other words, the overridden method in the subclass has the same name, return type, and parameters as the method in the superclass. On the other hand, overloading a method means having multiple methods with the same name but different parameters in the same class. Therefore, the correct answer is b. Overridden methods have the same signature.

The correct answer is "is-a" relationship because inheritance in object-oriented programming represents a relationship between classes where one class inherits the properties and behaviors of another class. This relationship implies that the inheriting class is a specialized version of the inherited class, indicating an "is-a" relationship.

The protected keyword in Java gives a member package access, meaning that it can be accessed by any class within the same package. This means that the member is not accessible to classes in different packages, but can be accessed by any class within the same package, including subclasses.

Inheritance allows us to customize existing software by creating subclasses that inherit properties and behaviors from a superclass. A superclass specifies commonality, meaning it contains shared properties and behaviors that can be inherited by subclasses. A superclass can be modified without affecting its subclasses, as long as the modifications do not change the inherited properties and behaviors. Similarly, a subclass can be modified without modifying its superclass, as long as the modifications are specific to the subclass and do not affect the inherited properties and behaviors. Therefore, all of the statements A, B, and D are true.

Private fields of a superclass cannot be accessed directly in a subclass because they are not visible outside the class. However, they can be accessed indirectly by calling public or protected methods declared in the superclass. These methods can provide access to the private fields by returning their values or modifying them. Therefore, option b is the correct answer.

The default equals implementation in Java determines whether two references refer to the same object in memory. It checks if the memory addresses of the two objects are the same, indicating that they are the same object. It does not compare the values of the instance variables or the types of the objects.

The correct answer is b. This is because when calling a superclass constructor, the syntax is "keyword super" followed by a set of parentheses containing the superclass constructor arguments. This allows the subclass to pass any necessary arguments to the superclass constructor. The other options are not the correct syntax for calling a superclass constructor.

The method that changes the text the label displays is "setText". This method allows the programmer to update the text content of a label component in a graphical user interface. It takes a string as an argument and replaces the current text with the new specified text.

Inheritance allows objects of a subclass to be treated like objects of their superclass. This means that a subclass can inherit the properties and behaviors of its superclass, allowing it to access and use the same methods and variables. This promotes code reuse and allows for more efficient and organized programming, as subclasses can inherit and build upon the functionality of their superclass without having to redefine it.

The given statement "A superclass object is a subclass object" is false. In object-oriented programming, a superclass is a class from which other classes, called subclasses, inherit properties and methods. A subclass can have additional properties and methods that are not present in the superclass. Therefore, a superclass object cannot be a subclass object because it does not have the additional properties and methods defined in the subclass.

If the superclass's constructor does not assign a value to an instance variable, the instance variable will be initialized to its default value. In Java, instance variables are automatically assigned default values if no explicit value is given. For example, numeric types are initialized to 0, boolean types are initialized to false, and object references are initialized to null. Therefore, the program will compile and run without any errors because the instance variables will still have valid default values.

Inheritance allows a reference of a superclass type to refer to an object of a subclass type. Therefore, a reference of type A can be treated as a reference of type B. This is known as upcasting.

The correct answer is c. ImageIcon. The ImageIcon class represents an image that can be displayed on a JLabel. It is used to create an icon from an image file and can be set as the icon for a JLabel component.

This functionality should not be factored out to a superclass because it is specific to a certain group of animals (mammals) and does not apply to all animals in general. Factoring it out to a superclass would result in incorrect behavior for mammals, as they do not lay eggs.

When a superclass has protected instance variables, it means that these variables can be accessed by the subclass. This allows the subclass object to assign invalid values to the superclass's instance variables, potentially leaving the object in an inconsistent state. Additionally, subclass methods are more likely to be written in a way that depends on the superclass's data implementation, meaning that any changes to the superclass's implementation may require modifications to all the subclasses. Therefore, all of the statements mentioned in options a, b, and c are true, making option d the correct answer.

The default implementation of the clone() method in the Object class performs a shallow copy. A shallow copy creates a new object and copies the non-static fields of the original object to the new object. However, if the field is a reference type, the reference is copied, not the actual object. This means that both the original object and the cloned object will refer to the same objects. Any changes made to the shared objects will be reflected in both the original and cloned objects.

When referencing the superclass's method, if the keyword "super" and a dot (.) separator are not used to prefix the superclass method name, it will cause infinite recursion. This means that the method will keep calling itself indefinitely, leading to a stack overflow error.