Kiểu dữ liệu trong Java: kiểu nguyên thủy, kiểu tham chiếu

Hai nhóm: kiểu nguyên thủy và kiểu tham chiếu

Mọi giá trị trong Java đều có một kiểu dữ liệu (data type), và kiểu đó thuộc một trong hai nhóm. Kiểu nguyên thủy (primitive type) chứa trực tiếp một giá trị thô: một con số, một ký tự, hoặc đúng/sai. Kiểu tham chiếu (reference type) chứa một tham chiếu (con trỏ) tới một đối tượng nằm ở chỗ khác trong bộ nhớ: String, mảng, và mọi lớp do bạn hoặc thư viện định nghĩa.

Sự phân biệt này quan trọng vì kiểu nguyên thủy nhẹ và được sao chép theo giá trị, còn biến tham chiếu trỏ tới các đối tượng dùng chung. Hãy bắt đầu với tám kiểu nguyên thủy: chúng là nền móng cho mọi thứ khác.

Tám kiểu nguyên thủy

Java có đúng tám kiểu nguyên thủy có sẵn. Sáu kiểu là số, một kiểu là ký tự, một kiểu là boolean:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // 8-bit integer,  -128 .. 127
        short  s = 30000;        // 16-bit integer
        int    i = 2_000_000;    // 32-bit integer (the default for whole numbers)
        long   big = 9_000_000_000L; // 64-bit integer - note the L

        float  f = 3.14f;        // 32-bit decimal - note the f
        double d = 3.141592653589793; // 64-bit decimal (the default for decimals)

        char   c = 'A';          // a single 16-bit Unicode character
        boolean flag = true;     // only true or false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Vài điều cần để ý ngay: dấu gạch dưới trong 2_000_000 chỉ là dấu phân cách cho dễ đọc và trình biên dịch bỏ qua, hậu tố L và f là bắt buộc (xem thêm bên dưới), còn char dùng nháy đơn trong khi String dùng nháy kép.

Chọn kiểu số

Bạn gần như không bao giờ cần byte hay short: chúng chỉ tiết kiệm bộ nhớ trong những mảng rất lớn. Lựa chọn thực sự là giữa int/long cho số nguyên và float/double cho số thập phân.

Cái bẫy ở đây là tràn số (overflow). Một int vượt quá phạm vi sẽ lặng lẽ quay vòng: không báo lỗi, chỉ ra kết quả sai:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // wraps to a negative number!

        long safe = (long) maxInt + 1;  // promote to long first
        System.out.println(safe);
    }
}

maxInt + 1 bị tràn thành -2147483648 vì cả hai toán hạng đều là int và kết quả vẫn là int. Ép kiểu một vế sang long trước sẽ tính toán bằng 64 bit. Khi giá trị có thể lớn, nhất là số mili giây tính từ năm 1970, hãy dùng long.

Literal và hậu tố

Một literal số viết trơn có kiểu mặc định, và điều này hay khiến người học vấp. 100 là int; 3.14 là double. Để viết literal kiểu long hoặc float, bạn phải thêm hậu tố:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // without L this is too big for int -> error
        float ratio = 0.5f;               // without f the right side is a double -> error
        double pi = 3.14;                 // fine - decimals default to double

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Bỏ L khỏi 8_000_000_000L thì code không biên dịch được, vì literal đã vượt phạm vi int trước khi tới được biến long. Bỏ f khỏi 0.5f thì Java báo rằng không thể gán double cho float mà không ép kiểu. Hậu tố không phân biệt hoa thường, nhưng hãy dùng L viết hoa: chữ l thường trông y hệt chữ số 1.

char thực chất là một con số

Một char lưu một đơn vị mã Unicode 16 bit, nghĩa là nó cũng là một số nguyên không dấu nhỏ. Bạn có thể tính toán với nó và chuyển qua lại bằng ép kiểu:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - the Unicode value of 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Cách này đôi khi tiện để dịch chữ cái, nhưng đừng dựa vào nó để xử lý văn bản: việc đó là của String. Lưu ý char dùng nháy đơn ('A'); nháy kép ("A") tạo ra một String một ký tự, là một kiểu hoàn toàn khác.

Giá trị mặc định (và cái bẫy của biến cục bộ)

Thuộc tính và phần tử mảng mà bạn không khởi tạo sẽ nhận một giá trị mặc định hợp lý. Nhưng điều này chỉ áp dụng cho thuộc tính và ô mảng: biến cục bộ không có giá trị mặc định, và dùng biến trước khi gán giá trị là lỗi biên dịch, không phải bất ngờ lúc chạy.

public class Main {
    static int counter;        // field -> defaults to 0
    static boolean ready;      // field -> defaults to false
    static String name;        // field -> defaults to null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // array elements default to 0
        System.out.println(nums[0]); // 0
    }
}

Nếu bạn viết int x; System.out.println(x); bên trong main, trình biên dịch sẽ từ chối với thông báo "variable x might not have been initialized." Sự nghiêm ngặt đó là có chủ đích: nó ngăn bạn đọc phải dữ liệu rác. Các giá trị mặc định cần nhớ: kiểu số là 0, boolean là false, char là '\u0000', và mọi kiểu tham chiếu là null.

Tiếp theo: chuỗi

String là kiểu tham chiếu bạn sẽ dùng nhiều nhất: văn bản, ghép giá trị, dữ liệu người dùng nhập. Nó hoạt động khác với các kiểu nguyên thủy ở đây: nó là đối tượng, nó bất biến, và so sánh chuỗi có những cạm bẫy riêng. Trang tiếp theo sẽ nói về nó.