Chapter 8 Class Design Notes1

Question 1

Understanding Inheritance

Answer 1

• Inheritance is the process by which a subclass automatically includes any public or protected members of the class, including primitives, objects, or methods, defined in the parent class.
• subclass or child class
• superclass or parent class
• inheritance is transitive
  Z class –> Y class –> X class
• Package-private members are available if the child class is in the same package as the parent class.
• private members are restricted to the class they are defined in and are never available via inheritance. This doesn’t mean the parent class doesn’t have private members that can hold data or modify an object; it just means the child class has no direct reference to them.

Question 2

SINGLE VS. MULTIPLE INHERITANCE

Answer 2

• Java supports single inheritance, by which a class may inherit from only one direct parent class. (only can extends one class)
• Java also supports multiple levels of inheritance, by which one class may extend another class, which in turn extends another class. You can have any number of levels of inheritance, allowing each descendant to gain access to its ancestor’s members.
• To truly understand single inheritance, it may helpful to contrast it with multiple inheritance, by which a class may have multiple direct parents. By design, Java doesn’t support multiple inheritance in the language because multiple inheritance can lead to complex, often difficult-to-maintain data models.
• Java does allow one exception to the single inheritance rule that you’ll see in Chapter 9—a class may implement multiple interfaces.

Question 3

How to prevent a class from being extended?

Answer 3

• It is possible in Java to prevent a class from being extended by marking the class with the final modifier.
• If you try to define a class that inherits from a final class, then the class will fail to compile.

Question 4

INHERITING OBJECT

Answer 4

• In Java, all classes inherit from a single class: java.lang.Object, or Object for short.
• Furthermore, Object is the only class that doesn’t have a parent class.
• You might be wondering, “None of the classes I’ve written so far extend Object, so how do all classes inherit from it?” The answer is that the compiler has been automatically inserting code into any class you write that doesn’t extend a specific class.

Question 5

Creating Classes

Question 6

EXTENDING A CLASS

Answer 6

public abstract class ElephantSeal extends Seal {
    // Methods and Variables defined here
}

1. public or default (package-private) access modifier
2. abstract or final keyword (optional)
3. class keyword (required)
4. Class name (required)
5. extends parent class (optional)

Question 7

APPLYING CLASS ACCESS MODIFIERS

Answer 7

• top-level class can only have public or package-private access.
• An inner class is a class defined inside of another class and is the opposite of a top-level class.
• In addition to public and package-private access, inner classes can also have protected and private access.
• We will discuss inner classes in Chapter 9.
• As you might recall, a Java file can have many top-level classes but at most one public top-level class.
• In fact, it may have no public class at all.
• There’s also no requirement that the single public class be the first class in the file.
• One benefit of using the package-private access is that you can define many classes within the same Java file.

Question 8

ACCESSING THE THIS REFERENCE

Answer 8

public class Flamingo {
    private String color;
    public void setColor(String color) {
        color = color;
    }
}		

Java uses the most granular scope, so when it sees color = color, it thinks you are assigning the method parameter value to itself.

• when you have a local variable with the same name as an instance variable is to use the this reference or keyword.
• The this reference refers to the current instance of the class and can be used to access any member of the class, including inherited members.
• It can be used in any
  
  • instance method,
  • constructor,
  • and instance initializer block.
• It cannot be used when there is no implicit instance of the class, such as in a
  
  • static method
  • or static initializer block.

public void setColor(String color) {
    this.color = color;
}

Question 9

CALLING THE SUPER REFERENCE

Answer 9

• super reference refers the members accessible via inheritance.
• No access to current class members
• you often only use super when you have a naming conflict via inheritance. For example, you have a method or variable defined in the current class that matches a method or variable in a parent class.

Question 10

Declaring Constructors

Answer 10

• a constructor is a special method that matches the name of the class
• and has no return type.
• It is called when a new instance of the class is created.
• Like method parameters, constructor parameters can be any valid class, array, or primitive type, including generics, but may not include var.

Question 11

CREATING A CONSTRUCTOR

Answer 11

public class Bunny {
    public Bunny() { //constructor name match class name and not return type
        System.out.println("constructor");
    }
}

• A class can have multiple constructors, so long as each constructor has a unique signature. In this case, that means the constructor parameters must be distinct.
• declaring multiple constructors with different signatures is referred to as constructor overloading.
• Constructors are used when creating a new object. This process is called instantiation because it creates a new instance of the class. A constructor is called when we write new followed by the name of the class we want to instantiate.

Question 12

DEFAULT CONSTRUCTOR

Answer 12

• Every class in Java has a constructor whether you code one or not.
• If you don’t include any constructors in the class, Java will create one for you without any parameters.
• This Java-created constructor is called the default constructor and is added anytime a class is declared without any constructors.
• We often refer to it as the default no-argument constructor for clarity.
• The default constructor has an empty parameter list and an empty body.

Question 13

private constructors

Answer 13

> [!NOTE]
Having only private constructors in a class tells the compiler not to provide a default no-argument constructor.It also prevents other classes from instantiating the class.This is useful when a class has only static methods or the developer wants to have full control of all calls to create new instances of the class.Remember, static methods in the class, including a main() method, may access private members, including private constructors.

Question 14

CALLING OVERLOADED CONSTRUCTORS WITH this()

Answer 14

• Constructors can be called only by writing new before the name of the constructor.
• They are not like normal methods that you can just call.
• Use this() to calls another constructor on the same instance of the class.
• the this() call must be the first statement in the constructor.
• The side effect of this is that there can be only one call to this() in any constructor

Question 15

There’s one last rule for overloaded constructors you should be aware of.

Answer 15

• The compiler is capable of detecting that this constructor is calling itself infinitely. Since this code can never terminate, the compiler stops and reports this as an error.

public class Gopher {
    public Gopher(int dugHoles) {
        this(5); // DOES NOT COMPILE
    }
}

• the constructors call each other, and the process continues infinitely. Since the compiler can detect this, it reports this as an error.

public class Gopher {
    public Gopher() {
        this(5); // DOES NOT COMPILE
    }
    public Gopher(int dugHoles) {
        this(); // DOES NOT COMPILE
    }
}

Question 16

THIS VS. THIS()

Answer 16

• Despite using the same keyword, this and this() are very different.
  
  • The first, this, refers to an instance of the class,
  • while the second, this(), refers to a constructor call within the class.
• The exam may try to trick you by using both together, so make sure you know which one to use and why.

Question 17

CALLING PARENT CONSTRUCTORS WITH SUPER()

Answer 17

• In Java, the first statement of every constructor is either a call to another constructor within the class, using this(), or a call to a constructor in the direct parent class, using super().
• If a parent constructor takes arguments, then the super() call also takes arguments.

Question 18

SUPER VS. SUPER()

Answer 18

• Like this and this(), super and super() are unrelated in Java.
  
  • The first, super, is used to reference members of the parent class,
  • while the second, super(), calls a parent constructor.
• Anytime you see the super keyword on the exam, make sure it is being used properly.

Question 19

Understanding Compiler Enhancements

Answer 19

Java compiler automatically inserts a call to the no-argument constructor super() if you do not explicitly call this() or super() as the first line of a constructor.

Question 20

ARE CLASSES WITH ONLY PRIVATE CONSTRUCTORS CONSIDERED FINAL?

Answer 20

• only an inner class defined in the class itself can extend it.
• An inner class is the only one that would have access to a private constructor and be able to call super().
• Other top-level classes cannot extend such a class.
• Don’t worry—knowing this fact is not required for the exam. We include it here for those who were curious about declaring only private constructors.

Question 21

Missing a Default No-Argument Constructor
What happens if the parent class doesn’t have a no-argument constructor?

Answer 21

• you must create at least one constructor in your child class that explicitly calls a parent constructor via the super() command.
• We can fix this by adding a call to a parent constructor that takes a fixed argument.

public class Mammal {
public Mammal(int age) {}
}
public class Elephant extends Mammal { // DOES NOT COMPILE
}

Question 22

SUPER() ALWAYS REFERS TO THE MOST DIRECT PARENT

Answer 22

For constructors, though, super() always refers to the most direct parent.

Question 23

CONSTRUCTORS AND FINAL FIELDS

Answer 23

• final static variables must be assigned a value exactly once. You saw this happen in the
  
  • line of the declaration
  • and in a static initializer.
• Instance variables marked final follow similar rules. They can be assigned values in
  
  • the line in which they are declared
  • or in an instance initializer.
  • The constructor is part of the initialization process, so it is allowed to assign final instance variables in it.
• For the exam, you need to know one important rule. By the time the constructor completes, all final instance variables must be assigned a value.
• Unlike local final variables, which are not required to have a value unless they are actually used, final instance variables must be assigned a value.
• Default values are not used for these variables.
• If they are not assigned a value in the line where they are declared or in an instance initializer, then they must be assigned a value in the constructor declaration. Failure to do so will result in a compiler error on the line that declares the constructor.

Question 24

> [!NOTE]
On the exam, be wary of any instance variables marked final.
Make sure they are assigned a value in the line where they are declared, in an instance initializer, or in a constructor.
They should be assigned a value only once,
and failure to assign a value is considered a compiler error in the constructor.
We can assign a null value to final instance variables, so long as they are explicitly set.

Answer 24

• instance variables marked final.
• assigned a value
  
  • in the line where they are declared,
  • in an instance initializer,
  • or in a constructor.
• assigned a value only once,
• failure to assign a value is considered a compiler error in the constructor.
  We can assign a null value to final instance variables, so long as they are explicitly set.

Question 25

**ORDER OF INITIALIZATION**

Question 26

**Class Initialization**

Answer 26

* First, you need to **initialize the class, which involves invoking all static members in the class hierarchy, starting with the highest superclass and working downward.** * This is often referred to as **loading the class**. * The JVM controls when the class is initialized, although you can assume the class is loaded before it is used. * The **class may be initialized when the program first starts**, when a **static member of the class is referenced, or shortly before an instance of the class is created.** * **The most important rule with class initialization is that it happens at most *once* for each class.** * **The class may also never be loaded if it is not used in the program.** **Initialize Class X** 1. **If there is a superclass Y of X, then initialize class Y first.** 2. **Process all static variable declarations in the order they appear in the class.** 3. **Process all static initializers in the order they appear in the class.**

Question 27

**WHY THE HIPPO PROGRAM PRINTED C AFTER AB** ``` public class Animal { static { System.out.print("A"); } } public class Hippo extends Animal { static { System.out.print("B"); } public static void main(String[] grass) { System.out.print("C"); new Hippo(); new Hippo(); new Hippo(); } } public class HippoFriend { public static void main(String[] grass) { System.out.print("C"); new Hippo(); } } ```

Answer 27

**Assuming the class isn’t referenced anywhere else, this program will likely print** ***`CAB`***, * with the Hippo class not being loaded until it is needed inside the main() method. * We say likely, because the rules for **when classes are loaded are determined by the JVM at runtime.** * For the exam, you just need to know that **a class must be initialized before it is referenced or used**. * Also, **the class containing the program entry point, aka the main() method, is loaded before the main() method is executed.**

Question 28

**Instance Initialization**

Answer 28

* **An instance is initialized anytime the *`new`* keyword is used.** In our previous example, there were three new Hippo() calls, resulting in three Hippo instances being initialized. * Instance initialization is a bit more complicated than class initialization, because **a class or superclass may have many constructors declared but only a handful used as part of instance initialization.** * **First, start at the lowest-level constructor where the new keyword is used.** * Remember, **the first line of every constructor is a call to this() or super(), and if omitted, the compiler will automatically insert a call to the parent no-argument constructor super().** * **Then, progress upward and note the order of constructors.** * **Finally, initialize each class starting with the superclass, processing each instance initializer and constructor in the reverse order in which it was called.** **Initialize Instance of X** 1. **If there is a superclass Y of X, then initialize the instance of Y first.** 2. **Process all instance variable declarations in the order they appear in the class.** 3. **Process all instance initializers in the order they appear in the class.** 4. **Initialize the constructor including any overloaded constructors referenced with this().**

Question 29

**REVIEWING CONSTRUCTOR RULES**

Answer 29

1. The **first statement of every *`constructor`*** is a call to an overloaded constructor via ***`this()`***, or a direct parent constructor via ***`super()`***. 2. **If the first statement of a *`constructor`* is *not* a call to *`this()`* or *`super()`***, then the **compiler will insert a no-argument *`super()`* as the first statement of the *`constructor`*.** 3. **Calling *`this() and super()`* *after the first statement* of a *`constructor`* results in a compiler error.** 4. **If the parent class doesn’t have a no-argument constructor**, then **every constructor in the child class must start with an explicit *`this() or super()`* constructor call.** 5. **If the parent class doesn’t have a no-argument constructor and the child doesn’t define any constructors, then the child class will not compile.** 6. If a class only defines ***`private`* constructors**, then it **cannot be extended by a top-level class.** 7. **All final instance variables must be assigned a value exactly *once* by the end of the constructor.** Any final instance variables not assigned a value will be reported as a **compiler error on the line the constructor is declared.**

Question 30

**Inheriting Members**

Answer 30

One of Java’s biggest strengths is leveraging its inheritance model to simplify code. **Java allows subclass to replace, or override, the parent method implementation at runtime.**

Question 31

**CALLING INHERITED MEMBERS**

Answer 31

* **Java classes may use any *`public or protected`* member of the parent class, including *`methods, primitives, or object references`*.** * **If the parent class and child class are part of the *same package*, then the child class may also use any *`package-private`* members defined in the parent class.** * Finally, a **child class may never access a *`private`* member of the parent class**, at least not through any direct reference. * As you saw earlier in this chapter, a **private member age was accessed indirectly via a public or protected method.** * To reference a member in a parent class, you can just call it directly * Remember, you can **use *`this`* to access visible members of the current or a parent class,** * and you can **use *`super`* to access visible members of a parent class.** ``` class Fish { protected int size; private int age; public Fish(int age) { this.age = age; } public int getAge() { return age; } } public class Shark extends Fish { private int numberOfFins = 8; public Shark(int age) { super(age); this.size = 4; } public void displaySharkDetails() { System.out.print("Shark with age: "+getAge()); System.out.print(" and "+size+" meters long"); System.out.print(" with "+numberOfFins+" fins"); } } ```

Question 32

**INHERITING METHODS**

Answer 32

Inheriting a class not only **grants access to inherited methods** in the parent class but also **sets the stage for collisions between methods defined in both the parent class and the subclass.** In this section, we’ll review the rules for method inheritance and how Java handles such scenarios.

Question 33

**Overriding a Method** **What if there is a method defined in both the parent and child classes with the *same signature*?**

Answer 33

* The solution is to **override the method in the child class.** * In Java, **overriding a method occurs when a subclass declares a new implementation for an inherited method with the *same signature* and compatible return type.** * Remember that a ***method signature* includes the *name* of the method and method *parameters*.** * When you override a method, you may **reference the parent** version of the method using the ***`super`* keyword**. * In this manner, **the keywords *`this`* and *`super`* allow you to select between the current and parent versions of a method, respectively.**

Question 34

**To override a method, you must follow a number of rules.**

Answer 34

**The compiler performs the following checks when you override a method:** 1. The method in the child class must have the **same signature** as the method in the parent class. 2. The method in the child class **must be at least as accessible** as the method in the parent class. 3. The method in the child class **may not declare a checked exception that is new or broader** than the class of any exception declared in the parent class method. 4. If the method **returns a value, it must be the same or a subtype** of the method in the parent class, known as **covariant return types**.

Question 35

**METHOD OVERRIDING AND RECURSIVE CALLS**

Answer 35

* A ***recursive* method is one that calls itself** as part of execution. * It is common in programming but must have a termination condition that triggers the end to recursion at some point or depth. * In this example, there is no termination condition; therefore, **the application will attempt to call itself infinitely and produce a *`StackOverflowError`* at runtime.** ``` public double getAverageWeight() { return getAverageWeight()+20; // StackOverflowError } ```

Question 36

**DEFINING SUBTYPE AND SUPERTYPE**

Answer 36

**When discussing *`inheritance`* and *`polymorphism`*, we often use the word *`subtype`* rather than *`subclass`*, since Java includes *`interfaces`***. **A *`subtype`* is the relationship between two types where one type inherits the other.** If we define **X to be a subtype of Y**, then one of the following is true : * X and Y are classes, and **X is a subclass of Y**. * X and Y are interfaces, and **X is a subinterface of Y**. * X is a class and Y is an interface, and **X implements Y** (either directly or through an inherited class). Likewise, a **supertype** is the reciprocal relationship between two types where one type is the ancestor of the other. **Remember, a subclass is a subtype, but not all subtypes are subclasses.**

Question 37

**OVERLOADING VS. OVERRIDING**

Answer 37

* **Overloading and overriding** a method are simLilar in that they both involve redefining a **method using the same name**. * They differ in that an **overloaded method will use a different list of method parameters.** * This distinction allows **overloaded methods a great deal more freedom in syntax** than an overridden method would have. Any time you see a method on the exam with the same name as a method in the parent class, **determine whether the method is being overloaded or overridden first;** doing so will help you with questions about whether the code will compile. **Java avoids these types of ambiguity problems by limiting overriding a method to access modifiers that are as accessible or more accessible than the version in the inherited method.** **that overriding a method cannot declare new checked exceptions or checked exceptions broader than the inherited method.** This is done for similar polymorphic reasons as limiting access modifiers. In other words, you could end up with an object that is more restrictive than the reference type it is assigned to, resulting in a checked exception that is not handled or declared. We will discuss what it means for an exception to be checked in Chapter 10, “Exceptions.” For now, you should just recognize that if **a broader checked exception is declared in the overriding method, the code will not compile.** **The overriding method must use a return type that is *covariant* with the return type of the inherited method.**

Question 38

> **[!NOTE]** > **A simple test for *covariance* is the following:** > Given an inherited return type A and an overriding return type B, **can you assign an instance of B to a reference variable for A without a cast?** > **If so, then they are covariant.** > **This rule applies to *primitive* types and *object* types alike.** > **If one of the return types is void, then they both must be void, as nothing is covariant with void except itself.**

Answer 38

* **covariance test** * assing instance of B to a reference variable for A without cast * This rule applices to **primitive** types and **object** types * **If one of the return types is void, then they both must be void, as nothing is covariant with void except itself.**

Question 39

**Overriding a Generic Method**

Question 40

**Review of Overloading a Generic Method**

Answer 40

**Cannot overload methods by changing the generic type due to type erasure.** To review, only one of the two methods is allowed in a class because type erasure will reduce both sets of arguments to (List input). ``` public class LongTailAnimal { protected void chew(List