Return Values, Composition, and Incremental Development

1. Return Values, Composition, and Incremental Development

Title

Think Java 2e · Chapter 4 · Methods and Testing

Sections 4.6-4.9 · pp. 58-64

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 4 (Methods and Testing), Sections 4.6-4.9, pp. 58-64. Everything on these slides can be checked against those pages.

1. Use Math methods and constants, and say why PI has no parentheses.

2. Compose method calls, passing one call's result as another's argument.

3. Recognise the 'cannot find symbol' error caused by omitting a class name.

4. Write a value-returning method: declare a return type and use a return statement.

5. Develop a method incrementally from a stub, checking intermediate values as you go.

6. Explain what scaffolding is and why you remove it.

• 4.6 — Math Methods
• 4.7 — Composition
• 4.8 — Return Values
• 4.9 — Incremental Development

3. Retrieve before you read

Warm-up

One idea from the previous lesson, because this one removes its main limitation.

4. Methods that hand something back

Concept

Every method you have written so far was void. This lesson replaces that word with a real type, so a method can compute a value and give it to whoever called it — which is what makes methods composable.

• 4.6 — the Math class: methods and constants you did not have to write
• 4.7 — composition: one call's result as another's argument
• 4.8 — return values: declaring a return type and returning
• 4.9 — incremental development, stubs and scaffolding

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 4 (Methods and Testing), Sections 4.6-4.9, pp. 58-64 — Sections 4.6-4.9, printed pages 58-64.

5. Math methods and constants

Section

Section 4.6

6. You do not always have to write the method

Concept

The Java library contains thousands of classes you can use. The Math class provides common mathematical operations — and because it is in java.lang, you do not have to import it.

double root = Math.sqrt(17.0);

double angle = 1.5;
double height = Math.sin(angle);

double degrees = 90;
double radians = degrees / 180.0 * Math.PI;

Values for the trigonometric functions — sin, cos and tan — must be in radians. That is the single most common source of wrong answers when people first use the Math class.

7. A constant is not a method

Notation

Math.PI and Math.sqrt look similar and behave completely differently. The parentheses are the tell, as they were in Lesson 3a.

The habit worth forming: take a minute to read the documentation for a class before using it. The easiest way to find it is a web search for Java and the class name.

8. Converting degrees to radians, two ways

Worked example

Do the conversion by hand first, then with the library method, and check they agree. Checking a library call against something you computed yourself is a habit worth keeping.

double degrees = 90;
double byHand = degrees / 180.0 * Math.PI;
double byLibrary = Math.toRadians(degrees);
System.out.println(byHand);
System.out.println(byLibrary);

9. Which of these will not compile?

Elimination

One of these treats a constant as a method.

10. int, long, and how big a number can get

Concept

Math.round returns a long, which is a type you have not met. It is worth knowing what it is and why it exists.

long x = Math.round(Math.PI * 20.0);   // 63, rounded up from 62.8319

Note the contrast with Lesson 3b: a (int) cast truncates toward zero, so (int) 62.83 would be 62. Math.round rounds to the nearest, giving 63. Two different operations, and choosing between them is a decision you should make deliberately.

11. Passing degrees to a trigonometric method

Trap

System.out.println(Math.sin(90));

System.out.println(Math.sin(Math.toRadians(90)));   // 1.0

// or by hand:
System.out.println(Math.sin(90 / 180.0 * Math.PI));

12. Which is bigger, round or a cast?

Prediction

The same value, two ways of making it a whole number.

double d = 2.7;
System.out.println((int) d);
System.out.println(Math.round(d));

13. Match the Math member to what it gives

Matching

Two constants and two methods.

14. Why does Math.round return a long?

Socratic

It could have returned an int. Ask why it does not.

15. Composition

Section

Section 4.7

16. A method call is an expression

Concept

You have learned to evaluate expressions like the sine of pi over two: first evaluate the argument, then the function itself. Java methods compose the same way — you can use any expression as an argument, as long as its value has the right type.

double x = Math.cos(angle + Math.PI / 2.0);

double y = Math.exp(Math.log(10.0));

double z = Math.pow(2.0, 10.0);   // 1024.0

In Java the log method always uses base e. Some Math methods take more than one argument: Math.pow raises its first argument to the power of its second.

17. Evaluating a nested call from the inside out

Picture it

Exactly the process you use for the logarithm of one over the sine of pi over two: evaluate the innermost argument, then the function around it, and repeat.

That last value is worth a comment: the cosine of pi over two is exactly zero mathematically, and Java gives a number around 10 to the minus 17. That is Lesson 2b's rounding error, appearing exactly where you were told to expect it.

18. Passing one method's result to another

Worked example

You can take the result of one method and pass it straight to another. Trace what happens, and in what order.

double x = Math.exp(Math.log(10.0));

19. Order the evaluation

Ranking

For Math.sqrt(Math.pow(3.0, 2.0) + Math.pow(4.0, 2.0)).

20. Forgetting the class name

Concept

When using Math methods, beginners often leave off the word Math. The resulting error message is confusing until you know what it is telling you.

double x = pow(2.0, 10.0);   // no Math.

The last two lines are the useful hint. If you do not specify a class name when referring to a method, the compiler looks in the current class by default — so it searched Test.java for a pow method and found none. Writing Math.pow tells it where to look.

21. cannot find symbol, for two different reasons

Trap

double x = pow(2.0, 10.0);    // forgot the class name
Scanner in = new Scanner(System.in);   // forgot the import

double x = Math.pow(2.0, 10.0);   // class name supplied

import java.util.Scanner;         // at the top of the file
Scanner in = new Scanner(System.in);

22. What is the error?

Prediction

One word is missing.

double x = sqrt(16.0);

23. Compose two calls

Fill the middle

Compute the square root of 2 raised to the 10th power.

24. Why can a method call be an argument?

Explain it to yourself

State the rule that makes composition possible.

25. Return values

Section

Section 4.8

26. Declare a return type and return a value

Concept

When you invoke a void method, the invocation is usually on a line by itself. When you invoke a value-returning method, you have to do something with the result — assign it to a variable, or use it as part of an expression.

public static double calculateArea(double radius) {
    double result = Math.PI * radius * radius;
    return result;
}

The last line is a new form of the return statement meaning return immediately from this method, and use the following expression as the return value.

27. A value in, a value out

Picture it

When main invokes calculateArea, the value 5.0 is assigned to the parameter radius; calculateArea then returns 78.54, which is assigned to the variable area.

Two crossings of the boundary, in opposite directions. The argument goes down into the new frame as a parameter; the return value comes back up. Nothing else passes between them.

28. Writing calculateArea two ways

Worked example

The expression you return can be arbitrarily complex, so the method can be written more concisely. Both versions are correct, and the choice is about debugging.

// with a temporary variable
public static double calculateArea(double radius) {
    double result = Math.PI * radius * radius;
    return result;
}

// more concisely
public static double calculateArea(double radius) {
    return Math.PI * radius * radius;
}

29. void or value-returning?

Discrimination

Decide from what the method is for, before looking at any code.

30. The return type is a promise

Concept

When you declare that the return type is double, you are making a promise that this method will eventually produce a double value. The compiler holds you to it.

The type of the expression in the return statement must match the return type of the method itself. This is the same bargain as declaring a variable's type: you say what will be there, and the compiler checks every place it could go wrong.

31. Calling a value-returning method and ignoring the result

Trap

double radius = 5.0;
calculateArea(radius);            // the value is computed and thrown away
System.out.println(radius);       // still 5.0 — nothing changed

double radius = 5.0;
double area = calculateArea(radius);        // caught in a variable
System.out.println(area);

System.out.println(calculateArea(3.0) * 2); // used in an expression

32. What does this print?

Prediction

Watch what the caller does with the result.

public static int doubled(int n) {
    return n * 2;
}

public static void main(String[] args) {
    int x = 5;
    doubled(x);
    System.out.println(x);
}

33. Write a value-returning method

Fill the middle

A method that returns the larger of two integers is not possible yet — but the square is.

34. What is missing from this method?

Missing information

It declares a return type but the compiler rejects it.

35. Incremental development

Section

Section 4.9

36. Start with a working program and change it a little

Concept

People often make the mistake of writing a lot of code before they try to compile and run it — and then spend far too long debugging. A better approach is incremental development.

• Start with a working program and make small, incremental changes. At any point, if there is an error, you will know where to look.
• Use variables to hold intermediate values so you can check them, with print statements or a debugger.
• Once the program is working, you can consolidate multiple statements into compound expressions — but only if it does not make the program harder to read.

This is the same principle Section 1.9 gave for debugging, applied to writing rather than to fixing. It is also how Linux began, as a program that switched between printing AAAA and BBBB.

37. A stub is a method that compiles and does nothing

Notation

The first step is to decide what the method's inputs and output are, and write the header with a placeholder body.

The header is the hard part and the body is the easy part. Getting the inputs and output right first is what makes the rest mechanical.

38. Choosing a test case with a known answer

Worked example

To test the method we invoke it from main with sample values. The values are not arbitrary — they are chosen so that you already know the right answer.

double dist = distance(1.0, 2.0, 4.0, 6.0);
// horizontal distance 3.0, vertical distance 4.0
// so the answer should be 5.0

39. Order the incremental steps

Ranking

Building the distance method, from nothing to finished.

40. Scaffolding: code that helps you build and then goes

Concept

The print statements you add to check intermediate values are useful while you are building and are not part of the finished method. Think Java calls them scaffolding.

public static double distance
        (double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    System.out.println("dx is " + dx);      // scaffolding
    System.out.println("dy is " + dy);      // scaffolding
    return 0.0;    // stub
}

The name is exact: scaffolding is helpful for building the program but is not part of the final product. Leaving it in is not harmless — it clutters the output and confuses anyone who reads the method later.

41. Writing the whole method before compiling

Trap

// write all of it
// compile
// 6 errors, in 4 different lines
// fix one, recompile, 5 errors
// ...

// stub          -> compile, run           (finds header errors)
// add dx, dy    -> compile, run, print   (should be 3.0 and 4.0)
// add dsquared  -> compile, run, print   (should be 25.0)
// add sqrt      -> compile, run          (should be 5.0)

42. Why compile a stub that does nothing?

Prediction

It returns 0.0 and computes nothing. It seems like a wasted step.

43. Which lines are scaffolding?

Error analysis

A method part-way through development. Decide what stays and what goes.

Removing scaffolding is a real step, not tidying. A method that prints while computing cannot be used inside a larger program without spraying output everywhere.

44. Develop a method incrementally, on paper

Constraint

Practise the method itself rather than the example.

45. Building distance, step by step

Section

Section 4.9, continued

46. The finished method, and how it was reached

Concept

Here is the completed method. Nothing in it is complicated — the point of the section is that it was never written in this form. It was grown, one checked line at a time.

public static double distance
        (double x1, double y1, double x2, double y2) {
    double dx = x2 - x1;
    double dy = y2 - y1;
    double dsquared = dx * dx + dy * dy;
    double result = Math.sqrt(dsquared);
    return result;
}

Each line was compiled and run before the next was added. At no point was there more than one line of unverified code in the method.

47. Four versions of one method

Picture it

The same method at each stage. What grows is the body; what stays constant is that it compiles and runs at every step.

The left version is worth more than it looks. It proves the header is right, which is where most of the syntax errors in a new method live.

48. Tracing distance with the test case

Worked example

Run the finished method by hand on the values chosen earlier, checking each intermediate against what was predicted.

double dist = distance(1.0, 2.0, 4.0, 6.0);

49. Which intermediate would reveal a missing square root?

Prediction

Suppose the method returned dsquared instead of its square root.

double dx = x2 - x1;        // 3.0
double dy = y2 - y1;        // 4.0
double dsquared = dx * dx + dy * dy;
return dsquared;            // the bug

50. When to take bigger steps

Concept

Incremental development is a dial rather than a rule. The right step size depends on how confident you are, and there is a simple feedback signal for adjusting it.

Think Java's own phrasing: as you gain more experience programming, you might write and debug more than one line at a time. But if you find yourself spending a lot of time debugging, consider taking smaller steps. The amount of time you spend debugging is the signal telling you to adjust.

51. Testing with values whose answer you do not know

Trap

double d = distance(1.7, 2.3, 5.1, 8.8);
System.out.println(d);   // 7.457881...  is that right?

double d = distance(1.0, 2.0, 4.0, 6.0);
System.out.println(d);   // must be exactly 5.0

52. Test case: useful or not?

Definition probe

A test is useful only if you know what it should produce.

53. Watch the method grow

Scale up

Four stages, each one compiled and run before the next.

The first. That is the whole argument for compiling a stub that does nothing: it verifies the part of the method that everything else depends on, while there is almost nothing to search.

54. Where else does 'always keep it working' appear?

Real world

Incremental development is not just advice for beginners. It has a name in professional practice.

55. void methods and value-returning methods

Comparison

The two kinds, side by side. Fill the blanks.

The fourth row is the practical difference. A void method is a dead end; a value-returning one can be built into something larger, which is what makes a program more than a list of actions.

56. The pattern to carry away

Pattern

Developing any new method follows the same four stages, and the discipline is worth more than any individual piece of Java in this chapter.

// 1. header: what goes in, what comes out
public static double average(double a, double b, double c) {
    return 0.0;                      // stub - compile it now
}

// 2. test case with a KNOWN answer
double x = average(2.0, 4.0, 6.0);   // must be 4.0

// 3. one step at a time, checking intermediates
double sum = a + b + c;              // print it: expect 12.0

// 4. finish, then remove the scaffolding
return sum / 3.0;

• A constant has no parentheses; a method does.
• A value-returning method call is an expression, so it can go anywhere a value can.
• The return type is a promise the compiler holds you to at both ends.
• Never let the amount of unverified code get large.

57. Check: return values

Check

Work it out before you click.

public static int addTen(int n) {
    return n + 10;
}

public static void main(String[] args) {
    int a = 5;
    int b = addTen(a);
    System.out.println(a + " " + b);
}

58. Check: Math methods

Check

Work it out before you click.

59. Check: incremental development

Check

Work it out before you click.

60. Why library methods are worth finding

Real world

You could have written toRadians yourself in one line. There are reasons to look for the library version first.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, out loud.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Four sections that complete the chapter: methods you did not write, methods that hand a value back, and the discipline for building them without ever debugging much at once.

• The Math class gives you sqrt, sin, pow, round, toRadians and more — and it needs no import.
• Constants have no parentheses: Math.PI, not Math.PI().
• Trigonometric methods take radians, which is a silent source of wrong answers.
• Math.round rounds to the nearest and returns a long; a cast truncates toward zero.
• A value-returning call is an expression, so calls compose — innermost first.
• Omitting the class name gives cannot find symbol, because the compiler searches your own class.
• A value-returning method declares a return type and uses a return statement, and the caller must use the result.
• Develop incrementally: stub, test case with a known answer, one checked step at a time, then remove the scaffolding.