Status check

• A07 posted (due early next week, after exam; but more node practice)
• Quiz 08 to prep for exam
• Exam: next time (Wed)!

The inefficiency of Strings

Not covered last time:

String str = "";
for (int i = 0; i < 5; i++) {
  str += i + " ";
}
System.out.println(str); //prints: 0 1 2 3 4 

• Strings immutable, so when you add two strings together, needs to create a new one, copying both over
• Loop creates 10 new Strings.

StringBuilder

StringBuilder str = new StringBuilder();
for (int i = 0; i < 5; i++) {
  str.append(i);
  str.append(" ");
}
System.out.println(str.toString()); //prints: 0 1 2 3 4

• java.lang.StringBuilder (and older StringBuffer)
• no import required
• Basically an internal char array that grows like an ArrayList
• This blog post gives a good summary.
• toString() method when you're done building

Recap: ADTs

• Stack: LIFO; only affect one end
• Queue: FIFO; only affect one end or other
• List: can affect any element in sequence
• Iterator: Efficient traversal of list while still hiding/encapsulating implementation.

Implementations:

• Array-based
• Node-based (linked list)
• Variations: singly-linked, doubly-linked, tail pointer, circular (including array), sentinel node, etc.

Efficiency and Trade-offs

• * - resizing the array is amortized
• iterator - assuming iterator is at necessary location
• When to choose one over other? ArrayList over LinkedList most of the time

Perspective on Big-O

• Gives you a mental framework for estimation and theoretical comparison
• Processing a gigabyte of sorted characters
• 1GB? Hah, tiny! Fits in your smartphone's memory; 1/4 or 1/8 of your laptop's memory.
• Adding an extra character in O(1) - basically instant
• Adding an extra character in O(n) - noticable; about 1 second (since CPUs = Ghz)
• Sorting using an O(n²) sort - 32 years!!

Java's Collections

Interfaces

• List
• Queue
• Deque (usable as Stack)

Implementations

• ArrayList (List)
• LinkedList (List, Queue, Deque)
• ArrayDeque (Queue, Deque)

Java OOP

• instance variables, constructors
• inheritance, overriding (vs overloading; super), polymorphism
• interfaces, abstract classes (implementing)
• generics

For Exam 2

Essentials:

• OOP (Q05: Dog and DogPark; Q08)
• Know how to work with Nodes (A06a, Q07, Q08, (A07))
• Know how to work with Stack, Queue, List objects (A06b, Q08)
• Know the +/- of different implementation options

Background

• We'll use Swing: javax.swing.*
• Older: java.awt.
• (Abstract Windowing Toolkit) (Swing still uses parts of this)
• Oracle is now pushing JavaFX (RIAs using XML + CSS too)
• We'll code by hand to get an idea of how this all works
  • As with all coding, once you know what you're doing, tools will help you
• Tutorial: Creating a GUI with Swing
  • Fairly huge; somewhat skimmable

Overview

1. Make a plan (design)
2. Pick your components (widgets)
3. Layout your components
4. Implement the behavior (using event listeners)
5. Deploy (application, applet, etc.)

1: Our simple example

• A number pad (as for a calculator or phone)

2: Select components

• Swing Tutorial -> Using Swing Components -> Visual Guide helps a lot here
• Tutorial has basics for each possible component: description, examples, essential methods
• Not complete though. Once you know what you need, you can see full API for more
• Buttons for 0 - 9, a text field, a non-editable display part

3: Layout components

• Containers.
• Top-level (JFrame, JAppet) vs JPanel
• Tip: Build a JPanel that contains everything, then put that JPanel into a top-level container
• Every container has a layout manager for its components
• Swing Tutorial -> Laying Out Components Within a Container -> Visual Guide helps a lot here
• We'll keep it simple: nested JPanels and simple layout managers (Flow, Grid, or Border)

Sample code: Default Flow Layout

  JPanel top = new JPanel();

  //create buttons
  JButton[] buttons = new JButton[10];
  for (int i = 0; i < buttons.length; i++) {
    buttons[i] = new JButton("" + i);
    if (i > 0) {
      top.add(buttons[i]);  //add each button to the top JPanel
    }
  }
  top.add(buttons[0]);

  //then put top into a JFrame (window)...

GridLayout

  JPanel top = new JPanel();
  top.setLayout(new GridLayout(4, 3));  //row, col

  //create buttons
  JButton[] buttons = new JButton[10];
  for (int i = 0; i < buttons.length; i++) {
    buttons[i] = new JButton("" + i);
    if (i > 0) {
      top.add(buttons[i]);  //add each button to the top JPanel
    }
  }
  top.add(buttons[0]);

  //then put top into a JFrame...

Layout Managers

• Constructor/rules for each is a little different, so look it up in tutorial
• Can nest JPanels, so break design down into pieces, with different simple layouts for each
• (Or learn how GridBagLayout works)

NumberPad

public class NumberPad {

  //components we may need to refer to later
  private JPanel top;
  private JButton[] buttons;
  private JButton enter;
  private JTextField input;
  private JLabel output;

  /** Builds the top-level JPanel of the NumberPad GUI. */
  public NumberPad() {
    //top level
    this.top = new JPanel();
    top.setLayout(new BorderLayout());

    //first row: input field
    this.input = new JTextField();
    top.add(input, BorderLayout.PAGE_START);  //put in top

    //create buttons
    buttons = new JButton[10];
    for (int i = 0; i < buttons.length; i++) {
      buttons[i] = new JButton("" + i);
    }

    //center row: a grid of buttons 1-9, and then 2 more buttons underneath
    JPanel center = new JPanel();
    center.setLayout(new GridLayout(4, 3));
    for (int i = 1; i <= 9; i++) {
      center.add(buttons[i]);
    }
    center.add(new Label("")); //spacer
    center.add(buttons[0]);
    this.enter = new JButton("Enter");
    center.add(this.enter);
    this.top.add(center, BorderLayout.CENTER);

    //bottom row: an non-editable output/status field
    this.output = new JLabel(" ");  //a space so it has some height
    this.top.add(this.output, BorderLayout.PAGE_END);
  }
  
  public static void main(String[] args) {
    JFrame window = new JFrame("Number pad");
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    NumberPad pad = new NumberPad();
    window.setContentPane(pad.top);
    window.pack();
    window.setVisible(true);
  }  

4: Implement Behavior

• At this point, can click buttons and type in text field... but nothing happens.
• Relies on an event listener architecture (described on board)
• Simplest approach: Make number pad an ActionListener, register self with all components, and then sort out details from a single method

Complete implementation

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class NumberPad implements ActionListener {

  //components we may need to refer to later
  private JPanel top;
  private JButton[] buttons;
  private JButton enter;
  private JTextField input;
  private JLabel output;

  /** Builds the top-level JPanel of the NumberPad GUI. */
  public NumberPad() {
    //top level
    this.top = new JPanel();
    top.setLayout(new BorderLayout());

    //first row: input field
    this.input = new JTextField();
    this.input.setHorizontalAlignment(JTextField.RIGHT);
    this.input.addActionListener(this);
    top.add(input, BorderLayout.PAGE_START);  //put in top

    //create buttons
    buttons = new JButton[10];
    for (int i = 0; i < buttons.length; i++) {
      buttons[i] = new JButton("" + i);
      buttons[i].addActionListener(this);

    }

    //center row: a grid of buttons 1-9, and then 2 more buttons underneath
    JPanel center = new JPanel();
    center.setLayout(new GridLayout(4, 3));
    for (int i = 1; i <= 9; i++) {
      center.add(buttons[i]);
    }
    center.add(new Label("")); //spacer
    center.add(buttons[0]);
    this.enter = new JButton("Enter");
    this.enter.addActionListener(this);
    center.add(this.enter);
    this.top.add(center, BorderLayout.CENTER);

    //bottom row: an non-editable output/status field
    this.output = new JLabel(" ");  //a space so it has some height
    this.top.add(this.output, BorderLayout.PAGE_END);
  }

  public void actionPerformed(ActionEvent ae) {
    if (ae.getSource() == this.enter || ae.getSource() == this.input) {
      //Enter button clicked or enter pressed in input field
      this.output.setText("Entered: " + this.input.getText());
      this.input.setText("");
    }else if (ae.getSource() instanceof JButton) {
      JButton pressed = (JButton) ae.getSource();
      //one of the buttons must have been clicked: add that value to input
      this.input.setText(this.input.getText() + pressed.getText());
    }
  }

  public static void main(String[] args) {
    JFrame window = new JFrame("Number pad");
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    NumberPad pad = new NumberPad();
    window.setContentPane(pad.top);
    window.pack();
    window.setVisible(true);
  }
}

Just the beginning of GUIs...

• Much more complexity possible: many different components, layouts, event listener types, skins, customizations.
• For animation and complex interfaces, need to deal with threads
• IDE tools exist to help with construction (GUI builders).
• But the concepts here are the same across all GUI building (even in some other langagues):
  1. Make a plan (design)
  2. Pick your components (widgets)
  3. Layout your components
  4. Implement the behavior (using event listeners)
  5. Deploy (application, applet, etc.)
• We haven't talked about deployment options yet... We'll talk about applets next time.
  • In the mean time, see this applet version of the number pad

For next time...

• Quiz 08 before Wed.
• Exam on Wednesday
• A07 (linked list implementation) by early next week
• A08 (small GUI thing) posted by end of this week; due end of next week.
• We'll start searching and sorting next week