05b: OOP Principles

ICS211, Spring 2013
Dr. Zach

(switch view)

Status check

Encapsulation, Abstraction, and Reuse

lessons learned over time

Quick History of Software (1/3)

Quick History of Software (2/3)

// unstructured programming example
10 sum = 0
20 i = 1
30 if (i > 5) goto 70
35 println i
40 sum = sum + i
50 i = i + 1
60 goto 30
70 print "Total: " sum

Quick History of Software (3/3)

Lessons from Computing History

Trends (what we've learned works well):

Software Engineering Principles --> OOP

Encapsulation

Example: Square, No Encapsulation

public class Square {
  public int side;
  public int area;
  public int perimeter;
  
  public Square(int side) {
    this.side = side;
    this.area = side * side;
    this.perimeter = 4 * side;
  }
}

Square sq = new Square(5);
sq.area = 36;  //oops!  Other fields are now incorrect!

Example: Square, With Encapsulation

public class Square {
  private int side;
  private int area;
  private int perimeter;
  
  public Square(int side) {
    this.setSide(side);  //call method to do necessary work
  }
  
  public int getSide() {
    return this.side;
  }
  
  public void setSide(int side) {
    this.side = (side < 0) ? 0 : side;  //side must be 0+
    //recalculate all details
    this.area = this.side * this.side;
    this.perimeter = 4 * this.side;  
  }

  public int getArea() {
    return this.area;
  }

  public int getPerimeter() {
    return this.perimeter;
  }
}

Encapsulation Advantages

Example: Square, with implementation changed

public class Square {
  private int side;
  
  public Square(int side) {
    this.setSide(side);  //call method to do necessary work
  }
  
  public int getSide() {
    return this.side;
  }
  
  public void setSide(int side) {
    this.side = (side < 0) ? 0 : side;  //side must be 0+
  }

  public int getArea() {
    return this.side * this.side;
  }

  public int getPerimeter() {
    return 4 * this.side;
  }
}

If implementation is private, can change it without breaking existing code that uses public interface

Encapsulation Disadvantages

Advantages really pay off in large projects; not so much in small ones.

Sidenote: Various meanings of "user"

Abstraction

Reuse

Abstract Data Types (ADTs)

ADT: Stack

What is a data structure?

Abstract Data Type (ADT)

(In casual discussion, "data structure" and "ADT" often overlap. But sort of like difference between "method" and "algorithm".)

ADT: Stack

ADT: Stack, renamed

ADT: Stack, as Java code

To implement, need to know type of contents; use String for now... 

public class Stack {

  public Stack() { ... }

  public void push(String item) {...}

  public String pop() {...}

  public String peek() {...}

  public int size() {...}
}

How do we use this?

  Stack s = new Stack();
  System.out.println(s.size());  //0
  s.push("Alice");
  s.push("Bob");
  s.push("Carol");
  System.out.println(s.size());  //3
  System.out.println(s.peek());  //Carol
  System.out.println(s.pop());   //Carol
  s.pop();
  System.out.println(s.peek());  //Alice
  System.out.println(s.size());  //1

What would this print?

(Again, as an ADT, should just need to know the defined behavior of the stack, not how it works inside.)

ADT: Stack implementation


ADT: Stack code

public class Stack {

  private static final int SIZE = 5;

  private String[] items;  //holds contents
  private int top;         //index of current top element

  public Stack() {
    this.items = new String[SIZE];
    this.top = -1;
  }

  public void push(String item) {
    this.top++;
    this.items[this.top] = item;  //XXX: What if array is full?
  }

  public String peek() {
    return this.items[this.top];  //XXX: What if stack is empty and top == -1?
  }
  
  public String pop() {
    String item = this.items[this.top];  //XXX: What if stack is empty?
    this.top--;
    return item;
  }
  
  public int size() {
    return this.top + 1;
  }
}

//XXX: Problems

Java: Throwing Exceptions

Java: Throwing Exceptions

public void foo() {
  IllegalStateException err = new IllegalStateException();
  throw err;
}

public void foo() {
  throw new IllegalStateException();
}

Java: Throwing Exceptions

/**
 * Computes factorial of n.  
 * n must be positive or else throws IllegalArgumentException.
 */
public int factorial(int n) throws IllegalArgumentException {
  if (n < 0) {
    throw new IllegalArgumentException("Cannot compute factorial of a negative number.");
  }
  int fact = //...compute factorial here...
  return fact;  
}

ADT: Stack code, revised

/**
 * A Last-In, First-Out (LIFO) abstract data type.
 */
public class Stack {

  private static final int INITIAL_SIZE = 5;

  private String[] items;  //holds contents
  private int top;         //index of current top element

  /** Creates an empty stack. */
  public Stack() {
    this.items = new String[INITIAL_SIZE];
    this.top = -1;
  }

  /** Places the given item on the top of this stack. */
  public void push(String item) {
    this.top++;
    if (this.top == items.length) {
      //array is full, so replace with a copy that is double current size
      this.items = java.util.Arrays.copyOf(this.items, this.items.length * 2);
    }
    this.items[this.top] = item;
  }

  /** 
   * Returns a reference to the item currently on the top of this stack.
   * If the stack is empty, throws an IllegalStateException instead.
   */
  public String peek() throws IllegalStateException {
    if (this.top < 0) {
      throw new IllegalStateException("Can't peek() into empty stack.");
    }
    return this.items[this.top]; 
  }
  
  /** 
   * Removes and returns the item currently on the top of this stack.
   * If there is no top item, throws an IllegalStateException instead.
   */  
  public String pop() throws IllegalStateException {
    if (this.top < 0) {
      throw new IllegalStateException("Can't pop() from empty stack.");
    }
    String item = this.items[this.top]; 
    this.items[this.top] = null;  //optional, but allows garbage collection
    this.top--;
    return item;
  }
  
  /** Returns the number of items currently stored in this stack. */
  public int size() {
    return this.top + 1;
  }
}

ADT: Stack, conclusion

Enums

(quick summary)

One (old) way of handling constants

public class PlayingCard {
  //constant class variables
  public static final int CLUBS = 0;
  public static final int DIAMONDS = 1;
  public static final int HEARTS = 2;
  public static final int SPADES = 3;

  //instance variables
  private int value;
  private int suit;
  
  public PlayingCard(int value, int suit) {
    if (suit < 0 || suit > 3) {
      //oops... need to do something about it...
    }
  }
}

Defining an enum

public enum Suit {
  SPADES, HEARTS, DIAMONDS, CLUBS;
}

public enum Direction {
  N, NE, E, SE, S, SW, W, NW, HERE;
}

Example Use

// a constructor in class PlayingCard
public PlayingCard(int value, Suit suit) {
  //...
}

PlayingCard card = new PlayingCard(4, Suit.CLUBS);

Other advantages

Important methods

Every enum can has the following:

More enum details

Summary

Next time...