Tham số phương thức Java: đối số, truyền tham trị, return

Tham số giúp phương thức nhận đầu vào

Một phương thức lúc nào cũng làm đúng một việc như nhau thì rất hạn chế. Tham số (parameter) là các đầu vào bạn khai báo trong cặp ngoặc của phương thức, để cùng một phương thức có thể làm việc với những giá trị khác nhau mỗi lần được gọi.

Bạn liệt kê từng tham số kèm kiểu và tên. Bên trong thân phương thức, tham số hoạt động như một biến cục bộ bình thường, đã chứa sẵn giá trị mà bên gọi truyền vào.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name là tham số. "Sam" và "Alex" là các đối số (argument), tức những giá trị cụ thể được đưa vào ở lời gọi. Một định nghĩa phương thức, hai đầu ra khác nhau.

Tham số và đối số

Hai từ này hay bị dùng lẫn lộn, nhưng phân biệt rõ ràng vẫn có ích:

• Tham số là chỗ giữ chỗ trong phần khai báo: String name.
• Đối số là giá trị bạn thực sự truyền vào: "Sam".

Vậy void greet(String name) khai báo một tham số, còn greet("Sam") truyền một đối số. Khi ai đó nói "phương thức này nhận hai tham số", họ đang nói về phần khai báo; còn "tôi đã truyền hai đối số" là nói về lời gọi.

Nhiều tham số

Phân tách các tham số bằng dấu phẩy và cho mỗi tham số một kiểu riêng. Bạn không thể dùng chung một kiểu cho hai tham số như khi khai báo biến:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Đối số được ghép với tham số hoàn toàn theo vị trí, không theo tên. describe("Sam", 30, true) chạy được vì thứ tự khớp với (String name, int age, boolean active). Đổi chỗ hai đối số có kiểu tương thích, bạn sẽ gặp một bug logic âm thầm chứ không phải lỗi biên dịch, nên thứ tự rất quan trọng.

Một lỗi hay gặp là viết int add(int a, b). Mỗi tham số cần kiểu riêng: int add(int a, int b).

Trả về một giá trị

Tham số là cách dữ liệu đi vào; giá trị trả về là cách kết quả đi ra. Khai báo kiểu trả về trước tên phương thức, và dùng return để trao giá trị lại cho bên gọi:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 forces floating-point division
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

Kiểu trả về (double) phải khớp với thứ bạn thực sự return. Phương thức khai báo void không trả về gì: nó vẫn có thể dùng return; trống để thoát sớm, nhưng không thể trả về giá trị. Ngay khi return chạy, phương thức kết thúc và quyền điều khiển quay về chỗ gọi.

Java truyền tham trị

Điều này làm gần như ai cũng vấp lúc đầu. Khi bạn truyền một đối số, Java sao chép giá trị vào tham số. Với kiểu nguyên thủy, điều đó có nghĩa là phương thức có bản sao riêng: thay đổi tham số không bao giờ đụng tới biến của bên gọi:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // changes only this local copy
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // still 5
    }
}

x vẫn là 5. Phương thức đã sửa bản sao con số của riêng nó, không phải bản gốc.

Truyền đối tượng: vẫn là tham trị, nhưng để ý tham chiếu

Đối tượng có vẻ là ngoại lệ, nhưng thật ra không phải. Thứ được sao chép là tham chiếu (mũi tên trỏ tới đối tượng), không phải bản thân đối tượng. Vì vậy phương thức trỏ tới cùng một đối tượng và có thể thay đổi nó. Đó chính là lý do việc thêm phần tử vào một ArrayList dùng chung bên trong phương thức sẽ hiện ra ở phía bên gọi:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // mutates the shared object - visible to caller
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // reassigns the local copy only - NOT visible
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // still [a, b, new] - reassignment didn't escape
    }
}

Hai kết quả khác nhau, cùng một quy tắc. addItem đi theo tham chiếu và thay đổi list thật, nên bên gọi thấy new xuất hiện. replace gán lại tham số cho một list hoàn toàn mới, nhưng việc đó chỉ trỏ bản sao cục bộ của tham chiếu sang chỗ khác, nên list của bên gọi vẫn nguyên vẹn. Điều cần nhớ: bạn có thể thay đổi một đối tượng thông qua tham số, nhưng không bao giờ khiến biến của bên gọi trỏ sang chỗ mới được.

Tiếp theo: nạp chồng phương thức

Giờ bạn đã biết cách đưa cho phương thức đúng những đầu vào nó cần. Nhưng nếu bạn muốn một tên phương thức nhận được nhiều bộ tham số khác nhau, chẳng hạn print(int) và print(String), thì sao? Đó là nạp chồng phương thức (method overloading), nội dung của trang tiếp theo.