Chapter 8 Class Design Notes

Question 1

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.

When one class inherits from a parent class, all public and protected members are automatically available as part of the child 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.

• Subclass includes any public or protected members defined in the parent 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.

Question 2

inheritance is transitive

Answer 2

If child class X inherits from parent class Y, which in turn inherits from a parent class Z, then class X would be considered a subclass, or descendant, of class Z. By comparison, X is a direct descendant only of class Y, and Y is a direct descendant only of class Z.

Question 3

SINGLE VS. MULTIPLE INHERITANCE

Answer 3

Java supports single inheritance, by which a class may inherit from only one direct parent 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.

Java does allow one exception to the single inheritance rule that you’ll see in Chapter 9—a class may implement multiple interfaces.

• Java support single inheritance
• Java also support multiple levels of inheritance.
• A class may implement multiple interfaces

Question 4

How to prevent a class from being extended?

Answer 4

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 5

INHERITING OBJECT

Answer 5

• In Java, all classes inherit from a single class: java.lang.Object, or Object for short.
• The key is that when Java sees you define a class that doesn’t extend another class, it automatically adds the syntax extends java.lang.Object to the class definition.
• Object is alway no top of the inhert tree.

Question 6

Defining and 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

EXTENDING A CLASS

public class Animal {
   private int age;
   protected String name;
   public int getAge() {
      return age;
   }
   public void setAge(int newAge) {
      age = newAge;
   }
}
 
public class Lion extends Animal {
   public void setProperties(int age, String n) {
      setAge(age);
      name = n;
   }
   public void roar() {
      System.out.print(name + ", age " + getAge() + ", says: Roar!");
   }
   public static void main(String[] args) {
      var lion = new Lion();
      lion.setProperties(3, "kion");
      lion.roar();
   }
}

Answer 7

the Lion program prints the following:
kion, age 3, says: Roar!

Cannot access private variable

public class Lion extends Animal {
   ...
   public void roar() {
      System.out.print("Lions age: "+age);  // DOES NOT COMPILE
   }
   ...
}

Question 8

APPLYING CLASS ACCESS MODIFIERS

Answer 8

Top-level class can only have public or default (package-private) access modifier

Question 9

> [!NOTE:]
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.

Answer 9

• Inner class can have public, protected, default (package-private) and private access modifier.
• java file can have many top-level classes but at most one public top-level class.
• One benefit of using the package-private access is that you can define many classes within the same java file.

Question 10

> [!NOTE:]
For simplicity, any time you see multiple public classes or interfaces defined in the same code sample in this book, assume each class is defined in its own Java file.

Answer 10

test

Question 11

ACCESSING THE THIS REFERENCE

Answer 11

• 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.

Question 12

What do you think the following program prints?

public class Flamingo {
    private String color;
    public void setColor(String color) {
        color = color;
}
    public static void main(String... unused) {
        Flamingo f = new Flamingo();
        f.setColor("PINK");
        System.out.println(f.color);
    }
}

Answer 12

Output:

null

The assignment completes successfully within the method, but the value of the instance variable color is never modified and is null when printed in the main() method.

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

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.

Question 13

1: public class Duck {
2:     private String color;
3:     private int height;
4:     private int length;
5:
6:     public void setData(int length, int theHeight) {
7:         length = this.length; // Backwards – no good!
8:         height = theHeight; // Fine because a different name
9:         this.color = "white"; // Fine, but this. not necessary
10:     }
11:
12:     public static void main(String[] args) {
13:         Duck b = new Duck();
14:         b.setData(1,2);
15:         System.out.print(b.length + " " + b.height + " " + b.color);
16: } }

Answer 13

This code compiles and prints the following:
0 2 white

Question 14

How do we reference the version in the parent class instead of the current class?

Answer 14

To achieve this, you can use the super reference or keyword.

ex:

class Mammal {
    String type = "mammal";
}
public class Bat extends Mammal {
    String type = "bat";
    public String getType() {
        return super.type + ":" + this.type;
    }
    public static void main(String... zoo) {
        System.out.print(new Bat().getType());
    }
}

The program prints mammal:bat

Question 15

What does the following program output?

1:  class Insect {
2:     protected int numberOfLegs = 4;
3:     String label = "buggy";
4:  }
5:  
6:  public class Beetle extends Insect {
7:     protected int numberOfLegs = 6;
8:     short age = 3;
9:     public void printData() {
10:       System.out.print(this.label);
11:       System.out.print(super.label);
12:       System.out.print(this.age);
13:       System.out.print(super.age);
14:       System.out.print(numberOfLegs);
15:    }
16:    public static void main(String []n) {
17:       new Beetle().printData();
18:    }
19: }

Answer 15

That was a trick question—this program code would not compile!
line 13 does not complie.

while this includes current and inherited members, super only includes inherited members.

Question 16

Constructors Rules

Answer 16

1. a constructor is a special method that matches the name of the class and has no return type.
2. Like method parameters, constructor parameters can be any valid class, array, or primitive type, including generics, but may not include var.
3. A class can have multiple constructors, so long as each constructor has a unique signature. (constructor parameters must be distinct.)
4. During compilation, java generate default no-argument constructor if a class is declared without any constructors.
5. default constructor has an empty parameter list and an empty body.

Question 17

Can you tell why these two are not valid constructors for the Bunny class?

public class Bunny {
public bunny() { } // DOES NOT COMPILE
public void Bunny() { }
}

Answer 17

The first one doesn’t match the class name because Java is case sensitive.

The second method is a perfectly good method but is not a constructor because it has a return type.

Question 18

The following does not compile:

class Bonobo {
    public Bonobo(var food) { // DOES NOT COMPILE
    }
}

Answer 18

Like method parameters, constructor parameters can be any valid class, array, or primitive type, including generics, but may not include var.

Question 19

Constructor Overloading

Answer 19

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. Like methods with the same name but different signatures,
declaring multiple constructors with different signatures is referred to as constructor overloading.

ex:

public class Turtle {
private String name;
    public Turtle() {
        name = "John Doe";
    }
    public Turtle(int age) {}
    public Turtle(long age) {}
    public Turtle(String newName, String... favoriteFoods) {
        name = newName;
    }
}

Question 20

DEFAULT CONSTRUCTOR

Answer 20

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.

It is only in the compiled file with the .class extension that it makes an appearance.

Question 21

> [!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.

Answer 21

test

Question 22

CALLING OVERLOADED CONSTRUCTORS WITH THIS()

public class Hamster {
   private String color;
   private int weight;
   public Hamster(int weight) {                 // First constructor
      this.weight = weight;
      color = "brown";
   }
   public Hamster(int weight, String color) {   // Second constructor
      this.weight = weight;
      this.color = color;
   }
}

Answer 22

Constructors can be called only by writing new before the name of the constructor.
Cannot call constructor like normal method.

public Hamster(int weight) {
    Hamster(weight, "brown"); // DOES NOT COMPILE
}

When this() is used with parentheses, Java calls another constructor on the same instance of the class.

public Hamster(int weight) {
    this(weight, "brown");
}

Question 23

this() rule

Answer 23

Calling this() has one special rule you need to know. If you choose to call it, 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.

ex:

3: public Hamster(int weight) {
4: System.out.println("in constructor");
5: // Set weight and default color
6: this(weight, "brown"); // DOES NOT COMPILE
7: }

Question 24

Consider the following definition of the Gopher class:

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

Answer 24

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.

Question 25

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

Answer 25

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

Question 26

**THIS VS. THIS()**

Answer 26

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 27

**CALLING PARENT CONSTRUCTORS WITH *`SUPER()`***

Answer 27

``` public class Animal { private int age; public Animal(int age) { super(); // Refers to constructor in java.lang.Object this.age = age; } } public class Zebra extends Animal { public Zebra(int age) { super(age); // Refers to constructor in Animal } public Zebra() { this(4); // Refers to constructor in Zebra with int argument } } ```

Question 28

**super() rule**

Answer 28

**calling *`super()`* can only be used as the *first statement of the `constructor`*.**

Question 29

**SUPER VS. SUPER()**

Answer 29

* **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 30

**Understanding Compiler Enhancements** **the first line of every constructor is a call to either *`this()`* or *`super()`*** **How did these classes compile?** ``` public class Donkey {} public class Donkey { public Donkey() {} } public class Donkey { public Donkey() { super(); } } ```

Answer 30

**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**. For example, the **following three class and constructor definitions are equivalent**, because the compiler will automatically convert them all to the last example: ``` public class Donkey {} public class Donkey { public Donkey() {} } public class Donkey { public Donkey() { super(); } } ```

Question 31

**ARE CLASSES WITH ONLY PRIVATE CONSTRUCTORS CONSIDERED FINAL?**

Answer 31

Remember, **a final class cannot be extended.** What happens if you have a **class that is not marked final but only contains private constructors—can you extend the class?** The answer is **“yes,” but 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 32

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

Answer 32

``` public class Mammal { public Mammal(int age) {} } public class Elephant extends Mammal { // DOES NOT COMPILE } ``` **Since Elephant does not define any constructors, the Java compiler will attempt to insert a default no-argument constructor. As a second compile-time enhancement, it will also auto-insert a call to super() as the first line of the default no-argument constructor.** ``` public class Elephant extends Mammal { public Elephant() { super(); // DOES NOT COMPILE } } ``` **Fix :** ``` public class Elephant extends Mammal { public Elephant() { super(10); } } ``` For example, the following class compiles because Elephant now has a no-argument constructor, albeit one defined explicitly: ``` public class AfricanElephant extends Elephant {} ```

Question 33

***`SUPER()`* ALWAYS REFERS TO THE MOST DIRECT PARENT**

Answer 33

* A ***`class`*** may have ***`multiple ancestors`*** via inheritance. * In our previous example, AfricanElephant is a subclass of Elephant, which in turn is a subclass of Mammal. * For constructors, though, ***`super()`* always refers to the most direct parent.** * In this example, calling super() inside the AfricanElephant class always refers to the Elephant class, and never the Mammal class.

Question 34

**CONSTRUCTORS AND FINAL FIELDS** ``` public class MouseHouse { private final int volume; private final String name = "The Mouse House"; { volume = 10; } } ```

Answer 34

* ***`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.`***

Question 35

``` public class MouseHouse { private final int volume; private final String type; public MouseHouse() { this.volume = 10; type = "happy"; } } ```

Answer 35

In our MouseHouse implementation, the values for volume and type are assigned in the constructor. **Remember that the *`this`* keyword is *`optional`* since the instance variables are part of the class declaration, and there are *no constructor parameters with the same name*.**

Question 36

**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.**

Answer 36

* final instance variable * must be assigned a value * assinged a value in the line where they are declared * instance initializer * constructor

Question 37

``` public class MouseHouse { private final int volume; private final String type; { this.volume = 10; } public MouseHouse(String type) { this.type = type; } public MouseHouse() { // DOES NOT COMPILE this.volume = 2; // DOES NOT COMPILE } } ```

Answer 37

* In this example, the ***`first constructor`* that takes a String argument compiles.** Although a ***`final instance variable`* can be assigned a value only once, each constructor is considered independently in terms of assignment.** * The ***`second constructor`* does not compile for two reasons.** * First, the constructor **fails to set a value for the *`type variable`*.** The compiler detects that a value is never set for type and reports an error on the line where the constructor is declared. * Second, the constructor **sets a value for the volume variable, even though it was already assigned a value by the instance initializer.** The compiler reports this error on the line where volume is set.

Question 38

> [!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.**

Answer 38

* ***`Instance variables`* marked *`final`*** * Assigned a value only once * **declaration line** * **instance initializer** * **constructor** * **should be assigned a value only once, and failure to assign a value is considered a compiler error in the constructor**

Question 39

**How to fix MouseHouse() constructor?** ``` public class MouseHouse { private final int volume; private final String type; { this.volume = 10; } public MouseHouse(String type) { this.type = type; } public MouseHouse() { // DOES NOT COMPILE this.volume = 2; // DOES NOT COMPILE } } ```

Answer 39

What about final instance variables when a constructor calls another constructor in the same class? In that case, you have to follow the constructor logic pathway carefully, making sure every final instance variable is assigned a value exactly once. We can replace our previous bad constructor with the following one that does compile: ``` public MouseHouse() { this(null); } ``` This constructor does not perform any assignments to any final instance variables, but it calls the MouseHouse(String) constructor, which we observed compiles without issue. We use null here to demonstrate that the variable does not need to be an object value. **We can assign a null value to final instance variables, so long as they are explicitly set.**

Question 40

**REVIEWING *`CONSTRUCTOR`* RULES**

Answer 40

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 41

**ORDER OF INITIALIZATION** With inheritance, though, the order of initialization for an instance gets a bit more complicated. We’ll start with how to initialize the class and then expand to initializing the instance.

Answer 41

1. **Class Initialization** 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.** * If there is a **superclass Y** of X, then **initialize class Y first.** * **Process all static variable declarations in the order they appear in the class.** * **Process all static initializers in the order they appear in the class.** 2. **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. 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 42

**Taking a look at an example, what does the following program print?** ``` 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(); } } ```

Answer 42

* **It prints ABC exactly once.** * Since the **main() method is inside the Hippo class, the class will be initialized first, starting with the superclass and printing AB.** * Afterward, **the main() method is executed, printing C.** * Even though the main() method creates three instances, **the class is loaded only once.**

Question 43

**What if you instead called Hippo inside another program?** ``` 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 43

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 44

**See if you can figure out what the following application outputs:** ``` 1: public class ZooTickets { 2: private String name = "BestZoo"; 3: { System.out.print(name+"-"); } 4: private static int COUNT = 0; 5: static { System.out.print(COUNT+"-"); } 6: static { COUNT += 10; System.out.print(COUNT+"-"); } 7: 8: public ZooTickets() { 9: System.out.print("z-"); 10: } 11: 12: public static void main(String... patrons) { 13: new ZooTickets(); 14: } 15: } ```

Answer 44

The output is as follows: ***`0-10-BestZoo-z-`*** * First, we have to **initialize the class**. * Since there is **no superclass** declared, which means the superclass is Object, * we can start with the **static components** of ZooTickets. * In this case, lines 4, 5, and 6 are executed, printing 0- and 10-. * Next, we **initialize the instance**. * Again, since there is **no superclass declared**, * we start with the **instance components**. Lines 2 and 3 are executed, which prints BestZoo-. * Finally, we run the **constructor** on lines 8–10, which outputs z-.

Question 45

**Let’s try a simple example with inheritance.** ``` class Primate { public Primate() { System.out.print("Primate-"); } } class Ape extends Primate { public Ape(int fur) { System.out.print("Ape1-"); } public Ape() { System.out.print("Ape2-"); } } public class Chimpanzee extends Ape { public Chimpanzee() { super(2); System.out.print("Chimpanzee-"); } public static void main(String[] args) { new Chimpanzee(); } } ```

Answer 45

**The compiler inserts the super() command as the first statement of both the Primate and Ape constructors.** The code will execute with the parent constructors called first and yields the following output: ***`Primate-Ape1-Chimpanzee-`*** * Notice that only one of the two Ape() constructors is called. * You need to start with the call to new Chimpanzee() to determine which constructors will be executed. * Remember, constructors are executed from the bottom up, but since the first line of every constructor is a call to another constructor, the flow actually ends up with the parent constructor executed before the child constructor.

Question 46

**The next example is a little harder. What do you think happens here?** ``` 1: public class Cuttlefish { 2: private String name = "swimmy"; //5 3: { System.out.println(name); } //6 4: private static int COUNT = 0; // 1 5: static { System.out.println(COUNT); } // 2 6: { COUNT++; System.out.println(COUNT); } //7 7: 8: public Cuttlefish() { 9: System.out.println("Constructor"); //8 10: } 11: 12: public static void main(String[] args) { 13: System.out.println("Ready"); //3 14: new Cuttlefish(); //4 15: } 16: } ```

Answer 46

**The output looks like this:** ``` 0 Ready swimmy 1 Constructor ``` * There is no superclass declared, so we can skip any steps that relate to inheritance. * We first process the static variables and static initializers—lines 4 and 5, with line 5 printing **0**. * Now that the static initializers are out of the way, the main() method can run, which prints **Ready**. * Lines 2, 3, and 6 are processed, with line 3 printing **swimmy** and * line 6 printing **1**. * Finally, the constructor is run on lines 8–10, which print **Constructor**.

Question 47

**What does the following output?** ``` 1: class GiraffeFamily { 2: static { System.out.print("A"); } //1 3: { System.out.print("B"); } //3 4: 5: public GiraffeFamily(String name) { 6: this(1); 7: System.out.print("C"); //5 8: } 9: 10: public GiraffeFamily() { 11: System.out.print("D"); 12: } 13: 14: public GiraffeFamily(int stripes) { 15: System.out.print("E"); //4 16: } 17: } 18: public class Okapi extends GiraffeFamily { 19: static { System.out.print("F"); } //2 20: 21: public Okapi(int stripes) { 22: super("sugar"); 23: System.out.print("G"); //7 24: } 25: { System.out.print("H"); } //6 26: 27: public static void main(String[] grass) { 28: new Okapi(1); 29: System.out.println(); 30: new Okapi(2); 31: } 32: } ```

Answer 47

**The program prints the following :** ``` AFBECHG BECHG ``` * Let’s walk through it. Start with initializing the Okapi class. Since it has a superclass GiraffeFamily, initialize it first, printing **A** on line 2. * Next, initialize the Okapi class, printing **F** on line 19. * After the classes are initialized, execute the main() method on line 27. * The first line of the main() method creates a new Okapi object, triggering the instance initialization process. * Per the first rule, the superclass instance of GiraffeFamily is initialized first. * Per our third rule, the instance initializer in the superclass GiraffeFamily is called, and **B** is printed on line 3. * Per the fourth rule, we initialize the constructors. In this case, this involves calling the constructor on line 5, which in turn calls the overloaded constructor on line 14. The result is that **EC** is printed, as the constructor bodies are unwound in the reverse order that they were called. * The process then continues with the initialization of the Okapi instance itself. * Per the third and fourth rules, **H** is printed on line 25, * and **G** is printed on line 23, respectively. * The process is a lot simpler when you don’t have to call any overloaded constructors. * Line 29 then inserts a line break in the output. Finally, * line 30 initializes a new Okapi object. The order and initialization are the same as line 28, sans the class initialization, so **BECHG** is printed again. * Notice that D is never printed, as only two of the three constructors in the superclass GiraffeFamily are called. This example is tricky for a few reasons. There are multiple overloaded constructors, lots of initializers, and a complex constructor pathway to keep track of. Luckily, questions like this are rare on the exam. If you see one, just write down what is going on as you read the code.

Question 48

> [!NOTE] > When taking the exam, pay close attention to any question involving two or more classes related by inheritance. > Before even attempting to answer the question, you should check that the constructors are properly defined using the previous set of rules. > You should also verify the classes include valid access modifiers for members. > Once those are verified, you can continue answering the question.

Answer 48

test

Question 49

**CALLING INHERITED MEMBERS**

Answer 49

* 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.

Question 50

**INHERITING METHODS**

Answer 50

test

Question 51

**Overriding a Method**

Answer 51

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 52

``` public class Canine { public double getAverageWeight() { return 50; } } public class Wolf extends Canine { public double getAverageWeight() { return super.getAverageWeight()+20; } public static void main(String[] args) { System.out.println(new Canine().getAverageWeight()); System.out.println(new Wolf().getAverageWeight()); } } ```

Answer 52

In this example, in which the **child class Wolf overrides the parent class Canine**, the method ***`getAverageWeight()`*** runs, and the program displays the following: ``` 50.0 70.0 ```

Question 53

**METHOD OVERRIDING AND RECURSIVE CALLS** **what would the following code output if we removed the super keyword?** ``` public class Canine { public double getAverageWeight() { return 50; } } public class Wolf extends Canine { public double getAverageWeight() { //return super.getAverageWeight()+20; <-- if we remove super keyword will create infinite call and produe a StackOverflowError at runtime. return getAverageWeight()+20; // StackOverflowError } public static void main(String[] args) { System.out.println(new Canine().getAverageWeight()); System.out.println(new Wolf().getAverageWeight()); } } ```

Answer 53

In this example, the compiler would not call the parent Canine method; it would call the current Wolf method since it would think you were executing a recursive method call. **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.**

Question 54

**To override a method**, you must follow a number of rules. The compiler performs the following checks when you override a method: **Rules to override a method**

Answer 54

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 55

**DEFINING SUBTYPE AND SUPERTYPE**

Answer 55

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 56

The first rule of overriding a method is somewhat self-explanatory. **If two methods have the same name but *`different signatures`*, the methods are *`overloaded`*, not *`overridden`***. **Overloaded methods are considered independent and do not share the same polymorphic properties as overridden methods.**

Answer 56

test

Question 57

**OVERLOADING VS. OVERRIDING**

Answer 57

* **Overloading and overriding a method are similar 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.**

Question 58

**For example, compare the overloaded fly() with the overridden eat() in the Eagle class.** ``` public class Bird { public void fly() { System.out.println("Bird is flying"); } public void eat(int food) { System.out.println("Bird is eating "+food+" units of food"); } } public class Eagle extends Bird { public int fly(int height) { System.out.println("Bird is flying at "+height+" meters"); return height; } public int eat(int food) { // DOES NOT COMPILE System.out.println("Bird is eating "+food+" units of food"); return food; } } ```

Answer 58

* The **fly() method is overloaded** in the subclass Eagle, since the **signature changes from a no-argument method to a method with one int argument.** **Because the method is being overloaded and not overridden, the *`return type can be changed from void to int`*.** * The **eat() method is overridden** in the subclass Eagle, since the **signature is the same** as it is in the parent class Bird—they both take a single argument int. **Because the method is being overridden, the return type of the method in the Eagle class must be compatible with the return type for the method in the Bird class.** In this example, the **return type int is not a subtype of void; therefore, the compiler will throw an exception on this method definition.**

Question 59

**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.**

Answer 59

test

Question 60

**What’s the purpose of the second rule about access modifiers? Let’s try an illustrative example:** ``` public class Camel { public int getNumberOfHumps() { return 1; } } public class BactrianCamel extends Camel { private int getNumberOfHumps() { // DOES NOT COMPILE return 2; } } public class Rider { public static void main(String[] args) { Camel c = new BactrianCamel(); System.out.print(c.getNumberOfHumps()); } } ```

Answer 60

* In this example, **BactrianCamel attempts to *`override`* the getNumberOfHumps() method defined in the parent class but fails because the access modifier *`private is more restrictive`* than the one defined in the parent version of the method.** * **Let’s say BactrianCamel was allowed to compile, though. Would the call to getNumberOfHumps() in Rider.main() succeed or fail? As you will see when we get into polymorphism later in this chapter, the answer is quite ambiguous. The reference type for the object is Camel, where the method is declared public, but the object is actually an instance of type BactrianCamel, which is declared private.** * **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.**

Question 61

**if a broader checked exception is declared in the overriding method, the code will not compile. Let’s try an example:** ``` public class Reptile { protected void sleepInShell() throws IOException {} protected void hideInShell() throws NumberFormatException {} protected void exitShell() throws FileNotFoundException {} } public class GalapagosTortoise extends Reptile { public void sleepInShell() throws FileNotFoundException {} public void hideInShell() throws IllegalArgumentException {} public void exitShell() throws IOException {} // DOES NOT COMPILE } ```

Answer 61

* In this example, we have three overridden methods. These overridden methods use the **more accessible public modifier**, which is allowed per our second rule over overridden methods. The overridden sleepInShell() method declares **FileNotFoundException**, which is a subclass of the exception declared in the inherited method, **IOException**. **Per our third rule of overridden methods, this is a successful override since the exception is narrower in the overridden method.** * The overridden hideInShell() method declares an **IllegalArgumentException**, which is a superclass of the exception declared in the inherited method, **NumberFormatException**. While this seems like an invalid override since the overridden method uses a broader exception, **both of these exceptions are unchecked, so the third rule does not apply.** * The third overridden exitShell() method declares **IOException**, which is a superclass of the exception declared in the inherited method, **FileNotFoundException**. Since these are checked exceptions and IOException is broader, **the overridden exitShell() method does not compile in the GalapagosTortoise class**. We’ll revisit these exception classes, including memorizing which ones are subclasses of each other, in Chapter 10.

Question 62

**The fourth and final rule around overriding a method is probably the most complicated, as it requires knowing the relationships between the return types. The overriding method must use a return type that is covariant with the return type of the inherited method.** **Let’s try an example for illustrative purposes:** ``` public class Rhino { protected CharSequence getName() { return "rhino"; } protected String getColor() { return "grey, black, or white"; } } class JavanRhino extends Rhino { public String getName() { return "javan rhino"; } public CharSequence getColor() { // DOES NOT COMPILE return "grey"; } } ```

Answer 62

* The subclass JavanRhino attempts to override two methods from Rhino: getName() and getColor(). * Both overridden methods have the same name and signature as the inherited methods. * The overridden methods also have a broader access modifier, public, than the inherited methods. Per the second rule, a broader access modifier is acceptable. * From Chapter 5, you should already know that String implements the CharSequence interface, making String a subtype of CharSequence. * Therefore, the return type of getName() in JavanRhino is covariant with the return type of getName() in Rhino. * On the other hand, the overridden getColor() method does not compile because CharSequence is not a subtype of String. To put it another way, all String values are CharSequence values, but not all CharSequence values are String values. For example, a StringBuilder is a CharSequence but not a String. **For the exam, you need to know if the return type of the overriding method is the same or a subtype of the return type of the inherited method.**

Question 63

> [!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.** > **The last three rules of overriding a method may seem arbitrary or confusing at first, but as you’ll see later in this chapter when we discuss polymorphism, they are needed for consistency. Without these rules in place, it is possible to create contradictions within the Java language.**

Answer 63

test

Question 64

**Overriding a Generic Method**

Answer 64

**Review of Overloading a Generic Method** In Chapter 7, you learned that you **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