A Quick and Dirty Intro to Classes in Java - Part 2

Basic Mechanics

• A class is like a structure, but can contain methods (functions).
• All code appears within a class.
  • Any class can have a main method which must be declared as

    public static void main(String [] args) {
    	body
    }
    				

  • Program (application) is executed by invoking the interpreter on a class containing a main method. Execution begins at that method.
• Data fields of a class are called instance variables.
  • Instance variables are accessed in the same manner as fields in a struct in C.
  • Given an instance variable, val of a class Counter, and a variable ctr of that class type, we would write ctr.val.
• Functions of the class are called methods
  • Methods are accessed much like instance variables, but use function-call notation (we speak of the method being invoked).
  • Given a method, up of a class Counter, and a variable ctr of that class type, we would write ctr.up().
• We speak of the instance variables as comprising the state of objects of that class and the methods defining the class' behavior.
  (You can think of the behavior as something every object of the class has in common, while the state is what gives each object it's individual 'personality'.)
• Some examples
  • A Counter class containing
    • an instance variable, val containing the value of the counter
    • a method, up, that increments the counter's value by 1
    • a method, down, that decrements the counter's value by 1

    class Counter {
    	void up() {...}
    	void down() {...}
    	
    	int val;
    }
    				

  • A Stack class containing
    • an instance variable, arr, that will contain the elements of the stack
    • an instance variable, top, that will contain the index of the top of the stack
    • a method, push that pushes a value on the stack
    • a method, pop that removes the top element of the stack
    • a method, isEmpty that returns whether the stack has any elements

    class Stack {
    	void push(??? val) {...}
    	??? pop() {...}
    	boolean isEmpty() {...}
    	
    	int top;
    	??? arr[];
    }
    				

  • A Window class containing
    • an instance variable, width, that will contain the width (in pixels) of the window
    • an instance variable, height, that will contain the height (in pixels) of the window
    • an instance variable, x, that will contain the horizontal position (in pixels) of the window
    • an instance variable, y, that will contain the vertical position (in pixels) of the window
    • an instance variable, fgcolor, that will contain the text color of the window (where Color is itself a class)
    • an instance variable, bgcolor, that will contain the background color of the window (where Color is itself a class)
    • an instance variable, text, that will contain the text currently in the window
    • a method, move that changes the position of the window
    • a method, resize that changes the size of the window
    • a method, setFgColor that changes the text color of the window
    • a method, getFgColor that returns the text color of the window
    • a method, setBgColor that changes the background color of the window
    • a method, getBgColor that returns the background color of the window
    • a method, insert that will insert text into the window

    class Window {
    	void move(int newX, int newY) {...}
    	void resize(int new width, int newHeight) {...}
    	void setFgColor(Color newFgColor) {...}
    	Color getFgColor() {...}
    	void setBgColor(Color newBgColor) {...}
    	Color getBgColor() {...}
    	void insert(String newText, int where) {...}
    	
    	int width, height;
    	int x, y;
    	Color fgColor, bgColor;
    	String text;
    }
    				

• An object can thnus be thought of as a programming mechanismt that 'binds' data together with the methods that operate upon that data

• We can think of a class definition as defining a new type (just like struct defined a new type)
• We can then declare variables of the class type.
• These variables will then refer to objects of the class.

  Counter c1;
  Stack s2;
  Window w3;
  		

Objects (Instances)

• An object of a class is called an instance of the class.
• Declaring a variable does not actually create an object of the class.
• We need to be able to create instances of the class and then refer to them.
• The variable will act as a reference to objects of the class.
• We thus speak of reference variables

• Objects are created using the new operator
  • new Counter()
  • new Stack()
  • new Window()
• When new is done, it returns a reference to the newly created object.
• This reference can then be assigned to a reference variable of the class.
  • Counter counter = new Counter()
  • Stack stack = new Stack()
  • Window window = new Window()

• After new creates the object it invokes a method, known as a constructor to initialize the object
• The constructor is automatically invoked by new-- the programmer does not call it directly.
• The constructor is named after the class (as you can see above)

  		Counter() {val = 0;}
  	

• The constructors above took no arguments
  • They are known as default constructors
  • Default constructors are good for simple creation of an object
• Constructors can also have arguments
  • Counter(int val) {...} // pass in initial value
  • Stack(int capacity) {...} // pass in size of stack
  • Window(int width, int height) {...} // pass in initial height and width

• How do we write the body of Counter(int val) {...}?

  Counter(int val) {val = val;} // ??? both val's refer to the parameter
  		

• Could change parm name, but don't want to
• this refers to the current object

  Counter(int val) {this.val = val;} // this.val -> val instance variable of the current object
  		

• There are other contexts in which we need to speak of the receiver-- in particular when an object wishes to send itself as a parameter to a method
  • For example, when a system shuts down, it first notifies its open windows so that they can gracefully shut down their applications
  • To achieve this, a window registers with the system when the window is first created
  • Assume a class called OperatingSystem which contains a method:

    registerForShutdownNotification(Window window) {...}
    					

    i.e., calling this method registers the passed window so that it is notified when the system is about to shut down.
  • Now when a Window is created, we need the object to pass itself to the above method-- this is achieved using this:

    Window(...) {	// Window constructor
    	...
    	operatingSystem.registerForShutdownNotification(this);
    }
    					

• Can have more than one constructor (for Counter() and Counter(int val))
• In general, can have more than one method with the same name in a class as long as the method prototypes differ
• Binding time of method invocation to particular method?

public class Counter {
	public Counter() {val = 0;}		
	
	public void up() {val++;}
	public void down() {val--;}
	public int get() {return val;}
	
	public String toString() {return val+"";}
	
	private int val;
}
	

Notes:

• Don't need this here-- no clash with local vars or parms
• toString allows us to obtain a String representation of the object (more convenient than a print method)

A main method is often added to a class whose execution will either 'show-off' the behavior of the class, or test the class (basically the same thing).

public class Counter {
	public Counter() {val = 0;}		
	
	public void up() {val++;}
	public void down() {val--;}
	public int get() {return val;}
	
	public String toString() {return val+"";}	// The String concat, '+', converts integers to String automatically
	
	private int val;
	
	public static void main(String [] args) {
		Counter c = new Counter();
		System.out.println("After initialization: " + c.get());
		System.out.println("After initialization, using toString():" + c.toString());
		// The String concat, '+', calls an object's toString automatically
		System.out.println("After initialization, using toString() implicitly: " + c);
		
		System.out.println("going up!");
		for (int i = 0; i < 10; i++) {
			c.up();
			System.out.println("The counter after " + i + " up(s) is now: " + c);
		}
		
		System.out.println("down we go!");
		for (int i = 0; i < 10; i++) {
			c.down();
			System.out.println("The counter after " + i + " down(s) is now: " + c);
		}
	}
}
	

Simple Class Design

• Look for the 'nouns' in the problem specification-- those are the classes
• Try to select the 'primary' class
• User scenario for each class
  • Provides the methods (behavior)
  Look for what must be maintained between method invocations, or in order to implement a method
  • Provides the instance variables (state)
  Repeat until all classes are specified