{"id":"class-diagrams-methods","slug":"methods","title":"Constructors and methods in a box","text":"A box has room for more than fields. Under a second line come the class's constructors and methods. Here's the recycling center's bin with them:\n\n\n
\n\n
The diagram as text
Bin, a class
private field material: String
private field capacity: int
private field load: int
public constructor Bin(material: String, capacity: int)
public method getMaterial(): String
public method add(kilos: int): boolean
public method empty(): void
public method toString(): String
\n\n\n- A **constructor** is the class's name with its parameters in parentheses, and nothing after them: a constructor has no return type, in a diagram as in Java.\n- A **method** is its name, its parameters in parentheses, a colon and its **return type**: `getMaterial(): String` returns a String. A method that returns nothing has `void`.\n- Each **parameter** is written like a field, name first: `add(kilos: int)` takes an int called `kilos`. Parameters are separated by commas, and a method without parameters has empty parentheses.\n- The sign in front is the visibility again. Constructors and methods that other classes call are public, `+`. A private helper method gets a `-`.\n- Constructors come first, then methods.\n\nSo each line gives you a header:\n\n| In the box | In Java |\n|---|---|\n| `+Bin(material: String, capacity: int)` | `public Bin(String material, int capacity)` |\n| `+getMaterial(): String` | `public String getMaterial()` |\n| `+add(kilos: int): boolean` | `public boolean add(int kilos)` |\n| `+empty(): void` | `public void empty()` |\n\n`toString` is one of Bin's methods, so it has a line too. `@Override` isn't shown: a box shows headers, and nothing above them or inside them.\n\n### What a box doesn't say\n\nThe box gives every header, but not what the methods do. Does `add` refuse a load that doesn't fit? What does `toString` return? A diagram leaves that to the code, or, before the code exists, to words. The team that drew this box agreed that a new bin is empty, that `add` puts the load in and returns `true` only if the bin's load stays within its capacity (otherwise it changes nothing and returns `false`), and that `empty` sets the load back to 0. With those words and the box, the class almost writes itself:\n\n```java\npublic class Main {\n public static void main(String[] args) {\n Bin glass = new Bin(\"glass\", 500);\n System.out.println(glass.add(300));\n System.out.println(glass.add(250));\n System.out.println(glass);\n glass.empty();\n System.out.println(glass.add(250) + \" \" + glass.getMaterial());\n }\n}\n// ==== Bin.java ====\npublic class Bin {\n private String material;\n private int capacity;\n private int load;\n\n public Bin(String material, int capacity) {\n this.material = material;\n this.capacity = capacity;\n this.load = 0;\n }\n\n public String getMaterial() {\n return this.material;\n }\n\n public boolean add(int kilos) {\n if (this.load + kilos > this.capacity) {\n return false;\n }\n this.load += kilos;\n return true;\n }\n\n public void empty() {\n this.load = 0;\n }\n\n @Override\n public String toString() {\n return this.material + \": \" + this.load + \"/\" + this.capacity + \" kg\";\n }\n}\n```\n\n```output\ntrue\nfalse\nglass: 300/500 kg\ntrue glass\n```\n\nThe challenges in this module work the same way: a box, and words that say what the methods do. Follow the box's headers exactly. Other classes call the methods by those names, with those types, and a header that's different can make their calls fail to compile, or quietly change what they compute.\n","task":"The ward gives each of its beds an object. Write the class `Bed` in `Bed.java`, as this box shows:\n\n\n
\n\n
The diagram as text
Bed, a class
private field number: int
private field patient: String
public constructor Bed(number: int)
public method isFree(): boolean
public method assign(name: String): void
public method release(): void
public method toString(): String
\n\n\n- A new bed is free: its patient is `null`.\n- `assign` puts the patient's name in the bed, and `release` makes the bed free again.\n- `isFree` says whether the bed is free.\n- `toString` returns `Bed 4: free` for a free bed and `Bed 4: Ines Moreau` for a bed with a patient, with the bed's own number and patient.\n\nThe check runs:\n\n```java\nBed bed = new Bed(4);\nSystem.out.println(bed + \" \" + bed.isFree());\nbed.assign(\"Ines Moreau\");\nSystem.out.println(bed + \" \" + bed.isFree());\nbed.release();\nSystem.out.println(bed);\n```\n\nand expects:\n\n```\nBed 4: free true\nBed 4: Ines Moreau false\nBed 4: free\n```\n","kind":"code","seed":"// ==== Bed.java ====\npublic class Bed {\n\n}\n\n// ==== Main.java ====\npublic class Main {\n public static void main(String[] args) {\n Bed bed = new Bed(4);\n System.out.println(bed + \" \" + bed.isFree());\n bed.assign(\"Ines Moreau\");\n System.out.println(bed + \" \" + bed.isFree());\n bed.release();\n System.out.println(bed);\n }\n}\n","solution":"// ==== Bed.java ====\npublic class Bed {\n private int number;\n private String patient;\n\n public Bed(int number) {\n this.number = number;\n this.patient = null;\n }\n\n public boolean isFree() {\n return this.patient == null;\n }\n\n public void assign(String name) {\n this.patient = name;\n }\n\n public void release() {\n this.patient = null;\n }\n\n @Override\n public String toString() {\n if (this.isFree()) {\n return \"Bed \" + this.number + \": free\";\n }\n return \"Bed \" + this.number + \": \" + this.patient;\n }\n}\n\n// ==== Main.java ====\npublic class Main {\n public static void main(String[] args) {\n Bed bed = new Bed(4);\n System.out.println(bed + \" \" + bed.isFree());\n bed.assign(\"Ines Moreau\");\n System.out.println(bed + \" \" + bed.isFree());\n bed.release();\n System.out.println(bed);\n }\n}\n","hints":["Start with the two instance variables from the box's fields, then the constructor `public Bed(int number)`. Each method line becomes a header: `+assign(name: String): void` is `public void assign(String name)`.","`isFree` returns `this.patient == null`, and `release` sets the patient back to `null`. `toString` checks `isFree()` and returns one text or the other."],"tests":[{"name":"Test 1","stdin":"","call":"Bed bed = new Bed(4);\nSystem.out.println(bed + \" \" + bed.isFree());\nbed.assign(\"Ines Moreau\");\nSystem.out.println(bed + \" \" + bed.isFree());\nbed.release();\nSystem.out.println(bed);\n","expect":"Bed 4: free true\nBed 4: Ines Moreau false\nBed 4: free","hidden":false},{"name":"Test 2","stdin":"","call":"Bed first = new Bed(1);\nBed second = new Bed(2);\nsecond.assign(\"Oskar Lund\");\nSystem.out.println(first.isFree() + \" \" + second.isFree());\nSystem.out.println(first + \" / \" + second);\nsecond.release();\nfirst.assign(\"Mei Tan\");\nSystem.out.println(first + \" / \" + second);\n","expect":"true false\nBed 1: free / Bed 2: Oskar Lund\nBed 1: Mei Tan / Bed 2: free","hidden":true}],"require":[{"pattern":"\\bprivate\\s+String\\s+patient\\s*;","message":"The box's field `-patient: String` is `private String patient;`."},{"pattern":"\\bpublic\\s+void\\s+assign\\s*\\(\\s*String\\s+\\w+\\s*\\)","message":"The box's line `+assign(name: String): void` is the header `public void assign(String name)`."}],"forbid":[],"more":[{"task":"A garden center's greenhouses open their vents when it gets warm. The team drew this box, and `Main.java` was written from it:\n\n\n
\n\n
The diagram as text
Greenhouse, a class
private field name: String
private field degrees: double
private field open: boolean
public constructor Greenhouse(name: String, degrees: double)
public constructor GameBox(title: String, pieces: int)
public method lose(count: int): void
public method find(count: int): void
public method isComplete(): boolean
public method toString(): String
private method present(): int
\n\n\n- A new box has all its pieces: none are missing.\n- `lose` adds to the missing pieces. `find` takes found pieces off them, but never below 0.\n- `isComplete` says whether no pieces are missing.\n- `present` is a private helper that returns how many pieces are in the box. `toString` uses it, and returns `Harbor Lights: 80 of 84 pieces`, with the box's own title and numbers.\n\nThe check runs:\n\n```java\nGameBox box = new GameBox(\"Harbor Lights\", 84);\nbox.lose(5);\nbox.find(1);\nSystem.out.println(box + \" \" + box.isComplete());\nbox.find(10);\nSystem.out.println(box + \" \" + box.isComplete());\n```\n\nand expects:\n\n```\nHarbor Lights: 80 of 84 pieces false\nHarbor Lights: 84 of 84 pieces true\n```\n","kind":"code","seed":"// ==== GameBox.java ====\npublic class GameBox {\n\n}\n\n// ==== Main.java ====\npublic class Main {\n public static void main(String[] args) {\n GameBox box = new GameBox(\"Harbor Lights\", 84);\n box.lose(5);\n box.find(1);\n System.out.println(box + \" \" + box.isComplete());\n box.find(10);\n System.out.println(box + \" \" + box.isComplete());\n }\n}\n","solution":"// ==== GameBox.java ====\npublic class GameBox {\n private String title;\n private int pieces;\n private int missing;\n\n public GameBox(String title, int pieces) {\n this.title = title;\n this.pieces = pieces;\n this.missing = 0;\n }\n\n public void lose(int count) {\n this.missing += count;\n }\n\n public void find(int count) {\n this.missing -= count;\n if (this.missing < 0) {\n this.missing = 0;\n }\n }\n\n public boolean isComplete() {\n return this.missing == 0;\n }\n\n @Override\n public String toString() {\n return this.title + \": \" + this.present() + \" of \" + this.pieces + \" pieces\";\n }\n\n private int present() {\n return this.pieces - this.missing;\n }\n}\n\n// ==== Main.java ====\npublic class Main {\n public static void main(String[] args) {\n GameBox box = new GameBox(\"Harbor Lights\", 84);\n box.lose(5);\n box.find(1);\n System.out.println(box + \" \" + box.isComplete());\n box.find(10);\n System.out.println(box + \" \" + box.isComplete());\n }\n}\n","hints":["Three instance variables, a constructor that sets `missing` to 0, and a method for each line of the box. The `-` in front of `present` makes it `private int present()`.","`find` subtracts, then sets `missing` back to 0 if it went below. `present()` returns the pieces minus the missing ones, and `toString` calls `this.present()`."],"tests":[{"name":"Test 1","stdin":"","call":"GameBox box = new GameBox(\"Harbor Lights\", 84);\nbox.lose(5);\nbox.find(1);\nSystem.out.println(box + \" \" + box.isComplete());\nbox.find(10);\nSystem.out.println(box + \" \" + box.isComplete());\n","expect":"Harbor Lights: 80 of 84 pieces false\nHarbor Lights: 84 of 84 pieces true","hidden":false},{"name":"Test 2","stdin":"","call":"GameBox tiles = new GameBox(\"Word Tiles\", 100);\nSystem.out.println(tiles + \" \" + tiles.isComplete());\ntiles.lose(3);\ntiles.lose(4);\nSystem.out.println(tiles);\ntiles.find(7);\nSystem.out.println(tiles.isComplete());\n","expect":"Word Tiles: 100 of 100 pieces true\nWord Tiles: 93 of 100 pieces\ntrue","hidden":true}],"require":[{"pattern":"\\bprivate\\s+int\\s+present\\s*\\(\\s*\\)","message":"The box's line `-present(): int` is a private method: `private int present()`."},{"pattern":"\\bpresent\\s*\\(\\s*\\)","min":2,"message":"Call the helper `present()` in `toString`."}],"forbid":[]}]}