📓2.5: Methods that Return Values
Table of Contents
📖 This page is a condensed version of CSAwesome Topic 2.5
📝 Take notes in a Codespace during class, coding along with the instructor.
- Go to GitHub and click on your picture in the TOP RIGHT corner
- Select
Your repositories - Open
CS2-Unit-2-Notes - Now on your repository, click and select the
Codespacestab - Click
Create Codespace on main(unless you already have one listed there), wait for the environment to load, then you’re ready to code!
Methods that Return Values
All the methods on Turtle that we’ve discussed so far have had a void return type. Such methods are sometimes called void methods. Because a void method doesn’t return any value, the only point of calling one is because it does something that can be observed by the user or by other code—it changes the state of the object or maybe causes something to happen like drawing a line on the screen. Or both. These things they do are sometimes called “effects”.
In contrast, methods with a return type of anything other than void are called non-void methods. These methods return a value that the code calling the method can use. And because methods are called on an object, these methods can be used to return values that tell us things about an object’s internal state.
In well-designed programs, non-void methods typically don’t have effects; they just compute and return a value. And void methods obviously can’t return values. So most methods are of one kind or the other: either a void method which is called for some effect or a non-void method that is called to compute a value but otherwise has no effect. To put it another way, void methods do things while non-void methods produce values.
Accessors / Getters
A simple kind of method that returns a value is what is formally called an accessor because it accesses a value in an object. In the real world everyone calls them getters. A getter is a method that takes no arguments and has a non-\ void return type. In Java they are almost always named something that starts with get, and they usually just return the value of one of the object’s instance variables. For example, the Turtle class has several getters, getWidth and getHeight which return the width and the height of a Turtle object and getXPos and getYPos which return the x and y values of the Turtle\ ’s position.
That means that after you construct a Turtle, either at the default position in the middle of the World or by specifying a starting point as arguments to the constructor, you don’t need to keep track of where you put it; you can always get its current position with the getXPos and getYPos getters. Better yet, after creating a Turtle and moving it all around with the forward and turn methods we discussed in the previous section, you don’t have to figure out where it ended up; you can just ask it for its new position, again with the getXPos and getYPos getters.
Note that when you use a getter, you need to do something with the value it returns. You might assign it to a variable, use it in an expression, or print it out. If you don’t, you’re just getting a value and doing nothing with it—you might as well not have bothered to call the getter in the first place.
Here are some examples of using getters on the Turtle object yertle.
Turtle yertle = new Turtle(world);
int width = yertle.getWidth();
int height = yertle.getHeight();
System.out.println("Yertle's width is: " + width);
System.out.println("Yertle's height is: " + height);
System.out.println("Yertle's x position is: " + yertle.getXPos() );
System.out.println("Yertle's y position is: " + yertle.getYPos() );
⚠️ A common mistake is forgetting to do something with the value returned from a method. When you call a method that returns a value, you should do something with that output, like assigning it to a variable, using it in an expression, or printing it out.
Methods with Arguments and a Return Value
Since getters take no arguments, all they can do is return a value based on the current state of the object. But often it’s useful to have methods that compute values based on both the current state of the object and some arguments.
For example, while we could use a Turtle\ ’s getXPos and getYPos getters and some math (remember your Pythagorean Theorem?) to figure out how far away a Turtle is from any given point, if that’s a thing we need to do in a lot of programs using Turtle, it might be nice to be able to ask a Turtle directly for its distance from a given point. After all, it knows where it is, so why not do the math for us?
And indeed, the Turtle class has a method called getDistance that takes two int arguments representing an x value and a y value and returns the distance between the Turtle\ ’s current position and that x,y point. This is not a getter because it doesn’t just get an existing value; it computes a new value based on the arguments it is passed as well as the state of the Turtle.
Methods that take arguments and return values are somewhat like mathematical functions. Given some input, they return a value. (Mathematicians expect that a function always returns the same value, given the same arguments. So they would not consider something like getDistance(x, y) a true function since its return value also depends on the current position of the Turtle. But we’re doing programming, not math.)
We will save a deeper discussion of actually writing getters and other methods until Unit 5, but for the AP progress checks for this unit, you should be able to trace through method calls like the ones below. Notice that the return statement in a method returns the value, and it must match declared return type of the method. The calling method must then do something useful with that value.
💻 In-Class Activity
⭐️ Summary
-
Non-void methods are methods that return values (provide output).
-
Non-void methods typically do not have other effects, and are called purely to generate the value they return.
-
It is up to the caller of a non-void method to do something with the return value, such as assigning it to a variable or using it as part of an expression.
-
The value returned by a method has to match the declared return type of the method. Thus it can only be used where a value of that type is allowed, such as being assigned to a variable of that type.
🛑 When class ends, don’t forget to SAVE YOUR WORK!
- Navigate to the
Source Controlmenu on the LEFT sidebar - Click the button on the LEFT menu
- Type a brief commit message at the top of the file that opens, for example:
updated Main.java - Click the small
✔️checkmark in the TOP RIGHT corner - Click the button on the LEFT menu
- Finally you can close your Codespace!
Acknowledgement
Content on this page is adapted from Runestone Academy - Barb Ericson, Beryl Hoffman, Peter Seibel.