方法的调用和定义

将多个句子合并并将其命名为一个单独的处理的内容。

public class Main {
  public static void main(String[] args) {
    System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
    student();
    System.out.println("先生：今日も１日お勉強がんばりましょう♪");
  }

  public static void student() {
    System.out.println("生徒：おはようございます");
  }
}

有两个“public static”开头的方法，一个是“main”方法，参数是字符串数组，另一个是“student”方法。这就是所谓的方法。我们将逐步解释。

在第三行中，将会输出”先生：大家，早上好♪”。

第4行
student();
這是一個方法。
更詳細地說，這是方法的調用。
student是方法的名稱。
括號的詳細內容稍後會解釋，請忽略它。
通過寫方法名（）來調用方法，並且可以多次調用相同的方法。
在這個例子中，在第7行的
public static void student() {
進行調用。

第8行：
System.out.println(“学生：早上好”);
会被输出。
以前的情况下，处理在这里结束了，但对于方法来说，会返回到主方法。
换句话说，下一个处理将在第5行进行。

第五行
输出”先生：今天也要加油学习哦♪”。

先生：みなさ〜ん、おはようございま〜す♪
生徒：おはようございます
先生：今日も１日お勉強がんばりましょう♪

有类似的印象吗？
当我叫出方法名后，好像会召唤出某种处理并立即处理完毕，然后迅速离开……我就有这样的印象。

在这里稍微整理一下。
召唤魔人的方法是通过调用魔法师的召唤方法，具体如下所示。

メソッド名（）

魔人的创建方法可以通过创建一个方法来实现，定义方法的方式如下：

public static void メソッド名() {
　命令文
}

当然，如果定义的方法名和调用的方法名不匹配，则无法调用。
顺便问一下，如果只定义方法而不调用会发生什么呢？

public class Main {
  public static void main(String[] args) {
    System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
    System.out.println("先生：今日も１日お勉強がんばりましょう♪");
  }

  public static void student() {
    System.out.println("生徒：おはようございます");
  }
}

先生：みなさ〜ん、おはようございま〜す♪
先生：今日も１日お勉強がんばりましょう♪

我将向您介绍在这里用方法区分处理的好处。

通过使用方法，程序可以变得更易读，更容易理解整体。
当出现故障时，修复也更容易。
由于可以重复使用方法，因此无需重复编写相同的处理，还可以省去编写代码的麻烦。

只有调用方法而没有其他处理，所以在这次中感受不到任何优势，但是如果代码量增加，是否会更能体会到它的好处呢？

公共静态void主（字符串[] args）{ }

当Java文件被执行时，始终会自动执行main方法。
main方法会指示各个方法，在得到支持后，各个方法会执行各自的处理。

这个家伙曾经是个谜。

完全不知道意思是什么，只是像佛经一样记住了。
看起来好像是通过输入这样像佛经一样的文言来执行程序。
也就是说，不写任何东西就不会执行任何程序。

这个主要方法似乎作为领导者，向其他方法发出了各种指示。

之前一直在想这是什么呢？但原来挺重要的嘛。

public class Main {
    public static void student() {
        System.out.println("生徒：おはようございます");
    }

    public static void main(String[] args) {
        System.out.println("先生：みなさ〜ん、おはようございま〜す♪");
        student();
        System.out.println("先生：今日も１日お勉強がんばりましょう♪");
    }
}

如果要首先处理main方法，即使将main方法放在最底部，main方法也会从上面被读取到… 对吗？

先生：みなさ〜ん、おはようございま〜す♪
生徒：おはようございます
先生：今日も１日お勉強がんばりましょう♪

成功加载了！

从main方法以外调用方法

public class Main {
    public static void main(String[] args) {
        methodA();
    }

    public static void methodA() {
        System.out.println("メソッドA:メソッドＢさ〜ん");
        System.out.println("メソッドA:こちらメソッドＡです");
        System.out.println("メソッドA:この処理おねがいしまーす");
        methodB();
    }

    public static void methodB() {
        System.out.println("メソッドB:はーい、メソッドＢでーす");
        System.out.println("メソッドB:承知しましたー");
        System.out.println("メソッドB:処理まわしまーす");
    }
}

メソッドA:メソッドＢさ〜ん
メソッドA:こちらメソッドＡです
メソッドA:この処理おねがいしまーす
メソッドB:はーい、メソッドＢでーす
メソッドB:承知しましたー
メソッドB:処理まわしまーす

最初的起点是main方法，但是其他方法可以将处理流程传递给其他方法。

魔人方法A可以自己调用魔人方法B并请求处理。

参数 shù)

当调用方法时，如果同时传递参数，就可以在方法中利用该值，就像提供给方法的额外信息一样。

我刚才在定义和调用方法时记得有括号的存在。参数将使用这个括号。

因为我认为通过您查看使用方法会更快，所以我会写下代码。

public class Main {
    public static void main(String[] args) {
        like("いるか");
    }

    public static void like(String animal) {
        System.out.println("私の好きな動物は" + animal + "です");
    }
}

希望能够能够清楚地解释，但可惜我似乎无法很好地解释，所以请魔人来使用魔法方法。

在第三行使用像是的魔法，讓魔人方法登場。
在此時，寫下傳給魔人方法的內容時，我們將傳遞「いるか」。

魔人メソッドが受け取ったいるかを確認します。

喜欢（String animal）

魔人メソッド会检查括号中的内容，并发现它被写作String。
在这里，我们认识到这个“いるか”是一个字符。
然后，如果代码中出现了animal这个词，就会把它替换为“いるか”。

我在第6行找到了一个动物。

私の好きな動物はいるかです

这是一个选择的问题，只需要一个选项 :

となります：这将是 (zhè shì)

方法、参数、变量等混杂在一起，感觉有点混乱。我对文字理解较薄弱，但如果将其拟人化，或者加入一些故事情节，以有趣的方式思考，这样更容易让我记忆深刻，理解也更加深入。

1. 使用like(“いるか”)方法时，召唤魔人并只允许携带物品。
2. 使用like(String animal)方法时，魔人会检查携带物品并确认数据类型为字符串，然后将其放入名为animal的变量中等待。
3. 我最喜欢的动物是” + animal + “！来了，快放进去！

似乎是这样的

顺便说一下，刚才

public static void student() {
和
学生();

所以，我认为没有传递任何参数。
即使没有传递任何信息，( )也是必需的，所以请务必填写。

我将提供关于参数的调用和定义方法的详细信息。

メソッド名（引数）

public static void メソッド名(型 変数) {
　命令文
}

传递多个参数

只需用逗号分隔

public class Main {
    public static void main(String[] args) {
        myself("みき", 5);
    }

    public static void myself(String name, int birth) {
        System.out.println("私の名前は" + name + " " + birth + "月生まれです");
    }
}

在第三行的myself方法中，将”みき”和5作为参数传递。
在第五行中，确认将”みき”作为字符串(String)赋值给name。
然后确认将5作为整数(int)赋值给birth。
由于第六行有name和birth，分别进行赋值。

私の名前はみき 5月生まれです

当你想要添加多个信息时，只需用逗号分隔即可，非常简单。不过需要注意一点。

我自己（”みき”，5）；
public static void myself(String name, int birth)

不可以这样做
即使我按照Miki(文本)的顺序先传了5(整数)，
但因为接收方要求的是int(整数)和String(文本)的顺序，所以会导致编译错误。

顺便提一下，传递给方法的参数被称为实际参数（例如：”みき” 和 5）。
接收端被称为形式参数（例如：String name 和 int birth）。

返回值

从被调用的方法返回值到调用它的方法。

public class Main {
    public static void main(String[] args) {
        int answer = number(10, 20);
        System.out.println("答えは" + answer);
    }

    public static int number(int x, int y) {
        int sum = x + y;
        return sum;
    }
}

在第三行，调用了一个方法，方法名为number。将10和20作为参数传递给方法number。

第6行：定义一个公共的静态方法number，该方法接收两个整数x和y作为参数。
其中的第3个int指的是该方法的返回值类型。
通常情况下，我认为该方法的返回值类型是void（即没有返回值）。
但是这里涉及到了返回值，在继续向下讲解之前，先放一放这个解释，我们先继续往前走。

第7行：
int sum = x + y;

第6行中, number(int x, int y)被传入了10和20。
也就是说，
x = 10
y = 20
因此，10 + 20的答案30被赋值给变量sum。

第八行
返回总和;
返回30，即将30返回给main方法的number(10, 20)。

第三行
int answer = number(10, 20);
number(10, 20) 返回了 30。
换句话说，
int answer = 30
30 将被赋值给 answer。

第四行显示的答案是30。

答えは30

让我解释一下前面第6行的内容。
public static int 的意思是返回值的类型。
这个返回值指的是第8行的 return sum 的 sum。
sum 的值被赋为了30。
也就是说它是一个整数。
整数的数据类型是 int。
所以这里就是 public static int。

順便说一下，一直以来都广泛使用的 void。
void 表示没有返回值。
如果没有返回值，则为… void
如果有返回值，则为… 返回值的类型
这样就可以了。

型 変数名 = メソッド名（引数リスト）;

public static 戻り値の型 メソッド名(引数リスト) {
　命令文
return 戻り値
}

使用return时需要注意一点。
return不仅会返回值，还会结束方法的执行。
在return后面写代码也不会被执行。
会导致编译错误。

直接使用返回值。

刚刚使用变量返回了一个返回值，不过也可以直接使用它。

public class Main {
    public static void main(String[] args) {
        System.out.println("答えは" + sum(10, 20));
    }

    public static int sum(int x, int y) {
        int answer = x + y;
        return answer;
    }
}

答えは30

超载

定义一个具有相同名称的方法。

原则上，不能给方法取相同的名字，但如果类型或参数数量不同，就可以进行多次定义。

public class Main {
    public static void main(String[] args) {
        fruit("りんご");
        fruit("りんご", "みかん");
    }

    public static void fruit(String name) {
        System.out.println("これは" + name + "です");
    }

    public static void fruit(String name1, String name2) {
        System.out.println("これは" + name1 + "と" + name2 + "です");
    }
}

これはりんごです
これはりんごとみかんです

“パソコンくん（JVM）は、同じメソッド名を持つ fruits ですが、引数の数が異なるため、それを正しく認識してくれます。”

使用数组作为参数。

public class Main {
    public static void main(String[] args) {
        String[] fruits = {"りんご", "みかん", "いちご"};
        food(fruits);
    }

    public static void food (String[] fruits) {
        for (String element : fruits) {
            System.out.println(element);
        }
    }
}

在第3行创建名为fruits的数组。
在第4行调用food方法。
通过第7行的for循环遍历数组并输出数组中的所有元素。

りんご
みかん
いちご

这里是注意事项：
在 public static void food (String[] fruits) 的 String 之后，别忘了加上 [] 哦。