Giới thiệu chung

Cốt lõi của bất kỳ ngôn ngữ lập trình nào là cách nó lưu trữ và thao tác dữ liệu. Ngôn ngữ lập trình Java có thể hoạt động với các loại dữ liệu khác nhau, chẳng hạn như số, ký tự, luận lý, v.v. Để làm việc với các loại dữ liệu này, ngôn ngữ lập trình Java hỗ trợ khái niệm biến. Một biến giống như một thùng chứa trong bộ nhớ chứa dữ liệu được sử dụng bởi chương trình Java. Nó là một định danh có giá trị có thể thay đổi được.

Biến được liên kết với một kiểu dữ liệu định nghĩa kiểu dữ liệu sẽ được lưu trữ trong biến.

Java là một ngôn ngữ chặt chẽ, bất kỳ biến hoặc đối tượng nào được tạo từ một lớp phải thuộc về kiểu của nó và phải lưu trữ cùng một loại dữ liệu. Trình biên dịch kiểm tra tất cả các biến biểu thức và tham số để đảm bảo rằng chúng tương thích với kiểu dữ liệu của chúng. Trong trường hợp nếu phát hiện có lỗi hoặc không khớp thì phải sửa chúng trong thời gian biên dịch. Điều này làm giảm các lỗi thời gian chạy xảy ra ở các ngôn ngữ khác do loại dữ liệu không khớp.

Biến

Biến là một vị trí trong bộ nhớ của máy tính lưu trữ dữ liệu được sử dụng trong chương trình Java.

Biến được sử dụng trong chương trình Java để lưu trữ dữ liệu thay đổi trong quá trình thực thi chương trình. Chúng là những đơn vị lưu trữ cơ bản trong một chương trình Java. Các biến có thể được khai báo để lưu trữ các giá trị, chẳng hạn như tên, địa chỉ và chi tiết lương. Chúng phải được khai báo trước khi chúng có thể được sử dụng trong chương trình.

Cú pháp:

datatype variableNane;

Trong đó:

• datatype: kiểu dữ liệu hợp lệ trong Java.
• variableName: tên biến hợp lệ.

Ví dụ:

int rollNumber;
char grade;

Quy tắc đặt tên biến

Ngôn ngữ lập trình Java cung cấp tập hợp các quy tắc và quy ước phải tuân theo để đặt tên biến. Ví dụ, tên biến nên ngắn gọn và có ý nghĩa. Việc sử dụng các quy ước đặt tên đảm bảo thực hành lập trình tốt và dẫn đến ít lỗi cú pháp hơn.

Các quy tắc và quy ước đặt tên biến như sau:

Tên biến có thể bao gồm các chữ cái và chữ số Unicode, dấu gạch dưới (_) và ký hiệu đô la ($).

Tên của biến phải bắt đầu bằng một chữ cái, ký hiệu đô la ($) hoặc ký tự gạch dưới (_)

Tuy nhiên, theo phong cách code phổ biến, quy ước code khi đặt tên luôn bắt đầu tên biến của bạn bằng một chữ cái, không phải ‘$’ hoặc ‘_’.

Tên biến không được là từ khóa hay từ dành riêng trong Java

Tên biến trong Java phân biệt chữ hoa chữ thường (ví dụ: tên biến số và Số đề cập đến hai biến khác nhau)

Nếu tên biến bao gồm một từ duy nhất, thì tên đó phải ở dạng chữ thường (ví dụ: velocity hoặc ratio).

Nếu tên biến bao gồm nhiều hơn một từ, chữ cái đầu tiên của mỗi từ tiếp theo phải được viết hoa (ví dụ: employeeNumber và accountBalance).

Ví dụ:

Tên biến	Hợp lệ/không hợp lệ
rollNumber	Hợp lệ
a34x_b23	Hợp lệ
$abc_def	hợp lệ
_2010_tax	hợp lệ
$$_	hợp lệ
abc#Ghi	không hợp lệ
Integer	không hợp lệ
4short	không hợp lệ

Gán giá trị cho biến

Các giá trị có thể được gán cho các biến bằng cách sử dụng toán tử gán (=) giá trị cho các biến như sau:

Có hai cách để gán giá trị cho biến

Tại thời điểm khai báo biến

Ví dụ:

int rollNumber = 150;
char grade = 'A';

Sau khi khai báo biến

int rollNumber;
rollNumber = 150;

Ở đây, biến rollNumber được khai báo trước và sau đó, theo yêu cầu của biến trong mã, nó được khởi tạo bằng chữ số 101.

Ngooài ra, một số hàm nâng cao mô tả như sau:

// declares three integer variables x, y, and z
int x,y,z;
//Declares three integer variables, initializes a and c
int a = 5 , b, c=10;
//Declares a byte variable numand initializes its value to 20
byte num = 20;
//Declares the character variable n with value 'c'
char n = 'c';
// Stores value 10 in num1 and num2
int num2;
int num1 = num2 = 10;

Lưu ý – trong Java, một biến phải được khai báo trước khi nó có thể được sử dụng trong chương trình. Do đó, Java có thể được gọi là ngôn ngữ lập trình có phong cách lập trình với cú pháp chặt chẽ

Các kiểu biến khác nhau

Ngôn ngữ lập trình Java cho phép bạn xác định các kiểu biến khác nhau. Các biến này được phân loại như sau:

• Instance variables
• Static variables
• Local variables

Chúng được mô tả như sau:

Instance variables (biến thực thể/biến thể hiện): Trạng thái của một đối tượng được biểu diễn dưới dạng các trường hoặc thuộc tính hoặc biến thể hiện trong định nghĩa lớp. Mỗi đối tượng được tạo từ một lớp chứa các biến thể hiện riêng của nó. Nói cách khác, mỗi đối tượng sẽ có bản sao biến đối tượng riêng.

Hình dưới mô phỏng các biến thực thể được khai báo trong một khuôn mẫu lớp. Tất cả các đối tượng từ lớp chứa các biến đối tượng riêng của chúng là các trường không tĩnh.

Static variables (Biến tĩnh): Đây còn được gọi là biến lớp. Chỉ có một bản sao của biến tĩnh. ‘được duy trì trong bộ nhớ được chia sẻ bởi tất cả các đối tượng thuộc lớp đó. Các trường này được khai báo bằng cách sử dụng từ khóa STATIC và thông báo cho trình biên dịch rằng chỉ có một bản sao của biến này tồn tại bất kể số lần lớp đã được khởi tạo.

Local variables (biến cục bộ): Các biến được khai báo trong các khối hoặc phương thức của một lớp được gọi là biến cục bộ. Một phương thức đại diện cho hành vi của một đối tượng. Các biến cục bộ có thể nhìn thấy trong các phương thức đó và không thể truy cập được bên ngoài chúng. Một phương thức lưu trữ trạng thái tạm thời của nó trong các biến cục bộ. Không có từ khóa đặc biệt nào để khai báo một biến cục bộ, do đó, vị trí khai báo của biến khiến nó trở thành biến cục bộ.

Phạm vi của biến

Trong Java, các biến có thể được khai báo trong một lớp, phương thức hoặc trong bất kỳ khối nào. Các ranh giới của khối, nghĩa là mở và đóng các dấu ngoặc nhọn xác định phạm vi của các biến trong Java. Một phạm vi xác định Khả năng hiển thị của các biến đối với phần khác của chương trình. Mỗi khi một khối được xác định, nó sẽ tạo ra một phạm vi mới.
Tương tự, thời gian tồn tại của một biến xác định khoảng thời gian mà biến đó tồn tại trong một chương trình.

Các ngôn ngữ khác, chẳng hạn như C và C++ xác định khả năng hiển thị hoặc phạm vi của một biến trong hai loại. Đây là toàn cầu và địa phương. Trong Java, hai phạm vi chính của một biến được định nghĩa trong một lớp hoặc trong một phương thức.

Các biến được khai báo trong lớp có thể là biến thể hiện hoặc biến tĩnh. Các biến thể hiện được sở hữu bởi các đối tượng của lớp. Do đó, sự tồn tại hoặc phạm vi của chúng phụ thuộc vào việc tạo đối tượng. Tương tự, các biến tĩnh được chia sẻ giữa các đối tượng và tồn tại trong suốt thời gian tồn tại của một lớp.

Suy luận kiểu biến cục bộ

Các biến được định nghĩa trong các phương thức của một lớp là các biến cục bộ. Thời gian tồn tại của các biến này phụ thuộc vào việc thực thi các phương thức. Điều này có nghĩa là bộ nhớ được phân bổ cho các biến khi phương thức được gọi và bị hủy khi phương thức trả về. Sau khi các biến bị hủy, chúng không còn tồn tại nữa.

Các phương thức cũng có tham số. Tham số là các biến được khai báo với phương thức. Chúng giữ các giá trị được truyền cho chúng trong khi gọi phương thức. Các biến tham số cũng được coi là biến cục bộ. Điều đó có nghĩa là chúng tồn tại cho đến khi quá trình thực thi phương thức hoàn tất.

package main;

public class ScopeOfVariable {
	public static void main(String[] args) {
		int x;
		x = 10;
		{
			// x can accessible within main() block
			int y = 20; // y only accessible in this block
			System.out.println("x and y:" + x + " "+y);
			x = y * 2;
		}
	}
}

Kiểu dữ liệu

Khi bạn định nghĩa một biến trong Java, bạn phải thông báo cho trình biên dịch biến đó là loại gì. Đó là, liệu nó có được lưu trữ một số nguyên, một ký tự hay một số loại dữ liệu khác hay không. Thông tin này cho trình biên dịch biết cần phân bổ bao nhiêu dung lượng trong bộ nhớ tùy thuộc vào kiểu dữ liệu của một biến.

Do đó, các kiểu dữ liệu xác định loại dữ liệu có thể được lưu trữ trong các biến và thao tác có thể được thực hiện trên chúng.

Trong Java, các kiểu dữ liệu thuộc hai loại như sau:

• Kiểu dữ liệu nguyên thủy (Primitive data types)
• Kiểu dữ liệu tham chiếu (Reference data types)

Các kiểu dữ liệu nguyên thủy

Ngôn ngữ lập trình Java cung cấp tám kiểu dữ liệu nguyên thủy để lưu trữ dữ liệu trong các chương trình Java. Kiểu dữ liệu nguyên thủy, còn được gọi là kiểu dữ liệu dựng sẵn, lưu trữ một giá trị tại một thời điểm, chẳng hạn như một số hoặc một ký tự. Kích thước của mỗi loại dữ liệu sẽ giống nhau trên tất cả các máy khi thực thi chương trình Java.

Các kiểu dữ liệu nguyên thủy được xác định trước bằng ngôn ngữ Java và được xác định là các từ dành riêng.

Mô phỏng kiểu dữ liệu nguyên thủy Java

Các kiểu dữ liệu số nguyên (Integer)

Các kiểu dữ liệu số nguyên được Java hỗ trợ là byte, short, int và long. Các kiểu dữ liệu này có thể lưu trữ các giá trị số nguyên đã ký. Số nguyên có dấu là những số nguyên có khả năng biểu thị số dương cũng như số âm, chẳng hạn như -40.

Các ngôn ngữ, chẳng hạn như C hoặc C++, hỗ trợ số nguyên có dấu và không dấu, nhưng Java không hỗ trợ

• byte – Được sử dụng để lưu trữ một lượng nhỏ dữ liệu. Đây là loại 8:bit có dấu và có thể lưu trữ các giá trị nằm trong khoảng từ -128 đến 127. Điều này hữu ích khi làm việc với luồng dữ liệu từ mạng hoặc tệp. Dữ liệu này
• short – Loại dữ liệu này ít được sử dụng nhất. Nó là loại 16-bit có dấu và có thể lưu trữ các giá trị nằm trong khoảng từ 32,768 đến 32,767, Loại này chủ yếu áp dụng cho các máy tính 16-bit. Kiểu dữ liệu này được sử dụng để lưu trữ các số nhỏ hơn, ví dụ: mã số nhân viên. ngắn. từ khóa được sử dụng để khai báo một biến ngắn.
• int – Đây là kiểu dữ liệu được sử dụng phổ biến nhất để lưu trữ các số nguyên. Đây là loại 32 bit có dấu và có thể lưu trữ các giá trị nằm trong khoảng từ -2.147.483.648 đến 2.147.483.647. Đây là kiểu dữ liệu linh hoạt và hiệu quả nhất. Nó có thể được sử dụng để lưu trữ tổng số tiền lương được trả cho tất cả các nhân viên của công ty. Từ khóa int được sử dụng để khai báo một biến số nguyên.
• long – itis a signed 64-bit type and can store values ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. It is useful when an int type is not large enough to hold the desired value. The range of value a long data type can store is quite large for example, population of a country. long keyword is used to declare long variables for storing large numeric values.

Các kiểu dữ liệu dấu phẩy động/số thực (float)

Các kiểu dữ liệu dấu chấm động được Java hỗ trợ là float và double.

• float – Loại này hỗ trợ một giá trị chính xác duy nhất với bộ nhớ 32 bit. Chúng hữu ích khi một số yêu cầu một thành phần phân số, nhưng với độ chính xác thấp hơn. Ví dụ: biểu diễn tiền bằng đô la và xu được yêu cầu phải ở dạng giá trị dấu phẩy động. Cái phao. từ khóa is, được sử dụng để lưu trữ các giá trị float. Ví dụ, float squRoot, cubeRoot;
• double – Loại này hỗ trợ độ chính xác kép với bộ lưu trữ 64 bit. Độ chính xác kép là bộ xử lý fon nhanh hơn được tối ưu hóa cho các phép tính toán học. Loại dữ liệu này hữu ích khi cần duy trì độ chính xác trong khi thực hiện các phép tính. Từ khóa kép được sử dụng để lưu trữ các số có giá trị lớn. Ví dụ: nhân đôi số thập phân lớn.

Kiểu dữ liệu ký tự (character)

kiểu dữ liệu char thuộc nhóm này và đại diện cho các ký hiệu trong một bộ ký tự như chữ cái và số. kiểu dữ liệu char lưu trữ ký tự Unicode 16 bit và giá trị của nó nằm trong khoảng từ 0 (‘\10000″) đến 65,535 (‘\ueeee’).

Unicode là bộ ký tự 16 bit, chứa tất cả các ký tự thường dùng trong xử lý thông tin. Đó là một nỗ lực để hợp nhất các bảng chữ cái của các ngôn ngữ khác nhau trên thế giới thành một bộ ký tự quốc tế và duy nhất.

Kiểu dữ liệu luận lý (Boolean)

kiểu dữ liệu boolean thuộc nhóm này và đại diện cho các giá trị đúng hoặc sai. Loại dữ liệu này được sử dụng để theo dõi các điều kiện true/false. Kích thước của nó không được xác định chính xác.

Kiểu dữ liệu chuỗi (String)

Ngoài các kiểu dữ liệu nguyên thủy, ngôn ngữ lập trình Java cũng hỗ trợ các chuỗi. Một chuỗi là một chuỗi các ký tự. Java không cung cấp bất kỳ kiểu dữ liệu nguyên thủy nào để lưu trữ các chuỗi, thay vào đó cung cấp một lớp String để tạo các biến chuỗi. Lớp String được định nghĩa trong gói java.lang trong Java SE API.

String str="AStringData";

Câu lệnh, String str tạo một đối tượng String và không phải là kiểu dữ liệu nguyên thủy. Khi bạn đặt một giá trị chuỗi trong dấu ngoặc kép, môi trường thời gian chạy Java sẽ tự động tạo một đối tượng kiểu Chuỗi. Ngoài ra, khi biến String được tạo với giá trị “A String Data”, nó sẽ không đổi và bạn không thể thay đổi giá trị của biến trong chương trình. Tuy nhiên, việc khởi tạo biến chuỗi với giá trị mới sẽ tạo ra một đối tượng Chuỗi mới. Hành vi này của các chuỗi làm cho chúng trở thành các đối tượng bất biến.

Ví dụ:

public class PrimitiveExample {
    public static void main(String[] args) {
        // Integer types
        byte myByte = 10;
        short myShort = 20;
        int myInt = 30;
        long myLong = 40L;

        // Floating-point types
        float myFloat = 3.14f;
        double myDouble = 2.71828;

        // Character type
        char myChar = 'A';

        // Boolean type
        boolean myBoolean = true;

        // Print the values
        System.out.println("Byte: " + myByte);
        System.out.println("Short: " + myShort);
        System.out.println("Int: " + myInt);
        System.out.println("Long: " + myLong);
        System.out.println("Float: " + myFloat);
        System.out.println("Double: " + myDouble);
        System.out.println("Char: " + myChar);
        System.out.println("Boolean: " + myBoolean);
    }
}

Output:

Byte: 10
Short: 20
Int: 30
Long: 40
Float: 3.14
Double: 2.71828
Char: A
Boolean: true

Các kiểu dữ liệu tham chiếu

Trong Java, các đối tượng và mảng được gọi là các biến tham chiếu. Khi một đối tượng hoặc một mảng được tạo, một lượng bộ nhớ nhất định được gán cho nó và địa chỉ của khối bộ nhớ này được lưu trong biến tham chiếu. Nói cách khác, kiểu dữ liệu tham chiếu là một địa chỉ của một đối tượng hoặc một mảng được tạo trong bộ nhớ.

Liệt kê và mô tả ba loại dữ liệu tham chiếu ở bảng dưới:

Kiểu dữ liệu	Mô tả
Array	Nó là một tập hợp của một số mục có cùng kiểu dữ liệu. Ví dụ, tên của các sinh viên trong một lớp có thể được lưu trữ trong một mảng
Class	Nó là sự đóng gói của các biến đối tượng (thuộc tính) và các phương thức đối tượng
Interface	Nó là một loại lớp trong Java được sử dụng để thực hiện kế thừa

Literals

Literals là các mục dữ liệu có giá trị cố định hoặc không đổi. Do đó, chúng ta cũng gọi Literals là hằng số trong Java. Literal đại diện cho một giá trị cố định được gán cho một biến. Nó được thể hiện trực tiếp trong mã và không yêu cầu tính toán.

Một số literal cho các kiểu dữ liệu nguyên thủy:

Integer	Float	Character	Boolean
50	35.7F	‘C’	true

Một literal được sử dụng bất cứ nơi nào một giá trị của loại của nó được cho phép. Tuy nhiên, có một số loại nghĩa đen khác nhau. Một số trong số chúng là:

Integer literals

Các ký tự số nguyên được sử dụng để biểu thị một giá trị int, mà trong Java là một giá trị số nguyên 32 bit. Trong một chương trình, số nguyên có lẽ là loại được sử dụng phổ biến nhất. Bất kỳ giá trị số nguyên nào cũng được coi là một integer literal

Integers literals có thể được biểu diễn dưới dạng:

Giá trị thập phân có cơ số là 10 và bao gồm các số từ 0 đến 9. Ví dụ: int decNum = 56;

Các giá trị thập lục phân có cơ số là 16 và bao gồm các số từ 0 đến 9 và các chữ cái A đến F. Ví dụ, int hexNum = 0x1c;

Các giá trị nhị phân có cơ số là 2 và bao gồm các số 0 và 1. Java SE 7 hỗ trợ các ký tự nhị phân. Ví dụ: int binNum = 0b0010;

Một số nguyên cũng có thể được gán cho các kiểu số nguyên khác, chẳng hạn như byte hoặc long. Khi một giá trị bằng chữ được gán cho một biến byte hoặc short, không có lỗi nào được tạo ra nếu giá trị literal nằm trong phạm vi của loại mục tiêu. Các số nguyên có thể được biểu thị bằng một ký tự viết hoa tùy chọn (‘L’) hoặc ký tự viết thường (‘l’) ở cuối, ký tự này cho máy tính coi số đó là một số long (số nguyên 64 bit)

Floating-Point Literals

Floating-point literals đại diện cho các giá trị thập phân với một thành phần phân số. Floating-point literals có một số phần:

• Thành phần số nguyên, ví dụ 0, 1, 2)… 9.
• Dấu thập phân, ví dụ 4.90, 3.141, v.v.
• Số mũ được biểu thị bằng chữ E hoặc e theo sau là số thập phân, có thể dương hoặc âm. Ví dụ: e+208, 7.436E6, 23763E-05
• Hậu tố, D, d , F hoặc f

Chữ dấu phẩy động trong Java mặc định có độ chính xác gấp đôi. Một chữ nổi được biểu thị bằng F hoặc f được thêm vào giá trị và một chữ kép được biểu thị bằng D hoặc d.

Boolean Literal

Boolean literals rất đơn giản và chỉ có hai giá trị logic – true và false. Các giá trị này không chuyển đổi thành bất kỳ biểu diễn số nào. Một chữ boolean thực sự trong Java không bằng một, cũng không phải chữ fale bằng không. Chúng chỉ có thể được gán cho các biến boolean hoặc được sử dụng trong các biểu thức với các toán tử boolean.

Character Literals

Chữ ký tự được đặt trong dấu nháy đơn. Tất cả các ký tự ASCII hiển thị có thể được đặt trực tiếp trong dấu ngoặc kép, chẳng hạn như ‘, ‘g’,’$’ và ‘z’. Các ký tự đơn không thể được đặt trong dấu ngoặc đơn được sử dụng với escape sequence

Null Literals

‘Khi một đối tượng được tạo, một lượng bộ nhớ nhất định sẽ được phân bổ cho đối tượng đó. Địa chỉ bắt đầu của bộ nhớ được phân bổ được lưu trữ trong một biến đối tượng, nghĩa là một biến tham chiếu.
Tuy nhiên, đôi khi, biến tham chiếu không mong muốn tham chiếu đến đối tượng đó. Trong trường hợp như vậy, biến tham chiếu được gán giá trị bằng chữ null.

Ví dụ:

Car toyota = null;

String Literals

String literals bao gồm chuỗi các ký tự được đặt trong dấu ngoặc kép. Ví dụ: “wielcome to Java”, “Hello\nworld”.

Ký tự gạch dưới trong Numeric Literals

Java cho phép bạn thêm các ký tự gạch dưới (_) giữa các chữ số của một chữ số. Ký tự gạch dưới chỉ có thể được sử dụng giữa các chữ số.

Chữ nguyên vẹn, ký tự gạch dưới có thể được cung cấp cho số điện thoại, số nhận dạng hoặc số bộ phận, v.v. Tương tự, đối với các chữ số dấu phẩy động, dấu gạch dưới được sử dụng giữa các giá trị thập phân lớn.

Việc sử dụng ký tự gạch dưới theo nghĩa đen giúp cải thiện khả năng đọc của chương trình Java.

Các hạn chế đối với việc sử dụng dấu gạch dưới trong chữ số như sau:

• Một số không thể bắt đầu hoặc kết thúc bằng dấu gạch dưới.
• Trong chữ dấu phẩy động, dấu gạch dưới không được đặt liền kề với dấu thập phân.
• Không thể đặt dấu gạch dưới trước hậu tố, L hoặc F
• Không thể đặt dấu gạch dưới trước hoặc sau mã định danh nhị phân hoặc thập lục phân, chẳng hạn như b hoặc x

Danh sách Bảng hiển thị vị trí hợp lệ và không hợp lệ của ký tự gạch dưới:

Numeric Literal	Valid/Invalid
1234_9876_5012_5454L	Valid
_8976	Invalid do dấu gạch dưới được đặt ở đầu
3.14_15F	Valid
0b11010000_11110000_00001111	Valid
3.14_15F	Invalid vì dấu gạch dưới liền kề với dấu thập phân
0x_78	Invalid vì dấu gạch dưới được đặt sau hệ thập lục phân

Escape Sequences

Các Escape Sequences có thể được sử dụng cho ký tự và chuỗi ký tự. Một Escape Sequences Là một dãy ký tự đặc biệt được dùng để biểu diễn các ký tự, không thể nhập trực tiếp vào một chuỗi. Ví dụ: để bao gồm các khoảng trống tab hoặc một ký tự dòng mới trong một dòng hoặc để bao gồm các ký tự có ký hiệu khác trong chương trình Java (\ hoặc “), các Escape Sequences được sử dụng.

Escape Sequences bắt đầu bằng ký tự gạch chéo ngược (\), biểu thị rằng (các) ký tự theo sau phải được xử lý theo cách đặc biệt. Đầu ra được hiển thị bởi Java có thể được định dạng với sự trợ giúp của các ký tự Escape Sequences.

Danh sách escape sequence:

Ví dụ:

System.out.println("Hello\nWorld");
System.out.println("Name:\tJohn");
System.out.println("C:\\path\\to\\file");
System.out.println("She said, \"Hello!\"");
System.out.println('I\'m happy.');

Output:

Hello
World
Name:    John
C:\path\to\file
She said, "Hello!"
I'm happy.

Hằng số và kiểu dữ liệu liệt kê (enumerations)

Xét một đoạn mã tính diện tích hình tròn. Để tính diện tích hình tròn, giá trị của PI và bán kính phải được cung cấp trong công thức. Giá trị của PI là một giá trị không đổi. Giá trị này sẽ không thay đổi bất kể giá trị được cung cấp cho bán kính.

Tương tự, các hằng số trong Java là các giá trị cố định được gán cho các mã định danh không bị sửa đổi trong suốt quá trình thực thi mã. Chúng được xác định khi bạn muốn giữ lại các giá trị để sử dụng lại chúng sau này hoặc để ngăn bất kỳ sửa đổi nào đối với các giá trị. Trong Java, việc khai báo các biến hằng được bắt đầu bằng từ khóa final. Khi biến hằng được khởi tạo với một giá trị, bất kỳ nỗ lực thay đổi giá trị nào trong chương trình sẽ tạo ra lỗi biên dịch.

Cú pháp:

final data_type variable_name=value;

Ví dụ:

public class ConstantsExample {
    public static final int MAX_COUNT = 100;
    public static final double PI = 3.14159;
    public static final String GREETING = "Hello, World!";
    
    public static void main(String[] args) {
        System.out.println("Max count: " + MAX_COUNT);
        System.out.println("PI value: " + PI);
        System.out.println("Greeting: " + GREETING);
    }
}

Output:

Max count: 100
PI value: 3.14159
Greeting: Hello, World!

Lưu ý – Từ khóa cuối cùng cũng có thể được áp dụng ở cấp độ phương thức hoặc lớp. Khi được áp dụng cho một phương thức, thì nó không thể bị ghi đè. Khi được áp dụng cho một khai báo lớp, thì lớp đó không thể được mở rộng.

Java SE 5.0 đã giới thiệu kiểu liệt kê (enumeration). Một kiểu liệt kê được định nghĩa là một danh sách chứa các hằng số. Trong các ngôn ngữ trước đây, như C++, kiểu dữ liệu liệt kê là một danh sách các hằng số nguyên được đặt tên, nhưng trong Java, kiểu dữ liệt kê là một kiểu lớp. Điều này có nghĩa là nó có thể chứa các biến thực thể, phương thức và hàm khởi tạo. Kết quả là, khái niệm liệt kê đã được mở rộng trong Java. Kiểu dữ liệu liệt kê được tạo bằng cách sử dụng từ khóa enum.

Cú pháp:

enum enum_name {
constant1, constant2, ..., constant
}

Mặc dù, enum là một lớp trong Java, nhưng chúng ta không sử dụng toán tử new để khởi tạo nó. Thay vào đó, hãy khai báo biến kiểu liệt kê để sử dụng nó trong chương trình Java. Điều này tương tự như việc sử dụng các kiểu dữ liệu nguyên thủy. Kiểu dữ liệu liệt kê chủ yếu được sử dụng với các cấu trúc ra quyết định, chẳng hạn như câu lệnh trường hợp chuyển đổi.

Ví dụ:

public class EnumExample {
    enum Day {
        MONDAY,
        TUESDAY,
        WEDNESDAY,
        THURSDAY,
        FRIDAY,
        SATURDAY,
        SUNDAY
    }
    
    public static void main(String[] args) {
        Day today = Day.WEDNESDAY;
        
        switch (today) {
            case MONDAY:
            case TUESDAY:
            case WEDNESDAY:
            case THURSDAY:
            case FRIDAY:
                System.out.println("It's a weekday.");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("It's a weekend.");
                break;
        }
    }
}

Formated output và input

Khi nào một đầu ra được hiển thị trên màn hình, nó cần phải được định dạng. Định dạng có thể được thực hiện như sau:

• print và println
• printf
• format()

Các phương thức này hoạt động tương tự nhau. Phương thức format() sử dụng java.util.Formatter để thực hiện công việc định dạng.

Phương thức print() và println()

Các phương thức này chuyển đổi tất cả dữ liệu thành chuỗi và hiển thị dưới dạng một giá trị. Các phương thức sử dụng phương thức tostring() thích hợp để chuyển đổi các giá trị. Các phương thức này cũng có thể được sử dụng để in tổ hợp hỗn hợp của chuỗi và giá trị số dưới dạng chuỗi trên đầu ra tiêu chuẩn.

Ví dụ:

public class DisplaySum {
    public static void main(String[] args) {
        int num1 = 42;
        int num2 = 107;
        int sum = num1 + num2;
        
        System.out.print("The sum of ");
        System.out.print(num1);
        System.out.print(" and ");
        System.out.print(num2);
        System.out.print(" is ");
        System.out.print(sum);
        System.out.println();
        
        int num3 = 15;
        sum = num1 + num2 + num3;
        
        System.out.println("The sum of " + num1 + ", " + num2 + ", and " + num3 + " is " + sum + ".");
    }
}

Phương thức printf()

Phương thức printf() có thể được sử dụng để định dạng đầu ra số cho màn hình đen

Một số format specifier (bổ từ định dạng):

Format Specifier	Description
%d	Kết quả được định dạng dưới dạng số nguyên thập phân
%f	Kết quả được định dạng là số thực
%o	Kết quả được định dạng dưới dạng số bát phân
%e	Kết quả được định dạng dưới dạng số thập phân trong ký hiệu khoa học
%n	Kết quả được hiển thị trong một dòng mới

Ví dụ:

public class PrintfExample {
    public static void main(String[] args) {
        String name = "Alice";
        int age = 25;
        double height = 1.65;
        
        System.out.printf("Name: %s, Age: %d, Height: %.2f meters\n", name, age, height);
        
        int number = 42;
        System.out.printf("The answer is %d\n", number);
        
        double pi = Math.PI;
        System.out.printf("The value of pi is approximately %.4f\n", pi);
    }
}

Phương thức format()

Phương thức này định dạng nhiều đối số dựa trên một chuỗi định dạng. Chuỗi định dạng bao gồm thông tin ký tự chuỗi bình thường được liên kết với các chỉ định định dạng và danh sách đối số.

%[arg_index$] [flags] [width] [.precision] conversion character

Trong đó:

arg_index: một số nguyên theo sau là ký hiệu $. Số nguyên chỉ ra rằng đối số sẽ được in ở vị trí đã đề cập.

flags: Là tập hợp các ký tự định dạng kết quả xuất ra. Có các cờ khác nhau có sẵn trong Java.

Flag	Description
“-“	Căn trái
“+”	Bao gồm một dấu (+ hoặc -) với đối số này
“0”	Đệm đối số này bằng số 0
“,”	Sử dụng dấu tách nhóm theo ngôn ngữ cụ thể
“(“	Đặt số âm trong ngoặc đơn

width: Cho biết số lượng ký tự tối thiểu được in và không được âm.

precision: Cho biết số chữ số được in sau dấu thập phân. Được sử dụng với số dấu phẩy động.

conversion character: Chỉ định loại đối số sẽ được định dạng. Ví dụ: b cho boolean, cho char, d cho số nguyên, f cho dấu phẩy động và s cho chuỗi.

Các giá trị trong ‘[]’ là tùy chọn. Các yếu tố bắt buộc duy nhất của trình xác định định dạng là % và ký tự chuyển đổi.

Ví dụ:

public class FormatExample {
    public static void main(String[] args) {
        String name = "Alice";
        int age = 25;
        double height = 1.65;
        
        String formattedString = String.format("Name: %s, Age: %d, Height: %.2f meters", name, age, height);
        System.out.println(formattedString);
        
        int number = 42;
        formattedString = String.format("The answer is %d", number);
        System.out.println(formattedString);
        
        double pi = Math.PI;
        formattedString = String.format("The value of pi is approximately %.4f", pi);
        System.out.println(formattedString);
    }
}

Ví dụ 2:

public class FormatFlagsExample {
    public static void main(String[] args) {
        int number = -42;
        double value = 1234.56789;

        // Use "+" flag to display sign for positive and negative numbers
        String formattedNumberWithSign = String.format("Number with sign: %+d", number);
        System.out.println(formattedNumberWithSign);

        // Use "-" flag to left-justify the text (width = 10)
        String formattedLeftJustifiedText = String.format("Left-justified text: %-10s", "Hello");
        System.out.println(formattedLeftJustifiedText);

        // Use "0" flag to pad the number with leading zeros (width = 6)
        String formattedNumberWithLeadingZeros = String.format("Number with leading zeros: %06d", number);
        System.out.println(formattedNumberWithLeadingZeros);

        // Use "," flag to add a comma as a thousand separator
        String formattedNumberWithCommaSeparator = String.format("Number with comma separator: %,d", 1234567);
        System.out.println(formattedNumberWithCommaSeparator);

        // Use "(" flag to enclose negative numbers in parentheses
        String formattedNumberWithParentheses = String.format("Number with parentheses: %(d", number);
        System.out.println(formattedNumberWithParentheses);

        // Use combination of flags for formatting floating-point number
        String formattedFloatingPointNumber = String.format("Floating-point number: %+010.3f", value);
        System.out.println(formattedFloatingPointNumber);
    }
}

Output:

Number with sign: -42
Left-justified text: Hello     
Number with leading zeros: -0042
Number with comma separator: 1,234,567
Number with parentheses: (42)
Floating-point number: +001234.568

Nhập vào theo định dạng (Formated Input)

Lớp Scanner cho phép người dùng đọc hoặc chấp nhận các giá trị của các loại dữ liệu khác nhau từ bàn phím. Nó chia đầu vào thành các mã thông báo và dịch các mã thông báo riêng lẻ tùy thuộc vào loại dữ liệu của chúng.

Để sử dụng lớp Scanner, chúng ta truyền đối tượng InputStream vào hàm khởi tạo.

Ví dụ:

Scanner input = new Scanner(System.in);

Ở đây, input là một đối tượng của lớp Scanner và Sytem.in là một đối tượng luồng đầu vào (input stream).

Bảng dưới liệt kê các phương thức khác nhau của lớp Scanner có thể được sử dụng để nhận các giá trị số từ ngời dùng:

Phương thức	Mô tả
nextByte()	Đọc giá trị Byte nhập vào từ người dùng
nextInt()	Đọc giá trị Int nhập vào từ người dùng
nextLong()	Đọc giá trị Long nhập vào từ người dùng
nextFloat()	Đọc giá trị Float nhập vào từ người dùng
nextDouble()	Đọc giá trị Double nhập vào từ người dùng

Ví dụ:

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Reading a byte
        System.out.print("Enter a byte: ");
        byte byteValue = scanner.nextByte();
        System.out.println("You entered: " + byteValue);

        // Reading an integer
        System.out.print("Enter an integer: ");
        int intValue = scanner.nextInt();
        System.out.println("You entered: " + intValue);

        // Reading a long
        System.out.print("Enter a long: ");
        long longValue = scanner.nextLong();
        System.out.println("You entered: " + longValue);

        // Reading a float
        System.out.print("Enter a float: ");
        float floatValue = scanner.nextFloat();
        System.out.println("You entered: " + floatValue);

        // Reading a double
        System.out.print("Enter a double: ");
        double doubleValue = scanner.nextDouble();
        System.out.println("You entered: " + doubleValue);

        scanner.close();
    }
}

Output:

Enter a byte: 100
You entered: 100

Enter an integer: 42
You entered: 42

Enter a long: 12345678900
You entered: 12345678900

Enter a float: 3.14
You entered: 3.14

Enter a double: 3.14159265359
You entered: 3.14159265359

Toán tử (Operator)

Tất cả các ngôn ngữ lập trình cung cấp một số cơ chế để thực hiện các hoạt động khác nhau trên dữ liệu được lưu trữ trong các biến. Hình thức hoạt động đơn giản nhất liên quan đến số học (chẳng hạn như cộng, chia, v.v.) hoặc so sánh giữa hai hoặc nhiều biến. Một tập hợp các ký hiệu được sử dụng để chỉ ra loại hoạt động sẽ được thực hiện trên dữ liệu. Các ký hiệu này được gọi là toán tử.

Xét biểu thức:

z = x + y;

Ký hiệu + trong câu lệnh được gọi là Toán tử và phép toán được thực hiện là phép cộng. Phép toán này được thực hiện trên hai biến x và y, được gọi là Toán hạng. Sự kết hợp của cả toán tử và toán hạng, z = x + y, được gọi là Biểu thức.

Java cung cấp một số loại toán tử và chúng như sau:

• Toán tử gán
• Toán tử số học
• Toán tử một ngôi
• Toán tử điều kiện
• Toán tử logic
• Toán tử Bitwise

Toán tử gán

Toán tử gán cơ bản là một dấu bằng duy nhất, ‘=’. Toán tử này được sử dụng để gán giá trị bên phải của nó cho toán hạng bên trái của nó. Việc gán giá trị cho nhiều biến có thể được thực hiện cùng một lúc. Nói cách khác, nó cho phép bạn tạo một chuỗi các phép gán.

Xem xét các câu lệnh sau:

int balance =3456;
char gender = 'M';

Giá trị 3456 và ‘M’ được gán cho các biến, balance và gender.

Ngoài toán tử gán cơ bản, còn có các toán tử kết hợp cho phép bạn sử dụng một giá trị trong một biểu thức, rồi đặt giá trị của nó thành kết quả của biểu thức đó.

Ví dụ:

int x = 3;
x += 5;

Sau câu lệnh thứ hai giá trị của x là 8, ý nghĩa của câu lệnh là x = x + 5.

Ví dụ:

x=10; // Gán giá trị 10 cho biến x
x+=5; // Tăng giá trị của x lên 5
x-=5; //Giảm giá trị của x xuống 5
x*=5; // Nhân giá trị của x với 5
x/=2; // Chia giá trị của x cho 2
x%=2; // Chia giá trị của x cho 2 và trả về phần dư

Toán tử số học

Các toán tử số học thao tác dữ liệu số và thực hiện các phép toán số học phổ biến trên dữ liệu.
Toán hạng của toán tử số học phải là kiểu số. Toán hạng Boolean không thể được sử dụng, nhưng toán hạng ký tự được cho phép. Các toán tử được đề cập ở đây có bản chất là nhị phân, nghĩa là chúng hoạt động trên hai toán hạng, chẳng hạn như x+y. Ở đây, + Là toán tử nhị phân hoạt động trên x và y.

Bảng dưới liệt kê các toán tử số học:

Toán tử	Mô tả
+	Phép cộng – Trả về tổng của các toán hạng
–	Phép trừ – Trả về hiệu của hai toán hạng
*	Phép nhân – Trả về tích của các toán hạng
/	Phép chia – Trả về kết quả của phép toán chia
%	Chia lấy dữ – Trả về phần kết quả dư từ phép chia

Đoạn mã dưới thể hiện việc sử dụng các toán tử số học.

x=2+3; // Trả về 5
y=8-5; // Trả về 3
x=5*2; //Trả về 10
x=5/2; // Trả về 2
y=10%3; //Trả về 1

Toán tử một ngôi

Toán tử một ngôi chỉ yêu cầu một toán hạng. Chúng thực hiện các thao tác khác nhau như tăng giảm giá trị của một biến đi 1, phủ định một biểu thức hoặc đảo ngược giá trị của một biến boolean.

Bảng dưới liệt kê các toán tử một ngôi:

Toán tử	Mô tả
+	Cộng một ngôi – Cho biết giá trị dương
–	Trừ một ngôi – Phủ định một biểu thức
++	Toán tử tăng – Tăng giá trị của một biến lên 1
—	Toán tử giảm – Giảm giá trị của một biến đi 1
!	Toán tử phủ định – Đảo ngược một giá trị boolean

Các toán tử ++ và — có thể được áp dụng trước (tiền tố) hoặc sau (hậu tố) toán hạng. Các câu lệnh ++variable và variable++ đều dẫn đến việc tăng giá trị của biến lên 1. Điểm khác biệt duy nhất là phiên bản tiền tố (++variable) sẽ tăng giá trị trước khi đánh giá, trong khi phiên bản hậu tố (variable++) sẽ đánh giá đầu tiên và sau đó tăng giá trị ban đầu.

Ví dụ:

int i = 5;
int j = i++; // j = 5, i = 6
int k = ++i  // k = 6, i = 6
i= -i // i = -6
boolean result = false; // result is false
result = !result; // result is true

Toán tử điều kiện/so sánh

Các toán tử điều kiện kiểm tra mối quan hệ giữa hai toán hạng. Một biểu thức liên quan đến các toán tử có điều kiện luôn đánh giá thành một giá trị boolean (true hoặc false).

Toán tử	Mô tả
==	Kiểm tra sự bằng nhau của hai giá trị
!=	Kiểm tra sự khác nhau của hai giá trị
>	Kiểm tra xem giá trị bên trái có lớn hơn giá trị bên phải không
<	Kiểm tra xem giá trị bên trái có nhỏ hơn giá trị bên phải không
>=	Kiểm tra xem giá trị bên trái có lớn hơn hoặc bằng giá trị bên phải không
<=	Kiểm tra xem giá trị bên trái có nhỏ hơn hoặc bằng giá trị bên phải không

Ví dụ:

public class ComparisonOperatorsExample {
    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 5;

        // Using comparison operators to compare two values
        System.out.println("num1 == num2: " + (num1 == num2));
        System.out.println("num1 != num2: " + (num1 != num2));
        System.out.println("num1 > num2: " + (num1 > num2));
        System.out.println("num1 < num2: " + (num1 < num2));
        System.out.println("num1 >= num2: " + (num1 >= num2));
        System.out.println("num1 <= num2: " + (num1 <= num2));

        // Using comparison operators with boolean values
        boolean isTrue = true;
        boolean isFalse = false;

        System.out.println("isTrue == isFalse: " + (isTrue == isFalse));
        System.out.println("isTrue != isFalse: " + (isTrue != isFalse));
    }
}

Output:

num1 == num2: false
num1 != num2: true
num1 > num2: true
num1 < num2: false
num1 >= num2: true
num1 <= num2: false
isTrue == isFalse: false
isTrue != isFalse: true

Toán tử logic

Toán tử logic (&& và | |) hoạt động trên hai biểu thức boolean.

Bảng dưới mô tả danh sách toán tử:

Toán tử	Mô tả
&&	AND – Chỉ trả về true nếu cả hai biểu thức đều true
||	OR – Trả về true nếu một trong hai biểu thức là true hoặc cả hai biểu thức đều true

Ví dụ:

public class LogicalAndExample {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        boolean result1 = a && b;
        boolean result2 = a && true;
        boolean result3 = false && true;

        System.out.println("result1: " + result1); // Output: result1: false
        System.out.println("result2: " + result2); // Output: result2: true
        System.out.println("result3: " + result3); // Output: result3: false
    }
}

Ví dụ 2:

public class LogicalOrExample {
    public static void main(String[] args) {
        boolean x = true;
        boolean y = false;

        boolean result1 = x || y;
        boolean result2 = x || false;
        boolean result3 = false || false;

        System.out.println("result1: " + result1); // Output: result1: true
        System.out.println("result2: " + result2); // Output: result2: true
        System.out.println("result3: " + result3); // Output: result3: false
    }
}

Toán tử Bitwise

Các toán tử bitwise hoạt động trên các biểu diễn dữ liệu nhị phân. Các toán tử này được sử dụng để thay đổi các bit riêng lẻ trong một toán hạng.

Bảng dưới liệt kê các toán tử bitwise khác nhau:

Toán tử	Mô tả
&	Bitwise AND – so sánh hai bit và tạo ra kết quả là 1 nếu cả hai bit đều là 1; ngược lại, nó trả về 0
|	Bitwise OR – so sánh hai bit và tạo ra kết quả là 1 nếu ít nhất 1 trong 2 bit là 1, nếu không nó trả về 0
^	XOR (Exclusive OR) so sánh hai bit và tạo ra kết quả là 1 nếu một trong hai hoặc cả hai bit là 1; ngược lại, nó trả về 0
~	Bitwise NOT Sử dụng để đảo ngược tất cả các bit của toán hạng
>>	Right Shift – Di chuyển tất cả các bit trong một số sang phải một vị trí giữ nguyên dấu của số âm
<<	Left Shift – Di chuyển tất cả các bit trong một số sang trái theo vị trí đã chỉ định

Ví dụ:

public class BitwiseOperatorsExample {
    public static void main(String[] args) {
        int a = 5; // Binary: 0000 0101
        int b = 3; // Binary: 0000 0011

        int bitwiseAndResult = a & b;
        int bitwiseOrResult = a | b;
        int bitwiseXorResult = a ^ b;
        int bitwiseNotA = ~a;
        int leftShiftResult = a << 2;
        int rightShiftResult = a >> 1;
        int unsignedRightShiftResult = a >>> 1;

        System.out.println("Bitwise AND Result: " + bitwiseAndResult); // Output: 1
        System.out.println("Bitwise OR Result: " + bitwiseOrResult);   // Output: 7
        System.out.println("Bitwise XOR Result: " + bitwiseXorResult); // Output: 6
        System.out.println("Bitwise NOT of A: " + bitwiseNotA);        // Output: -6
        System.out.println("Left Shift Result: " + leftShiftResult);   // Output: 20
        System.out.println("Right Shift Result: " + rightShiftResult); // Output: 2
        System.out.println("Unsigned Right Shift Result: " + unsignedRightShiftResult); // Output: 2
    }
}

Toán tử 3 ngôi

Toán tử 3 ngôi (?:) là toán tử viết tắt cho câu lệnh if-else. Nó làm cho mã của bạn nhỏ gọn và dễ đọc hơn.

Cú pháp:

expression1 ? expression2 : expression3

Trong đó

expression1: Đại diện cho một biểu thức đánh giá giá trị boolean là true hoặc false.
expression2: Được thực hiện nếu expression1 ước tính là đúng.
expression3: Được thực thi nếu expression1 đánh giá là sai.

Ví dụ:

public class ConditionalOperatorExample {
    public static void main(String[] args) {
        int number = 10;
        
        // Using the conditional operator to check if the number is positive or negative
        String result = (number >= 0) ? "Positive" : "Negative";
        System.out.println("The number is " + result);

        // Using the conditional operator to find the maximum of two numbers
        int a = 15;
        int b = 8;
        int max = (a > b) ? a : b;
        System.out.println("The maximum of " + a + " and " + b + " is: " + max);
        
        // Using the conditional operator to check if a number is even or odd
        int value = 7;
        String evenOdd = (value % 2 == 0) ? "even" : "odd";
        System.out.println("The number " + value + " is " + evenOdd);
    }
}

Output:

The number is Positive
The maximum of 15 and 8 is: 15
The number 7 is odd

Thứ tự ưu tiên của toán tử

Các biểu thức được viết thường bao gồm một số toán tử. Các quy tắc ưu tiên quyết định thứ tự mà mỗi toán tử được đánh giá trong bất kỳ biểu thức đã cho nào.

Bảng dưới mô tả thứ tự ưu tiên của toán tử:

Sắp xếp	Toán tử
1.	Ngoặc tròn ()
2.	Toán tử một ngôi như +, -,++,–, ~,!
3.	Số học và bitwise như *,/,%,+,-,<<,>>
4.	Toán tử quan hệ như >,<,>=,<=,==,!=
5.	Toán tử điều kiện và Bitwise như &,^,|,&&,||
6.	Các toán tử điều kiện và gán như ?:,=,*=,/=,+=,-=

Tính kết hợp của toán tử

Trong lý thuyết ngôn ngữ lập trình , tính kết hợp của một toán tử là một thuộc tính xác định cách các toán tử có cùng mức độ ưu tiên được nhóm lại khi không có dấu ngoặc đơn. Dưới đây là bảng mô tả tính kết hợp của toán tử

Toán tử	Mô tả	Tính kết hợp
(),++,–	Dấu ngoặc đơn, tăng sau, giảm sau	Trái sang phải
++,–,+,-,!,~	Tăng/giảm trước cộng | trừ một ngôi, logic NOT, bitwise NOT trừ một ngôi, logic NOT và bitwise NOT	Trừ một ngôi logical NOT, bitwise NOT
Phải sang trái	*,/,%,+,-	Phép nhân, cộng
Trái sang phải	<<,>>	Dịch chuyển theo bit
Trái sang phải	<,>,>=,<=,==,!=	Toán tử quan hệ và đẳng thức
Trái sang phải	&,^,|	Bitwise AND,OR,NOT
Trái sang phải	&&, ||	Điều kiện AND,OR
Trái sang phải	?:	Toán tử 3 ngôi

Ép kiểu dữ liệu

Trong bất kỳ ứng dụng nào, có thể có những tình huống trong đó một loại dữ liệu có thể yêu cầu được chuyển đổi thành loại dữ liệu khác. Tính năng ép kiểu trong Java giúp chuyển đổi như vậy.

Chuyển đổi kiểu hoặc ép kiểu đề cập đến việc thay đổi một thực thể của kiểu dữ liệu này sang kiểu dữ liệu khác. Chẳng hạn, các giá trị từ một tập hợp giới hạn hơn, chẳng hạn như số nguyên, có thể được lưu trữ ở định dạng nhỏ gọn hơn. Nó có thể được chuyển đổi sau này sang một định dạng khác cho phép thực hiện các thao tác trước đây không thể thực hiện được, chẳng hạn như phép chia với độ chính xác đến vài chữ số thập phân. Trong các ngôn ngữ OOP, chuyển đổi kiểu cho phép các chương trình coi các đối tượng thuộc một loại là một trong các kiểu tổ tiên của chúng để đơn giản hóa việc tương tác với chúng.

Có hai loại chuyển đổi: ngầm định và tường minh. Thuật ngữ để chuyển đổi kiểu ngầm định là ép buộc(coercion). Hình thức chuyển đổi kiểu tường minh phổ biến nhất được gọi là casting. Chuyển đổi kiểu tường minh cũng có thể đạt được với các quy trình chuyển đổi được xác định riêng biệt, chẳng hạn như một hàm khởi tạo tạo đối tượng nạp chồng (overloaded object constructor).

Ép kiểu ngầm định

Khi dữ liệu thuộc một kiểu cụ thể được gán cho một biến thuộc kiểu khác, thì quá trình chuyển đổi loại tự động sẽ diễn ra. Nó còn được gọi là ép kiểu ngầm định, miễn là nó đáp ứng các điều kiện được chỉ định:

• Hai kiểu dữ liệu phải tương thích
• Kiểu dữ liệu đích phải có kích thước vùng nhớ lớn hơn nguồn

Các kiểu dữ liệu số nguyên thủy có thể được ép kiểu ngầm định như sau:

• byte (8 bit) thành short, int, long, float, double.
• short (16 bit) thành int, long, float, double.
• int (32 bit) thành long, float, double.
• long(64 bits) thành float, double.

Điều này còn được gọi là quy tắc thăng cấp kiểu (type promotion rule). Thăng cấp kiểu được liệt kê như sau:

• Tất cả giá trị byte và short được thăng cấp thành kiểu int.
• Nếu một toán hạng long, toàn bộ biểu thức được thăng cấp thành long.
• Nếu một toán hạng là Float thì toàn bộ biểu thức được thăng cấp thành Float.
• Nếu một toán hạng là double thì toàn bộ biểu thức được thăng cấp thành double.

Ép kiểu tường minh

Loại dữ liệu có độ chính xác thấp hơn, chẳng hạn như ngắn, có thể được chuyển đổi thành loại có độ chính xác cao hơn, chẳng hạn như int, mà không cần sử dụng phép truyền rõ ràng. Tuy nhiên, để chuyển đổi loại dữ liệu có độ chính xác cao hơn thành độ chính xác thấp hơn
kiểu dữ liệu, chẳng hạn như kiểu dữ liệu float sang int, thì bắt buộc phải truyền rõ ràng. Nếu không, trình biên dịch sẽ hiển thị thông báo lỗi.

Cú pháp:

(data_type) value;

Ví dụ:

float a=21.347687;
int b = (int) a+5;

Giá trị float trong a được chuyển đổi thành giá trị số nguyên 21. Sau đó, nó được thêm vào 5 và giá trị kết quả, 26, được lưu trữ trong b. Loại chuyển đổi này được gọi là cắt ngắn (truncation). Thành phần phân số bị mất khi 2 dấu chấm động được gán cho kiểu số nguyên, dẫn đến mất độ chính xác.