Class Diagrams, Scope, Garbage Collection, and StringBuilder

1. Class Diagrams, Scope, Garbage Collection, and StringBuilder

Title

Think Java 2e · Chapter 10 · Mutable Objects

Sections 10.6-10.11 · pp. 173-179

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 10 (Mutable Objects), Sections 10.6-10.11, pp. 173-179. Everything on these slides can be checked against those pages.

1. Locate and skim the Java library source, and say what most of Point.java consists of.

2. Read and draw a UML class diagram, including the public and private markers.

3. Distinguish parameters, local variables and attributes by when they are created and where they can be used.

4. Explain the order in which the compiler resolves a variable name.

5. Say when an object becomes eligible for garbage collection.

6. Choose between String and StringBuilder, and explain the cost of concatenating in a loop.

• 10.6 — Java Library Source
• 10.7 — Class Diagrams
• 10.8 — Scope Revisited
• 10.9 — Garbage Collection
• 10.10 — Mutable vs Immutable
• 10.11 — StringBuilder Objects

3. Retrieve before you read

Warm-up

One idea from Chapter 4 and one from Chapter 9, both about to be extended.

4. Looking at classes from the outside and the inside

Concept

The previous lesson used Point and Rectangle. This one looks at how they are described — as a diagram, as source code, and in terms of what lives how long.

• 10.6 — the Java library source, and what it looks like
• 10.7 — UML class diagrams
• 10.8 — scope: parameters, locals and attributes
• 10.9 — garbage collection
• 10.10-10.11 — mutable against immutable, and StringBuilder

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 10 (Mutable Objects), Sections 10.6-10.11, pp. 173-179 — Sections 10.6-10.11, printed pages 173-179.

5. The Java library source

Section

Section 10.6

6. The library is written in Java, and you can read it

Concept

So far you have used several classes from the Java library — System, String, Scanner, Math and Random. These classes are written in Java, so you can read the source code to see how they work.

// the library source ships as a ZIP archive named src.zip
// Linux:    /usr/lib/jvm/.../lib
// macOS:    /Library/Java/JavaVirtualMachines/.../Contents/Home/lib
// Windows:  C:\Program Files\Java\...\lib

The library contains thousands of files, many of them thousands of lines long — that is more than one person could read and understand fully, but do not be intimidated. You are skimming, not auditing.

7. What Point.java actually contains

Notation

Open it and skim. It uses language features you have not met, and the proportions are the interesting part.

Appendix B covers Javadoc properly. The point here is simply that the library is not a black box: it is Java, written by people, and you can look.

8. Reading a method you already use

Worked example

Compare your own moveRect from Lesson 10a with the library's translate. Both move a rectangle, and one of them is much longer.

// yours, from Lesson 10a
public static void moveRect(Rectangle box, int dx, int dy) {
    box.x = box.x + dx;
    box.y = box.y + dy;
}

// the library's, in outline
public void translate(int dx, int dy) {
    int oldv = this.x;
    int newv = oldv + dx;
    if (dx < 0) {
        ...           // overflow handling
    }
    ...
}

9. What is most of Point.java?

Prediction

Open it and look at the proportions.

10. Documentation as part of the source

Concept

The comments in Point.java are not ordinary // comments. They start with /** and carry structured tags, and a tool turns them into the documentation you have been reading online.

You saw a doc comment in Lesson 3b's Convert program without a name for it. Appendix B is entirely about this, and the practical consequence is that the documentation you look up and the comments in the source are the same words — which is why library documentation is usually accurate.

11. Assuming a library method is simple because its job is

Trap

// "I'll just write my own instead of importing Rectangle"
public static void grow(Rectangle r, int h, int v) {
    r.x = r.x - h;
    r.y = r.y - v;
    r.width = r.width + 2 * h;
    r.height = r.height + 2 * v;
}

box.grow(50, 50);       // tested, documented, handles the edges

12. Where would you find each class?

Definition probe

The folders inside src.zip correspond to packages.

13. Why is the library open to read?

Real world

It could have shipped as compiled byte code only.

14. What does 'more than you may have expected' mean?

Explain it to yourself

Think Java's comment about grow and translate.

15. Class diagrams

Section

Section 10.7

16. A box with attributes and methods

Concept

Point and Rectangle objects have attributes and methods — attributes are an object's data, methods are its code. An object's class definition specifies which it has, and UML defines a graphical way to summarise that.

UML — Unified Modeling Language, a standard way to draw diagrams for software engineering.

class diagram — An illustration of the attributes and methods for a class.

Each class is a box with the name of the class, a list of attributes, and a list of methods. Both Point and Rectangle have additional methods; the diagram shows only the ones introduced in this chapter.

17. Reading the notation

Notation

Three conventions, and the first one catches Java programmers out because it is deliberately not Java.

That last distinction is the important one. A memory diagram shows these particular objects, right now; a class diagram shows what any object of this class has.

18. Drawing Rectangle

Worked example

Four attributes and two methods, using the conventions above.

// From the chapter:
//   attributes: x, y, width, height   - all int, all public
//   methods:    translate(int, int)
//               grow(int, int)

19. What does the plus sign mean?

Prediction

UML visibility markers.

Point
+ x: int
+ y: int

20. Class diagrams and memory diagrams

Concept

The two kinds of diagram in this book answer different questions, and confusing them is a common early mistake.

The third row is the clearest test. A program with fifty Rectangles has fifty boxes in its memory diagram and still one in its class diagram — because there is only one Rectangle class.

21. Drawing values in a class diagram

Trap

// wrong - this is a memory diagram wearing a class diagram's clothes
Rectangle
------------------
+ x = 0
+ y = 0
+ width = 100
+ height = 200

// class diagram: what every Rectangle has
Rectangle
+ x: int
+ width: int

// memory diagram: what this one holds
box ---> Rectangle [ x = 0, width = 100 ]

22. Class diagram or memory diagram?

Discrimination

Which question is being asked?

23. Write a UML attribute line

Fill the middle

A public int attribute called height.

24. What can a class diagram not tell you?

Counterexample

It summarises a class completely, in one sense.

25. Scope revisited

Section

Section 10.8

26. Three kinds of variable

Concept

Section 4.5 introduced the idea that variables have scope — the part of a program where a variable can be used. The library's Rectangle.translate uses all three kinds at once.

public void translate(int dx, int dy) {
    int oldv = this.x;
    int newv = oldv + dx;
    if (dx < 0) {
        ...

Parameters and local variables are created when a method is invoked and disappear when it returns. They can be used anywhere inside the method, but not in other methods and not in other classes.

27. Two lifetimes, side by side

Picture it

A frame lives from call to return. An object lives as long as something refers to it. Those are different clocks.

Attributes are created when an object is created and disappear when the object is destroyed. They can be used in any of the object's methods using the keyword this — and if they are public, in other classes via a reference, as box1.x.

28. How the compiler resolves a name

Worked example

When the Java compiler encounters a variable name, it searches backward for its declaration — and the order it searches in is fixed.

public void translate(int dx, int dy) {
    int oldv = this.x;
    int newv = oldv + dx;
    ...
}

29. Which kind of variable?

Definition probe

Where it is declared decides what it is.

30. What this means

Concept

this is a reference to the object the method was invoked on. It is the missing piece that connects Lesson 10a's box.translate(50, 100) to the method's body.

box.translate(50, 100);

// inside translate:
//   this   refers to the object box refers to
//   this.x is that object's x attribute
//   dx     is 50

This is why invoking a method on an object works at all: the object comes in as this, without appearing in the parameter list. Chapter 11 makes this central when you write your own classes; for now it is enough to read it as the object this method was called on.

31. Expecting a local variable to persist

Trap

public void translate(int dx, int dy) {
    int oldv = this.x;      // local
    this.x = oldv + dx;
}
// oldv is gone the moment translate returns.
// Nothing outside can see it, and the next call gets a fresh one.

// a value needed only during this call  -> local variable
int oldv = this.x;

// a value the object must keep              -> attribute
this.x = oldv + dx;

32. Order the compiler's search

Ranking

When it meets a bare variable name.

33. Which x does this refer to?

Prediction

A local variable shares a name with an attribute.

public void shift(int dx) {
    int x = 100;          // a local variable
    this.x = x + dx;      // which x is which?
}

34. Why does the library write this.x?

Explain it to yourself

Inside a method, a bare x would usually find the attribute anyway.

35. Garbage collection

Section

Section 10.9

36. When does an object cease to exist?

Concept

Attributes exist as long as the object exists. But when does an object stop existing? The answer is: when nothing refers to it any more.

Point blank = new Point(3, 4);
blank = null;

garbage collection — The process of finding objects that have no references and reclaiming their storage space.

The first line creates a Point and makes blank refer to it. The second changes blank so that instead of referring to the object, it refers to nothing. After the second assignment there are no references to the Point object.

37. An object nobody can reach

Picture it

The object is still in memory, taking up space. From the program's point of view it has ceased to exist.

If there are no references to an object, there is no way to access its attributes or invoke a method on it. As the program runs, the system automatically looks for such stranded objects and deletes them, so the space can be reused.

38. Three ways an object becomes garbage

Worked example

Setting a variable to null is the clearest case and the rarest. Objects usually become unreachable for one of two other reasons.

// 1. the reference is overwritten
Point p = new Point(3, 4);
p = new Point(5, 6);          // the first Point is now garbage

// 2. the reference goes out of scope
public static void f() {
    Point q = new Point(1, 2);
}                             // q disappears; the Point is garbage

// 3. explicitly, with null
Point r = new Point(7, 8);
r = null;

39. Is the first Point garbage?

Prediction

The reference is overwritten.

Point p = new Point(3, 4);
p = new Point(5, 6);

40. Why this is worth having

Concept

In languages without garbage collection, the programmer frees memory explicitly — and the two ways of getting that wrong are both serious.

Java removes an entire category of bug by taking the decision away from you. The cost is the occasional pause while collection runs, and less control over exactly when memory is reclaimed — which is why some systems still use languages that make you do it by hand.

41. Thinking null deletes the object

Trap

Point a = new Point(3, 4);
Point b = a;
a = null;

System.out.println(b.x);      // still 3

Point a = new Point(3, 4);
Point b = a;
a = null;
b = null;                     // now it is unreachable

42. Reachable or garbage?

Definition probe

Count the references to the object.

43. Do you have to free objects yourself?

Prediction

Java's answer differs from some other languages'.

44. When would you notice garbage collection?

Edge cases

It is meant to be invisible. Sometimes it is not.

45. Mutable, immutable, and StringBuilder

Section

Sections 10.10-10.11

46. Two designs, each with advantages

Concept

Points and Rectangles are mutable because their attributes can be modified — directly, like box.x = 15, or through methods like box.translate(15, 0). Strings and Integers are immutable: they allow no direct access to their attributes and provide no methods that change them.

Neither design is always better, which is why you will see both. Knowing which kind of object you hold is what matters.

47. The surprise that immutability makes possible

Notation

Because strings cannot change, the compiler is allowed to share them — with a result that contradicts Lesson 6b's advice.

A rule that works only in the cases you happen to test is worse than no rule. This example explains why == sometimes appears to work, which is exactly the knowledge that stops you relying on it.

48. Where immutability becomes expensive

Worked example

Building a long string by concatenating many small pieces is the case where mutable objects are both more efficient and arguably more natural.

String text = "";
for (int i = 0; i < 10; i++) {
    String line = in.nextLine();      // new string
    text = text + line + '\n';        // two more strings
}
System.out.print("You entered:\n" + text);

49. How many String objects does this loop create?

Prediction

Count per iteration, then multiply.

String text = "";
for (int i = 0; i < 10; i++) {
    String line = in.nextLine();      // new string
    text = text + line + '\n';        // two more strings
}
System.out.print("You entered:\n" + text);

50. StringBuilder: a mutable string

Concept

The Java library provides the StringBuilder class for exactly this reason. Because StringBuilder objects are mutable, they can implement concatenation far more efficiently.

StringBuilder text = new StringBuilder();
for (int i = 0; i < 10; i++) {
    String line = in.nextLine();
    text.append(line);
    text.append('\n');
}
System.out.print("You entered:\n" + text);

The append method takes a String and appends it to the end of the StringBuilder. Each time it is invoked, it modifies the StringBuilder; it does not create any new objects. If you need the result as a String, call toString(). Programs that manipulate large amounts of text run much faster with StringBuilder than with String.

51. Concatenating in a loop

Trap

String result = "";
for (int i = 0; i < n; i++) {
    result = result + something;      // copies everything so far
}

StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) {
    sb.append(something);             // modifies in place
}
String result = sb.toString();

52. String or StringBuilder?

Definition probe

The deciding question is how many pieces, and whether it is in a loop.

53. Does append create a new object?

Prediction

StringBuilder is mutable.

StringBuilder sb = new StringBuilder();
sb.append("hello");
System.out.println(sb);

54. Mutable against immutable

Trade off

Fill the blanks from Sections 10.10 and 10.11.

Read across the last row: whether you have to assign a method's result is a reliable signal of which kind of object you are holding. It is the practical form of the whole distinction.

55. Three lifetimes

Comparison

This lesson introduced a third clock. Fill the blanks.

The bottom-right cell is the one that makes aliasing possible, and the one garbage collection is about: an object's life is decided by references, not by scope.

56. The pattern to carry away

Pattern

Two questions answer most of what this lesson covered, and both are about lifetime.

// how long must this value live?
int oldv = this.x;      // one method call    -> local variable
this.x = newv;          // as long as the object -> attribute

// how many pieces am I joining?
String s = "Total: " + n;              // a couple -> concatenation

StringBuilder sb = new StringBuilder(); // many, in a loop
for (...) { sb.append(piece); }         // -> StringBuilder
String result = sb.toString();

• The compiler resolves names locals, then parameters, then attributes — so this.x removes all doubt.
• An object is garbage when its last reference goes, not when one variable is set to null.
• A class diagram shows types; a memory diagram shows values.
• Concatenating in a loop is quadratic — use StringBuilder.

57. Check: scope

Check

Work it out before you click.

public void shift(int dx) {
    int temp = this.x;
    this.x = temp + dx;
}

58. Check: garbage collection

Check

Work it out before you click.

Point a = new Point(1, 2);
Point b = a;
a = null;

59. Check: StringBuilder

Check

Work it out before you click.

StringBuilder sb = new StringBuilder();
sb.append("a");
sb.append("b");
System.out.println(sb);

60. Why the same question keeps coming back

Real world

Mutable or immutable is not a Java detail. It is one of the recurring design questions in programming.

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

Six sections that step back from using objects to describing them — how they are documented, drawn, scoped, and reclaimed.

• The Java library is written in Java, ships its source in src.zip, and is mostly documentation.
• A UML class diagram shows a class's attributes and methods, with + for public and - for private.
• A class diagram is compile-time; a memory diagram is run-time — types against values.
• Three kinds of variable: parameters and locals live with the frame; attributes live with the object.
• The compiler searches locals, then parameters, then attributes — so this.x removes any doubt.
• this refers to the object a method was invoked on, which is how box.translate(...) reaches box's data.
• An object is garbage when nothing refers to it, and Java reclaims it automatically.
• Immutable objects are safe to share; mutable ones are efficient to change — and StringBuilder exists because concatenating in a loop is quadratic.