Pack Recipes into Methods

01 / 13

Before you begin: Put the examples in the right place

This chapter uses JDK 21 and does not require the preview function. A complete program is given for each common example, saved with annotated file names. Multiple examples are placed in their own folders to avoid auxiliary classes with the same name.

javac -encoding UTF-8 ExampleFile.java
java ExampleClass

Class names are case-sensitive. If the complete challenge code is divided into multiple sections, please connect them in the same file in order. Do not create separate classes for the continued sections. Run verification only lists the program output; additional input sequences are provided where input is required.

02 / 13

Do you need to copy the recipe again every time?

A Fang is responsible for the pre-departure inspection. He copied "check the pickaxe, load the food, and bring the torch" three times: once during the day, once at night, and again according to the instructions of his deskmate. As a result, the number of torches was changed in two places, and the third place remained at the old version.

A method is like a recipe card with a name. Write a set of actions once and call them with method names when needed. When modifying the rules, only the recipe card needs to be modified, and there is no need to chase three copy-pasted monsters.

Starting with four questions

• What is the difference between method definition and invocation?
• Why is main still the birth point of the program?
• How to give a method an understandable action name?
• How to prove that the behavior has not changed after refactoring?

03 / 13

Name a group of instructions

First find actions that are exactly the same or have the same concept, and then move them into methods. Method names start with verbs, such as packFood, checkArmor, printDivider.

public class L12Example02 {
    static void prepareMining() {
        System.out.println("Check pick");
        System.out.println("Load 16 bread");
        System.out.println("Bring on 64 Root torch");
    }
    public static void main(String[] args) {
        prepareMining();
        prepareMining();
    }
}

Check pick
Load 16 bread
Bring on 64 Root torch
Check pick
Load 16 bread
Bring on 64 Root torch

04 / 13

Define and call void method

Defining the method is just to write the recipe in the book; calling the method is to actually start working with the materials. The following classes can be compiled and run directly.

public class L12Example03 {
    static void packFood() {
        System.out.println("Load 16 bread");
    }
    static void checkArmor() {
        System.out.println("Check Armor Durability");
    }
    public static void main(String[] args) {
        packFood();
        checkArmor();
    }
}

Load 16 bread
Check Armor Durability

05 / 13

Calling sequence and return route

When Java encounters a method call, it will temporarily leave the current location and enter the called method. After the method is executed to the right curly brace, the program returns to the next line where it was called.

public class L12Example04 {
    static void ringBell() { System.out.println("Ding"); }
    public static void main(String[] args) {
        System.out.println("Departure");
        ringBell();
        ringBell();
        System.out.println("Mine");
    }
}

Departure
Ding
Ding
Mine

06 / 13

A method only does one thing

doEverything() sounds powerful, but is actually like a chest stuffed with rotten flesh, diamonds, and seventeen wooden hoes. The best method is to complete a clear action and describe it with verbs.

public class L12Example05 {
    static void checkEquipment() { System.out.println("Check equipment"); }
    static void packFood() { System.out.println("Pack food"); }
    static void chooseMine() { System.out.println("Select mine"); }
    static void prepareTrip() {
        checkEquipment();
        packFood();
        chooseMine();
    }
    public static void main(String[] args) {
        prepareTrip();
    }
}

Check equipment
Pack food
Select mine

Naming check

• Use humpback for method names, such as checkArmor.
• The name should describe the action, do not write method1.
• When the method is too long, look for small steps that can be individually named.

07 / 13

Divide the pixel house into skills

The pixel house in the previous lesson can be reconstructed as a "parameter-free version" first: the roof is responsible for the first two rows, and the walls are responsible for the remaining five rows and the doors and windows are judged within the grid. In the next lesson, we'll use parameters to let the same method handle different sizes.

public class PixelMethods {
    static void printRoof() {
        System.out.println("  ^^^^^  ");
        System.out.println(" ^^^^^^^ ");
    }
    static void printBody() {
        for (int row = 2; row < 7; row++) {
            for (int col = 0; col < 9; col++) {
                char block = ' ';
                if (col == 4 && row >= 3 && row <= 5) block = 'D';
                else if ((col == 1 || col == 7)
                        && (row == 3 || row == 4)) block = 'O';
                else if (row == 2 || row == 6 || col == 0 || col == 8)
                    block = '#';
                System.out.print(block);
            }
            System.out.println();
        }
    }
    public static void main(String[] args) {
        printRoof();
        printBody();
    }
}

  ^^^^^  
 ^^^^^^^ 
#########
#O  D  O#
#O  D  O#
#   D   #
#########

08 / 13

Reuse methods and small tests

Multiplexing is not blind multiple calls. Each call should have a clear location, and the method itself should be individually inspectable.

public class L12Example07 {
    static void divider() { System.out.println("================"); }
    public static void main(String[] args) {
        divider();
        System.out.println("Block Academy");
        divider();
    }
}

================
Block Academy
================

Three types of inspections

• Normal: All methods are called as planned.
• Boundary: Call only one method or call it twice.
• Error: Intentionally misspelled method name, observe compiler prompts.

09 / 13

Method Failure Clinic

Method bugs are often divided into two class: the compiler blocks them directly, or the program can run but takes one less step. The second type is more disguised, so check the call list.

public class L12Example08 {
    static void packFood() { System.out.println("Pack food"); }
    public static void main(String[] args) {
        System.out.println("Departure");
    }
}

Departure

public class BadNestedMethod {
    public static void main(String[] args) {
        static void checkArmor() { }
    }
}

10 / 13

Challenge Blueprint Mine Preparation Process

The challenge deliverable is MiningPrep.java. The program must contain five custom methods, called by main in a reasonable order.

Construction Contract

• Each of the five methods has clear action names.
• Each method outputs at least one piece of verifiable information.
• main is only responsible for arranging the process and does not repeat the output inside the method.
• Run it normally once, then delete a call to create a logic error.

11 / 13

Challenge Implementation Five Methods Queuing

Create new MiningPrep.java. The class name and file name are consistent. These preparation methods require no input and do not return a value. void means there is no return value; static makes them callable directly from static main. The two are different design choices.

public class MiningPrep {
    static void checkPickaxe() {
        System.out.println("Pickaxe durability checked");
    }
    static void packFood() {
        System.out.println("Load 16 bread");
    }
    static void packTorches() {
        System.out.println("Load 64 Root torch");
    }
    static void wearArmor() {
        System.out.println("The armor has been put on");
    }
    static void printPlan() {
        System.out.println("Route: Main Mine Road -> Supply station -> Go home");
    }
    public static void main(String[] args) {
        checkPickaxe();
        packFood();
        packTorches();
        wearArmor();
        printPlan();
    }
}

Pickaxe durability checked
Load 16 bread
Load 64 Root torch
The armor has been put on
Route: Main Mine Road -> Supply station -> Go home

12 / 13

Expansion tasks and clearance review

The job requires handing over the source code, a run result and a bug record. Just submitting screenshots doesn't count, because screenshots won't tell you where the semicolon is hiding.

Third gear operation

• Wooden pick: write three prompt methods morningTip, nightTip, and dangerTip, and call them once from main.
• Iron pick: Put the roof and the wall containing doors and windows of the pixel house in Lesson 11 into the method respectively, keeping the output unchanged.
• Diamond Pickaxe: Design challenge battle process, including at least four methods of preparation, battle, second stage, and victory.

13 / 13

Own acceptance record

Write expectations before running, and record actual results after running. Normal cases show that the program does things; edge cases show that it knows when to stop; error cases show that it rejects unreasonable requests.

• Write a bug as: triggering conditions, phenomena, causes, and minimal repairs.
• Organize a rule worth remembering and explain it in your own words. Don't just copy the definition.
• Change an example, keep a record of the test, and let the results prove your understanding.