CS106A, Stanford Handout #18. Writing a Class

Transcription

1 CS106A, Stanford Handout #18 Fall, Nick Parlante Writing a Class Up to now we have used classes like Binky and DWindow defined by others, but now it is time to see how to write our own classes. Object Oriented Programming (OOP) is great at breaking a large problem into smaller, more manageable pieces. This strength has made OOP the dominant style for creating new programs. To write an OOP program, we must formulate the program as being made up of many "objects" each of which is controlled by a "class". The social contract of objects Each object "encapsulates" its own part of the data. For example, a person object might contain "name" and " address" data. The "Person" class contains the code and definitions used by each person object. Each object is responsible for operations on its data. For example, the Person class might implement a send to() method that sends an to its individual. Each object calls methods on other objects, so they can operate on their bits of data. In particular, an object might contain within it a pointer ("reference") to another object. This allows the first object to call methods on the second object when necessary. The data of the whole program is divided up into objects. Each object owns its little part of the data and does operations on it. Objects call methods on each other to prompt them to do operations. The main() starts the whole thing up creating the initial objects and calling the first methods to start things off. Stoplight We will start with a simple Stoplight example. A Stoplight object controls three DOvals on screen, and operates them so they look like your typical red-yellow-green stoplight. Every object contains some data that it manages. In this case, the Stoplight object will own and control three DOval objects. The Stoplight class implements methods bered(), beyellow() and begreen() that prompt the receiver stoplight object to change its appearance.

2 2 A Stoplight as it appears on screen. Client Side As an introduction to the Stoplight class we can look at some typical client code that uses a Stoplight; then we can look at how the Stoplight class itself works. The client code below creates a Stoplight object and then loops around calling the begreen(), beyellow(), and bered() methods on it. This code has the hallmarks of OOP client code: Creates an object with "new" and the constructor for the desired class, e.g. new Stoplight() Stores a pointer to the new object in a variable e.g. Stoplight light = new Stoplight(); Calls methods on the object using the dot (.) syntax e.g. light.begreen(); light.beyellow(); // StoplightClient.java * Simple client code that drives a Stoplight object. * Just for fun, we give lots of red and just a little green. * Runs an infinite loop that cycles the light. import stanford.cslib.*;

3 3 public class StoplightClient { public static void main(string[] args) { Stoplight light = new Stoplight(); // while-true -- loops and never exits while (true) { // 3 seconds of red light.bered(); DWindow.waitSeconds(3.0); // 0.5 seconds of green light.begreen(); DWindow.waitSeconds(0.5); // 1 second of yellow light.beyellow(); DWindow.waitSeconds(1.0); Writing the Stoplight Class The features of the Stoplight object above are defined by the code in the Stoplight class. How is a class written? Before looking at the syntax, we can think about the things a class needs to define for its objects. A class defines three things for its objects Storage what information should be stored inside of each object. These are called "instance variables". Constructor code how should new objects of this class be set up when they are first created? The "constructor" is code in the class that sets up new objects of the class when they are first created. Method code what operations can the objects peform? "Methods" in the class contain the code that the objects can perform. Each Stoplight object contains, or "owns", three DOval objects that will be installed in a DWindow. The DOvals are themselves objects, but that's fine. We are not writing the DOval class; it is already written. We are just creating and keeping pointers to three DOvals, so we can order them around. Our Stoplight class is a client of the existing DOval class our class uses DOval objects. The variables inside of an object are called "instance variables" or "ivars". Our Stoplight object will contain three instance variables, one for each of three DOvals. The instance variables are named myred, myyellow, and mygreen (will follow the convention that instance variables are named starting with "my"). In the client main() shown above, the code creates a single Stoplight object and stores a pointer to it in a local variable called "light". "Local" variables are declared inside of a method and used for temporary storage. This is the only sort of variable we have used up

4 4 until now. Local variables use an area of memory called the "stack", which we will draw off to the left. Objects are given memory by the "new" operator in an area of memory called the "heap", which we will draw on the right. For the above client code, the picture of memory will look something like the following. We see one Stoplight object, and the Stoplight class that defines how that object behaves. Stack Heap light myred myyellow mygreen Stoplight object // Code that defines how // Stoplight objects work. public class Stoplight { Stoplight class As we build up a program with objects with pointers to each other and whatnot, it's very common to make a diagram like this to help us think about the program. Class Definition Syntax Now we are ready for the details of the Java syntax to define a class: defining the storage, constructors, and methods of the class.

5 5 Class Syntax Usually the class begins with a comment that describes the basic role of the class. Then there are "import" statements that identify non-default external classes that the class uses. For CS106A, there are just a couple imports we will commonly use // import standard Java graphics classes import java.awt.*; // import Stanford classes import stanford.cslib.*; 1. Instance Variables ivars The central feature of an object is what data does it contain? A class declares "instance variables" for its objects, also known as "ivars" or "fields" or "data members". Each instance variable is space that will be available inside every object of the class. So if an MP3 class declares instance variables mytitle and mygenre, then every MP3 object will have instance variables inside it called mytitle and mygenre, ready to store the information for that object. For the Stoplight example, we want each Stoplight to store three DOval objects. The line "public class Stoplight {" begins the class declaration, and the first thing inside it are the declarations of the three instance variables myred, myyellow, and mygreen public class Stoplight { private DOval myred; private DOval myyellow; private DOval mygreen; // our three DOval ivars. Each instance variable is declared with the word "private", followed by the type of the variable, followed by its name. We will usually put the instance variable declarations at the top of a class, since they are so central to how the class works. However, in reality, the elements in a class (variables, code, etc.) can be in any order. If the role of an ivar is not clear from its name, we would add a comment describing what that ivar stores. "my" Convention Every Stoplight object contains its own "myred", "myyellow" and "mygreen" instance variables. There are several conventions in use for how to name the ivars Java does not have any formal requirement about how they are named. We will use the convention of beginning their names with "my" to help emphasize that they are inside of an object. This will help distinguish instance variables from the other sorts of variable, such as local variables. There are several different naming conventions in use in the OOP community; "my" is just the one we are using.

6 6 private vs. public Encapsulation Every element in a class can be declared "private" or "public". Suppose we have some "client" code of the class i.e. code somewhere else in the program that makes use of the class. The public/private options control which aspects of the class are available to the client code. Something that is "public" may be referenced by client code. Something that is "private" may not be used directly by client code. The compiler enforces that client code obeys public and private restrictions. Typically, instance variables are declared private. This is part of "encapsulation" OOP design, where each object is protective of its data and internal workings, not allowing client code to use those parts directly. 2. Constructor The "constructor" is one-time setup code that runs to initialize new objects of the class at the time that "new" is called. The constructor is the place to allocate and set up the object's data. To set up the new object, the constructor puts data in each of the object's ivars. So a typical constructor has an assignment ("=") for each ivar to give it an initial value. Syntactically, the constructor has the same name as the class and is typically declared public. Constructors and methods (below) can take arguments, but we will save that for a later. For our Stoplight example, the constructor is named "Stoplight()". It creates a DWindow object, creates and installs three DOvals, and stores the pointers to the DOval objects in the three ivars. We could keep a pointer to the DWindow as well, however we never need to call a method on it, so we do not bother. We need to keep pointers to objects, only if we need to contact or use them later. * Constructor -- code that runs when the client creates * a new Stoplight object. * Sets up the ivars. * "public" = accessible to clients. public Stoplight() { DWindow window = new DWindow("Stoplight", 70, 190); // Create three DOvals // each is 50 pixels around, separated by 10 pixels of space myred = new DOval(10, 10, 50, 50); window.add(myred); myyellow = new DOval(10, 70, 50, 50); window.add(myyellow); mygreen = new DOval(10, 130, 50, 50); window.add(mygreen);

7 7 3. Methods "Methods" in a class contain the code that objects of the class can run. The "bered()" method in the Stoplight class contains the code that runs when the client calls "bered()" on a Stoplight object. The prototype of a method begins with "public" or "private" followed by the return type of the method. For now, we will use "void" as the return type which means that the method does not return a value. The name of the method is followed by its list of arguments in parenthesis. For now, the list of arguments will be empty (). * Methods -- these contain the code that runs when * the client sends a message to a Stoplight object. * Lights the green, clears the others. public void begreen() { mygreen.setcolor(color.green); myred.setcolor(color.black); myyellow.setcolor(color.black); Receiver Relative Coding Code in a method always executes in the context of a specific object. If some client calls the method "light.bered();", the bered() method code runs on the specific Stoplight object referenced by the "light" variable. The method is said to run "on" or "against" that object which is knows as the "receiver". Method and constructor code can refer to ivars simply by name, e.g. "myred", but where does that ivar come from? If there are two Stoplight objects in memory, which myred does the code use? It uses the myred of the receiver whichever Stoplight object the method was called on. Methods and constructors always run "on" a receiver object, and all the ivar references are on that receiver. The code can refer to variables like myred or mygreen, confident that the OOP class/object machinery will pull the data from the right receiver object. This turns out to be a convenient way to write code. We write code in a method and it is always in the context of the receiver object of the method. All of its ivars myred, myyellow, mygreen fall to hand conveniently just by name. Complete Stoplight.java Code Here is the complete source code for the Stoplight class as it appears in the file Stoplight.java. Much of this code appears in the explanations above, but here it is in one piece as you will see it when writing your own classes

8 8 // Stoplight.java CS106A -- a first example of defining a class. * Each Stoplight object owns and controls three DOvals that * are installed in a DWindow. * Implements begreen(), beyellow(), bered() methods. * // import standard Java graphics classes import java.awt.*; // import Stanford classes import stanford.cslib.*; // (This marks the beginning of the class definition) public class Stoplight { * Instance variables ("ivars") * Every Stoplight object will have myred, myyellow, and mygreen * ivars in it that store pointers to the three DOvals. * "private" = not accessible to clients. private DOval myred; private DOval myyellow; private DOval mygreen; * Constructor -- code that runs when the client creates * a new Stoplight object. * Sets up the ivars. * "public" = accessible to clients. public Stoplight() { // Create a DWindow for the DOvals // We do not need to call methods on the window later, // so we do not need to keep a pointer to it in an ivar. // Store the pointer in a local variable, just for use // while the constructor runs. DWindow window = new DWindow("Stoplight", 70, 190); // Create three DOvals // each is 50 pixels around, separated by 10 pixels of space myred = new DOval(10, 10, 50, 50); window.add(myred); myyellow = new DOval(10, 70, 50, 50); window.add(myyellow); mygreen = new DOval(10, 130, 50, 50); window.add(mygreen);

9 9 * begreen(), bered(), beyellow() methods * Lights the green, clears the others. public void begreen() { mygreen.setcolor(color.green); myred.setcolor(color.black); myyellow.setcolor(color.black); * Lights the yellow, clears the others. public void beyellow() { myyellow.setcolor(color.yellow); myred.setcolor(color.black); mygreen.setcolor(color.black); * Lights the red, clears the others. public void bered() { myred.setcolor(color.red); mygreen.setcolor(color.black); myyellow.setcolor(color.black); // End of the Stoplight class definition Stoplight Intersection Client Example In our first Stoplight client, we just had one Stoplight object and the one Stoplight class, so the difference between an object and a class was not emphasized. Here is a second client that creates two Stoplight objects, one Stoplight object for a north-south road and a second Stoplight object for an intersecting east-west road. This example has two Stoplight objects, each with its own DOvals. However, there is still just one Stoplight class, containing the code that both the Stoplight objects use. The local variables in the client main(), "north" and "east" are allocated in the stack. All the objects are in the heap. // StoplightClient2.java * Runs two Stoplights -- one north/south, one east/west import stanford.cslib.*;

10 10 public class StoplightClient2 { public static void main(string[] args) { Stoplight north = new Stoplight(); // for the north/south direction Stoplight east = new Stoplight(); // for the east/west direction while (true) { // north goes north.begreen(); east.bered(); DWindow.waitSeconds(2.0); north.beyellow(); DWindow.waitSeconds(1.0); // east goes north.bered(); east.begreen(); DWindow.waitSeconds(2.0); east.beyellow(); DWindow.waitSeconds(1.0); Stack Heap north east myred myyellow mygreen Stoplight object myred myyellow mygreen Stoplight object // Code that defines how // Stoplight objects work. public class Stoplight { Stoplight class

11 11