Methods

1
Methods
2
Complexity

• The programmer's biggest adversary is complexity
• Primitive types and the basic statements
  (assignment, while, if, etc.) are theoretically
  enough to perform any computation
• Everything else in Java is designed to organize
  actions and data in order to control complexity
• In particular, we try to organize everything into
  relatively small, independent parts, with few
  interactions among them

3
Why objects?

• Object-oriented programming models the world as a
  collection of objects
• This organization
• allows us to think about one object at a time
• allows us to use pre-written objects
• It works best when the objects are relatively
  independent, rather than deeply intertwined

4
A fruity analogy

• Programs can be like grapeseach part is complete
  in itself, and only loosely connected to the
  other parts
• Grapes are better

• Programs can be like pomegranatesall wrapped up
  together and impossible to get to one part
  without disturbing many other parts

5
Why methods?

• There are two main reasons for using methods
• Objects have behaviors, and we try to have each
  method perform one behavior
• Methods are also a way of breaking a complex
  behavior down into simpler components (Divide
  and conquer)

6
Modeling behaviors Example 1
class Animal int hunger 10 int fatigue
10 void eat() hunger-- void sleep()
fatigue 0 void hide() ...

• When you define methods, you are defining a
  vocabulary with which to talk about your problem

7
Modeling behaviors Example 2
class Document String text boolean
saved void open() ... void save()
... void edit() ...
8
Divide and conquer Example 1
class Animal ... void eat()
Food f findFood() chew(f)
swallow(f) digest(f)
9
Divide and conquer Example 2
class Document ... void open(File
inFile) String fileName
askUserForName() if (fileExists(fileNam
e)) loadFile(fileName)
saved true else
complainToUser()
10
When do you write a method?

• Write a new method
• If there is a particular behavior of an object
  that you need to implement
• Typically, methods like this are used from
  outside, to communicate something to the object
• To break a complex problem into simpler parts
• The new methods should each perform a single,
  clearly defined task
• Typically, these sub-methods are not made
  available outside the class
• To do the same thing in more than one place
• Its always a bad idea to copy code

11
Kinds of methods

• There are two kinds of methods
• instance methods (the default kind)
• Can only be executed by an individual object
• May use this
• May use class variables and class methods
• May use its own instance variables and other
  instance methods
• class methods (denoted by the keyword static)
• Executed by the class itself, not by an object
• May not use this (why not?)
• May use class variables and class methods
• May not use instance variables or instance
  methods (why not?)

12
A common error

• class Test int fudge 0 public
  static void main(String args)
  System.out.println(fudge)
• non-static variable fudge cannot be referenced
  from a static context

13
When to make a method static

• Instance methods are more capable than static
  methodsthey can access their own instance
  variables and methods, as well as class variables
  and methods
• They are intended to be used by instances
  (objects)
• Class (static) methods can only access class
  variables and methods
• They are appropriate when what you are doing does
  not depend on any particular object
• If a method never makes use of the instance
  variables or instance methods of the object, it
  should probably be static

14
Examples of static methods

• Youre tired of writing System.out.println, so
  you write this method
• static void println(String s)
  System.out.println(s)
• You want to perform a task that isnt specific to
  the individual object
• static int nextCard() return
  random.nextInt(10) 1

15
Defining a method

• A method has the syntax
• return-type method-name ( formal-parameters )
  method-variables code
• Example
• int add ( int number1, int number2 ) int
  sum number1 number2 return sum

16
Information flow

• We call a method like this
• result add( 3 , 5 )
• int add ( int number1, int number2 ) int
  sum number1 number2 return sum

17
Formal parameters

• int add ( int number1, int number2 ) int
  sum number1 number2 return sum
• When you enter a method, the formal parameters
  are created and assigned initial values
• You must specify the types of the formal
  parameters
• The formal parameters are variables that you can
  use however you like
• When the method returns, the formal parameters
  are discarded

18
Method variables

• int add ( int number1, int number2 ) int
  sum number1 number2 return sum
• Within a method, you may create additional
  variables
• You can use these variables within the method
• When the method returns, the variables are
  discarded
• Formal parameters get their values from
  outside, method variables are created inside,
  but they are otherwise alike

19
Primitive parameters are copied in

• int m 3int n 5result add( m , n )
• int add ( int number1 , int number2 ) while
  (number1 gt 0) number1--
  number2 return number2

This is call by value
20
Objects are different

• Person p new Person("John")

21
Object references are copied in

• Person p new Person("John")changeName( p
  )
• void changeName(Person per ) per.name
  "Jack"

"Jack"
per.name "Jack"
This means that p and per refer to the same
object!
p is not changed, but changes made to the
object referenced by per remain changed when the
method returns.
This is call by reference
22
Assignments

• When using a method, values are assigned to the
  formal parameters
• Normal assignment statements work the same way
• int m 5int nn m // the value 5 is
  copied from m to n
• Person p1 new Person("John")Person p2p2
  p1 // the reference is copied from p1 to p2
• Hence, p1 and p2 are different names for the same
  Person changes made to one change the other

23
Object references are copied in

• Person p new Person("John")changeName( p
  )
• void changeName(Person per ) per.name
  "Jack" per new Person("Mary")

Changes made to the object referenced by per
remain changed when the method returns.
But changes to per itself are not copied back
p still refers to the Jack object
This is call by reference
24
Using instance methods I

• You dont call a method, you send a message to an
  object
• Suppose I know about an object john that is an
  instance of class Person
• Suppose further that the Person class has an
  instance method goAway()
• I can tell john to go away like this
  john.goAway()
• Notice that I say who Im talking to, and what
  message I want to convey
• This is always the form the object, a dot, then
  the message

25
Using instance methods II

• Suppose I want to tell john to read a book
• I also need to say which book
• This is additional information
• Additional information is provided by actual
  parameters
• I can do this john.readBook("Moby Dick")
• The form is object . message (actual-parameters)
  
• Suppose I want to tell john to kiss someone
• I can do this john.kiss(mary)
• Is mary affected by this?
• Yes! A reference to the mary object is passed to
  kiss

26
Using instance methods III

• Suppose I want to tell myself to do something
• (Im pretending to be an object of type Person)
• I refer to myself by using the keyword this
• I can talk to myself like this
• this.readBook("Mirror Dance")
• Or, as a convenience, I can leave out the
  explicit reference to myself
• readBook("Mirror Dance")
• That is, any object can use its own methods and
  variables (the ones declared by its class)
  without explicitly naming itself

27
Using class methods I

• If a method is a class method, any object of that
  class can refer to it directly, without using
  this
• Example
• class DumbExample static void
  println(String s) // class method
  System.out.println(s)
• void doSomething( ) // instance method,
  ... // in the
  same class println("I did it!")
  

28
Using class methods II

• To use a class method from outside the class, you
  can send a message to the class
• Examples
• x Math.abs(y)
• DumbExample.println("I can do it too")
• System.out.println("So that's what this means!")

29
Vocabulary

• instance method a method that can only be
  executed by objects (instances) of a class
• class method a method that can be executed by
  the class itself
• actual parameter a value given to a method
• formal parameter a variable used by a method to
  refer to the value it has been given
• call by value to copy the value of an actual
  parameter into a formal parameter
• call by reference to copy the reference to an
  object from the actual parameter into the formal
  parameter

30
The End