一个java方法由访问修饰符、静态修饰符、返回类型、方法名、参数列表和方法体六部分组成；1. 访问修饰符决定方法的访问权限，如public、private等；2. 静态修饰符static表示方法属于类本身而非实例；3. 返回类型指定方法执行后返回的数据类型，无返回值用void；4. 方法名为调用方法的标识，遵循小驼峰命名法；5. 参数列表定义方法所需的输入，多个参数以逗号分隔；6. 方法体包含具体执行逻辑的代码块，位于花括号内；静态方法通过“类名.方法名”调用，不依赖对象实例，不能访问非静态成员；非静态方法需通过对象调用，可访问所有成员并使用this关键字；方法重载允许同一类中同名方法通过不同参数列表实现多种功能，提升调用灵活性；方法重写发生在继承中，子类提供父类方法的新实现，实现运行时多态，增强代码可扩展性。
Java中，方法是实现代码复用的核心机制，它允许你将一段特定的逻辑封装起来，然后在程序的任何地方多次调用，避免重复编写相同的代码，大大提高了开发效率和可维护性。说白了，它就是把一个特定的任务打包成一个可执行的单元，想用的时候直接拿来用，不用每次都从头写一遍。
解决方案
在Java里定义和调用方法，其实就是把你要重复执行的代码块，用一个名字和一些规则包装起来。
定义方法
立即学习“Java免费学习笔记（深入）”；
一个方法的定义通常包含以下几个部分：
-
访问修饰符 (Access Modifier)：比如
public
、private
、protected
或默认（包级私有），这决定了谁能调用这个方法。我个人觉得，刚开始学的时候，用public
最省心，因为这样它可以在任何地方被访问到。 -
静态修饰符 (Static Modifier)：可选的
static
关键字。如果方法是static
的，它属于类本身，可以直接通过类名调用，不需要创建类的实例。如果是非static
的，它就属于类的某个具体对象，必须先创建对象才能调用。这玩意儿一开始确实容易混淆，但用多了就自然了。 -
返回类型 (Return Type)：方法执行完后返回的数据类型。如果你不需要返回任何东西，就用
void
。比如，一个计算两个数之和的方法，返回类型就是int
或double
。 -
方法名 (Method Name)：给方法起个名字，要符合Java的命名规范（小驼峰命名法，比如
calculateSum
）。这个名字就是你以后调用它的“代号”。 -
参数列表 (Parameter List)：括号
()
里的部分，定义了方法需要接收哪些输入。每个参数都有类型和名称，用逗号分隔。如果没有参数，就留空()
。 -
方法体 (Method Body)：花括号
{}里的代码块，这是方法实际执行的逻辑。
这是一个简单的例子：
public class MyCalculator {
// 定义一个静态方法，用于计算两个整数的和
public static int add(int num1, int num2) {
int sum = num1 + num2;
return sum; // 返回计算结果
}
// 定义一个非静态方法，用于打印一条欢迎信息
public void greet(String name) {
System.out.println("你好，" + name + "！欢迎来到Java世界。");
}
}调用方法
调用方法就相对简单了，根据方法是静态还是非静态，调用方式有所不同：
-
调用静态方法：直接使用“类名.方法名(参数)”的形式。
int result = MyCalculator.add(10, 20); // 调用静态的add方法 System.out.println("10 + 20 = " + result); // 输出 30对我来说，静态方法就像是工具箱里的通用工具，随时拿来就能用，不用特意去“生产”一个工具。
-
调用非静态方法：首先需要创建类的实例（对象），然后通过“对象名.方法名(参数)”的形式调用。
MyCalculator calculator = new MyCalculator(); // 创建MyCalculator类的对象 calculator.greet("小明"); // 调用非静态的greet方法，输出“你好，小明！欢迎来到Java世界。”非静态方法则更像是某个特定物品（比如一台手机）才有的功能，你得先有这台手机，才能用它的拍照功能。
通过这种方式，你可以把复杂的逻辑拆分成一个个小的方法，每个方法只负责一个特定的任务，这样代码不仅清晰，而且更容易维护和复用。比如，如果你需要多次计算两个数的和，定义一个
add方法就比每次都写
a + b要优雅得多。
一个Java方法究竟由哪些部分组成？
一个完整的Java方法定义，其实就像一份详细的“工作说明书”，它明确告诉编译器这个方法能做什么、需要什么输入、会给出什么输出以及谁能使用它。我们来拆解一下：
-
访问修饰符 (Access Modifier)：这就像是给你的方法设定了一个“访问权限”。
public
：最开放，任何地方都能访问。protected
：同包或子类可以访问。default
(不写任何修饰符)：只有在同一个包内的类才能访问。private
：最严格，只能在定义它的类内部访问。 选择哪个修饰符，取决于你希望这个方法在多大范围内被使用。我通常会先用public
，等到代码结构更清晰时，再考虑是否需要收紧权限。
-
静态修饰符 (Static Modifier)：
static
关键字，它决定了这个方法是属于“类”的，还是属于“对象”的。-
static
方法：直接通过类名调用，不需要创建类的实例。它不能直接访问类的非静态成员变量或非静态方法（因为它们依赖于特定的对象）。 -
非
static
方法：必须通过类的实例（对象）来调用。它可以访问类的所有成员（包括静态和非静态）。 刚学Java那会儿，我老是搞不清楚static
到底是个啥玩意儿，什么时候用，什么时候不用。后来才明白，它其实就是告诉你，这个方法是不是需要一个具体的“实例”才能跑起来。
-
-
返回类型 (Return Type)：方法执行完毕后，会把一个结果“吐”出来，这个结果的数据类型就是返回类型。
- 如果方法不返回任何值，就用
void
。比如一个只负责打印信息的方法。 - 如果方法计算了一个整数结果，就用
int
。 - 如果返回一个字符串，就用
String
。 这个类型必须和方法体中return
语句返回的值类型匹配。
- 如果方法不返回任何值，就用
方法名 (Method Name)：这是方法的“身份证”，必须是唯一的（在同一个类中，如果参数列表不同则可以重载）。命名时通常采用小驼峰命名法，比如
getUserName
、calculateArea
。一个好的方法名能让人一眼看出它的功能。-
参数列表 (Parameter List)：括号
()
里的部分，定义了方法在执行时需要接收哪些外部数据。每个参数都包含数据类型和参数名，多个参数之间用逗号,
分隔。- 例如：
int num1, String message
。 - 如果方法不需要任何输入，参数列表就是空的
()
。 这些参数就像是方法的“输入端口”，外部数据通过这里传递进来。
- 例如：
方法体 (Method Body)：花括号
{}里的所有代码，这是方法真正执行业务逻辑的地方。所有你想让这个方法完成的任务，都在这里实现。这里面可以包含变量定义、条件判断、循环、调用其他方法等等。
// 这是一个完整的方法定义示例
public class DataProcessor {
// public: 任何地方可访问
// static: 属于类本身
// String: 返回一个字符串
// processData: 方法名
// (int id, String rawData): 参数列表
public static String processData(int id, String rawData) {
// 方法体开始
if (rawData == null || rawData.isEmpty()) {
return "Error: Data is empty for ID " + id;
}
String processed = rawData.trim().toUpperCase(); // 简单的处理逻辑
System.out.println("处理ID " + id + " 的数据：" + processed);
return "Processed: " + processed;
// 方法体结束
}
// 另一个非静态方法示例
public void logActivity(String activity) {
System.out.println("日志记录：" + activity);
}
}理解这些组成部分，是写好Java方法的第一步。就像盖房子，你得先知道地基、墙壁、屋顶都是什么，才能开始动工。
静态方法和非静态方法在使用上有什么根本区别？
这是Java初学者最容易混淆，也是最核心的概念之一。说白了，区别在于它们“属于谁”，以及“如何被调用”。
静态方法（static
method）
- 归属：它属于类本身，而不是类的任何特定对象。你可以把它想象成一个公共工具，这个工具是属于整个工具箱（类）的，而不是工具箱里某个具体的螺丝刀（对象）。
-
调用方式：直接通过类名调用，不需要创建类的实例。例如
ClassName.staticMethod()
。 -
访问限制：静态方法内部不能直接访问类的非静态成员变量和非静态方法。因为非静态成员是属于对象的，而静态方法在被调用时，可能根本还没有任何对象被创建。它也无法使用
this
关键字，因为this
指向的是当前对象实例。 -
常见用途：通常用于工具类、辅助方法、工厂方法，或者那些不需要依赖任何对象状态就能完成的功能。比如
Math.random()
、Integer.parseInt()
都是典型的静态方法。
非静态方法（Instance method / 实例方法）
- 归属：它属于类的某个具体对象（实例）。每个对象都有自己的一套非静态方法，它们操作的是这个对象特有的数据。
-
调用方式：必须先创建类的实例（对象），然后通过对象引用来调用。例如
objectName.instanceMethod()
。 -
访问限制：非静态方法可以访问类的所有成员，包括静态的和非静态的。因为当非静态方法被调用时，它一定是通过一个具体的对象来调用的，所以它能够访问该对象的状态。它可以使用
this
关键字来引用当前对象。 -
常见用途：用于描述对象的行为，或者需要操作对象特定属性的功能。比如一个
Car
类的drive()
方法，它会改变这辆车的行驶状态。
什么时候用哪个？
我个人在思考用
static还是不用
static时，会问自己一个问题：这个方法需要访问对象的特定数据吗？
- 如果答案是“不需要”，它只是执行一个通用的计算或者操作，不依赖任何对象的特定状态，那么它很可能适合做成静态方法。比如一个计算圆面积的方法，它只需要半径，不需要知道是哪个具体的圆对象。
- 如果答案是“需要”，它要操作某个对象的属性，或者描述某个对象的行为，那么它就应该是一个非静态方法。比如一个
User
对象的updateProfile()
方法，它显然需要修改这个User
对象的姓名、地址等属性。
理解了这两者的区别，你就能更好地设计你的类和方法，让代码结构更合理，也更容易维护。
方法重载与方法重写：它们如何提升代码的灵活性和可扩展性？
方法重载（Overloading）和方法重写（Overriding）是Java多态性的两种体现，它们虽然名字相似，但概念和应用场景大相径庭。不过，它们的核心目的都是为了让代码更灵活、更易于扩展。
方法重载 (Method Overloading)
定义：在同一个类中，可以有多个方法拥有相同的名字，但它们的参数列表（参数的类型、数量或顺序）必须不同。返回类型和访问修饰符可以相同也可以不同，但不能作为区分重载方法的依据。
目的：提供更灵活的接口。想象一下，你有一个
print
方法，你可能想打印整数，也可能想打印字符串，或者打印浮点数。与其为每种类型都起一个不同的方法名（比如printInt
,printString
,printDouble
），不如都叫print
，让Java根据你传入的参数类型自动选择正确的方法。这极大地提高了代码的可读性和易用性。-
特点：
- 发生在同一个类中。
- 编译时多态（或称静态多态），编译器在编译时就能确定调用哪个重载方法。
- 参数列表必须不同。
-
示例：
public class Printer { public void print(int num) { System.out.println("打印整数: " + num); } public void print(String text) { System.out.println("打印字符串: " + text); } public void print(double num, String unit) { System.out.println("打印带单位的浮点数: " + num + " " + unit); } } // 调用时 Printer p = new Printer(); p.print(100); // 调用 print(int) p.print("Hello Java"); // 调用 print(String) p.print(3.14, "米"); // 调用 print(double, String)我记得有一次，我需要处理不同类型的数据，但又不想为每种类型都写一个完全不同的方法名，那时候方法重载就成了我的救星。它让API设计变得非常优雅。
方法重写 (Method Overriding)
定义：发生在父类和子类之间。子类可以提供一个与父类中方法签名（方法名、参数列表、返回类型）完全相同的方法实现。
目的：实现运行时多态。当子类需要提供父类方法的一个特定实现时，就使用方法重写。比如，一个
Shape
类有一个draw()
方法，Circle
和Rectangle
两个子类都需要draw()
，但它们画的方式肯定不同，这时子类就会重写draw()
方法。-
特点：
- 发生在继承关系中（父类与子类之间）。
- 运行时多态（或称动态多态），JVM在运行时根据对象的实际类型来决定调用哪个方法。
- 方法签名必须完全相同。
- 子类重写方法的访问修饰符不能比父类更严格（可以相同或更宽松）。
- 可以使用
@Override
注解，它能帮助编译器检查你是否正确地重写了方法。
-
示例：
class Animal { public void makeSound() { System.out.println("动物发出声音"); } } class Dog extends Animal { @Override // 强烈建议加上这个注解，帮助检查 public void makeSound() { System.out.println("狗叫：汪汪！"); } } class Cat extends Animal { @Override public void makeSound() { System.out.println("猫叫：喵喵！"); } } // 调用时 Animal myAnimal1 = new Dog(); // 父类引用指向子类对象 Animal myAnimal2 = new Cat(); myAnimal1.makeSound(); // 输出 "狗叫：汪汪！" myAnimal2.makeSound(); // 输出 "猫叫：喵喵！"方法重写是面向对象多态性的基石，写框架和库的时候简直离不开它。它允许你编写更通用、更灵活的代码，因为你可以操作父类类型的引用，但实际执行的是子类特有的行为。这对于构建可扩展的系统至关重要。
