LECTURE NOTES
29 NOVEMBER 2004

ASSIGNMENTS
Wed 12/1 Assignment 5 Design
Fri 12/3 CodeLab #12
Wed 12/15 Assignment 5 Code

INHERITANCE AND CONSTRUCTORS

What?
- inheriting constructors
How?
- never occurs

What?
- defining a constructor for a subclass
How?
- define manually
- compiler will define default iff you don't define any

What?
- meaning of constructor in an inheritance hierarchy
  - subclass is a specialization of the superclass
  - means logically must create the inherited part and the specialized part
Why?
- every subclass includes a call to the constructor of its superclass
How?
- use the super() method

What?
- default constructor
  public <class>() {
      super();
  }

When?
- you define a subclass constructor without a call to super
What?
- compiler automatically adds call to super as the first line of your constructor

When?
- no explicit inheritance
What?
- default superclass is Object

What?
- choosing a specific superclass constructor
How?
- pass arguments, ensuring that a constructor with those types exists

When?
- define a class with at least one explicit constructor
- all explicit constructors take arguments
- subclasses don't explicitly call super
What?
- implicit call to super does not pass arguments
- no such super constructor exists
- causes a compiler error

What?
- avoiding constructor errors
How?
- never rely on default constructors

ABSTRACT SUPERCLASSES AND ABSTRACT METHODS

Why?
- sometimes doesn't make sense for the class to be instantiable
  - logical
  - semantic
What?
- abstract class
How?
1. declare the class with the abstract modifier
   
   abstract class <class> {...}

2. ensure the class includes at least one abstract method

What?
- *abstract method*
How?
1. declare the method with the keyword abstract
   <visibility> abstract <return type> <method>(<args)
2. omit the method definition
   <visibility> abstract <return type> <method>(<args);
Why?
- force instantiable subclasses to implement a method,
  without implementing it in the (abstract) superclass
  - makes the abstract class definition incomplete,
    because it is missing the implementation of at least
    one method

What?
- methods that cannot be declared abstract
Which?
- private methods
- static methods

What?
- ensure a class has an abstract method
How?
1. explicitly declare an abstract method
2. fail to implement some inherited abstract method

What?
- *implemented method*
  - opposite of an abstract method

What?
- *abstract superclass*
Why?
- because an abstract class is only useful if it is used 
  as a superclass

What?
- distinction btw noninstantiable and abstract
  - noninstantiable is a superset of abstract

What?
- noninstantiable class: class for which we cannot create an instance

What?
- making a noninstantiable class without making it abstract
How?
- explicitly create at least one constructor
- ensure all constructors are private

What?
- intent of abstract class: define interface common to all subclasses
  without having to implement it immediately

What?
- declaring a class abstract in a program diagram
How?
  +--------------------+
  | Student {abstract} |
  +--------------------+