© 2006 Pearson EducationMaking Objects 1 of 36
MAKING OBJECTS
• Views of a Class
• Defining Your Own Class
• Declaring Instance Variables
• Declaring Methods
• Sending Messages
© 2006 Pearson EducationMaking Objects 2 of 36
Example: The CSMobile
• How can we best design and build the CSMobile?
• Think object-oriented: the CSMobile is an object with properties and capabilities
• Create a class to model the CSMobile and then make instances of that class
© 2006 Pearson EducationMaking Objects 3 of 36
Specifications of the CSMobile
• A basic (ok, ridiculously simple) specification for the CSMobile:
The CSMobile should have an engine and wheels so that it can move around. It also should have doors so that people can get in and out. The CSMobile should have the ability to move forward and backward. It should also be able to turn left and right.
• What are the CSMobile’s properties?– engine, wheels, doors
• What are the CSMobile’s capabilities?– move forward, move backward, turn left, turn right– don’t forget the constructor — all objects have the
ability to construct themselves (when sent a message to do so by another object)
• What would this look like in Java?– remember, properties are represented by instance
variables– capabilities are represented by methods
• Let’s see...
© 2006 Pearson EducationMaking Objects 4 of 36
Simple Syntax for CSMobileNote: The point of this to show an outline of what a generic classlooks like. Some functionality has been elided with // comments.
/** * This class models a vehicle that * can move and turn. */
public class CSMobile { // declare class
// declare instance variables private Engine _engine; private Door _driverDoor,
_passengerDoor; private Wheel _frontDriverWheel, _rearDriverWheel, _frontPassengerWheel, _rearPassengerWheel;
public CSMobile() { // declare constructor
// construct the component objects_engine = new Engine();_driverDoor = new Door();_passengerDoor = new Door();_frontDriverWheel = new Wheel();_rearDriverWheel = new Wheel();_frontPassengerWheel = new Wheel();_rearPassengerWheel = new Wheel();
} // end constructor for CSMobile
© 2006 Pearson EducationMaking Objects 5 of 36
Simple Syntax for CSMobile (cont.)
// declare and define methods
public void moveForward() {// code to move CSMobile forward
}
public void moveBackward() {// code to move CSMobile backward
}
public void turnLeft() {// code to turn CSMobile left
}
public void turnRight() {// code to turn CSMobile right
}
} // end of class CSMobile
© 2006 Pearson EducationMaking Objects 6 of 36
CSMobile Syntax Explained (1 of 5)
/** ... */– everything between /** and */ is a block comment
• useful for explaining specifics of classes• compiler ignores comments• but we comment for people who want to read our
code– class CSMobile has a kind of block comment called
a header comment• appears at top of class• explains purpose of class
public class CSMobile {– declares that we are about to create a class named CSMobile
– public indicates that any other object can create an instance of this class
© 2006 Pearson EducationMaking Objects 7 of 36
CSMobile Syntax Explained (2 of 5)
• Everything associated with class must appear within the curly braces, the body
{ all instance variables and methods;
no code may appear outside braces }
// ...– everything on the same line after // is a comment– known as inline comment– describes important features in code
private Engine _engine;– declares an instance variable named _engine of
type Engine– reserved word private
• indicates that instance variable will be available only to methods within this class
• other objects do not have access to _engine• CSMobile “encapsulates” its _engine
– remember, properties are objects themselves• every object must be an instance of some class• class of instance variable is called its type —
determines what messages can be sent to this property
© 2006 Pearson EducationMaking Objects 8 of 36
CSMobile Syntax Explained (3 of 5)
– name of instance variable is _engine• Our coding convention: prefix all instance variables
with an underscore, “_”
private Door _driverDoor,
_passengerDoor;– can declare multiple instance variables of the same
type– just separate them with a comma_driverDoor and _passengerDoor are both instance variables of type Door
public CSMobile() {– constructor for class CSMobile– remember: constructor is first message sent to
instance– same identifier as its class– () makes it a method
© 2006 Pearson EducationMaking Objects 9 of 36
CSMobile Syntax Explained (4 of 5)
_engine = new Engine();
– reserved word new tells Java that you want to make a new instance
– equals sign, =, means variable on left side “gets” value of right side
– so value of instance variable _engine will be new instance of class Engine• i.e., _engine “gets” a new Engine
– most common use of constructors is to initialize instance variables• i.e., construct initial state• that’s just what we’re doing here!
– note: Constructor CSMobile() refers directly to instance variable _engine• all methods, including constructor, have direct access
to all of their class’ instance variables
– rest of instance variables are initialized in same way
© 2006 Pearson EducationMaking Objects 10 of 36
CSMobile Syntax Explained (5 of 5)
public void moveForward() {
– declares a method named moveForward
– reserved word public indicates this method is to be part of class’ public interface• thus any other object that knows about an instance of
this class can send instance moveForward message
– reserved word void indicates that this method does not return result when called• some methods return values to calling method• more on return types next lecture• constructor declaration does not include return value
– moveForward is name of method• CS15 convention: method names should start with
lowercase letter and all new words in method name should be capitalized
– anything inside curly braces is part of method definition’s body
© 2006 Pearson EducationMaking Objects 11 of 36
CSMobile
• That’s it for the basic skeleton of class CSMobile!
• Now you know how to write a class with properties and capabilities– can declare variables and methods
• By the end of the course, you will be able to write the full CSMobile class!– will be able to fully define methods– will add a few more instance variables and change
methods a little– but... basic structure will be the same!
• Next we look at representation of our three types of properties– components– associations with other objects– attributes
© 2006 Pearson EducationMaking Objects 12 of 36
Object Relationships and Diagrams
• In our description, we said the CSMobile had an engine, doors, and wheels; these are components
• It can be said that the CSMobile is composed of its engine, doors, and wheels
• Containment is one way of associating objects with one another
• How do you determine containment?– class CSMobile has an instance variable of type Engine
– class CSMobile creates an instance of type Engine– therefore, CSMobile is composed of an Engine
• How do we diagram containment?
slideExamples.Car.Engine
SlideExamples.Car.CSMobile
_engine
© 2006 Pearson EducationMaking Objects 13 of 36
In the City…
• Let’s say we have a City object.
• City contains and therefore constructs– parks– schools– streets– cars, e.g., CSMobiles (hey, why not?)
• Therefore, City can call methods on – parks– schools– streets– CSMobiles
• But, relationship is not symmetric!
• Park, School, Street and CSMobile classes don’t automatically have access to City -- i.e., they can’t call methods on City
• How can we provide CSMobile with access to City?
© 2006 Pearson EducationMaking Objects 14 of 36
The Association Relationship
• Answer: Associate the CSMobile with its City
• How do you determine the association relationship?– we’ll add to class CSMobile an instance variable of
type City– class CSMobile doesn’t create its instance of type City; therefore, City won’t be a component of CSMobile
– we say: class CSMobile “knows about” City – tune in next time to see how to set up an association
(“knows about”) relationship in Java
• How do we diagram association?
slideExamples.Car.CSMobile
_city
SlideExamples.Car.City
© 2006 Pearson EducationMaking Objects 15 of 36
Attributes• The CSMobile has certain attributes
– color, size, position, etc.
• Attributes are properties that describe the CSMobile– we’ll add to class CSMobile an instance variable of
type Color– CSMobile is described by its Color– different than “ is composed of ” relationship– class CSMobile doesn’t contain its Color, nor is it
associated with it– we say: Color is an attribute of class CSMobile– class CSMobile may set its own Color or another
class may call a method on it to set its Color– the actual color of the CSMobile is an attribute, but
it is also an instance of the Color class• all instance variables are instances!
• How do we diagram an attribute?
– because attributes don’t have the full weight of other object relationships, we just put their type and name in line, without an arrow for the reference
SlideExamples.Car.CSMobile
Color _color
© 2006 Pearson EducationMaking Objects 16 of 36
CSMobile
Class Box
• Used to document an individual class schematically– rectangle represents class (you might use an index
card instead), labeled with its name at the top– next section shows properties of class (instance
variable name optional)– finally show capabilities of class
• note that constructor is assumed• don’t need to show it under capabilities
• Example of class CSMobile with the added properties just discussed:
Engine _engineDoor _driverDoor, _passengerDoorWheel _frontDriverWheel, _rearDriverWheel, _frontPassengerWheel, _rearPassengerWheelCity _cityColor _color
moveForwardmoveBackwardturnLeftturnRight
© 2006 Pearson EducationMaking Objects 17 of 36
Class Diagrams
• A class diagram shows how generic classes relate to other classes– rectangle represents class, much like the class box– important relationships are connected with lines – important properties have name with reference to
class boxes representing their type– attributes have type and identifier (but don’t show
references)
CSMobile
_city
_engine
Color _color
moveForward
moveBackward
turnLeft
turnRight
City
knows about
Engine
contains an
Note: Properties and Capabilities of City and Engine have been elided for clarity
Note: Doors and Wheels have been elided for clarity
© 2006 Pearson EducationMaking Objects 18 of 36
Working With Variables
• Variables in Java are like variables in math– hold single (reference to a) value that can vary over
time– but need to have previously defined value to be used
• Remember CSMobile? Creating an instance variable was done in two parts1. declaration: private Engine _engine;2. initialization: _engine = new Engine();
• What is value of _engine before step 2? What would happen if step 2 were omitted?
• Java gives all variables a default value of null– i.e., it has no useful value– null is another reserved word in Java– it means a non-existent memory address
© 2006 Pearson EducationMaking Objects 19 of 36
Uninitialized Variables and null
• If you forget to give your variables initial values, Java VM will reward you with a runtime error in the form of a
– runtime errors are problems that occur while your program is running
– i.e., your program compiled successfully, but it does not execute successfully
– for now, when runtime errors occur, your program is usually stopped by Java VM
• NullPointerException– if you get such an error, make sure you have
initialized all of your object’s instance variables!– most common occurrence of a NullPointerException is trying to send a message to an uninitialized variable
WATCH OUT!
NullPointerException
© 2006 Pearson EducationMaking Objects 20 of 36
Assigning Values to Variables
• Assignment provides a way to change the value of variables– replaces current value of variable with new value– example: _engine = new Engine();– we say: _engine “gets” a new instance of class Engine
• As we’ve seen, equals sign, =, is Java’s syntax for assignment– variable on left side of equals “gets” value of right
side– not like equals in Math! (which denotes equality of
left- and right-hand sides)
• Using = with new– calls the constructor of the class– constructor results in new instance of class– new instance is value assigned to variable
• Using = without new– assigns from one value to another– ex: _exteriorColor = _interiorColor;– makes the exterior color have the same value as the
interior color
© 2006 Pearson EducationMaking Objects 21 of 36
Working With Methods
• We know how to declare methods, but how do we call them? How can we send messages between objects?
• Syntax is variableIdentifier.methodIdentifier();
public class City {
private CSMobile _csMobile;
public City() { _csMobile = new CSMobile(); _csMobile.moveForward();
}
}
• Sending a message (“calling moveForward on _csMobile”) causes code associated with method to be executed_csMobile.moveForward() is a method call
• _csMobile is message’s receiver (one being told to move)
• dot (“.”) separates receiver from message name• moveForward is name of message to be sent• () denotes parameters to the message• more on parameters next lecture! woo hoo!
© 2006 Pearson EducationMaking Objects 22 of 36
this keyword (1 of 2)
• What if we want one method in a class to call another method in the same class?– let’s say we want the CSMobile to have a turnAround() method
– will want the turnAround() method to call the CSMobile’s own turnLeft() or turnRight() method twice
• In order for current instance to be receiver of message, we need a way to refer to it
• Reserved word this is shorthand for “this instance”– current instance, this, is receiver of message– so what we’re really doing with this is having an
instance send a message to itself
© 2006 Pearson EducationMaking Objects 23 of 36
this keyword (2 of 2)
• Example of using this to call a method on the current instance of the class
public void turnAround() { this.turnLeft(); this.turnLeft();}
this.turnLeft();
– tells the current class to execute the code in its turnLeft() method
– since calling your own methods is common, using this is optional
– this.turnLeft() and turnLeft() do the same thing
– using this makes it more clear
public void turnAround() {
turnLeft();
turnLeft();
}
• Now that we’ve seen how to call methods, let’s do something with the CSMobile...
may be shorter, but not as clear
© 2006 Pearson EducationMaking Objects 24 of 36
Example: Driving Around Town
• Given a “world” where the CSMobile moves only along the roads defined by a regular grid:– think of it as a simplified city map: The streets are all
the same length and go only horizontally and vertically (also, they are all 2-way)
– CSMobile can move forward in direction it is facing and can turn 90 degrees left or right
– can move only one block at a time
• Get CSMobile to corner of A St. and Third Av. and back, given…
• these initial conditions:– CSMobile starts at corner of B St. and First Av.
facing north
A S
t.
B S
t.
First Av.
Second Av.
Third Av.
© 2006 Pearson EducationMaking Objects 25 of 36
Example: Analyzing the Problem
• Most important first step is to analyze and understand the problem– ask questions about specifications of problem– restate nature of problem in your own words
• Understanding the specifications– only horizontal and vertical movement is allowed– CSMobile can only turn in right angles– moves from intersection to intersection
• Understanding the problem– must move two blocks North and one block West to
get to Third and A– must move two blocks South and one block East to
get back to First and B
• Solution:
Third Av.and A St.
© 2006 Pearson EducationMaking Objects 26 of 36
Example: Pseudocode
• You can describe how to complete this task at some level of detail in English; this is called “pseudocode”
tell CSMobile to move forward one blocktell CSMobile to move forward one blocktell CSMobile to turn lefttell CSMobile to move forward one blocktell CSMobile to turn lefttell CSMobile to move forward one blocktell CSMobile to move forward one blocktell CSMobile to turn lefttell CSMobile to move forward one block
• Pseudocode is more detailed than the initial problem specification, but not as detailed as the code itself– multiple levels of pseudocode may be used– decomposition process is called stepwise refinement
because each successive level is more detailed or refined
– good programming flows from specification to pseudocode to actual code
• Now that we’ve pseudocoded, let’s see the actual code...
© 2006 Pearson EducationMaking Objects 27 of 36
Code Reusability
• Is our pseudocode reusable? What happens if we want to go back?
• The CSMobile is not pointing in the same direction after the trip as it was in the beginning!– We have changed the state of the CSMobile– We should add a left turn at the end so that the
CSMobile is pointing in the same direction as in the beginning:
Third Av.and A St.
© 2006 Pearson EducationMaking Objects 28 of 36
Reusable Pseudocode
• Here’s our new pseudocode:tell CSMobile to move forward one blocktell CSMobile to move forward one blocktell CSMobile to turn lefttell CSMobile to move forward one blocktell CSMobile to turn lefttell CSMobile to move forward one blocktell CSMobile to move forward one blocktell CSMobile to turn lefttell CSMobile to move forward one blocktell CSMobile to turn left
• The final left turn leaves the CSMobile facing in the original direction
• Always think about what effects a method has on the state of an object– Other parts of the code depend on correct execution– Hand simulate to be sure
© 2006 Pearson EducationMaking Objects 29 of 36
Syntax for Trip to Third and A
/** * This class models the process of a CSMobile * driving from the corner of First Av and B St * to Third Av and A St and back. */
public class TripToThirdAndA {
private CSMobile _csMobile;
public TripToThirdAndA() { _csMobile = new CSMobile(); }
public void takeTrip() { _csMobile.moveForward(); _csMobile.moveForward(); _csMobile.turnLeft(); _csMobile.moveForward(); _csMobile.turnLeft(); _csMobile.moveForward(); _csMobile.moveForward(); _csMobile.turnLeft(); _csMobile.moveForward(); _csMobile.turnLeft(); }
} // class TripToThirdAndA
© 2006 Pearson EducationMaking Objects 30 of 36
Syntax for Application
/** * This class exists to start everything up. */
public class TripApp extends wheels.users.Frame {
private TripToThirdAndA _trip;
public TripApp() { _trip = new TripToThirdAndA(); _trip.takeTrip(); }
public static void main ( String[] argv ) { new TripApp(); } } // end of class TripApp
© 2006 Pearson EducationMaking Objects 31 of 36
TripToThirdAndA Syntax Explained
• Note name of class:– describes process that object models– a TripToThirdAndA– usually, you would have ability to drive to Third and
A be a capability of CSMobile, but we haven’t yet learned how to extend functionality of existing class
• Basic rundown:– declares instance variable of type CSMobile– initializes CSMobile instance in constructor– calls methods on CSMobile instance in takeTrip
method
_csMobile.moveForward();– message sent by instance of TripToThirdAndA– message sent to instance of CSMobile– TripToThirdAndA tells its contained CSMobile
instance to move forward– all other method calls are similar!
© 2006 Pearson EducationMaking Objects 32 of 36
TripApp Syntax Explained
• Only purpose of app is to start everything up:
// create the instance_trip = new TripToThirdAndA();
// call method on the instance_trip.takeTrip();
• This instance, in turn, calls methods (moveForward, turnLeft, etc.) on its contained _csMobile instance
© 2006 Pearson EducationMaking Objects 33 of 36
Steps of Execution
• What’s going on inside the JavaVM?
_csMobile.moveForward(); _csMobile.moveForward(); . . .
• takeTrip method ends, so control returns to TripToThirdAndA constructor
• TripToThirdAndA constructor ends, so control returns to TripApp constructor
• TripApp constructor ends, so mainline ends and so does the program
Mainline instantiates TripApp
TripApp
_trip = new TripToThirdAndA();
_trip.takeTrip();
CSMobile is created and told to take a
trip
inside takeTrip()
© 2006 Pearson EducationMaking Objects 34 of 36
We’re Done!
• It’s that simple!
• Now you know how to create and use a class
• Next time: Customizing methods and the mysterious association relationship
© 2006 Pearson EducationMaking Objects 35 of 36