CSC 224 Lecture Notes

• We need to finish the slides from last weeks lecture
• Let's go over the homeworks.
• Then let's go over everything we've covered in the reading and the notes thus far
  • Ask any questions you want
  • We can spend as much time as you need
  • I have a short class planned because I want to get everybody up to speed

• an interface is simply a list of methods with no bodies
  • similar to an abstract class where every method is abstract, and every field is final static

• having your class implement an interface is like a promise that your class will support the listed methods
  • Other classes may insist that you implement certain interfaces
  • The Arrays class will only sort objects that implement the Comparable interface... more on that later
• Interfaces define abilities, so rather than extending an interface you implement an interface. Since a car is driveable an automobile class might implement a driveable interface. class Automobile implements Driveable { public boolean startEngine() { if (notTooCold) { engineRunning = true; } return engineRunning; } public void stopEngine() { engineRunning = false; } public float accelerate(float acc) { // .. } public boolean turn(Direction dir) { // .. } }
• Another possible use of interfaces is as a holder of predefined values.
  • By placing initialized variables within the interface, you can bestow those values on a class by having the class implement the interface.
• Unlike class inheritance, a class can implement multiple interfaces
  • A Car class might want to implement Drivable; but also Comparable, and more...
• You can declare a variable of an interface type!
  • If you code to the interface you can change the implementation w/o changing the code that uses the methods

We subclass classes, so what do you think we can do with interfaces? If we create an interface that extends another interface then that is a subinterface.

    interface OffRoadDrivable extends Drivable {
      static final boolean fourWheelDrive = true;
    }

Remember that if we implement OffRoadDrivable we must be sure to override all the methods in both this interface and the Drivable interface.

• models an abstract concept
• contains real methods
• contains abstract methods
• contains any type of variable
• to use we must extend it
• may be extended by other abstract classes

• models a behavior or set of attributes
• contains only abstract methods
• contains only static final variables
• to use we must implement it
• may be extended by other interfaces

• classes which extend or implement must override all methods

• The java.util.Arrays has a sort() method that will sort an array of objects; but only if every object in the array implements Comparable!
• In order to sort you must be able to compare, implementing this interface guarantees that the sort method of the Arrays class can execute this kind of command: int x = obj1.compareTo(obj2);
  • x will be greater than zero if obj1 is greater than obj2, less than zero if the reverse, or zero if equal
• Why not provide the compareTo() method without implementing the Comparable interface?

Strong typing means that when a method call is made in Java, the compiler must check to ensure that the method actually exists. Somewhere in the sort method of the Arrays class a call is made like this:

(Comparable)a[i].compareTo((Comparable)a[j])

if the cast is allowed, the object implements Comparable, and thus the existance of the method is assured.

• An inner class is a class defined inside another class, Why?
  • An object of the inner class can access the private data of the outer class
  • Inner classes can be hidden from other classes in the same package
  • Helpful when writing event-driven programs (more next week)

• GUI (Graphical User Interface)
• javax.swing is the current standard for Java, don't mind the 'x'
  • Swing is much richer than the original Java GUI libraries
  • It is also more portable, adapts to the native platform
  • Plus it's a little easier to code in
  • Be careful, many of the methods used are inherited from the superclasses of Swing

• java.awt.Frame.setIconImage()
  • Sets an icon to associate your frame with
• java.awt.Frame.setTitle()
  • Lets you title your frame

• java.awt.Component.setLocation(x, y)
  • Where your component, including frames, will be on the screen
• java.awt.Component.setBounds(x, y, width, height)
  • Where and how big (in pixels) on the screen

ContentPanes and Panels [19/22]

The empty part of the frames we keep drawing is the ContentPane, when we want to add more interesting things, we draw graphic images on a Panel and then place the panel onto the ContentPane.