Chapter 2: Object Orientation

Question 1

What is encapsulation?

Answer 1

Hiding implementation details, and only expose instance variables through public methods.

• protect instance variables
• make public accessor methods (getters/setters)

Question 2

What is polymorphism?

Answer 2

You can treat any subclass as the superclass (or a interface). Every type in java is polymorphic because they can be treated as their own type as well as the Object type.

Question 3

Describe a IS-A relationship

Answer 3

In java expressed using the extends and implements keyword (inheritance).

Car IS-A vechicle
Horse IS-A animal

Question 4

Describe a HAS-A relationship

Answer 4

Whether a object has a reference to another object.

Car HAS-A engine

Question 5

What is wrong?

class PlayerPiece extends GameShape, Animatable {
}

Answer 5

A class can only extend a single class.

Question 6

What are the 5 important rules for overriding methods?

Answer 6

• Argument list must exactly match
• Return type must be the same, or a subtype.
• The access level can be less restrictive
• Can only override non-final protected or public methods (or default if in the same package).
• You can’t introduce new exceptions in the throw clause, you can throw fewer exceptions.

Question 7

Which overloaded method will be called?
class Foo {
   public void doStuff(Animal a) {} // 1
   public void doStuff(Horse a) {} // 2
}

Animal animal = new Horse();
new Foo().doStuff(animal);

Answer 7

doStuff(Animal a) will be called.

The reference type (not the object type) is used to determine which method is invoked.

Question 8

What is overloading?

Answer 8

Adding a new method with the same name as an already existing method but with an different argument list

Question 9

What is a downcast?

Answer 9

Casting a object down to a more specific type in the inheritance tree.

Dog d = (Dog) animal;

Question 10

What is a upcast?

Answer 10

Casting a object to a more generic type in the inheritance tree.

Animal a = (Animal) dog;
Animal a = dog; // implicit cast

Question 11

What is wrong?
interface Pet { void foo(); }
class Dog implements Pet { void foo() {} }
class Beagle extends Dog implements Pet {}

Answer 11

Nothing. A subclass definining a interface that is already implemented by a superclass is perfectly fine.

Question 12

True or False:
A class can extend multiple classes

Answer 12

False

Question 13

True or False:

A interface can extend multiple classes

Answer 13

False

Question 14

True or False:

A interface can extend multiple interfaces

Answer 14

True

Question 15

Finish the following senteces about return types:

1. A overloaded method return type ….
2. A overriden method return type ….

Answer 15

1. Can be completely different from the original return type.
2. Must be the same or a subclass of the original return type.

Question 16

What can be said about the compiler provided default constructor?

Answer 16

• Only inserted if no constructors are defined in the class.
• It is always a no-arg constructor
• Has the same visibility as the class
• If the super-class doesnt have a no-arg constructor the the default-constructor will not be supplied.

Question 17

Which static method is called?
class Animal {
public static void doStuff() {} // 1
}

class Dog extends Animal {
public static void doStuff() {} // 2
}

Animal a = new Dog();
a.doStuff();

Answer 17

1

For static method invocation the reference variable type is used. And not the actual object type.

Question 18

What is losely coupled and tightly coupled?

Answer 18

Losely: If the only knowledge A has about B, is what B has exposed through its interface.
Tightly: If A relies on parts of B that are not exposed through its interfase

Question 19

What is High Cohesion?

Answer 19

Cohesion is used to indicate the degree of which a class has a single, well-focused purpose. The more focused a class is, the higher the cohesion.

Question 20

What will be printed?
class Sub
{
    Sub(){ startUp("StartUp"); }
    void startUp(String s){ System.out.println("InSub"); }
}

class SubSub extends Sub
{
    SubSub(){  }
    void startUp(String s){  System.out.println("InSubSub");   }
}

public class TestClass
{
    public static void main(String args[]){ new SubSub(); }
}

Answer 20

InSubSub

Question 21

Consider these two interfaces:

interface I1
{
   void m1() throws java.io.IOException;
}
interface I2
{
   void m1() throws java.sql.SQLException;
}

What methods have to be implemented by a class that says it implements I1 and I2 ?

Answer 21

void m1() {}
void m1() throws java.sql.SQLException {}
void m1() throws java.io.IOException {}

Are all valid, a implementation class may always choose to take less risk (throw less exceptions).

Question 22

What will be the output?
class A { int i = 10;  int m1( ) { return i; } }
class B extends A { int i = 20;  int m1() { return i; } }
class C extends B { int i = 30;  int m1() { return i; } }

System.out.println(o1.m1( ) );
System.out.println(o2.i );

Answer 22

30, 20

Variables are SHADOWED and methods are OVERRIDDEN.
Which variable will be used depends on the class that the variable is declared of.
Which method will be used depends on the actual class of the object that is referenced by the variable.