【Java】Java 中的方法：从基础到实战的全面解析

By - YunYang
Posted on 2026-04-032026-04-03
Posted in Java

【Java】Java 中的方法：从基础到实战的全面解析

大家好，我是云扬～今天想和大家深入聊聊 Java 中的核心概念 —— 方法。作为后端开发中高频使用的知识点，掌握方法的定义、声明和使用技巧，能让我们的代码更简洁、可维护性更强。废话不多说，咱们直接进入正题！

一、Java 中的方法是什么？

方法本质上是一段封装好的可重用代码块，它就像一个 “功能黑盒”：输入参数，经过内部逻辑处理后，返回结果（或无返回）。它的核心价值主要体现在三点：

代码复用：编写一次，多处调用，避免重复造轮子；
提高可读性：将复杂逻辑拆分到不同方法中，代码结构更清晰；
按需执行：只有被主动调用时才会执行，节省资源。

提到方法，Java 程序员最熟悉的莫过于main()方法 —— 它是程序的入口点，每个可执行的 Java 程序都必须包含它：

public class HelloWorld {
    // 程序入口方法
    public static void main(String[] args) {
        System.out.println("Hello, Java Methods!");
    }
}

二、如何声明一个方法？

方法的声明格式看似复杂，实则有固定套路，完整结构如下：

[访问权限修饰符] [返回类型] 方法名([参数列表]) {
    // 方法体：业务逻辑代码
}

下面我们逐个拆解关键部分，并搭配代码示例说明：

1. 访问权限修饰符

Java 提供四种访问权限，控制方法的可见范围：

修饰符	可见范围	适用场景
public	所有类	对外提供的公共接口
private	仅当前类	类内部的工具方法
protected	同包 / 子类	父子类之间的方法复用
default	仅同包	包内组件间的通信

示例：不同权限的方法声明

public class MethodDemo {
    // public方法：所有类可调用
    public void publicMethod() {
        System.out.println("这是public方法");
    }

    // private方法：仅MethodDemo类内部可调用
    private int privateMethod(int a, int b) {
        return a + b;
    }

    // protected方法：同包或子类可调用
    protected String protectedMethod(String name) {
        return "Hello, " + name;
    }

    // default方法：仅同包可调用
    boolean defaultMethod() {
        return true;
    }
}

2. 返回类型

方法执行后需返回数据时，指定返回数据的类型（基本类型、对象、集合等）；
无需返回数据时，用void关键字标识。

示例：带返回值与无返回值的方法

public class ReturnDemo {
    // 无返回值方法：void标识
    public void printInfo() {
        System.out.println("无返回值方法");
    }

    // 返回基本类型（int）
    public int add(int x, int y) {
        return x + y; // 返回语句：结束方法并返回结果
    }

    // 返回对象类型（String）
    public String getUserName() {
        return "云扬";
    }
}

3. 方法名与方法重载

命名规范：采用小驼峰命名法，名称需体现方法功能（如subtract表示减法，getUserInfo表示获取用户信息）；
方法重载：同一个类中，方法名相同但参数列表不同（参数个数、类型、顺序不同）的多个方法，与返回类型无关。

示例：方法重载实战

public class OverloadDemo {
    // 两个int类型参数的减法
    public int subtract(int a, int b) {
        return a - b;
    }

    // 三个int类型参数的减法（参数个数不同）
    public int subtract(int a, int b, int c) {
        return a - b - c;
    }

    // 两个double类型参数的减法（参数类型不同）
    public double subtract(double a, double b) {
        return a - b;
    }

    public static void main(String[] args) {
        OverloadDemo demo = new OverloadDemo();
        System.out.println(demo.subtract(10, 3)); // 调用第一个方法，输出7
        System.out.println(demo.subtract(10, 3, 2)); // 调用第二个方法，输出5
        System.out.println(demo.subtract(10.5, 3.2)); // 调用第三个方法，输出7.3
    }
}

4. 参数列表与方法签名

参数列表：包含参数类型和参数名，多个参数用逗号分隔，无参数时圆括号为空；
方法签名：Java 中判断方法唯一性的标识，由方法名 + 参数列表组成（与访问权限、返回类型无关）。

示例：带参数与无参数的方法

public class ParameterDemo {
    // 无参数方法
    public void showWelcome() {
        System.out.println("欢迎访问云扬のBlog！");
    }

    // 单个参数方法
    public void showUserAge(int age) {
        System.out.println("用户年龄：" + age);
    }

    // 多个参数方法
    public String createUser(String name, int age, String address) {
        return "姓名：" + name + "，年龄：" + age + "，地址：" + address;
    }
}

三、Java 方法的分类

根据定义主体不同，Java 方法可分为标准类库方法和用户自定义方法，后者又可细分为实例方法、静态方法和抽象方法。

1. 标准类库方法（内置方法）

Java 官方提供的预先定义好的方法，无需自己实现，直接调用即可，常见于String、System等核心类：

public class LibraryMethodDemo {
    public static void main(String[] args) {
        String str = "Java方法";
        
        // String类的length()方法：获取字符串长度
        int length = str.length();
        System.out.println("字符串长度：" + length); // 输出4
        
        // String类的equals()方法：比较字符串内容
        boolean isEqual = str.equals("Java方法");
        System.out.println("内容是否相等：" + isEqual); // 输出true
        
        // System类的println()方法：控制台打印
        System.out.println("调用标准类库方法成功！");
    }
}

2. 用户自定义方法

当内置方法无法满足需求时，自己编写的方法，根据是否有static修饰，分为实例方法和静态方法。

（1）实例方法

无static修饰，属于类的实例（对象），必须创建对象后才能调用；
常用场景：操作对象的成员变量，如 getter/setter 方法。

示例：实例方法与 getter/setter 实战

public class Student {
    // 成员变量（私有，通过getter/setter访问）
    private String name;
    private int score;

    // setter方法：设置成员变量值
    public void setName(String name) {
        this.name = name; // this指代当前对象
    }

    public void setScore(int score) {
        // 逻辑校验：分数需在0-100之间
        if (score >= 0 && score 100) {
            this.score = score;
        } else {
            System.out.println("分数输入无效！");
        }
    }

    // getter方法：获取成员变量值
    public String getName() {
        return this.name;
    }

    public int getScore() {
        return this.score;
    }

    // 自定义实例方法：计算成绩等级
    public String getGrade() {
        if (score >= 90) {
            return "A";
        } else if (score >= 80) {
            return "B";
        } else if (score >= 60) {
            return "C";
        } else {
            return "D";
        }
    }

    public static void main(String[] args) {
        // 1. 创建Student对象（实例）
        Student student = new Student();
        
        // 2. 调用setter方法设置值
        student.setName("小明");
        student.setScore(85);
        
        // 3. 调用getter方法获取值
        System.out.println("姓名：" + student.getName()); // 输出"小明"
        System.out.println("分数：" + student.getScore()); // 输出85
        
        // 4. 调用自定义实例方法
        System.out.println("成绩等级：" + student.getGrade()); // 输出"B"
    }
}

（2）静态方法

有static修饰，属于类本身，无需创建对象，直接通过 “类名.方法名” 调用；
注意事项：静态方法中不能直接访问非静态成员变量和实例方法。

示例：静态方法的定义与调用

public class StaticMethodDemo {
    // 静态方法：工具类常用（如数学计算、字符串处理）
    public static int multiply(int a, int b) {
        return a * b;
    }

    // 静态方法：打印系统信息
    public static void printSystemInfo() {
        System.out.println("系统名称：Java Demo");
        System.out.println("版本：1.0.0");
    }

    public static void main(String[] args) {
        // 直接通过类名调用静态方法，无需创建对象
        int result = StaticMethodDemo.multiply(5, 6);
        System.out.println("乘法结果：" + result); // 输出30
        
        StaticMethodDemo.printSystemInfo();
    }
}

（3）抽象方法

无方法体（仅声明，无花括号包裹的逻辑），用abstract关键字修饰；
必须声明在抽象类（abstract class）中，子类继承抽象类后，必须重写所有抽象方法（除非子类也是抽象类）。

示例：抽象方法与抽象类实战

// 抽象类：包含抽象方法的类必须声明为抽象类
abstract class Shape {
    // 抽象方法：无方法体，仅定义方法签名
    public abstract double calculateArea();
    public abstract double calculatePerimeter();
}

// 子类继承抽象类，必须重写所有抽象方法
class Circle extends Shape {
    private double radius; // 半径

    public Circle(double radius) {
        this.radius = radius;
    }

    // 重写抽象方法：计算圆的面积
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }

    // 重写抽象方法：计算圆的周长
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}

public class AbstractMethodDemo {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        System.out.println("圆的面积：" + circle.calculateArea()); // 输出≈78.54
        System.out.println("圆的周长：" + circle.calculatePerimeter()); // 输出≈31.42
    }
}

四、总结

Java 方法是代码组织的核心，掌握它的关键在于：

理解方法的核心价值：复用、可读性、按需执行；
牢记方法声明的完整结构，尤其是访问权限、返回类型和参数列表的用法；
区分不同类型的方法（实例方法、静态方法、抽象方法）的适用场景；
灵活运用方法重载，提升代码的灵活性。

希望这篇文章能帮助大家理清 Java 方法的知识点～如果你有更多疑问或实战经验，欢迎在评论区留言交流！后续我还会分享更多 Java 核心技术，记得关注云扬の Blog 哦～

Tags:Java

云扬のBlog