Outline of Class 13: Inheritance and Exceptions

Miscellaneous

• We may have prospective students in class today. Treat them well.
• There's still room for one person for Sunday's dinner. Let me know if you're interested.
• assignment three is now ready.
• Read chapers two and three in Bailey for Monday.
• Sign up for the Math/CS picnic!
• Bailey provides an easier input mechanism than I describe. Read his documentation for information on how to use it.

Inheritance

• Java, like most object-oriented languages, lets you subclass existing classes to refine their functionality for particular instances.
• For example, we might have a general DrawableObject class and refine that to particular drawable objects, such as Circle or Square.
• How do you indicate that one class is a subclass of another? With the extends keyword.

  public class Circle extends DrawableObject {
    // ...
  }
  

• A subclass inherits all the methods and fields of its superclass (with some restrictions due to protection mechanisms).
• A subclass may also override any of these methods by including its own definition.
• Java allows you to use a member of a subclass anywhere a member of a superclass is permitted. For example, it is perfectly valid to write:

  DrawableObject obj = new Circle();
  

• Java is much more restrictive on using members of superclasses in place of members of subclasses.
• Why do you think Java has these restrictions?
• Java permits only single inheritance -- a particular class can only directly derive from one other class.
  • In the alternative, multiple inheritance -- a particular class can directly derive from more than one other class.
  • Single inheritance makes analysis and design much easier. Otherwise, there are potential problems with the same method name being defined in both parent classes.
  • Java provides interfaces to support many of the needs of multiple inheritance.
• Reminder: to "load" information about another class into your class file, use

  import OtherClass;

  before your class definition.

Problems in Programs

• It's a given that things go wrong in programs.
  • Sometimes, due to mistakes in input or logic, an invalid operation is executed. This may be division by 0, an out-of-bounds array reference, or a number of other things.
  • Sometimes, due to problems beyond the programmer's control, the system as a whole cannot respond and requested.
• What do we do about such problems?
  • Only write correct code.
  • Let the program crash in such cases.
  • Try to predict the cases, and prefix any statement that may have problems with a test and recovery.
  • Wait for the system to tell us about the problem, and react to that notification.

Exceptions

• Java supports a concept known as exceptions. Basically, Java admits that things can go wrong, and programmers may want to handle those things.
• Possible problems are called exceptions, presumably because they are exceptions to the rule.
• When something goes wrong, one throws an exception.
• To respond to an exception, one catches it.
• In Java, all exceptions are subclasses of java.lang.Throwable, and most are subclasses of java.lang.Exception.
• The basic structure of Java code for catching with exceptions is

  try {
    // stuff that may have problems
  }
  catch (ExceptionClass e1) {
    // Handle one type of exception
  }
  catch (AnotherExceptionClass e2) {
    // Handle another type of exception
  }
  finally {
    // Clean up code that is always executed.
  }
  

• If you write a method that throws an exception, you must include information about this as part of your method description, as in

  public int MyCoolMethod() throws AlphaBet,Crispies {
    // ...
  }
  

• If your method calls a method that throws an exception, you will (usually) have to either catch the exception or indicate that your method can throw that exception.
• There are a few exceptions that you don't have to explicitly catch or throw. Experience will show you which those are.