Ch 5 - Class Design

Question 1

true/false, the following code compiles:
public class Zoo {
	public Zoo() {
		super();
		System.out.println("Zoo created");
}}

Answer 1

true

Question 2

What is the least amount of classes in a .java file you can have that are public?

Answer 2

none

Question 3

true/false, the followng code compiles:
public class Animal {
	private int age;
	public Animal(int age) {
		super();
		this.age = age;
}}
public class Zebra extends Animal {
	public Zebra(int age) {
		super(Age);
	}
	public Zebra() {
		this(4);
}}

Answer 3

true

Question 4

true/false, the following code compiles:
public class Zoo {
	public Zoo() {
		System.out.println("Zoo created");
		super();
}}

Answer 4

false

Question 5

How many interfaces marked public can you have in a single .java file?

Answer 5

1

Question 6

The following class does not have an access modifier:
class Rodent {}
What does this mean?

Answer 6

It has the default package private modifier, which indicates the class can only be accessed by a class within the same package.

Question 7

Any class that inherits another class is know as what?

Answer 7

A child class

Question 8

true/false, the following code compiles:
public class Animal {
	private int age;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
}}
public class Lion extends Animal {
	private void roar() {
		System.out.println("The " + age + " year old lion says Roar!");
}}

Answer 8

false. Although the Lion class extends the Animal class, it does not have direct access to the “age” member of Animal.

Question 9

What is the name of the object that all java classes inherit from?

Answer 9

java.lang.Object

Question 10

What is referred to as the process by which the new child subclass automatically includes any public or protected primitives, objects, or methods defined in the parent class.

Answer 10

inheritance

Question 11

How do you prevent a class from being inherited?

Answer 11

By using the ‘final’ specifier.

Question 12

true/false, when the java compiler sees that your class doesn’t extend another class, it automatically inserts code to extend java.lang.Object.

Answer 12

true

Question 13

In the following code, what is the line containing the word super() calling?
public class Animal {
	private int age;
	public Animal(int age) {
		super();
		this.age = age;
}}

Answer 13

The parent constructor in java.lang.Object.

Question 14

How many classes can one class directly inherit from?

Answer 14

Just one. However, multiple inheritance can be achieved by one class inheriting from another, which inherits from another, …

Question 15

How many classes can a .java file contain?

Answer 15

As many as you want.

Question 16

How many classes can have the public access modifier in a single .java file?

Answer 16

one

Question 17

true/false, the following code compiles:
public class Zoo {
	public Zoo() {
// Calling the parent constructor
		super();
		System.out.println("Zoo created");
}}

Answer 17

true

Question 18

true/false, the following code compiles:
public class Zoo {
	public Zoo() {
// Calling the parent constructor
		super();
		super();
		System.out.println("Zoo created");
}}

Answer 18

false

Question 19

true/false, the following code compiles:
public class Animal {
	public Animal(String s) {
	}
}
public class Elephant {
	public static void main(String[] args) {
		Animal a = new Animal();
	}
}

Answer 19

false. Since the class Animal doesn't have a no argument constructor, the following line in the Elephant class does not compile:
Animal a = new Animal();

Question 20

true/false, in Java, the child constructor is always executed before the parent constructor.

Answer 20

false. The parent constructor is always executed before the child constructor.

Question 21

What is the output of the following code?
class Primate {
	public Primate() {
		System.out.println("Primate");
}}
class Ape extends Primate {
	public Ape() {
		System.out.println("Ape");
}}
public class Chimpanzee extends Ape {
	public static void main(String[] args) {
		new Chimpanzee();
}}

Answer 21

Primate

Ape

Question 22

true/false, if no super() call is declared in a constructor, Java will insert a no-argument super() as the first statement of the constructor.

Answer 22

true

Question 23

true/false, the following code compiles:
public class Animal {
	public Animal(String s) {
	}
}
public class Elephant extends Animal {
	public Elephant() {
		super("Stephen");
	}
}

Answer 23

true

Question 24

true/false, a child class may access the private members of the parent class.

Answer 24

false

Question 25

true/false, the first statement of every constructor is a call to another constructor within the class using this() or a call to a constructor in the direct parent using this().

Answer 25

false. The first statement of every constructor is a call to another constructor within the class using this() or a call to a constructor in the direct parent using super().

Question 26

true/false, you can call the parent constructor as well as another constructor in your same class from within one constructor, eg:
public Animal(int age) {
	super("Stephen");
	this("Stephen");
}

Answer 26

false. You can only call one or the other, not both.

Question 27

true/false, the compiler automatically inserts a call to the no-argument constructor super() if the first statement is not a call to the parent constructor.

Answer 27

true

Question 28

true/false, the super() call may be used after the first statement of the constructor

Answer 28

false. The super() call may not be used after the first statement of the constructor.

Question 29

true/false, if the parent doesn’t have a no-argument constructor, the compiler requires an explicit call to a parent constructor in each child constructor.

Answer 29

true

Question 30

true/false, you can call multiple other constructors from within one constructor:
public Animal(int age) {
	this("Stephen");
	this(48);
}

Answer 30

false. You can only make one other constructor call.

Question 31

true/false, if the parent doesn’t have a no-argument constructor and the child doesn’t define any constructors, the compiler will throw an error and try to insert a default no-argument constructor in the child class.

Answer 31

true

Question 32

true/false, the following code compiles:
public class Animal {
	public Animal(String s) {
	}
}
public class Elephant extends Animal {
}

Answer 32

false. Since the Elephant class does not define a constructor, the compiler will try to insert a default no-argument one for it that includes a ‘super()’ call.

Question 33

true/false, the following code compiles:
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: " + super.getAge());
		System.out.print(" and " + super.size + " meters long");
		System.out.print(" with " + this.numberOfFins + " fins");
}}

Answer 33

true

Question 34

true/false, the following code compiles:

pulic Rabbit(int age) {
super();
super.setAge(10);
}

Answer 34

true

Question 35

true/false, you can use the “super()” command from within a normal method to call a constructor.

Answer 35

false. You can only use “super()” from within a constructor.

Question 36

What is the output of the following code?
public class Canine {
	public double getAverageWeight() {
		return 50;
	}
}}
public class Wolf extends Canine {
	public double getAverageWeight() {
		return getAverageWeight() + 20;
	}
	public static void main(String[] args) {
		System.out.println(new Canine.getAverageWeight());
		System.out.println(new Wolf().getAverageWeight());
}}

Answer 36

Infinite loop on this line:
return getAverageWeight() + 20;
This happens because we did not use the "super" keyword to explicitly call the getAverageWeight() method in the parent class.

Question 37

true/false, when overriding a method, the method in the child class must be more accessible than the method in the parent class.

Answer 37

false. It must be at least as accessible or more accessible.

Question 38

When inheriting a class, what must the parent class members’ access modifiers be set to for us to see them?

Answer 38

public or protected

Question 39

true/false, the following code compiles:
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");
}}

Answer 39

true

Question 40

true/false, the following code compiles:
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: " + super.getAge());
		System.out.print(" and " + super.size + " meters long");
		System.out.print(" with " + super.numberOfFins + " fins");
}}

Answer 40

false. The following line fails to compile:
System.out.print(“ with “ + super.numberOfFins + “ fins”);
The this and super keywords may both be used for methods or variables defined in the parent class, but only this may be used for members defined in the current class.

Question 41

What is the difference between “super” and “super()”?

Answer 41

"super" is used to reference a member in the parent class, and it can be used in methods outside the constructor.
"super()" is used to reference a constructor in the parent class and can only be called from within the child class constructor. It must be the first uncommented line in the constructor.

Question 42

true/false, when overriding a method, the method in the child class can have a different signature as the method in the parent class.

Answer 42

false. It must have the same signature.

Question 43

true/false, when overriding a method, if the method returns a value, it must be the same type of the method in the parent class.

Answer 43

false. It can be the same type or a subclass of the method in the parent class.

Question 44

What is the output of the following code?
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 44

50. 0

70. 0

Question 45

true/false, the following code compiles:
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: " + this.getAge());
		System.out.print(" and " + this.size + " meters long");
		System.out.print(" with " + this.numberOfFins + " fins");
}}

Answer 45

true

Question 46

true/false, when overriding a method, the method in the child class may not throw a checked exception thta is new or broader than the class of any exception thrown in the parent class method.

Answer 46

true

Question 47

true/false, the following code compiles:

pulic Rabbit(int age) {
super.setAge(10);
super();
}

Answer 47

false. When using “super()” to call a parent constructor, it must be the first uncommented line in the constructor.

Question 48

true/false, the following code compiles:
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;
	}
	pubic int eat(int food) {
		System.out.println("Bird is eating " + food + " units of food");
		return food;
	}
}

Answer 48

false. The “eat()” method is not successfully overridden here since the return types, void and int, are not covariant.

Question 49

true/false, the following code compiles:
public class InsufficientDataException extends Exception {}
public class Reptile {
	protected boolean hasLegs() throws InsufficientDataException {
		throw new InsufficientDataException();
	}
	protected double getWeight() throws Exception {
		return 2;
}}
public class Snake extends Reptile {
	protected boolean hasLegs() {
		return false;
	}
	protected double getWeight() throws InsufficientDataException {
		return 2;
}}

Answer 49

true

Question 50

true/false, the following code compiles:
public class InsufficientDataException extends Exception {}
public class Reptile {
	protected boolean hasLegs() {
		throw new InsufficientDataException();
	}
	protected double getWeight() {
		return 2;
}}
public class Snake extends Reptile {
	protected boolean hasLegs() {
		return false;
	}
	protected double getWeight() throws InsufficientDataException {
		return 2;
}}

Answer 50

false. The getWeight() in the child class throws an exception that the parent does not.

Question 51

true/false, the following code compiles:
public class Camel {
	public int getNumberOfHumps() {
		return 0;
	}
}
public class BactrianCamel extends Camel {
	protected int getNumberOfHumps() {
		return 2;
	}
}

Answer 51

false. The getNumberOfHumps() method in the child class must be at least as accessible as the parent method.

Question 52

true/false, the following code compiles:
public class Bird {
	public void fly() {
		System.out.println("Bird is flying");
	}
}
public class Eagle extends Bird {
	public int fly(int height) {
		System.out.println("Bird is flying at " + height + " meters");
		return height;
	}
}

Answer 52

true. The method fly is successfully overloaded.

Question 53

true/false, the following code compiles:
public class Camel {
	protected int getNumberOfHumps() {
		return 0;
	}
}
public class BactrianCamel extends Camel {
	protected int getNumberOfHumps() {
		return 2;
	}
}

Answer 53

true. The getNumberOfHumps() method in the child successfully overrides the same method in the parent.

Question 54

true/false, the following code compiles:
public class Bird {
	public void eat(int food) {
		System.out.println("Bird is eating " + food + " units of food.");
	}
}
public class Eagle extends Bird {
	pubic int eat(int food) {
		System.out.println("Bird is eating " + food + " units of food");
		return food;
	}
}

Answer 54

false. The “eat()” method is not successfully overridden here since the return types, void and int, are not covariant.

Question 55

true/false, a child method may hide or eliminate a parent method’s exception without issue.

Answer 55

true

Question 56

true/false, the following code compiles:
public class Camel {
	protected String getNumberOfHumps() {
		return "Undefined";
	}
}
public class BactrianCamel extends Camel {
	private int getNumberOfHumps() {
		return 2;
	}
}

Answer 56

false. The getNumberOfHumps() method in the child class is not as accessible to the same method in the parent class. Also, the return types are not covariant.

Question 57

true/false, the following code compiles:
public class InsufficientDataException extends Exception {}
public class Reptile {
	protected boolean hasLegs() throws InsufficientDataException {
		throw new InsufficientDataException();
	}
	protected double getWeight() throws InsufficientDataException {
		return 2;
}}
public class Snake extends Reptile {
	protected boolean hasLegs() {
		return false;
	}
	protected double getWeight() throws Exception {
		return 2;
}}

Answer 57

false. The scope of the exception thrown in Snake.getWeight() is narrower than in Reptile.getWeight().

Question 58

What is the output of the following code:
public class Bear {
	public static void eat() {
		System.out.println("Bear is eating");
	}
}
public class Panda extends Bear {
	public void eat() {
		System.out.println("Panda bear is chewing");
	}
	public static void main(String[] args) {
		Panda.eat();
	}
}

Answer 58

Compiler error on this line:
public void eat() {
The compiler thinks you’ve trying to override a method that should be hidden.

Question 59

What is it called when methods replace parent methods in the calls defined in the child class?

Answer 59

Method hiding.

Question 60

true/false, for method hiding, the method in the child class must have the same signature as the method in the parent class.

Answer 60

true

Question 61

true/false, in Java, in a child class, it is possible to override a private method in the parent class.

Answer 61

false. However, the child class can define its own version of the method with the same or modified signature.

Question 62

true/false, for method hiding, the child class may not throw a checked exception that is new or broader than the class of any exception thrown in the parent class method.

Answer 62

true

Question 63

What is the output of the following code:
public class Bear {
	public void eat() {
		System.out.println("Bear is eating");
	}
}
public class Panda extends Bear {
	public static void eat() {
		System.out.println("Panda bear is chewing");
	}
	public static void main(String[] args) {
		Panda.eat();
	}
}

Answer 63

Compiler error on this line:
public static void eat() {
The compiler thinks you’re trying to hide a method that should be overridden.

Question 64

A child method replacing the parent method in calls defined in both the parent and child is called what?

Answer 64

Method overriding.

Question 65

true/false, for method hiding, the method in the child class must have the same visibility than the method in the parent class.

Answer 65

false. It must be at least as or more accessible than the method in the parent class.

Question 66

true/false, for method hiding, the method defined in the child class must be marked as static if it is marked as static in the parent class.

Answer 66

true.

Question 67

true/false, the following code compiles:
public class Camel {
	private String getNumberOfHumps() {
		return "Undefined";
	}
}
public class BactrianCamel extends Camel {
	private int getNumberOfHumps() {
		return 2;
	}
}

Answer 67

true. This code compiles without issue. If the method in the parent class were public or protected, the code would not compile.

Question 68

true/false, for method hiding, if the method returns a value, it must be different than that from the method in the parent class.

Answer 68

false. It must be the same or a subclass of that of the parent class, aka covariant.

Question 69

What is the output of the following code:
public class Bear {
	public static void eat() {
		System.out.println("Bear is eating");
	}
}
public class Panda extends Bear {
	public static void eat() {
		System.out.println("Panda bear is chewing");
	}
	public static void main(String[] args) {
		Panda.eat();
	}
}

Answer 69

Panda bear is chewing

Question 70

When a child class defines a static method with the same name and signature as a static method defined in a parent class, what is it called?

Answer 70

A hidden method

Question 71

When in a child class, you can access the parent version of a hidden variable using what keyword?

Answer 71

super

Question 72

Does the following code compile:
public class Bird {
	public final boolean hasFeathers() {
		return true;
	}
}
public class Penguin extends Bird {
	public boolean hasFeathers() {
		return false;
	}
}

Answer 72

no. It doesn’t matter if the method in the child class is marked “final” or not. If the method in the parent is marked that way, it cannot be overridden.

Question 73

When a parent method is overridden by a child method, the parent method is never used unless explicitly called using what syntax?

Answer 73

super.method()

Question 74

What is the output of the following code?
class Marsupial {
	public boolean isBiped() {
		return false;
	}
	public void getMarsupialDescription() {
		System.out.println("Marsupial walks on two legs: " + isBiped());
	}
}
public class Kangaroo extends Marsupial {
	public boolean isBiped() {
		return true;
	}
	public void getKangarooDescription() {
		System.out.println("Kangaroo hops on two legs: " + isBiped());
	}
	public static void main(String[] args) {
		Kangaroo joey = new Kangaroo();
		joey.getMarsupialDescription();
		joey.getKangarooDescription();
	}
}

Answer 74

Marsupial walks on two legs: true

Kangaroo walks on two legs: true

Question 75

true/false, you can hide a method in a parent class if it’s marked “final”.

Answer 75

false. You cannot hide a method in a parent class from the child class if it’s marked “final”.

Question 76

true/false, java allows variables to be overridden.

Answer 76

false. They can be hidden but not overridden.

Question 77

Does the following code compile:
public class Bird {
	public boolean hasFeathers() {
		return true;
	}
}
public class Penguin extends Bird {
	public final boolean hasFeathers() {
		return false;
	}
}

Answer 77

yes. It’s ok if the overriding method is marked “final” so long as the method being overridden is not marked “final”.

Question 78

When working with overridden variables, if you’re referencing the variable from within the parent class, the variable in which class is used (parent or child)?

Answer 78

parent.

Question 79

Does the following code compile:
public class Bird {
	public boolean hasFeathers() {
		return true;
	}
}
public class Penguin extends Bird {
	public boolean hasFeathers() {
		return false;
	}
}

Answer 79

yes

Question 80

true/false, at runtime the child version of an overridden method is always executed for an instance regardless of whether the method call is defined in a parent or child class method.

Answer 80

true

Question 81

true/false, final methods can be overridden.

Answer 81

false. Final methods cannot be overridden.

Question 82

When working with overridden variables, if you’re referencing the variable from within the child class, the variable in which class is used (parent or child)?

Answer 82

child

Question 83

What is the output of the following code?
public class Marsupial {
	public static boolean isBiped() {
		return false;
	}
	public void getMarsupialDescription() {
		System.out.println("Marsupial walks on two legs: " + isBiped());
}}
public class Kangaroo extends Marsupial {
	public static boolean isBiped() {
		return true;
	}
	public void getKangarooDescription() {
		System.out.println("Kangaroo hops on two legs: " + isBiped());
	}
	public static void main(String[] args) {
		Kangaroo joey = new Kangaroo();
		joey.getMarsupialDescription();
		joey.getKangarooDescription();
}}

Answer 83

Marsupial walks on two legs: false

Kangaroo walks on two legs: true

Question 84

true/false, when creating a method with the “final” keyword, you cannot override this method from a child class.

Answer 84

true.

Question 85

How do you hide a variable?

Answer 85

In your child class, you define a variable with the same name as a variable in the parent class.

Question 86

true/false, at runtime the parent version of a hidden method is always executed if the call to the method is defined in the child class.

Answer 86

false. The parent version of a hidden method is always executed if the call to the method is defined in the parent class.

Question 87

Does the following code compile:
public class Bird {
	public final boolean hasFeathers() {
		return true;
	}
}
public class Penguin extends Bird {
	public final boolean hasFeathers() {
		return false;
	}
}

Answer 87

no. You cannot override a method that is marked “final”.

Question 88

What is the output of the following code?
public class Rodent {
	protected int tailLength = 4;
	public void getRodentDetails() {
		System.out.println("[parentTail=" + tailLength + "]");
}}
public class Mouse extends Rodent {
	protected int tailLength = 8;
	public void getMouseDetails() {
		System.out.println("[tail=" + tailLength + ",parentTail="+super.tailLength+"]");
	}
	public static void main(String[] args) {
		Mouse mouse = new Mouse();
		mouse.getRodentDetails();
		mouse.getMouseDetails();
}}

Answer 88

[parentTail=4]

[tail=8,parentTail=4]

Question 89

true/false, an abstract method contains no implementation.

Answer 89

true

Question 90

true/false, the following code compiles:
public abstract class Animal {
	protected int age;
	public void eat() {
		System.out.println("Animal is eating");
	}
	public abstract String getName();
}
public class Swan extends Animal {
	public String getName() {
		return "Swan";
	}
}

Answer 90

true

Question 91

What is the output of the following code?
public class Parent1 {
	public boolean isBiped() {
		return false;
	}
	public void getMarsupialDescription() {
		System.out.println("Parent.myMethod1 - " + isBiped());
}}
public class Child1 extends Parent1 {
	public boolean isBiped() {
		return true;
	}
	public void getKangarooDescription() {
		System.out.println("Child.myMethod1 - " + isBiped());
	}
	public static void main(String[] args) {
		Child1 c1 = new Child1();
		c1.getMarsupialDescription();
		c1.getKangarooDescription();

		Parent1 p1 = new Parent1();
		p1.getMarsupialDescription();
}}

Answer 91

Parent.myMethod1 - true
Child.myMethod1 - true
Parent.myMethod1 - false

• you only override an instance method or hide a static method when you’re inheriting the method from the parent.

Question 92

What is the output of the following code?
public class Rodent {
	protected static int tailLength = 4;
	public void getRodentDetails() {
		System.out.println("[parentTail=" + tailLength + "]");
}}
public class Mouse extends Rodent {
	protected static int tailLength = 8;
	public void getMouseDetails() {
		System.out.println("[tail=" + tailLength + ",parentTail="+super.tailLength+"]");
	}
	public static void main(String[] args) {
		Mouse mouse = new Mouse();
		mouse.getRodentDetails();
		mouse.getMouseDetails();
}}

Answer 92

[parentTail=4]

[tail=8,parentTail=4]

Question 93

true/false, an abstract class can be instantiated.

Answer 93

false.

Question 94

true/false, you cannot define an abstract method as private.

Answer 94

true

Question 95

true/false, a concrete class must implement all of the abstract methods inherited from the abstract class that it is extending.

Answer 95

true

Question 96

true/false, the following code compiles:
public abstract class Whale {
	private abstract void sing();
}

Answer 96

false. An abstract method may not be marked private.

Question 97

true/false, an abstract method can be defined in a class that is not abstract.

Answer 97

false. Abstract methods must be defined in an abstract class.

Question 98

true/false, the following code compiles:
public abstract class Animal {
	public abstract String getName();
}
public class Walrus extends Animal { }

Answer 98

false. A concrete class must implement all inherited abstract methods from the abstract class that it is extending.

Question 99

true/false, an abstract class may extend another abstract class.

Answer 99

true

Question 100

true/false, abstract methods must not provide a method body/implementation in the abstract class in which it is declared.

Answer 100

true

Question 101

true/false, abstract classes may not be marked private, protected, or final.

Answer 101

true

Question 102

true/false, implementing an abstract method in a subclass follows the same rules for overriding a method. The name and signature must be the same, and the visibility of the method in the subclass must be at least as accessible as the method in the parent class.

Answer 102

true

Question 103

true/false, the following code compiles:
public class Chicken {
	public abstract void peck();
}

Answer 103

false. You cannot have an abstract method in a class that is not abstract.

Question 104

true/false, an abstract class is required to have at least one abstract method.

Answer 104

false. An abstract class doesn’t need to have any abstract methods.

Question 105

Why does the following code not compile?
public abstract class Turtle {
	public abstract void swim() {}
	pubic abstract int getAge() {
		return 10;
	}
}

Answer 105

The two methods do not compile because abstract methods are not allowed to have a body, even if it’s just open and close curly braces.

Question 106

Why is it that you cannot mark an abstract method or class as final?

Answer 106

Abstract classes and methods are meant to be extended or overwritten, and marking them as final takes away the ability to do that.

Question 107

true/false, an abstract class may include nonabstract methods and variables.

Answer 107

true

Question 108

true/false, the following code compiles:
public abstract class Goat {
	public abstract final void chew();
}

Answer 108

false. abstract methods are not allowed to be marked final.

Question 109

true/false, the following code compiles:
public abstract class Animal {
	public abstract String getName();
}
public abstract class BigCat extends Animal {
	public abstract void roar();
}
public class Lion extends BigCat {
	public String getName() {
		return "Lion";
}}

Answer 109

false. The class Lion must implement all abstract methods that it inherits, and it is missing the method roar().

Question 110

The first nonabstract subclass that extends an abstract class is known as what?

Answer 110

A concrete class.

Question 111

true/false, the first concrete class that extends an abstract class must provide an implementation for at least one of the inherited abstract methods.

Answer 111

false. it must provide an implementation for all of the inherited abstract methods.

Question 112

true/false, you can instantiate an an abstract class.

Answer 112

false

Question 113

true/false, the following code compiles:
public abstract class Animal {
	public abstract String getName();
}
public abstract class BigCat extends Animal {
	public abstract void roar();
}
public class Lion extends BigCat {
	public String getName() {
		return "Lion";
	}
	public void roar() 
		System.out.println("Roar!");
}}

Answer 113

true

Question 114

true/false, the following code compiles:
public final abstract class Tortoise {}

Answer 114

false

Question 115

true/false, you can define an abstract method in a non abstract class.

Answer 115

false. Abstract methods may only be defined in abstract classes.

Question 116

true/false, the following code compiles:
public abstract class Cow {}

Answer 116

true

Question 117

true/false, in an abstract class, you can define a method with a body, so long as it’s not marked abstract and not marked final.

Answer 117

true

Question 118

true/false, the following code compiles:
public abstract class Whale {
	protected abstract void sing();
}
public class HumpbackWhale extends Whale {
	protected void sing() {
		System.out.println("Humpback Whale is singing!");
	}
}

Answer 118

true

Question 119

true/false, an abstract class that extends another abstract class inherits all of its abstract methods as its own abstract methods.

Answer 119

true

Question 120

true/false, the following code compiles:
public abstract class Animal {
	public abstract String getName();
}
public abstract class BigCat extends Animal {
	public String getName() {
		return "Lion";
	}
	public abstract void roar();
}
public class Lion extends BigCat {
	public void roar() 
		System.out.println("Roar!");
}}

Answer 120

true.

Question 121

true/false, abstract methods may not be declared private or final.

Answer 121

true

Question 122

true/false, the following code compiles:
public abstract class Eel {
	public static void main(String[] args) {
		final Eel eel = new Eel();
	}
}

Answer 122

false. The following line fails to compile:
final Eel eel = new Eel();
You cannot have a private member in an abstract class.

Question 123

true/false, the following code compiles:
public abstract class Chicken {
	public abstract void peck();
}

Answer 123

true

Question 124

true/false, the following code compiles:
pubic abstract class Animal {
	public abstract String getName();
}
public class Bird extends Animal {
}
public class Flamingo extends Bird {
	public String getName() {
		return "Flamingo";
	}
}

Answer 124

false. The class Bird must implement all of the abstract methods defined in the Animal class.

Question 125

true/false, abstract classes may be defined with any number, including zero, of abstract and nonabstract methods.

Answer 125

true

Question 126

true/false, the following code compiles:
public abstract class Animal {
	public abstract String getName();
}
pubic class Walrus extends Animal {
}
public abstract class Eagle extends Animal {
}

Answer 126

false. The code fails to compile because the Walrus class does not implement all of the abstract methods that it inherits from the Animal class. The Eagle class does not need to implement the methods in Animal, even though it extends it, because it too is an abstract class.

Question 127

true/false, the following code compiles:
public abstract class Whale {
	protected abstract void sing();
}
public class HumpbackWhale extends Whale {
	private void sing() {
		System.out.println("Humpback Whale is singing!");
	}
}

Answer 127

false. When overriding a method in the parent, you cannot reduce visibility.

Question 128

true/false, an interface may not be marked final.

Answer 128

true.

Question 129

true/false, the following code compiles:
public interface WalksOnTwoLegs {}
public class TestClass {
	public static void main(String[] args) {
		WalksOnTwoLegs example = new WalksOnTwoLegs();
	}
}

Answer 129

false. You can not directly instantiate an interface.

Question 130

true/false, the following interfaces are equivalent:

public interface CanFly {
	void fly(int speed);
}
public abstract interface CanFly {
	public abstract void fly(int speed);
}

Answer 130

true. The compiler would automatically convert the first interface into the second.

Question 131

true/false, the following code compiles:
public abstract interface Int1 {
	public static final int MIN = 2;
	public abstract int getMaxDepth();
}

Answer 131

true. All interface variables are assumed to be static, and all interface methods are assumed to be abstract.

Question 132

true/false, the following code compiles:
public interface HasTail {
	public int getTailLength();
}
public interface HasWhiskers() {
	public int getNumberOfWhiskers();
}
public interface Seal extends HasTail, HasWhiskers { }

public class LeopardSeal implements HasTail, HasWhiskers { }

Answer 132

false. As a concrete class implementation, the class LeopardSeal should implement the getTailLength and getNumberOfWhiskers methods.

Question 133

What is an abstract data type that defines a list of abstract public methods that any class implementing it must provide?

Answer 133

An interface

Question 134

true/false, an interface is required to have at least one method.

Answer 134

false. An interface need not have any methods.

Question 135

What specifiers get automatically inserted into an interface definition if not provided by the developer?

Answer 135

public and abstract

Question 136

true/false, the following code compiles:

public final interface WalksOnTwoLegs {}

Answer 136

false. An interface may not be marked final.

Question 137

true/false, a class may not inherit multiple interfaces.

Answer 137

false. They can implement may interfaces.

Question 138

true/false, an interface that extends another interface, as well as an abstract class that implements an interface, inherits all of the abstract methods as its own abstract methods.

Answer 138

true

Question 139

true/false, all top-level interfaces are assumed to have public or default access.

Answer 139

true.

Question 140

true/false, the following code compiles:

public interface WalksOnTwoLegs {}

Answer 140

true

Question 141

true/false, the following code compiles:

public interface HasTail {
	public int getTailLength();
}
public interface HasWhiskers() {
	public int getNumberOfWhiskers();
}
public interface Seal extends HasTail, HasWhiskers { }

Answer 141

true

Question 142

Which of the following lines of code compile:

private final interface CanCrawl {
	private void dig(int depth);
	protected abstract double depth();
	public final void surface();
}

Answer 142

None of them:
private final interface CanCrawl { // interfaces cannot be marked final
private void dig(int depth); // all interface methods are assumed to be public.
protected abstract double depth(); // all interface methods are assumed to be public.
public final void surface(); // interface methods may not be marked final.
}

Question 143

true/false, interfaces can be instantiated directly.

Answer 143

false.

Question 144

true/false, the first concrete class that implements an interface, or extends an abstract class that implements an interface, must provide an implementation for all of the inherited abstract methods.

Answer 144

true.

Question 145

true/false, the following code compiles:
public interface Herbivore {
	public String eatPlants();
}
public interface Omnivore {
	public void eatPlants();
	public void eatMeat();
}
public class Bear implements Herbivore, Omnivore {
	public void eatMeat() {
		System.out.println("Eating meat");
	}
	public void eatPlants() {
		System.out.println("Eating plants");
	}
}

Answer 145

false. if the method name and input parameters are the same but the return types are different between the method defined in each of the interfaces, the class or interface attempting to inherit both will not compile.

Question 146

true/false, the following code compiles:
public class Hyena {}

public interface HasFur extends Hyena {}

Answer 146

false. An interface cannot extend or implement a class.

Question 147

true/false, an interface can extend another interface.

Answer 147

true

Question 148

true/false, the following code compiles:
public interface myInterface {
public int MYINTEGER = 0;
}

Answer 148

true

Question 149

true/false, the following code compiles:
public interface Herbivore {
	public int eatPlants();
}
public interface Omnivore {
	public void eatPlants();
}
public abstract class AbstractBear implements Herbivore, Omnivore {}

Answer 149

false. An interface or class that tries to implement two different interfaces, each containing a method with the same signature but different return type, will not compile.

Question 150

true/false, the value of an interface variable must be set when it is declared since it is marked as final.

Answer 150

true

Question 151

true/false, the following code compiles:

public interface CanRun {}

public class Chetah implements CanRun {}

Answer 151

true

Question 152

true/false, the following code compiles:
public interface Herbivore {
	public void eatPlants(int numPlants);
}
public interface Omnivore {
	public void eatPlants();
	public void eatMeat();
}
public class Bear implements Herbivore, Omnivore {
	public void eatMeat() {
		System.out.println("Eating meat");
	}
	public void eatPlants() {
		System.out.println("Eating plants");
	}
}

Answer 152

false. In this case, the eatPlants methods in each interface have different method signatures, meaning that each of them must be explicitly implemented. To make this code compile, you would change the Bear class to look like this:
public class Bear implements Herbivore, Omnivore {
	public void eatMeat() {
		System.out.println("Eating meat");
	}
	public void eatPlants() {
		System.out.println("Eating plants");
	}
	public void eatPlants(int numPlants) {
		System.out.println("Eating " + numPlants + " plants");
	}
}

Question 153

true/false, the following code compiles:

public interface myInterface {
private int MYINTEGER = 0;
}

Answer 153

false. interface varaibles are assumed to be public.

Question 154

true/false, interface variables are assumed to be public.

Answer 154

true

Question 155

true/false, the following code compiles:
public interface myInterface {
public int MYINTEGER;
}

Answer 155

false. Interface variables are assumed to be static and must be assigned a value when declared since it is marked as final.

Question 156

true/false, the following code compiles:

public interface CanRun {}
public class Chetah extends CanRun {}

Answer 156

false. A class cannot extend an interface.

Question 157

true/false, a class can extend an interface.

Answer 157

false. A class implements an interface, not extends it.

Question 158

true/false, the following code compiles:
public interface Herbivore {
	public int eatPlants();
}
public interface Omnivore {
	public void eatPlants();
}
public interface Supervore extends Herbivore, Omnivore {}

Answer 158

false. An interface or class that tries to implement two different interfaces, each containing a method with the same signature but different return type, will not compile.

Question 159

true/false, the following code compiles:

public interface myInterface {
protected int MYINTEGER = 0;
}

Answer 159

false. interface varaibles are assumed to be public.

Question 160

true/false, the following code compiles:
public interface Herbivore {
	public void eatPlants();
}
public interface Omnivore {
	public void eatPlants();
	public void eatMeat();
}
public class Bear implements Herbivore, Omnivore {
	public void eatMeat() {
		System.out.println("Eating meat");
	}
	public void eatPlants() {
		System.out.println("Eating plants");
	}
}

Answer 160

true. Because the eatPlants() method is in both interfaces with the same signature, it is ok to implement it just once in the Bear class. The method actually is implemented twice.

Question 161

true/false, an interface can implement another interface.

Answer 161

false.

Question 162

true/false, interface methods are assumed to be static and final.

Answer 162

false. An interface method cannot be marked final.

Question 163

true/false, interface variables are assumed to be static and final.

Answer 163

true.

Question 164

true/false, the following code compiles:
public interface Carnivore {
	public int getRequiredFoodAmount() {
		return 13;
	}
}

Answer 164

false. In an interface, for a method to have a body, it must be a default method.

Question 165

true/false, in an interface, if a method is marked with the “default” keyword, it does not need to provide a body.

Answer 165

false. All default methods must provide a method body.

Question 166

true/false, the following code compiles:
public interface HasFins {
	public default boolean doFinsHaveScales() {
		return true;
	}
}
public interface SharkFamily extends HasFins {
	public boolean doFinsHaveScales() {
		return false;
	}
}

Answer 166

false. The doFinsHaveScales method in the SharkFamily interface either needs to include the keyword “default” or remove the method body.

Question 167

true/false, a static method defined in an interface is not inherited in any classes that implement the interface.

Answer 167

true.

Question 168

true/false, the following code compiles:
public interface Hop {
	public static int getJumpHeight() {
		return 8;
	}
}

Answer 168

true

Question 169

true/false, a class that implements two interfaces containing static methods with the same signature will compile.

Answer 169

true. This is true because static methods in interfaces are not inherited by the subclass and must be accessed with a reference to the interface name.

Question 170

true/false, a default method cannot be marked as static, final, or abstract.

Answer 170

true.

Question 171

true/false, if a class implements two interfaces that have default methods with the same name and signature, the compiler will error out. However, if the implementing class overrides the duplicate methods, the code will compile.

Answer 171

true.

Question 172

true/false, the following code compiles:
public interface IsWarmBlooded {
	boolean hasScales();
	public default double getTemperature() {
		return 10.0;
	}
}

Answer 172

true.

Question 173

true/false, a default method will not compile if it marked as private or protected.

Answer 173

true.

Question 174

true/false, a default method within an interface defines an abstract method with a default implementation.

Answer 174

true.

Question 175

true/false, the following code compiles:
public interface HasFins {
	public default int getNumberOfFins() {
		return 4;
	}
}
public interface SharkFamily extends HasFins {
	public default int getNumberOfFins() {
		return 8;
	}
}

Answer 175

true

Question 176

true/false, the following code compiles:
public interface Carnivore {
public default void eatMeat();
}

Answer 176

false. A default method must have a method body.

Question 177

true/false, if a class implements two interfaces that have default methods with the same name and signature, the compiler will error out.

Answer 177

true.

Question 178

true/false, the following code compiles:
public interface Walk {
	public default int getSpeed() {
		return 5;
	}
}
public interface Run {
	public default int getSpeed() {
		return 10;
	}
}
public class Cat implements Walk, Run {
	public int getSpeed() {
		return 1;
	}
	public static void main(String[] args) {
		System.out.println(new Cat().getSpeed());
	}
}

Answer 178

true. It compiles because we’ve overridden the duplicate default method getSpeed() in the Cat class.

Question 179

true/false, the following code compiles:
public interface Hop {
	static int getJumpHeight() {
		return 8;
	}
}

Answer 179

true

Question 180

true/false, the following code compiles:
public interface Hop {
	public static int getJumpHeight() {
		return 8;
	}
}
public class Bunny implements Hop {
	public void printDetails() {
		System.out.println(Hop.getJumpHeight());
	}
}

Answer 180

true.

Question 181

true/false, a default method may be defined in regular class or an interface.

Answer 181

false. A default method may only be defined within an interface.

Question 182

true/false, the following code compiles:
public interface HasFins {
	public default double getLongestFinLength() {
		return 20.0;
	}
}
public interface SharkFamily extends HasFins {
	public double getLongestFinLength();
}

Answer 182

true

Question 183

true/false, a default method is a method defined within an interface with the default keyword in which a method body is provided.

Answer 183

true.

Question 184

true/false, a default method is not assumed to be static, final, or abstract.

Answer 184

true. The default method may be overridden by the implementing class.

Question 185

true/false, the following code compiles:
public interface Hop {
	protected static int getJumpHeight() {
		return 8;
	}
}

Answer 185

false, a static method in an interface cannot be marked private or protected.

Question 186

true/false, default methods in an interface are assumed to have protected access.

Answer 186

false, they are assumed to be public.

Question 187

true/false, a static method in an interface is assumed to be public and will not compile if marked as private or protected.

Answer 187

true.

Question 188

true/false, the following code compiles:
public interface Walk {
	public default int getSpeed() {
		return 5;
	}
}
public interface Run {
	public default int getSpeed() {
		return 10;
	}
}
public class Cat implements Walk, Run {
	public static void main(String[] args) {
		System.out.println(new Cat().getSpeed());
	}
}

Answer 188

false. The code fails to compile on this line:
public class Cat implements Walk, Run {
You cannot implement two identical default methods from different interface files, unless you also override those methods.

Question 189

true/false, the following code compiles:
public interface Hop {
	public static int getJumpHeight() {
		return 8;
	}
}
public class Bunny implements Hop {
	public void printDetails() {
		System.out.println(getJumpHeight());
	}
}

Answer 189

false. The code fails to compile on this line:
System.out.println(getJumpHeight());
You must have an explicit reference to the name of the interface.

Question 190

true/false, to reference a static method in an interface, a reference to the name of the interface must be used.

Answer 190

true.

Question 191

What is the output of the following code?
public class Primate {
	public boolean hasHair() {
		return true;
	}
}
public interface HasTail {
	public boolean isTailStriped() {
		public boolean isTailStriped;
	}
}
public class Lemur extends Primate implements HasTail {
	public boolean isTailStriped() {
		return false;
	}
	public int age = 10;
	public static void main(String[] args) {
		Lemur lemur = new Lemur();
		System.out.println(lemur.age);
		HasTail hasTail = lemur;
		System.out.println(hasTail.age);
		Primate primate = lemur;
		System.out.println(primate.isTailStriped());
	}
}

Answer 191

Compiler error on this line:
System.out.println(hasTail.age);
And compiler error on this line:
System.out.println(primate.isTailStriped());

Question 192

What is the output of the following code?
public class Reptile {
	public String getName() { return "Reptile"; }
}
public class Alligator extends Reptile {
	public String getName() { return "Alligator"; }
}
public class Crocodile extends Reptile {
	public String getName() { return "Crocodile"; }
}
public class ZooWorker {
	public static void feed(Reptile reptile) {
		System.out.println("Feeding: " + reptile.getName());
	}
	public static void main(String[] args) {
		feed(new Alligator());
		feed(new Crocodile());
		feed(new Reptile());
}}

Answer 192

Feeding: Alligator
Feeding: Crocodile
Feeding: Reptile

Question 193

What is the property of an object to take on many different forms?

Answer 193

Polymorphism

Question 194

true/false, when dealing with polymorphism, once an object has been assigned a new reference type, only the methods and variables available to that reference type are callable on the object without an explicit cast.

Answer 194

true.

Question 195

true/false, the following code compiles:

public class Rodent { }
public class Capybara extends Rodent {
	public static void main(String[] args) {
		Rodent rodent = new Rodent();
		Capybara capybara = (Capybara) rodent;
	}
}

Answer 195

true, the code compiles, but a ClassCastException is thrown at runtime from this line:
Capybara capybara = (Capybara) rodent;

Question 196

What is the output of the following code?
public class Bird {
	public String getName() {
		return "Unknown";
	}
	public void displayInformation() {
		System.out.println("The bird name is: " + getName());
	}
}
public class Peacock extends Bird {
	public String getName() {
		return "Peacock";
	}
	public static void main(String[] args) {
		Bird bird = new Peacock();
		bird.displayInformation();
	}
}

Answer 196

The bird name is: Peacock

Question 197

A java object may be accessed which three ways?

Answer 197

1. Using a reference with the same type as the object.
2. Using a reference that is a super class of the object.
3. Using a reference that defines an interface the object implements, either directly or through a superclass.

Question 198

What is the output of the following code?
public class Primate {
	public boolean hasHair() {
		return true;
	}
}
public interface HasTail {
	public boolean isTailStriped() {
		public boolean isTailStriped;
	}
}
public class Lemur extends Primate implements HasTail {
	public boolean isTailStriped() {
		return false;
	}
	public int age = 10;
	public static void main(String[] args) {
		Lemur lemur = new Lemur();
		System.out.println(lemur.age);
		HasTail hasTail = lemur;
		System.out.println(hasTail.isTailStriped());
		Primate primate = lemur;
		System.out.println(primate.hasHair());
	}
}

Answer 198

10
false
true

Question 199

true/false, the following code compiles:
public class Bird {}
public class Fish {
	public static void main(String[] args) {
		Fish fish = new Fish();
		Bird bird = (Bird) fish;
	}
}

Answer 199

false. Compiler error on this line:
Bird bird = (Bird) fish;
The Fish and Bird classes are not related through any class hierarchy.

Question 200

What is known as a method in which the specific implementation is not determined until runtime?

Answer 200

A virtual method.