CS100J Lecture 8 Previous Lecture This Lecture Programming Concepts Classes, Objects, and Methods --- reiterated Accessors Encapsulation Java Constructs return statement Visibility modifiers public private This Lecture Programming concepts defining your own constructor chaining objects together searching Field and method modifier static Object reference this Conjunction && Reading: Lewis & Loftus, Section 5.2 Savitch, Chapter 5 CS 100 Lecture 8

Problem Setting We wish to represent widgets: Class Widget is a collection of widgets Each widget has a unique serial number (ID#) The assignment of ID# to widgets should be automatic, unique, and immutable, i.e., not changeable. There should be no limit on the number of widgets that can be created. Method Widget idToWidget(int id) returns a reference to the widget with ID# equal to id, or null if there is no such widget. CS 100 Lecture 8

Class Definition /* Collection of widgets. */ import java.io.*; public class Widget { // Each widget w has a unique w.id > 0. // nextId is the ID# of the next widget // to be created. private static int nextId = 1; private int id; // Create a new widget with a unique ID#. public Widget() { id = nextId; nextId = nextId + 1; } CS 100 Lecture 8

Object Instantiation and Constructors Evaluation of the expression new class-name() creates a new object of the given class-name and returns a reference to that new object. A class can define its own constructor. A constructor is like a method, but … Has the same name as the class Is automatically invoked on newly instantiated objects to provide an opportunity for initialization Thus, evaluation of the expression really does three things: Create a new object of the given class-name Invoke any (parameterless) user-defined constructor of the class Return a reference to the new object. CS 100 Lecture 8

Constructors Class definition Constructor definition class class-name { constructors-declarations-and-methods } Constructor definition constructor-modifier class-name( parameter-list ) declaration-and-statement-list where constructor-modifier can be public private (use to be explained later) one other constructor-modifier later CS 100 Lecture 8

Field Declarations A field declaration can have field-modifiers field-modifiers type name ; Possible field-modifiers are: public private static others later A private field is not visible from outside the class definition. A static field is also called a class variable. A class variable is not an instance variable of each object; rather, there is precisely one instance of a class variable no matter how many objects of the class are eventually created CS 100 Lecture 8

Object Instances An object is a collection of instance variables (known as fields) and methods There is one class variable per static field declaration nextId 1 A class variable id fields methods A widget object id fields methods Another widget object id fields methods Another widget object CS 100 Lecture 8

Problem Setting, revisited We wish to represent widgets: Class Widget is a collection of widgets Each widget has a unique ID# Method idToWidget(int id) returns the widget with ID# equal to id, or null if there is no such widget. CS 100 Lecture 8

Method Definitions, revisited method-modifier return-type method-name( parameter-list ) { statement-list } Possible method-modifiers are: public private static others later A private method is not visible from outside the class definition. A static method is also called a class method. A class method is invoked on the class, not on an object of the class, e.g., class-name.method-name(expression-list) CS 100 Lecture 8

Method idToWidget But how are we going to find the widget? // Return the widget with id# id, // or null if there is no such widget. public static Widget idToWidget(int id) { . . . } But how are we going to find the widget? Idea: keep all widgets chained together. Objects can have fields that refer to other objects Needed later... The expression this evaluated in an instance method of object o, or in a constructor for object o, is a reference to o. CS 100 Lecture 8

Object Instances, revisited id previous 1 fields methods A widget object null id previous 2 fields methods Another widget object id previous 3 fields methods Another widget object last A class variable CS 100 Lecture 8

Class Definition, revisited /* Collection of widgets. */ import java.io.*; public class Widget { // Each widget w has a unique w.id > 0. // nextId is the ID# of the next widget // to be created. private static int nextId = 1; private int id; // For each widget w, w.previous is the // widget created immediately before // w was created, or null if w was the // first widget created. The most recent // widget to have been created is last. private static Widget last; private Widget previous; . . . } CS 100 Lecture 8

Constructor Widget, revisited /* Collection of widgets. */ import java.io.*; public class Widget { . . . // For each widget w, w.previous is the // widget created immediately before // r was created, or null if r was the // first widget created. The most recent // widget to have been created is last. private static Widget last; private Widget previous; // Create a new widget with a unique ID# // linked to the previous widget created. public Widget() { id = nextId; nextId = nextId + 1; previous = last; last = this; } CS 100 Lecture 8

Object Instances, revisited nextId 1 A class variable last null A class variable id previous fields methods A widget object null id previous fields methods Another widget object null id previous fields methods Another widget object null CS 100 Lecture 8

Pattern for Searching // Search for something. // Start at the first place to look. r = the first place look; while ( r is not what we are looking for and there are still more places to look ) r = the next place to look ; // Now r is either what we were looking for, // or is an indication that there were no // more places to look. CS 100 Lecture 8

Method idToWidget, revisited // Return the widget with id# id, // or null if there is no such widget. public static Widget idToWidget(int id) { Widget r = last; while (r != null && r.id != id) r = r.previous; return r; } expression && expression is called a conjunction. It is true only when both operands are true. If the left operand is false, the right operand is not evaluated. Note: The order of the conjunction is important! In particular, it would be wrong to use the conjunction r.id != id && r != null Why? CS 100 Lecture 8