Java面向对象基础——1.方法

目录

• Java中的方法
  • 方法的基本概念与作用
  • 方法的定义与基本语法
    • 各组成部分说明
    • 实例方法与字段访问
  • 方法的访问控制：public与private
    • private方法的应用示例
  • this关键字的使用
  • 方法参数的传递机制
    • 基本类型参数的传递
    • 引用类型参数的传递
    • 特殊情况：String类型的传递
  • 可变参数：灵活处理不定数量的参数
  • 综合示例：
  • 总结

---

Java中的方法

方法的基本概念与作用

方法是类中定义的具有特定功能的代码块，它封装了一系列操作，可以被重复调用。方法的主要作用包括：

• 封装逻辑：将特定功能的代码组织成方法，提高代码可读性和可维护性
• 控制访问：通过方法间接访问类的内部数据，保护数据安全性
• 接口抽象：对外暴露功能接口，隐藏实现细节
• 代码复用：定义一次可多次调用，减少重复代码

在面向对象设计中，一个类通常通过private修饰字段（Field），通过public方法提供对字段的访问和操作，这种模式称为"封装"。

方法的定义与基本语法

Java方法的定义语法如下：

修饰符 返回类型 方法名(参数列表) {
    // 方法体：实现功能的代码
    return 返回值; // 如果返回类型为void，则可省略
}

各组成部分说明

1. 修饰符：控制方法的访问权限，常用的有public（公开访问）、private（仅类内部访问）等
2. 返回类型：方法执行后返回的数据类型，无返回值时使用void
3. 方法名：遵循驼峰命名法（首字母小写，后续单词首字母大写），如getName
4. 参数列表：方法接收的输入数据，格式为"类型 参数名"，多个参数用逗号分隔
5. 方法体：实现具体功能的代码块
6. 返回值：通过return语句返回，其类型必须与声明的返回类型一致

实例方法与字段访问

下面通过一个完整示例展示方法如何访问和操作类的字段：

public class Person {
    // 私有字段，外部无法直接访问
    private String name;
    private int age;

    // 访问name字段的方法
    public String getName() {
        return name; // 返回name字段的值
    }

    // 修改name字段的方法
    public void setName(String name) {
        // 验证参数合法性
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("姓名不能为空");
        }
        this.name = name.strip(); // 去除首尾空格后赋值
    }

    // 访问age字段的方法
    public int getAge() {
        return age;
    }

    // 修改age字段的方法
    public void setAge(int age) {
        // 验证参数合法性
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄必须在0-150之间");
        }
        this.age = age;
    }
}

使用这个类时，外部代码只能通过方法间接操作字段：

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("  张三  "); // 调用方法设置姓名
        person.setAge(25); // 调用方法设置年龄

        System.out.println(person.getName()); // 调用方法获取姓名，输出"张三"
        System.out.println(person.getAge());  // 调用方法获取年龄，输出25
    }
}

这种通过方法访问字段的模式，是Java封装思想的典型应用。

方法的访问控制：public与private

Java通过访问修饰符控制方法的可见范围，最常用的是public和private：

• public方法：可以被类外部的代码调用，通常用于暴露类的功能接口
• private方法：只能被类内部的其他方法调用，通常用于封装内部辅助逻辑

private方法的应用示例

public class Person {
    private String name;
    private int birthYear;

    public void setBirthYear(int year) {
        this.birthYear = year;
    }

    public int getAge() {
        // 调用私有方法计算年龄
        return calculateAge(2023);
    }

    // 私有方法：仅内部使用的辅助方法
    private int calculateAge(int currentYear) {
        return currentYear - birthYear;
    }
}

在这个例子中，calculateAge()是私有方法，外部代码无法直接调用，但可以被类内部的getAge()方法调用。

this关键字的使用

在方法内部，this关键字代表当前对象的引用，主要用于：

1. 区分字段与局部变量：当方法参数与字段同名时，必须使用this指明字段

public void setName(String name) {
    this.name = name; // this.name表示字段，name表示参数
}

1. 调用当前对象的其他方法：

public void printInfo() {
    System.out.println("姓名：" + this.getName()); // 调用当前对象的getName()方法
    System.out.println("年龄：" + this.getAge());
}

1. 在构造方法中调用其他构造方法（后续章节介绍）

当方法参数与字段不同名时，this可以省略，Java会自动识别字段。

方法参数的传递机制

Java中方法参数的传递遵循"值传递"原则，但对于引用类型，传递的是对象的引用值，这会导致一些特殊现象。

基本类型参数的传递

基本类型（如int、double）参数传递的是值的副本，方法内部对参数的修改不会影响外部变量：

public class ParameterDemo {
    public static void main(String[] args) {
        int num = 10;
        System.out.println("调用前：" + num); // 10
        modifyValue(num);
        System.out.println("调用后：" + num); // 10（未被修改）
    }

    private static void modifyValue(int value) {
        value = 20; // 修改的是参数副本
    }
}

引用类型参数的传递

引用类型（如String[]、自定义对象）参数传递的是对象的引用地址，方法内部对对象的修改会影响外部变量：

public class ReferenceParameterDemo {
    public static void main(String[] args) {
        String[] names = {"张三", "李四"};
        System.out.println("调用前：" + names[0]); // 张三
        modifyArray(names);
        System.out.println("调用后：" + names[0]); // 王五（被修改）
    }

    private static void modifyArray(String[] arr) {
        arr[0] = "王五"; // 修改的是数组对象本身
    }
}

特殊情况：String类型的传递

String是引用类型，但它具有不可变性（一旦创建就不能修改），因此表现出类似基本类型的传递特性：

public class StringParameterDemo {
    public static void main(String[] args) {
        String name = "张三";
        System.out.println("调用前：" + name); // 张三
        modifyString(name);
        System.out.println("调用后：" + name); // 张三（未被修改）
    }

    private static void modifyString(String str) {
        str = "李四"; // 创建了新的String对象，原对象未变
    }
}

可变参数：灵活处理不定数量的参数

Java支持可变参数（Varargs），允许方法接收不定数量的同类型参数，语法为类型... 参数名：

public class VarargsDemo {
    // 计算多个整数的和
    public int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    public static void main(String[] args) {
        VarargsDemo demo = new VarargsDemo();
        System.out.println(demo.sum(1, 2, 3)); // 6
        System.out.println(demo.sum(10, 20));  // 30
        System.out.println(demo.sum(5));       // 5
        System.out.println(demo.sum());        // 0（允许传入0个参数）
    }
}

可变参数的本质是数组，在方法内部可以像数组一样访问，但调用时无需显式创建数组，更加方便。

注意：一个方法最多只能有一个可变参数，且必须是参数列表的最后一个参数。

综合示例：

下面通过一个完整示例展示方法在实际开发中的应用：

import java.util.Arrays;

public class Student {
    private String name;
    private int[] scores; // 存储多门课程成绩

    // 构造方法（后续章节详细介绍）
    public Student(String name, int[] scores) {
        this.name = name;
        this.scores = scores;
    }

    // 获取学生姓名
    public String getName() {
        return name;
    }

    // 获取所有成绩
    public int[] getScores() {
        // 返回数组的副本，避免外部修改内部数组
        return Arrays.copyOf(scores, scores.length);
    }

    // 计算平均成绩
    public double getAverageScore() {
        if (scores.length == 0) {
            return 0;
        }
        int total = sum(scores); // 调用私有方法
        return (double) total / scores.length;
    }

    // 计算总成绩（私有辅助方法）
    private int sum(int[] numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    // 判断是否所有成绩都及格（60分及以上）
    public boolean isAllPassed() {
        for (int score : scores) {
            if (score < 60) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        int[] scores = {85, 92, 78, 90};
        Student student = new Student("张三", scores);

        System.out.println("学生姓名：" + student.getName());
        System.out.println("成绩列表：" + Arrays.toString(student.getScores()));
        System.out.println("平均成绩：" + student.getAverageScore());
        System.out.println("是否全部及格：" + student.isAllPassed());
    }
}

总结

• 掌握封装的概念和作用
• 理解方法通过public/private等修饰符控制访问权限
• 理解方法参数的传递机制（基本数据类型、引用类型、String类型）
• 理解方法的可变参数的本质