Lecture Date: Wednesday, March 4
Let’s first review the method header (also called the signature):
public static int addNumbers(int a, int b)
public: This defines whether the method is visible or not in other parts of the program. For this class, all of your methods will be
static: This indicates whether the method is owned by the
class itself or by an instance of the class. So,
Math.pow(int x, int y) is
static because it is called on the class name itself, while
myTurtle.forward(50) is not
static because it is called on a particular instance of that class.
int: In this example,
int is our
return type. It is what is “given back” after the method has completed. If a method does not return anything, the type here is
addNumbers: This is the method’s name. Two methods can have the same name, if and only if they have different parameters.
(int a, int b): These are the parameters (or arguments) that are given to the method when it is called. They are typically used as input to whatever the method is executing.
Let’s consider some different types of methods:
Methods might or might not
return a value
As mentioned above, all methods have a return type - that’s the thing right before the name of the method. However, we could see a data type there that we know (like
String) or we could just see
void, like we do with
main. All methods
return - that’s what happens when they reach the end or finish by using the keyword
return. The difference is some bring back to the place where they were called some value of something. The return type listed in the method header provides.
Library methods are
The point of a library, like
Math is to provide a set of functionality with methods that you can use in your program without creating a particular object to do it. This is what it means for a method to be owned by the class, not by an instance of the object. A non-
static method is one that has to operate on a particular thing, like a specific
Scanner you created.
Some methods have effects, even if they are
println(String txt). This method is technically
void - it does not return anything. However, it does print stuff to the screen. A method can have an effect on the system even if it does not return a value. We will see this more when we consider how parameters are passed by value or passed by reference.
When you invoke a method, the following happens in order:
- A new piece of memory (called a “stack frame” or “activation record”) is created.
- The parameters of the method are created in that new memory.
- The arguments you pass in to the method invocation get copied into the new memory’s parameters in order.
- We note where we left off running the old method
- We stack the new memory on top of the old memory, covering up the old memory completely
- We start running the code in the new method’s body
When you return from a method, either with the
return keyword or by reaching the end of the body,
the new memory is removed (“popped”) from the stack, leaving us with the calling method’s memory.
We’ll do some examples of how methods get put on the stack.
(There may not be audio for this lecture.)