1 / 37

PARAMETERS - PowerPoint PPT Presentation

  • Uploaded on

PARAMETERS. Making Messages Specific Setting Up Associations Actual and Formal Parameters Return Types Accessor and Mutator Methods Local Variables Garbage Collection. Parameters. 1 of 37. September 17, 2013. Problem 1: Making Messages Specific. CS15Mobile needs a paint job!

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'PARAMETERS' - gad

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  • Making Messages Specific

  • Setting Up Associations

  • Actual and Formal Parameters

  • Return Types

  • Accessor and Mutator Methods

  • Local Variables

  • Garbage Collection


1 of 37

September 17, 2013

Problem 1 making messages specific
Problem 1: Making Messages Specific

  • CS15Mobile needs a paint job!

  • Let’s say we want to give CS15Mobile the capability of being painted different colors

  • One solution:

    • add a method to CS15Mobile for each color we want to paint with

      public void setRed();

      public void setBlue();

      public void setTeal();

      public void setMauve();


  • Not very elegant to write all these methods

  • Much more efficient to write onesetColor method in class CS15Mobile in which we could specify the color that we want to paint with

  • How do we make a message specific?


2 of 37

Problem 2 a smart cs15mobile
Problem 2: A Smart CS15Mobile

  • CS15Mobile is going for a drive!

  • It’s time to associate CS15Mobile with the City it’s driving in

    • this way it can call methods on class City to ask where schools and parks are located

  • Remember, CitycontainsCS15Mobile

    • Cityhas an instance variable of class CS15Mobile

    • this meansCity can call methods on this instance

  • But containment relationship is not symmetric

    • CS15Mobilecan’t automatically call methods on City (it doesn’t know about the city)

  • So how can we enable CS15Mobile to know its container, City, so it can call methods on City?

  • Need to associate a City instance with a CS15Mobile instance in order for a CS15Mobile to call methods on City

  • How do we associate two objects?


3 of 37


  • Answer: Parameters!

  • We use Parameters in two cases:

    1) To make messages between objects specific

    by sending additional information

    • in a setColor() method, we can specify color

    • in an eat() method, we can specify food

      2) For one object to learn about another object

      that it didn’t create

    • can use a method to let a CS15Mobile know about the City it is driving in

    • this is the way to set up association (“knows-about”) relationships

  • But how?


4 of 37

Sending and receiving
Sending and Receiving

  • The sending method sends specifics of a given situation to a receiving method

  • This is what the parentheses after the method names are for

    • parameters are variables that go inside the parentheses

  • In fact, you already know parameters quite well

    • a function in math is like a method that receives one or more parameters and computes a result

    • a mathematician can “send” the function a specific value of the parameter

    • example:






f(x) = x2 + 2x + 5


specific value

receiving function


5 of 37

Formal and actual parameters
Formal and Actual Parameters

  • x is a formal parameter

    • formal parameters are “dummy” variables that represent the type of object that will be passed in when the method is called; call them what you like!

    • they have no value of their own; they take on value of parameters passed in when method is called

    • placeholders, like x in x2 + 2x + 5

  • 2 is an Actual parameter

    • actual parameters are “actual” instances sent when calling method

    • sender passes a specific value/instance with method call to receiver

      f(x) = x2 + 2x + 5

  • Let’s see a method that receives parameters!

f(x) = x2 + 2x + 5



actual parameter formal parameter returns


6 of 37

Syntax the receiver
Syntax: The Receiver

package Demos.Car;


* This class models a CS15Mobile that

* can be repainted any color. The instance

* variables and other methods that we defined

* in previous lectures are elided for brevity.


public class CS15Mobile {

private java.awt.Color _color;

// other instance variable declarations elided

public CS15Mobile() {

_color = java.awt.Color.WHITE; // default

// other instance variable definitions elided


public void setColor(java.awt.ColornewColor) {

_color = newColor;


public void repaintCar() {

// assume these methods declared below repaintCar






// other methods elided




formal parameter


7 of 37

Syntax the sender
Syntax: The Sender

package Demos.Car;


* This simple App only sends the CS15Mobile’s

* setColor method a parameter, then repaints

* the car.


public class SimpleApp extends javax.swing.JFrame {

private CS15Mobile _15mobile;

public SimpleApp() {

_15mobile = new CS15Mobile();




public static void main (String[] argv) {

new SimpleApp();



actual parameter (no type needed)

What color

will the car be



8 of 37

Syntax for the receiver explained 1 2
Syntax for the Receiver Explained (1/2)

  • Syntax for class CS15Mobile:

    private java.awt.Color _color;

    • java.awt.Color is the built-in Java class that represents a color

    • CS15Mobile has an instance variable representing its color that is set in its constructor

      _color = java.awt.Color.WHITE; // default

    • java.awt.Color.WHITEis a constant

    • java.awt.Color class has many predefined constantcolors which are public instance variables of the Color class (examples: RED, GREEN, BLUE, WHITE)

    • it’s okay for them to be public instance variables as a special case because they are constant (cannot be changed!) so we don’t need to worry about their value changing unexpectedly

    • more on how you can create constants later in the course


9 of 37

Syntax for the receiver explained 2 2
Syntax for the Receiver Explained (2/2)



public void setColor(java.awt.ColornewColor) {

  • this method receivesa parameter (and returns none)

  • parameter is of typejava.awt.Color

    • tells Java that this method “takes in” an instance of the java.awt.Color class when it is called

  • java.awt.ColornewColoris a formal parameter

    • newColoris the name that the parameter will be referred to as, only in this method

    • can only use newColor within body of setColor(…) method (i.e., within the curly braces “{} ”)

    • don’t have to name it newColor, can use any name!

  • a method that receives one parameter is always declared with the form:


    • since formal parameter is only accessible within method, copy it into an instance variable so it is accessible to all methods within the class

    and doesn't disappear when method ends

    _color = newColor;

    read: _color “gets” the same Color

    as newColor(i.e., whatever actual value

    newColor is set to when setColor(…) is called)



10 of 37

Syntax for the sender explained
Syntax for the Sender Explained

  • Syntax for class SimpleApp:


    • example of a method call that sends a parameter

    • here, we send the constant java.awt.Color.BLUE as an actual parameter to the receiving method, setColor(…)

    • note: don’t specify the type of the parameter you “pass in” (in this case, don’t need java.awt.Colorin addition to the actual parameter)

      • this is because the parameter type is already specified in the CS15Mobile’ssetColor(…) method

      • what if you tried to pass in something that wasn’t a Color?


      • you would get a compiler error like:

        Incompatible type for method setColor()

        Can’t convert randomInstance to Color.

actual parameter (value)


11 of 37

More on actual and formal parameters
More on Actual and Formal Parameters

  • One-to-one correspondence needed between formal and actual parameters

    • order, type (class) of instances, and number of parameters sentmust match order, type, and number declared in method!


      • sends one parameter of type java.awt.Color

      • which matches:

        public void setColor(java.awt.ColornewColor)

      • expects one parameter of type java.awt.Color

  • Note: java.awt.Color.BLUE is very different from java.awt.Color blue. The former indicates a constant (with a specific value) and the latter would declare a variable of typejava.awt.Colornamedblue (without value).

  • Name of formal parameter does not have to be the same as the corresponding actual parameter

    • receiver cannot know what specific instances will be passed to it, yet it must know how to refer to it

      • receiver uses a dummy name to represent the parameter

    • sender may send different actual parameters

      • may send java.awt.Color.BLUE, java.awt.Color.Yellow, etc. tosetColor(…) method


12 of 37


A method’s signature is composed of its…

  • identifier (name)

  • class of its parameters

  • order of its parameters

  • Like a person’s signature, a method’s signature must be unique.

  • Creating two methods in one class with the exact same signature will cause an error like:

    someMethod() is already defined in MyClass: public void someMethod(){

  • Methods in different classes can still have the same signature; Java disambiguates based on type of instance


13 of 37

References as values of variables
References as Values of Variables

  • To send messages to an object, we must have a name for it

    • in Java, we can only access objects via references to them

  • Objects only contain references to component objects

    _color java.awt.Color

  • The equals sign =actually assigns references

    _15mobile = new CS15Mobile();

    • makes _15mobile refer to a new instance of class CS15Mobile

      • i.e., _15mobile is assigneda reference to an instance created byCS15Mobile()

        _color = newColor; //not new Color!!!

    • makes _color refer to the same instance of Color class that newColor does

      • i.e., _color is assigned the same color as newColor

      • both now refer to the same color instance

refers to an instance of


14 of 37

Review references revealed
Review: References Revealed

  • A reference is just a pointer to a location in memory

    • a version of an address people can understand

    • it’s easier to keep track of a name than some weird thing (like 0xeff8a9f4)

    • holds a memory address where instance is stored

    • Java also has primitives, which are not objects and do not have pointers (more on this later)


a reference


You knownothing,Jon Snow.

reference to

instance 1

reference to

instance 2

reference to

instance 3


15 of 37

Parameters as references
Parameters as References

  • Formal parameters refer to the same instance while the method is active; when the method is finished, so is the formal parameter name, which is why we usually store the parameter in an instance variable

    • the sender sends a reference to an instance using an actual parameter

    • the receiver’s corresponding formal parameter then refers to the same instance


public class SimpleApp {





Actual parameter



public class CS15Mobile {


public void setColor(java.awt.ColornewColor){




Formal parameter


16 of 37

Parameters and association
Parameters and Association

  • Finally, the moment you’ve all been waiting for...

  • Let’s use what we’ve learned about parameters to enable a CS15Mobile to know about its City -- called association

    • CS15Mobile can store a reference to its City so that it can send messages to it

  • Usually associations are done in the constructor

    • don’t forget that constructors are methods, too

    • they can receive parameters just like any other method

  • Let’s see all this in action...


17 of 37

Syntax the receiver1
Syntax: The Receiver

package Demos.Car;


* This class models a CS15Mobile that knows about

* its City. Again, the instance variables,

* constructor, and other methods that we defined

* in earlier slides are elided.


public class CS15Mobile {

private City _city;

public CS15Mobile(City myCity) {

_city = myCity; // store association

// More code elided


// … Other methods of CS15Mobile elided

} // End of class CS15Mobile

So when an instance of City instantiates aCS15Mobileit is expected to pass a reference to itself to theCS15Mobile’s constructor, so that the CS15Mobilecan be associated with the instance City.

The instance ofCitywill be referenced by the formal parameter namemyCity, whose value is then stored in the instance variable_city. Now the CS15Mobile can call any ofCity's public methods on  _city.


18 of 37

Syntax the sender1
Syntax: The Sender

package Demos.Car;


* This class models a city where CS15Mobiles

* exist. Because the City contains the

* CS15Mobile, it can send the CS15Mobile the

* reference to an instance of itself.


public class City {

private CS15Mobile _15mobile;

public City() {

_15mobile = new CS15Mobile(this);


// … Other methods of City elided

} // End of class City

  • Remember this(“Making Objects” lecture, slide 24)?

    • shorthand for “this instance”, i.e., instance where execution is currently taking place

  • To associate itself with CS15Mobile, Citypasses theCS15Mobilea reference to itself by using the reserved wordthis.

  • Now_15mobile is associated with “this” instance ofCity .


19 of 37

Syntax for the receiver explained
Syntax for the Receiver Explained

  • Syntax for class CS15Mobile

    public class CS15Mobile {

    private City _city;

    // _city is a variable storing the

    // City that this CS15Mobile is driving in

    // CS15Mobile constructor

    public CS15Mobile(City myCity) {

    _city = myCity;



    • standard constructor that receives a parameter

    • assigns the parameter passed in, myCity, to the instance variable _city

    • CS15Mobile now knows aboutmyCity


20 of 37

Syntax for the sender explained1
Syntax for the Sender Explained

  • Inside constructor for class City

    _15mobile = new CS15Mobile(this);

  • Constructor for CS15Mobile needs a City

    • we need to pass an instance of the City class to the constructor for CS15Mobile inside constructor for class City

    • where can we find an instance of City?

    • which instance of City?

    • since we’re in the Cityclass' constructor (i.e., execution is taking place inside a Cityinstance), use thisas our instance of City

Actual parameter sent by a City instance


_15mobile = new CS15Mobile(this);



public CS15Mobile(City myCity)

Formal parameter used by CS15Mobile constructor


21 of 37

Methods with multiple parameters
Methods with Multiple Parameters

  • Declaring a method that accepts more than one parameter is quite simple

    • for example, let’s say that the CS15Mobile is about to get a speeding ticket!

    • an instance of the Policeman class needs to know about the CS15Mobileas well as the City in order to write up the ticket

    • we could “hardwire” a particularCity in Policeman’s constructor (meaning the policeman will always be associated with that city) or allow City to be totally dynamic in a method like this:

      public void giveTicket(City myCity,

      CS15Mobile car) {


      This way Policeman can give a ticket to any CS15Mobile in any City

      method would be called like this:


Formal parameters

instance of class CS15Mobile

instance of class Policeman

instance of class City


22 of 37

Return types


Sending Object

Receiving Object


optional return

Return Types

  • Let’s say we want to ask the CS15Mobile for its color

  • Just like methods can take in information, they can also give back information (remember the example of a function that computes a result)

  • Methods can send a response back to the object that called the method

  • First, method must specify what type of object it responds with

    • so far, we’ve seen the word void in method declarations – the type of object that a method responds with takes the place of void

  • At the end of the called method, an object of the specified return type is returned to the caller

  • How does this look?


23 of 37

Return types1
Return Types

package Demos.Car;


* This class demonstrates the

* CS15Mobile using return types.


public class CS15Mobile {

private java.awt.Color _color;

// other instance variables elided

public CS15Mobile(City myCity) {

_color = java.awt.Color.WHITE;

// city association code elided


// setColor method elided

public java.awt.ColorgetColor() {

return _color;




24 of 37

Return types syntax explained
Return Types Syntax Explained

public java.awt.ColorgetColor()

  • note that instead of void, method says java.awt.Color

  • the void keyword means the method returns nothing

  • void can be replaced with class type to be returned

    • any object of the declared type can be returned

    • something that calls the getColormethod will expect a java.awt.Color to be returned


      _carColor = _15mobile.getColor();

  • at the end of a method, use the return keyword to give back an object of the appropriate class type

  • In the above example, the value returned by _15mobile.getColor() is assigned to the instance variable _carColor

instance of type java.awt.Color

instance variable of type java.awt.Color

instance variable of type CS15Mobile


25 of 37

Accessors and mutators 1 of 2
Accessors and Mutators (1 of 2)

  • Accessor and Mutator methods are simple helper methods used to “get” or “set” some property of an object

  • These methods are very simple but illustrate the concepts of parameters and return types

  • Mutator Methods:

    • “set” methods

    • use parameters but generally do not return anything (return void)

    • exist primarily to change the value of a particular private instance variable (property) in a safe way

      • allows programmer to give variables specific values, instead of leaving them null

    • names usually start with set (setColor, setSize, setCity)

    • examples, respectively:

      • method to set the color of an object

      • method to set the size of an object

      • method to set the city that a CS15Mobiledrives in


26 of 37

Accessors and mutators 2 of 2
Accessors and Mutators (2 of 2)

  • Accessor Methods:

    • “get” methods

    • use return types but generally do not take parameters

    • exist primarily to return information to the calling method

    • names usually start with get (getColor, getSize, getCity)

    • examples, respectively:

      • method that returns the color of an object

      • method that returns the size of an object

      • method that returns the city that a CS15Mobile drives in

  • Accessors and Mutators often occur in pairs

    //setColor(…) in CS15Mobile is a mutator!

    public void setColor(java.awt.ColornewColor){

    _color = newColor;


    //getColor() in CS15Mobile is an accessor!

    public java.awt.ColorgetColor(){

    return _color;



27 of 37

Using accessors and mutators together

What if you want to geta property from one instance and use it to seta property of another instance?

For example, you want to get the current color from one instance of class CS15Mobile and use it to set the current color of another instance of class CS15Mobile

How can you do this?

Answer: use a local variable!

Using Accessors and Mutators Together

What’s a local


And why do

I need it?!?


28 of 37

Local variables
Local Variables

We’ve seen instance variables

they operate within the scope of the entire class

an instance variable that belongs to a class can be accessed anywhere in the class — within any method

they cannot be directly accessed by other classes (because they shouldn’t be public !)

A local variable is declared within a single method

the local variable’s scope is only that method

this means that the local variable can be used only within the method in which it was created

The scope of a variable determines where it can be used

instance variables can be used by all methods of a class

local variables can only be used within the method that creates them

syntactically, scope of any variable is the code between the curly braces of where it is declared

Let’s see an example...


29 of 37

Example to help you with litebrite
Example to help you with LiteBrite


* Example written to demonstrate the use of

* local variables in conjunction with accessor

* and mutator methods.


public class ContrivedExample {

private CS15Mobile _15MobileOne, _15MobileTwo;

public ContrivedExample() {

_15MobileOne = new CS15Mobile();

_15MobileTwo = new CS15Mobile();



// _15MobileOne has a blue color


public void contrivedMethod() {

java.awt.ColortempColor =

_15MobileOne.getColor(); // accessor

// tempColor: blue

_15MobileTwo.setColor(tempColor); // mutator

//_15MobileTwo now also has a blue color




30 of 37

Syntax for contrivedmethod explained
Syntax forcontrivedMethod Explained

java.awt.ColortempColor = _15MobileOne.getColor();

tempColor is a local variable

stores the return value of _15MobileOne.getColor()

no need for modifier (i.e.,private) becausetempColorcan only be used withincontrivedMethod

OncecontrivedMethodhas finished execution, the value oftempColorwill “go out of scope” — will no longer exist

you will not be able to do anything with thatjava.awt.Colorexcept incontrivedMethod

note: by CS15 convention, local variables do not begin with an underscore

You can also usenewto create local variables, for example:

CS15Mobile mobile = new CS15Mobile();

It is unnecessary to store data as an instance variable if only one method needs to use it

local variables are used to store data temporarily

example: storing intermediate data in calculations


Pass tempColor as a parameter to setColor

just like you’d pass an instance variable!

Could have alternatively written:

we refer to this technique as nesting one method call inside another

avoids storing the color in a local variable altogether



31 of 37

Methods and variable types
Methods and Variable Types

There are three kinds of variables a method can use:

local variables (created and known only within that method)

parameters (acting like local variables)

instance variables (known to all methods in the class)

When do we use which kind of variable?

depends on how we want to deal with the variable outside of the method

different kinds of variables have different levels of accessibility or scope

parameters and local variables exist only within the method

parameters are passed between methods

instance variables exist within the class and are accessible to all methods of the class

Class 1

Instance Variables

Class 2

Instance Variables

Method A

Local Variables

Method B

Local Variables

Method C

Local Variables

Method D

Local Variables



32 of 37

Lost references garbage collection
Lost References / Garbage Collection

What happens when a variable goes out of scope?

you can no longer use the variable’s name to access the instance it refers to

you lose a reference to that instance

How else can you lose a reference to an instance?

assign variable to null (no useful value)

assign variable to some other instance

What happens when there is no reference to an instance?

the instance is garbage collected — it is removed from memory by the Java Virtual Machine

to put it simply, the instance doesn’t exist anymore

So make sure you don’t lose all references to an instance -- otherwise you won’t be able to access it anymore and the instance will disappear!


33 of 37

Garbage collection example
Garbage Collection Example

package GameOfThrones;


* Example written to demonstrate garbage

* collection in Java.


public class FirstSeason{

private Character _character;

public FirstSeason () {//constructor code elided


public void makeStark() {

_character = new Character(“Ned”);


public void makeLannister() {

_character = new Character(“Joffrey”);




34 of 37

Garbage collection
Garbage Collection

When the method makeStark() is called

When the method makeLannister()is called next

The old instance of Character in _charactergets erased

(goodbye Ned, hello Joffrey!)

Garabage Collection works the same way when local variables go out of scope!



35 of 37

Parameters review
Parameters Review

Parameter passing checklist:

does the number of actual parameters equal the number of formal parameters?

does the type (class) of each actual parameter match the type of its corresponding formal parameter?

are the parameters passed in correct order?

are parameter types specified in method declaration but omitted from method call?

Multiple mechanisms for factoring information:

classes factor out common properties and methods of instances

methods use parameters to factor out values of a piece of data

Next, we’ll find out about another form of factoring:



36 of 37

September 17, 2013


  • Reminder: Clock due tomorrow at 11:59pm.

    • No late handin!

  • LiteBrite goes out today! DQ’s will be due on Saturday at 10pm. Help Session will be Sunday at 5:30pm in MacMillan 117

  • No late handins for DQs!

    • DQs must be handed in electronically. With the “cs015_handin <Project Name>” command from the terminal.

    • Only after doing this you will receive a confirmation email.

  • Complete lab 0 (Intro to Linux) and turn in your signed collaboration policy if you haven’t already!

  • Complete Lab 1 (Intro to Java) this week.

  • Remember to print out your code when going to hours. You can do this by running “cs015_print *.java” from inside the directory that has your code

  • Concept of the week coming up this week and several announcements so check the website!