自定义方法是Java编程的核心技能，因为它能提升代码的可读性、可维护性和可复用性，避免代码重复和逻辑混乱；2. 方法通过参数接收输入，通过返回值输出结果，实现数据交换，其中基本类型参数传递值副本，对象类型传递引用副本，影响方式不同；3. 静态方法属于类，可直接通过类名调用，无需创建对象，适用于通用工具操作，而实例方法属于对象，必须通过对象调用，可访问实例变量，代表对象特定行为；4. 应优先使用实例方法以体现面向对象特性，在无需对象状态的场景下使用静态方法以提高便利性，合理区分二者有助于构建清晰、高效的程序结构。
在Java里，定义和调用自定义方法是编写任何有意义程序的基础，它让你的代码变得可复用、有组织，也更容易理解和维护。简单来说，方法就是一段封装了特定功能的代码块，你可以给它起个名字，然后在需要的时候通过这个名字来“调用”它，让它执行里面的操作。这就像你给一个复杂的任务（比如“泡一杯咖啡”）拆解成小步骤（“烧水”、“磨豆”、“冲泡”），然后每次想喝咖啡，你只需要说“泡一杯咖啡”，而不是重复所有细节。
解决方案
要定义一个自定义方法，你通常会指定它的访问修饰符（比如
，表示谁都可以访问）、返回值类型（方法执行完后会给你什么结果，如果没有结果就是
）、方法名（你给它起的名字）以及参数列表（方法执行时需要哪些输入）。
一个最简单的自定义方法定义看起来是这样的：
立即学习“Java免费学习笔记（深入）”；
public class MyUtilities { // 这是一个没有参数，没有返回值的方法 public void greetUser() { System.out.println("你好，欢迎来到Java的世界！"); } // 这是一个带参数，有返回值的方法 public int addNumbers(int a, int b) { int sum = a + b; return sum; // 返回计算结果 } // 主方法，程序的入口 public Static void main(String[] args) { // 创建MyUtilities类的实例，因为greetUser和addNumbers不是静态方法 MyUtilities utils = new MyUtilities(); // 调用greetUser方法 utils.greetUser(); // 输出：你好，欢迎来到Java的世界！ // 调用addNumbers方法，并接收返回值 int result = utils.addNumbers(10, 20); System.out.println("10 + 20 的结果是: " + result); // 输出：10 + 20 的结果是: 30 // 你也可以直接在打印语句中调用 System.out.println("5 + 7 的结果是: " + utils.addNumbers(5, 7)); // 输出：5 + 7 的结果是: 12 } }
这里面，
greetUser()
就是一个自定义方法，它不接受任何输入，也不返回任何东西，只是打印一句话。
addNumbers(int a, int b)
则是一个接受两个整数作为输入，并返回它们和的方法。在
main
方法里，我们首先创建了
MyUtilities
类的一个对象
utils
，然后通过这个对象来调用这些方法。记住，如果你的方法不是
static
的，你就需要先创建一个类的实例才能调用它。如果是
static
方法，可以直接通过类名调用，比如
MyClass.staticMethod()
。
为什么在Java编程中自定义方法是核心技能？
自定义方法，或者说函数，在Java里简直是基石。如果你想写出任何有点规模、能跑起来还算稳定的程序，就离不开它。它不只是一个“最佳实践”那么简单，它直接关系到你代码的可读性、可维护性、可复用性，以及最重要的——你的开发效率和理智。
想想看，如果你的程序里有几十上百行代码，全部堆在一个
main
方法里，那会是什么灾难？找个bug像大海捞针，想改个小功能可能牵一发而动全身。自定义方法就是把这些大象腿拆解成一个个小骨头，每个方法只负责一个具体、独立的功能。比如，你有一个处理用户输入的逻辑，一个计算结果的逻辑，一个保存数据的逻辑。把它们各自封装成方法，你就能清晰地看到程序的结构，当某个环节出问题时，你知道直接去看哪个方法。
更重要的是复用性。比如你写了一个计算税费的方法，如果不用方法，每次需要计算税费的地方你都得把那段计算逻辑重新写一遍。一旦税率变了，你得改几十个地方。用了方法，你只需要改那一个方法，所有调用它的地方都会自动生效。这简直是解放生产力，减少重复劳动，还能有效避免引入新的错误。它让你的代码变得模块化，就像乐高积木一样，你可以把不同功能的“积木”组合起来，构建出更复杂的系统。
参数传递与返回值：方法间数据交换的关键
方法之所以强大，很大一部分原因在于它们可以接收数据作为输入（参数），也可以把处理结果返回出去（返回值）。这就像你给一个工人下指令，你得告诉他“原料是什么”（参数），然后他完成工作后会给你“成品”（返回值）。
参数传递：当你调用一个方法时，你可以在括号里传入一些值，这些值就是参数。方法内部会使用这些参数来执行它的逻辑。Java中，参数传递遵循“值传递”的原则。对于基本数据类型（如
int
,
,
等），传递的是它们的实际值的副本。这意味着方法内部对参数值的修改不会影响到方法外部的原始变量。
public void modifyPrimitive(int num) { num = num + 10; // 这里修改的是num的副本 System.out.println("方法内部修改后的值: " + num); } // 调用示例 int originalNum = 5; modifyPrimitive(originalNum); System.out.println("方法外部原始值: " + originalNum); // 仍然是5，没有改变
但对于对象类型，传递的是对象引用的副本。这意味着方法内部可以通过这个引用访问并修改对象本身的属性，这些修改在方法外部是可见的。然而，如果你在方法内部将引用指向了另一个新对象，那这个改变不会影响到方法外部的原始引用。
public void modifyObject(StringBuilder sb) { sb.append(" World!"); // 修改了sb指向的实际对象 System.out.println("方法内部修改后的对象: " + sb); sb = new StringBuilder("New String"); // sb现在指向了一个新对象，这个改变只在方法内部有效 } // 调用示例 StringBuilder myString = new StringBuilder("Hello"); modifyObject(myString); System.out.println("方法外部原始对象: " + myString); // 输出：Hello World! (因为对象内容被修改了)
返回值：方法执行完毕后，如果它计算出了一个结果，或者需要告诉调用者某种状态，就可以通过
return
语句将这个结果返回。返回值的类型必须与方法定义时声明的返回类型一致。如果方法不需要返回任何值，那么它的返回类型就是
void
。
public String createGreeting(String name) { if (name == null || name.isEmpty()) { return "请提供一个名字。"; // 返回一个错误提示 } return "你好，" + name + "！"; // 返回拼接好的问候语 } // 调用示例 String greeting1 = createGreeting("张三"); System.out.println(greeting1); // 你好，张三！ String greeting2 = createGreeting(null); System.out.println(greeting2); // 请提供一个名字。
理解参数传递和返回值的机制，是掌握方法通信的关键。它决定了你的方法如何获取它所需的数据，以及如何将处理结果反馈给程序的其他部分。
静态方法与实例方法：Java对象世界的两种操作模式
在Java里，方法的定义前面有时会看到一个
static
关键字，这一下子就把方法分成了两种截然不同的类型：静态方法（Static Methods）和实例方法（Instance Methods）。搞清楚它们之间的区别，以及何时使用哪一种，是理解Java面向对象编程（OOP）非常重要的一步。
实例方法： 这是你最常接触到的方法类型，也是Java面向对象的核心。实例方法是属于对象的。这意味着，你必须先创建一个类的实例（也就是一个对象），然后才能通过这个对象来调用它的实例方法。实例方法可以访问并操作这个对象自己的实例变量（非静态成员变量）。它们代表了对象特有的行为。
想象一个
Car
类，它有一个
color
属性和一个
drive()
方法。
drive()
方法就是一个实例方法，因为每辆车（每个
Car
对象）都有它自己的行驶方式，而且它可能需要知道这辆车的颜色等信息。
public class Car { String color; // 实例变量 public Car(String color) { this.color = color; } // 实例方法 public void drive() { System.out.println(color + "色的汽车正在行驶。"); } } // 调用示例 Car myCar = new Car("红色"); // 创建一个Car对象 myCar.drive(); // 调用实例方法，输出：红色的汽车正在行驶。 Car yourCar = new Car("蓝色"); yourCar.drive(); // 蓝色汽车有自己的行驶行为，输出：蓝色的汽车正在行驶。
静态方法： 静态方法是属于类的，而不是属于任何具体的对象。你不需要创建类的实例就可以直接通过类名来调用它。静态方法通常用于执行不依赖于任何特定对象状态的操作，或者是一些通用的工具函数。它们不能直接访问类的非静态（实例）成员变量或调用非静态方法，因为它们在被调用时可能还没有任何对象存在。
一个典型的例子是
类中的方法，比如
Math.random()
或
Math.max()
。你不需要创建一个
Math
对象来使用它们，它们就是提供一些通用的数学运算。
public class Calculator { // 静态方法 public static int add(int a, int b) { return a + b; } // 静态方法不能直接访问非静态变量 // public void someInstanceMethod() { ... } // public static void test() { // someInstanceMethod(); // 错误：不能从静态上下文引用非静态方法 // } } // 调用示例 int sum = Calculator.add(5, 3); // 直接通过类名调用静态方法 System.out.println("5 + 3 = " + sum); // 输出：5 + 3 = 8
什么时候用哪个？
- 用实例方法：当你的方法需要访问或修改对象的特定数据（实例变量），或者它代表的是某个对象特有的行为时。这是面向对象编程的常态。
- 用静态方法：当你的方法是执行一个通用任务，不需要访问任何对象的特定状态，或者它是一个工具函数，比如数学运算、字符串处理、辅助性操作等。静态方法也常用于工厂方法（创建对象）或单例模式的实现。
对于初学者来说，有时候为了方便，会把所有方法都声明为
static
，这样就可以直接在
main
方法里调用。但要小心，过度使用静态方法可能会让你失去面向对象带来的很多好处，比如封装性和多态性。理解这两种方法的根本区别，是迈向更高级Java编程的关键一步。
