Hướng dẫn lập trình Java

Khái niệm cơ bản về Java

Chương này giải thích các cú pháp cơ bản của ngôn ngữ lập trình Java. Tôi sẽ giả định rằng bạn đã viết một số chương trình Java đơn giản. Mặt khác, đọc " Giới thiệu về lập trình Java cho lập trình viên lần đầu ".

Để thành thạo một ngôn ngữ lập trình, bạn cần nắm vững hai điều:
  1. Các cú pháp của ngôn ngữ lập trình: Không quá khó để tìm hiểu một nhóm nhỏ các từ khóa và cú pháp. Ví dụ, JDK 1.8 có 48 từ khóa; C11 có 44 và C ++ 11 có 73.
  2. Các thư viện Giao diện chương trình ứng dụng (API) được liên kết với ngôn ngữ: Bạn không muốn tự mình viết mọi thứ. Thay vào đó, bạn có thể sử dụng lại mã có sẵn trong thư viện. Thư viện học tập có thể khó khăn vì nó thực sự rất lớn, phát triển và có thể mang cuộc sống của chính nó như một ngôn ngữ lập trình khác.

Bài viết sẽ hướng dẫn bạn các kiến thức cơ bản sau:
1. Cú pháp cơ bản: biến, kiểu dữ liệu, lệnh in ra màn hình
2. Cấu trúc điều kiện: if, else if, switch
3. Cấu trúc vòng lặp: for, while, do while
4. Mảng và Chuỗi
5. Phương thức

Sau đây chúng ta sẽ lần lượt đi qua từng phần một :)  

1. Cú pháp cơ bản

1.1 Các bước viết chương trình Java

Các bước viết chương trình Java được minh họa như sau:

JavaBasics_Process.png
Bước 1: Viết mã nguồn Xxx.javabằng trình soạn thảo văn bản lập trình (như Sublime Text, Atom, Notepad ++, Textpad, gEdit) hoặc IDE (như Eclipse hoặc NetBeans HAY IntelliJ IDEA  ).
Bước 2: Biên dịch mã nguồn Xxx.javathành mã byte di động Java Xxx.classbằng cách sử dụng Trình biên dịch JDK bằng cách ban hành lệnh:
javac Xxx.java
Bước 3: Chạy mã byte được biên dịch Xxx.class với đầu vào để tạo đầu ra mong muốn, sử dụng Java Runtime bằng cách ban hành lệnh:
java Xxx


1.2 Mẫu chương trình Java

Bạn có thể sử dụng mẫu sau để viết chương trình Java của mình. Chọn một "Tên lớp " có ý nghĩa phản ánh mục đích của chương trình của bạn và viết các câu lệnh lập trình của bạn bên trong phần thân của main()phương thức. Đừng lo lắng về các thuật ngữ và từ khóa khác ngay bây giờ. Tôi sẽ giải thích chúng trong khóa học. Cung cấp chú thích ​​trong chương trình của bạn!
1
2
3
4
5
6
7
8
/**
 * Comment to state the purpose of the program
 */
public class Classname {   // Choose a meaningful Classname. Save as "Classname.java"
   public static void main(String[] args) {  // Entry point of the program
      // Your programming statements here!!!
   }
}

1.3 Một chương trình mẫu minh họa tuần tự, các quyết định và các cấu trúc vòng lặp

Dưới đây là một chương trình Java đơn giản thể hiện ba cấu trúc lập trình cơ bản: tuần tự , vòng lặp và điều kiện . Đọc " Giới thiệu về lập trình Java cho lập trình viên lần đầu " nếu bạn cần trợ giúp để hiểu chương trình này.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
 * Find the sums of the running odd numbers and even numbers from a given lowerbound 
 * to an upperbound. Also compute their absolute difference.
 */
public class OddEvenSum {  // Save as "OddEvenSum.java"
   public static void main(String[] args) {
      // Declare variables
      int lowerbound = 1, upperbound = 1000;  // Define the bounds
      int sumOdd  = 0;    // For accumulating odd numbers, init to 0
      int sumEven = 0;    // For accumulating even numbers, init to 0
      int absDiff;        // Absolute difference between the two sums

      // Use a while loop to accumulate the sums from lowerbound to upperbound
      int number = lowerbound;   // loop init
      while (number <= upperbound) {  // loop test
            // number = lowerbound, lowerbound+1, lowerbound+1, ..., upperbound
         // A if-then-else decision
         if (number % 2 == 0) {  // Even number
            sumEven += number;   // Same as sumEven = sumEven + number
         } else {                // Odd number
            sumOdd += number;    // Same as sumOdd = sumOdd + number
         }
         ++number;  // loop update for next number
      }
      // Another if-then-else Decision
      if (sumOdd > sumEven) {
         absDiff = sumOdd - sumEven;
      } else {
         absDiff = sumEven - sumOdd;
      }
      // OR using one liner conditional expression
      //absDiff = (sumOdd > sumEven) ? sumOdd - sumEven : sumEven - sumOdd;
 
      // Print the results
      System.out.println("The sum of odd numbers from " + lowerbound + " to " + upperbound + " is: " + sumOdd);
      System.out.println("The sum of even numbers from " + lowerbound + " to " + upperbound + " is: " + sumEven);
      System.out.println("The absolute difference between the two sums is: " + absDiff);
   }
}
Đầu ra mong muốn:
The sum of odd numbers from 1 to 1000 is: 250000
The sum of even numbers from 1 to 1000 is: 250500
The absolute difference between the two sums is: 500

1.4 Comments - Chú thích

Chú thích được sử dụng để ghi lại và giải thích mã và logic chương trình của bạn. Chú thích không phải là câu lệnh lập trình. Chúng bị bỏ qua bởi trình biên dịch và không có ảnh hưởng đối với việc thực hiện chương trình. Tuy nhiên, các bình luận RẤT QUAN TRỌNG để cung cấp tài liệu và giải thích cho người khác hiểu chương trình của bạn (và cũng cho chính bạn ba ngày sau đó).
Có hai loại comment ​trong Java:
  1. Chú thích nhiều dòng : bắt đầu bằng /* và kết thúc bằng */và có thể kéo dài nhiều dòng. /** .... */là một nhận xét tài liệu đặc biệt Nhận xét có thể được trích xuất để sản xuất  java docs. Những chú thích có thể được trích xuất để tạo ra java docs
  2. Chú thích cuối dòng (một dòng) : bắt đầu bằng //và kéo dài đến cuối dòng hiện tại.
Tôi khuyên bạn nên sử dụng các chú thích một cách thường xuyên  để giải thích và  chú thích lại mã của bạn.
Trong quá trình phát triển chương trình, thay vì xóa một đoạn các câu lệnh không thể hủy bỏ, bạn có thể chú thích các câu lệnh này để bạn có thể lấy lại chúng sau, nếu cần.

1.5 Statements and Blocks

Câu lệnh: Một câu lệnh lập trình lập trình là đơn vị độc lập nhỏ nhất trong một chương trình, giống như một câu trong tiếng Anh. Nó thực hiện một phần của hành động lập trình . Một câu lệnh lập trình phải được kết thúc bởi dấu chấm phẩy ( ), giống như một câu tiếng Anh kết thúc bằng một dấu chấm (Tại sao không kết thúc bằng một khoảng thời gian như một câu tiếng Anh? Điều này là do thời gian gặp sự cố với dấu thập phân - đó là thách thức đối với máy tính đời đầu để phân biệt giữa dấu chấm và dấu thập phân trong những ngày đầu của máy tính!).
Ví dụ như,

// Each of the following lines is a programming statement, which ends with a semi-colon (;).
// A programming statement performs a piece of programming action.
int number1 = 10;
int number2, number3 = 99;
int product;
number2 = 8;
product = number1 * number2 * number3;
System.out.println("Hello");
Block : Block là một nhóm các câu lệnh lập trình được bao quanh bởi một cặp dấu ngoặc nhọn { }Tất cả các câu lệnh bên trong khối được coi là một đơn vị. Các khối được sử dụng làm phần thân trong các cấu trúc như lớp, phương thức, if-other và loop, có thể chứa nhiều câu lệnh nhưng được coi là một đơn vị (một phần thân). Không cần đặt dấu chấm phẩy sau dấu ngoặc nhọn để kết thúc câu lệnh ghép. Khối trống (nghĩa là không có tuyên bố nào trong dấu ngoặc nhọn) được cho phép.
Ví dụ như,
// Each of the followings is a "compound" statement comprising one or more blocks of statements.
// No terminating semi-colon needed after the closing brace to end the "compound" statement.
// Take note that a "compound" statement is usually written over a few lines for readability.
if (mark >= 50) {     // A if statement
   System.out.println("PASS");
   System.out.println("Well Done!");
   System.out.println("Keep it Up!");
}
 
if (input != -1) {   // A if-else statement
   System.out.println("Continue"); 
} else { 
   System.out.println("Exit"); 
}
 
i = 1;
while (i < 8) {      // A while-loop statement
   System.out.print(i + " ");
   ++i; 
}
 
public static void main(String[] args) {   // A method definition statement
   ...statements... 
}
 
public class Hello {   // A class definition statement
   ...statements... 
}

1.6 White Spaces and Formatting Source Code

White Spaces - Không gian trốngTrống , tab và dòng mới được gọi chung là khoảng trắng .
Bạn cần sử dụng khoảng trắng để phân tách hai từ khóa hoặc mã thông báo để tránh sự mơ hồ, ví dụ

int sum = 0;     // Cannot write "intsum". Need at least one white space between "int" and "sum"
double average;  // Again, need at least a white space between "double" and "average"
Java, giống như hầu hết các ngôn ngữ lập trình, bỏ qua các khoảng trắng thừa . Đó là, nhiều khoảng trắng liền kề được coi là một khoảng trắng không gian duy nhất . Các khoảng trắng bổ sung và các dòng thừa được bỏ qua, ví dụ:
// Same as above with many redundant white spaces. Hard to read.
int  sum 
=0     ;

   double  
average
;

// Also same as above with minimal white space. Also hard to read
int sum=0;double average;
Formatting Source Code: Như đã đề cập, các khoảng trắng thừa được bỏ qua và không có ý nghĩa tính toán. Tuy nhiên, thụt lề thích hợp (với các tab và khoảng trống) và các dòng trống bổ sung cải thiện đáng kể khả năng đọc của chương trình. Điều này cực kỳ quan trọng đối với những người khác (và chính bạn ba ngày sau) để hiểu các chương trình của bạn.
Ví dụ, chương trình hello-world một dòng sau đây hoạt động. Nhưng bạn có thể đọc và hiểu chương trình một cách dễ dàng không?
public class Hello{public static void main(String[] args){System.out.println("Hello, world!");}}
BracesQuy ước của Java là đặt dấu ngoặc đầu ở cuối dòng và căn chỉnh dấu ngoặc cuối với điểm bắt đầu của câu lệnh. Ghép nối {} đúng cách. Không cân bằng {} là một trong những lỗi cú pháp phổ biến nhất cho người mới bắt đầu.
Thụt lề: thụt lề mỗi cấp độ của cơ thể của một khối bằng thêm 3 hoặc 4 khoảng trắng theo phân cấp của khối. Không sử dụng tab vì không gian tab phụ thuộc vào trình chỉnh sửa.
/**
 * Recommended Java programming style (Documentation comments about the class)
 */
public class ClassName {      // Place the beginning brace at the end of the current line
   public static void main(String[] args) {  // Indent the body by an extra 3 or 4 spaces for each level
   
      // Use empty line liberally to improve readability
      // Sequential statements
      statement-1;
      statement-2;
   
      // A if-else statement
      if (test) {
         true-statements;
      } else {
         false-statements;
      }
      
      // A loop statement
      init;
      while (test) {
         body-statements;
         update;
      }
   }
}   // Ending brace aligned with the start of the statement
"Mã được đọc thường xuyên hơn nhiều so với nó được viết." Do đó, bạn phải đảm bảo rằng mã của bạn có thể đọc được (bởi người khác và chính bạn 3 ngày sau đó), bằng cách tuân theo quy ước và kiểu mã hóa được khuyến nghị.


2.  Variables and Types

2.1  Variables - Name, Type and Value

Các chương trình máy tính thao tác (hoặc xử lý) dữ liệu. Một biến được sử dụng để lưu trữ một phần dữ liệu để xử lý. Nó được gọi là biến vì bạn có thể thay đổi giá trị được lưu trữ.
Chính xác hơn, một biến là một vị trí lưu trữ được đặt tên, lưu trữ giá trị của một loại dữ liệu cụ thể Nói cách khác, một biến có tên , loại và lưu trữ một giá trị .
  • Một biến có tên (hay còn gọi là định danh ), ví dụ radiusareaageheightvà numStudentsTên là cần thiết để xác định duy nhất và tham chiếu từng biến. Bạn có thể sử dụng tên để gán giá trị cho biến (ví dụ radius = 1.2:) và để truy xuất giá trị được lưu trữ (ví dụ radius*radius*3.1419265:).
  • Một biến có kiểu dữ liệu . Các kiểu dữ liệu Java được sử dụng thường xuyên là:
    • int: có nghĩa là cho số nguyên (số nguyên) như 123 và -456.
    • double: Có nghĩa là cho số dấu phẩy động (số thực) có một dấu thập phân tùy chọn và phần phân đoạn, chẳng hạn như 3.1416-55.661.2e3, hay -4.5E-6, nơi ehoặc biểu thị số mũ của cơ sở 10.
    • String: có nghĩa là cho các văn bản như "Hello"và "Good Morning!"String được đính kèm trong một cặp dấu ngoặc kép.
    • char: có nghĩa là cho một ký tự duy nhất, chẳng hạn như 'a''8'char được bao quanh bởi một cặp dấu ngoặc đơn.
  • Trong Java, bạn cần khai báo tên và loại biến trước khi sử dụng biến. Ví dụ như 

  • int sum;         // Declare an "int" variable named "sum"
    double average;  // Declare a "double" variable named "average"
    String message;  // Declare a "String" variable named "message"
    char grade;      // Declare a "char" variable named "grade"
  • Một biến có thể lưu trữ một giá trị của kiểu dữ liệu khai báo Điều quan trọng cần lưu ý là một biến trong hầu hết các ngôn ngữ lập trình được liên kết với một loại và chỉ có thể lưu trữ giá trị của loại cụ thể đó. Ví dụ: một intbiến có thể lưu trữ một giá trị nguyên như 123, nhưng KHÔNG phải là số dấu phẩy động, chẳng hạn như 12.34, chẳng hạn như chuỗi "Hello".
  • Khái niệm loại đã được giới thiệu trong các ngôn ngữ lập trình ban đầu để đơn giản hóa việc giải thích dữ liệu được tạo thành từ các chuỗi nhị phân ( 0 và 1). Kiểu xác định kích thước và bố cục của dữ liệu, phạm vi giá trị của nó và tập hợp các hoạt động có thể được áp dụng.
  • Sơ đồ dưới đây minh họa ba loại biến: intdouble và StringMột int biến lưu một số nguyên (hoặc toàn bộ số hoặc số điểm cố định); một biến double lưu trữ một số dấu phẩy động (hoặc số thực); một String biến lưu trữ văn bản.
variable

2.2 Identifiers - Định danh (hoặc Tên)

Một định danh là cần thiết để đặt tên cho một biến (hoặc bất kỳ thực thể nào khác, chẳng hạn như một phương thức hoặc một lớp). Java áp đặt các quy tắc sau đây trên các định danh :
  • Mã định danh là một chuỗi các ký tự, có độ dài bất kỳ, bao gồm chữ hoa và chữ thường (a-z, A-Z), chữ số (0-9), dấu gạch dưới ( _) và ký hiệu đô la ( $).
  • Khoảng trắng (trống, tab, xuống dòng) và ký tự đặc biệt khác (chẳng hạn như +-*/@&, dấu phẩy, vv) không được phép. Lưu ý rằng khoảng trống và dấu gạch ngang ( -) không được phép, nghĩa là " max value" và " max-value" không phải là tên hợp lệ. (Điều này là do khoảng trống tạo ra hai mã thông báo và dấu gạch ngang có dấu trừ!)
  • Một định danh phải bắt đầu bằng một chữ cái (a-z, A-Z)hoặc dấu gạch dưới ( _). Nó không thể bắt đầu bằng một chữ số (0-9)(vì điều đó có thể gây nhầm lẫn với một số). Mã định danh bắt đầu bằng ký hiệu đô la ( $) được dành riêng cho các thực thể do hệ thống tạo.
  • Một định danh không thể là một từ khóa dành riêng hoặc một chữ dành riêng (ví dụ classintdoubleifelsefortruefalsenull).
  • Định danh là phân biệt hoa thường  (case-sensitive). rose KHÔNG phải là a Rose, và KHÔNG phải là a ROSE.
Ví dụ: abc_xyz$123_1_2_3 là những định danh hợp lệ. Nhưng 1abcmin-valuesurface areaab@c KHÔNG là định danh hợp lệ.
Thận trọng : Lập trình viên không sử dụng ký tự trống trong bất kỳ tên nào (tên tệp, tên dự án, tên biến, v.v.). Nó không được hỗ trợ (ví dụ, trong Java và C / C ++) hoặc sẽ đặt ra cho bạn nhiều thách thức hơn.

Quy ước đặt tên biến

Tên biến là danh từ hoặc cụm danh từ được tạo thành từ nhiều từ không có khoảng cách giữa các từ. Từ đầu tiên được viết thường, trong khi các từ còn lại được viết hoa ban đầu. Đối với ví dụ, radiusareafontSizenumStudentsxMaxyMinxTopLeftisValidInput, và thisIsAVeryLongVariableName.  Quy ước này còn được gọi là trường hợp lạc đà (camel case): từ đầu tiên viết thường, các từ sau viết hoa chữ cái đầu tiên. 

khuyến nghị

  1. Điều quan trọng là chọn một tên tự mô tả và phản ánh chặt chẽ ý nghĩa của biến, ví dụ, numberOfStudents hoặc numStudents, nhưng không nên sử tên biến cộc lốc là hoặc x, để lưu trữ số lượng sinh viên. Nếu sử dụng chữ viết tắt thì okie, nhưng chữ viết tắt cần mang tính gợi nhớ. 
  2. Không sử dụng những cái tên vô nghĩa  như abcijkni1i2i3j99exercise85(mục đích của bài tập này là gì?), Và example12(ví dụ này về là gì?).
  3. Tránh đơn chữ cái tên như ijkabc, đó là dễ dàng hơn để gõ nhưng thường vô nghĩa. Trường hợp ngoại lệ là những cái tên phổ biến như xyzcho tọa độ, icho chỉ số. Tên dài khó nhập hơn, nhưng tự ghi lại chương trình của bạn. (Tôi đề nghị bạn dành đôi khi thực hành đánh máy của bạn.)
  4. Sử dụng danh từ số ít và số nhiều một cách thận trọng để phân biệt giữa các biến số ít và số nhiều. Ví dụ: bạn có thể sử dụng biến rowđể chỉ một số hàng và biến rows để chỉ nhiều hàng (chẳng hạn như một mảng các hàng - sẽ được thảo luận sau).

2.3 Khai Báo Biến

Để sử dụng một biến trong chương trình của bạn, trước tiên bạn cần giới thiệu nó bằng cách khai báo tên và loại của nó , theo một trong các cú pháp sau. Hành động khai báo một biến phân bổ một kho lưu trữ có kích thước có khả năng giữ một giá trị của loại.

SyntaxExample
// Declare a variable of a specified type
type identifier;
 
int sum;
double average;
String statusMsg;
// Declare multiple variables of the SAME type,
//  separated by commas
type identifier1, identifier2, ..., identifierN; 
int number, count;
double sum, difference, product, quotient;
String helloMsg, gameOverMsg;
// Declare a variable and assign an initial value
type identifier = initialValue;
 
int magicNumber = 99;
double pi = 3.14169265;
String helloMsg = "hello,";
// Declare multiple variables of the SAME type,
//  with initial values
type identifier1 = initValue1, ..., identifierN = initValueN; 
int sum = 0, product = 1;
double height = 1.2; length = 3.45;
String greetingMsg = "hi!", quitMsg = "bye!";
Hãy lưu ý rằng:
  • Một biến được khai báo với một loại . Khi loại biến được khai báo, nó chỉ có thể lưu trữ một giá trị thuộc về loại cụ thể đó. Ví dụ: một int biến chỉ có thể chứa số nguyên (chẳng hạn 123) và KHÔNG có số dấu phẩy động (chẳng hạn như -2.17) hoặc chuỗi văn bản (chẳng hạn như "Hello").
  • Mỗi biến chỉ có thể được khai báo một lần vì định danh sẽ là duy nhất.
  • Bạn có thể khai báo một biến ở bất cứ đâu trong chương trình, miễn là nó được khai báo trước khi sử dụng.
  • Loại biến không thể thay đổi bên trong chương trình, một khi nó được khai báo.
  • Một tuyên bố khai báo biến bắt đầu bằng một loại và chỉ hoạt động cho loại đó. Nói cách khác, bạn không thể khai báo các biến có hai loại khác nhau trong một tuyên bố khai báo.
  • Java là một ngôn ngữ gõ tĩnh . Điều này có nghĩa là loại được giải quyết tại thời gian biên dịch và không bao giờ thay đổi.

2.4 Hằng số ( final variable )

Các hằng số là các biến không thay đổi ( không thay đổi ), được khai báo bằng từ khóa finalBạn chỉ có thể gán giá trị cho các biến cuối cùng ONCE. Giá trị của chúng không thể thay đổi trong quá trình thực hiện chương trình. Ví dụ như:
final double PI = 3.14159265;  // Declare and initialize the constant

final int SCREEN_X_MAX = 1280;
SCREEN_X_MAX = 800;  //compilation error: cannot assign a value to final variable

// You can only assign value to final variables ONCE
final int SCREEN_Y_MIN;
SCREEN_Y_MIN = 0;   // First assignment
SCREEN_Y_MIN = 10;  //compilation error: variable might already have been assigned
Quy ước đặt tên liên tục: Sử dụng các từ viết hoa, nối với dấu gạch dưới. Ví dụ, MIN_VALUEMAX_SIZE, và INTEREST_RATE_6_MTH.

2.5 Expression - Biểu thức

Một biểu thức là sự kết hợp của các toán tử  (như '+'và '-') và toán hạng (biến hoặc literals), có thể được đánh giá để mang lại một giá trị duy nhất của một loại nhất định .
expression
Ví dụ,
// "int" literals
((1 + 2) * 3 / 4) % 6   // This expression is evaluated to an "int" value

// "double" literals
3.45 + 6.7              // This expression is evaluated to a "double" value

// Assume that variables sum and number are "int"
sum + number * number   // evaluates to an "int" value

// Assume that variables principal and interestRate are "double"
principal * (1.0 + interestRate)  // evaluates to a "double" value

2.6  Phép Gán (=)

Một câu lệnh gán đánh giá RHS - Right Hand Side (Phía bên tay phải) và gán giá trị kết quả cho biến của LHS - Left Hand Side (Phía bên tay trái).
Cú pháp cho câu lệnh gán là:
SyntaxExample
// Assign the RHS literal value to the LHS variable
variable = literalValue;
int number;
number = 9;
// Evaluate the RHS expression and assign the result to the LHS variable
variable = expression;
int sum = 0, number = 8;
sum = sum + number;
Câu lệnh gán phải được diễn giải theo cách này: Biểu thức trên RHS trước tiên được ước tính để tạo ra một giá trị kết quả (được gọi là giá trị r hoặc giá trị phải). Các r có giá trị sau đó được gán cho biến ở bên trái tay-side (LHS) hoặc l-giá trị . Xin lưu ý rằng trước tiên bạn phải đánh giá RHS, trước khi gán giá trị kết quả cho LHS. Ví dụ như,
int number;
number = 8;           // Assign RHS literal value of 8 to the LHS variable number
number = number + 1;  // Evaluate the RHS expression (number + 1),
                      //  and assign the resultant value back to the LHS variable number

8 = number;           // Invalid in Programming, LHS shall be a variable
number + 1 = sum;     // Invalid in Programming, LHS shall be a variable
'=' là phép gán, KHÔNG phải là dấu bằng
x_plus_one.gif
x_plus_one.gif
Trong Java, ký hiệu bằng nhau '='được gọi là toán tử gán . Ý nghĩa của '='lập trình khác với Toán học. Nó biểu thị việc gán giá trị RHS cho biến LHS , KHÔNG bằng nhau của RHS và LHS . RHS phải là một giá trị theo nghĩa đen hoặc một biểu thức đánh giá thành một giá trị; trong khi LHS phải là một biến.
Lưu ý rằng x = x + 1hợp lệ (và thường được sử dụng) trong lập trình. Nó đánh giá biểu thức RHS x + 1và gán giá trị kết quả cho biến LHS xMặt khác, x = x + 1 là bất hợp pháp trong Toán học.
Mặc dù x + y = 1 được phép trong Toán học, nó không hợp lệ trong lập trình vì LHS của câu lệnh gán sẽ là một biến.
Một số ngôn ngữ lập trình sử dụng ký hiệu " :=", " ->" hoặc " <-" làm toán tử gán để tránh nhầm lẫn với đẳng thức.

3.  Primitive Types and String

Trong Java, có hai loại chính của dữ liệu loại :
  1. Các loại nguyên thủy (ví dụ int,, double),
  2. Các kiểu tham chiếu (ví dụ, các đối tượng và mảng).
Chúng ta sẽ mô tả các loại nguyên thủy ở đây. Chúng tôi sẽ đề cập đến các loại tham chiếu (các lớp và các đối tượng) trong các chương sau về "Lập trình hướng đối tượng".

3.1  Built-in Primitive Types

TYPEDESCRIPTION
byteInteger8-bit signed integer
The range is [-27, 27-1] = [-128, 127]
short16-bit signed integer
The range is [-215, 215-1] = [-32768, 32767]
int32-bit signed integer
The range is [-231, 231-1] = [-2147483648, 2147483647] (≈9 digits, ±2G)
long64-bit signed integer
The range is [-263, 263-1] = [-9223372036854775808, 9223372036854775807] (≈19 digits)
floatFloating-Point 
Number

F x 2E
32-bit single precision floating-point number
(6-7 significant decimal digits, in the range of ±[1.4x10-45, 3.4028235x1038])
double64-bit double precision floating-point number
(14-15 significant decimal digits, in the range of ±[4.9x10-324, 1.7976931348623157x10308])
charCharacter
Represented in 16-bit Unicode '\u0000' to '\uFFFF'.
Can be treated as integer in the range of [0, 65535] in arithmetic operations.
(Unlike C/C++, which uses 8-bit ASCII code.)
booleanBinary
Takes a literal value of either true or false.
The size of boolean is not defined in the Java specification, but requires at least one bit.
booleans are used in test in decision and loop, not applicable for arithmetic operations.
(Unlike C/C++, which uses integer 0 for false, and non-zero for true.)
primitive types
Kiểu nguyên thủy được tích hợp vào ngôn ngữ để đạt hiệu quả tối đa, cả về không gian và hiệu quả tính toán.
Java có tám loại nguyên thủy , như được liệt kê trong bảng trên:
  • Có bốn loại số nguyên: 8 bit byte, 16 bit short, 32 bit int và 64 bit longChúng là các số nguyên được  trong biểu diễn phần bù của 2 và có thể giữ giá trị nguyên bằng 0, dương và âm của các phạm vi khác nhau như trong bảng.
  • Có hai loại dấu phẩy động: độ chính xác đơn 32 bit float và độ chính xác kép 64 bit doubleChúng được biểu diễn trong ký hiệu khoa học về nơi phân số ( ) và số mũ ( ) được lưu trữ riêng (theo quy định của tiêu chuẩn IEEE 754). Hãy lưu ý rằng không phải tất cả các số thực có thể được đại diện bởi dấu chấm (.) Điều này là do có các số thực vô hạn ngay cả trong một phạm vi nhỏ , nhưng có một số mẫu hữu hạn trong biểu diễn n-bit. Hầu hết các giá trị dấu phẩy động gần đúng với biểu diễn gần nhất của chúng.Fx2EFEfloatdouble[1.0, 1.1]
  • Các loại char đại diện cho một ký tự, chẳng hạn như '0''A''a'Trong Java, char được biểu diễn bằng Unicode 16 bit (ở định dạng UCS-2) để hỗ trợ quốc tế hóa ( i18n ). char có thể được coi là một số nguyên trong phạm vi của các [0, 65535]phép toán số học. Ví dụ, ký tự '0'là 48(thập phân) hoặc 30H(thập lục phân); ký tự 'A'là 65(thập phân) hoặc 41H(thập lục phân); ký tự 'a'là 97(thập phân) hoặc 61H(thập lục phân).
  • Java giới thiệu một loại nhị phân mới gọi là " boolean", lấy giá trị bằng chữ true hoặc falseboolean được sử dụng trong đánh giá trong quyết định và vòng lặp. Chúng không áp dụng cho các phép toán số học (như phép cộng và phép nhân).

    3.2  Integers vs. Floating-Point Numbers

    Trong lập trình máy tính, các số nguyên (như 123, -456) và các số dấu phẩy động (như 1.23, -4.56, 1.2e3, -4.5e-6) khác nhau HOÀN TOÀN.
    1. Số nguyên và số dấu phẩy động được biểu diễn và lưu trữ khác nhau.
    2. Số nguyên và số dấu phẩy động được vận hành khác nhau.
      Số nguyên và số dấu phẩy động được biểu diễn và lưu trữ trong bộ nhớ máy tính như thế nào?
      DataRep_Integers.png
      Các số nguyên được biểu diễn trong sơ đồ bổ sung được gọi là 2 như minh họa. Bit có ý nghĩa nhất được gọi là Sign Bit ( S), trong đó S=0 đại diện cho số nguyên dương và S=1 đại diện cho số nguyên âm. Các bit còn lại đại diện cho độ lớn của các số nguyên. Đối với các số nguyên dương, độ lớn giống như số nhị phân, ví dụ: if n=16short), 0000000000000010là Số nguyên âm yêu cầu chuyển đổi bổ sung 2.+210
      DataRep_Integers.png
      Các số dấu phẩy động được biểu diễn dưới dạng khoa học , trong đó Phân số ( F) và Số mũ ( E) được lưu trữ riêng. Ví dụ, để lưu trữ đầu tiên chuyển đổi thành nhị phân của sau đó bình thường hóa thành chúng tôi có và sau đó được lưu trữ với một số tỷ lệ.Fx2EFE12.75101100.1121.100112 x 23F=1.1011E=310=112
      Để biết chi tiết, hãy đọc " Biểu diễn dữ liệu - Số nguyên, số dấu phẩy động và ký tự ".
      Số nguyên và số dấu phẩy động được vận hành như thế nào?
      Số nguyên và số dấu phẩy động được vận hành khác nhau bằng cách sử dụng các mạch phần cứng khác nhau. Các số nguyên được xử lý trong CPU (Đơn vị xử lý trung tâm), trong khi các số dấu phẩy động được xử lý trong FPU (Đơn vị đồng xử lý điểm nổi).
      Hoạt động số nguyên là đơn giản. Ví dụ, bổ sung số nguyên được thực hiện như minh họa:
      Addition Integers
      Mặt khác, phép cộng dấu phẩy động rất phức tạp, như được minh họa:
      Addition FloatingPoint
      Rõ ràng là các phép toán số nguyên (như phép cộng) nhanh hơn nhiều so với các phép toán dấu phẩy động.
      Hơn nữa, số nguyên là chính xác. Tất cả các số trong phạm vi có thể được trình bày chính xác. Ví dụ: 32 bit intcó thể biểu thị TẤT CẢ các số nguyên từ -2147483648đến +2147483647không có khoảng cách ở giữa. Mặt khác, dấu phẩy động KHÔNG chính xác, nhưng gần đúng. Điều này là do có các số dấu phẩy động vô hạn trong bất kỳ khoảng nào (ví dụ: trong khoảng từ 0,1 đến 0,2). Không phải TẤT CẢ các số có thể được biểu diễn bằng độ chính xác hữu hạn (32 bit floathoặc 64 bit double).
      Bạn cần coi số nguyên và số dấu phẩy động là hai loại DISTINCT - RIÊNG BIỆT trong lập trình!
      Sử dụng số nguyên nếu có thể (nó nhanh hơn, chính xác hơn và sử dụng ít bit hơn). Chỉ sử dụng số dấu phẩy động nếu một phần phân số được yêu cầu.

      3.3 Biểu diễn dữ liệu - Data Representation

      Đọc " Biểu diễn dữ liệu - Số nguyên, số và ký tự dấu phẩy động " nếu bạn muốn hiểu cách các số và ký tự được thể hiện bên trong bộ nhớ máy tính.
      Tóm lại, Điều quan trọng cần lưu ý rằng char '1'khác với int 1byte 1short 1float 1.0double 1.0, và String "1"Chúng được thể hiện khác nhau trong bộ nhớ máy tính, với độ chính xác và giải thích khác nhau. Chúng cũng được xử lý khác nhau. Ví dụ như:

      • byte 1 là "00000001" (8-bit).
      • short 1 là "00000000 00000001" (16-bit).
      • int 1 là "00000000 00000000 00000000 00000001" (32-bit).
      • long 1 là "00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001" (64-bit).
      • float 1.0 là "0 01111111 0000000 00000000 00000000" (32-bit).
      • double 1.0 là "0 01111111111 0000 00000000 00000000 00000000 00000000 00000000 00000000" (64-bit).
      • char '1' là "00000000 00110001" (16-bit) (Unicode number 49).
      • String "1" là một đối tượng phức tạp (gồm rất nhiều rất nhiều bits).
      Có một sự khác biệt tinh tế giữa int và double 0.0 vì chúng có độ dài bit và biểu diễn bên trong khác nhau.
      Hơn nữa, bạn PHẢI biết loại giá trị trước khi bạn có thể diễn giải một giá trị. Ví dụ, mẫu bit này "00000000 00000000 00000000 00000001" không thể được hiểu trừ khi bạn biết loại của nó (hoặc đại diện của nó).

      3.4 Giá trị tối đa / tối thiểu của các loại số nguyên thủy

      Chương trình sau đây có thể được sử dụng để in độ dài tối đa , tối thiểu và bit của các kiểu nguyên thủy. Ví dụ, tối đa, tối thiểu và bit kích thước của intđược lưu giữ trong built-in hằng INTEGER.MIN_VALUEINTEGER.MAX_VALUEINTEGER.SIZE.

      /**
       * Print the minimum, maximum and bit-length of all primitive types (except boolean)
       */
      public class PrimitiveTypesMinMaxBitLen {
         public static void main(String[] args) {
            /* int (32-bit signed integer) */
            System.out.println("int(min) = " + Integer.MIN_VALUE);
            //int(min) = -2147483648
            System.out.println("int(max) = " + Integer.MAX_VALUE);
            //int(max) = 2147483647
            System.out.println("int(bit-length) = " + Integer.SIZE);
            //int(bit-length) = 32
      
            /* byte (8-bit signed integer) */
            System.out.println("byte(min) = " + Byte.MIN_VALUE);
            //byte(min) = -128
            System.out.println("byte(max) = " + Byte.MAX_VALUE);
            //byte(max) = 127
            System.out.println("byte(bit-length) = " + Byte.SIZE);
            //byte(bit-length) = 8
      
            /* short (16-bit signed integer) */
            System.out.println("short(min) = " + Short.MIN_VALUE);
            //short(min) = -32768
            System.out.println("short(max) = " + Short.MAX_VALUE);
            //short(max) = 32767
            System.out.println("short(bit-length) = " + Short.SIZE);
            //short(bit-length) = 16
      
            /* long (64-bit signed integer) */
            System.out.println("long(min) = " + Long.MIN_VALUE);
            //long(min) = -9223372036854775808
            System.out.println("long(max) = " + Long.MAX_VALUE);
            //long(max) = 9223372036854775807
            System.out.println("long(bit-length) = " + Long.SIZE);
            //long(bit-length) = 64
      
            /* char (16-bit character or 16-bit unsigned integer) */
            System.out.println("char(min) = " + (int)Character.MIN_VALUE);
            //char(min) = 0
            System.out.println("char(max) = " + (int)Character.MAX_VALUE);
            //char(max) = 65535
            System.out.println("char(bit-length) = " + Character.SIZE);
            //char(bit-length) = 16
      
            /* float (32-bit floating-point) */
            System.out.println("float(min) = " + Float.MIN_VALUE);
            //float(min) = 1.4E-45
            System.out.println("float(max) = " + Float.MAX_VALUE);
            //float(max) = 3.4028235E38
            System.out.println("float(bit-length) = " + Float.SIZE);
            //float(bit-length) = 32
      
            /* double (64-bit floating-point) */
            System.out.println("double(min) = " + Double.MIN_VALUE);
            //double(min) = 4.9E-324
            System.out.println("double(max) = " + Double.MAX_VALUE);
            //double(max) = 1.7976931348623157E308
            System.out.println("double(bit-length) = " + Double.SIZE);
            //double(bit-length) = 64
      
            /* No equivalent constants for boolean type */
         }
      }

      3.5 String (Chuỗi)

      Bên cạnh 8 loại nguyên thủy, một loại quan trọng và thường xuyên sử dụng khác là String. Một String là một chuỗi các ký tự (văn bản) như "Hello, world"String không phải là một kiểu nguyên thủy (điều này sẽ được xây dựng sau).
      Trong Java, một char là một ký tự đơn lẻ được bao bọc bởi dấu nháy đơn (ví dụ 'A''0''$'); trong khi a String là một chuỗi các ký tự được bao quanh bởi dấu ngoặc kép (ví dụ "Hello":).
      Ví dụ,

      String greetingMsg = "hello, world";  // String is enclosed in double-quotes
      char gender = 'm';       // char is enclosed in single-quotes
      String statusMsg = "";   // an empty String

      3.6  Choice of Data Types for Variables

      Là một lập trình viên, BẠN cần quyết định loại biến được sử dụng trong các chương trình của bạn. Hầu hết các lần, quyết định là trực quan. Ví dụ: sử dụng một kiểu số nguyên để đếm và toàn bộ số; một loại dấu phẩy động cho số có phần phân số, String cho tin nhắn văn bản, char cho một ký tự và boolean cho kết quả nhị phân.
      Điều quan trọng cần lưu ý là các chương trình của bạn sẽ có dữ liệu của các loại KHÁC BIỆT.
      Quy tắc của việc chọn kiểu dữ liệu
      • Đối với số, sử dụng một loại số nguyên nếu có thể. Chỉ sử dụng loại dấu phẩy động nếu số đó chứa một phần phân số. Mặc dù dấu chấm động số bao gồm số nguyên (ví dụ 1.02.03.0), số dấu chấm động là xấp xỉ (không chính xác) và đòi hỏi nhiều nguồn lực (tính toán và lưu trữ) cho các hoạt động.
      • Mặc dù có 4 loại số nguyên: 8 bit byte, 16 bit short, 32 bit int và 64 bit long, chúng ta sẽ sử dụng int cho các số nguyên nói chung. Sử dụng byteshort và long chỉ khi bạn có lý do chính đáng để chọn độ chính xác cụ thể đó.
      • Trong số đó có hai loại dấu phẩy động: 32 bit float và 64 bit double, chúng ta sẽ sử dụng double chung. float Chỉ sử dụng nếu bạn muốn bảo tồn lưu trữ và không cần độ chính xác double.
      • charboolean và String có cách sử dụng cụ thể của từng loại.
      Ví dụ (Tên và loại biến): Paul đã mua một máy tính xách tay mới của thương hiệu "thần tượng", với tốc độ xử lý 2,66GHz, RAM 8 GB, ổ cứng 500 GB, với màn hình 15 inch, với giá 1760,55 USD. Anh ấy đã chọn gói dịch vụ 'C' trong số các gói 'A', 'B', 'C' và 'D', cộng với dịch vụ tại chỗ nhưng không chọn bảo hành mở rộng. Xác định các loại dữ liệu và đặt tên cho các biến.
      Các tên và loại biến có thể là:

      String name = "Paul";
      String brand = "idol";
      double processorSpeedInGHz = 2.66; // or float
      double ramSizeInGB = 8;            // or float
      int harddiskSizeInGB = 500;        // or short
      int monitorInInch = 15;            // or byte
      double price = 1760.55;
      char servicePlan = 'C';
      boolean onSiteService = true;
      boolean extendedWarranty = false;
      Bài tập (Tên và loại biến): Bạn được yêu cầu phát triển phần mềm cho trường đại học. Hệ thống sẽ duy trì thông tin về sinh viên. Điều này bao gồm tên, địa chỉ, số điện thoại, giới tính, ngày sinh, chiều cao, cân nặng, bằng cấp theo đuổi (ví dụ: B.Sc., BA), năm học, điểm trung bình trung bình, có / không có học phí, không / không phải là học giả. Mỗi sinh viên được gán một số có 8 chữ số duy nhất là id.
      Bạn được yêu cầu xác định các biến, gán tên phù hợp cho từng biến và chọn một loại thích hợp. Viết các câu lệnh khai báo biến như trong ví dụ trên.

      3.7  Literals for Primitive Types and String

      Một literal , hoặc literal constant, là một giá trị không đổi cụ thể , chẳng hạn như 123-4563.1416, -1.2E34.5e-6'a'"Hello", được sử dụng trong nguồn chương trình. Nó có thể được gán trực tiếp cho một biến; hoặc được sử dụng như một phần của biểu thức. Họ được gọi là literals vì họ theo nghĩa đen và rõ ràng xác định giá trị của họ. Chúng tôi gọi nó theo nghĩa đen để phân biệt nó với một biến .
      Số nguyên ( int , dài , ngắn , byte ) bằng chữ
      Toàn bộ số theo nghĩa đen, như 123 và -456, được coi là một int mặc định. Ví dụ,
      int number = -123;
      int sum = 1234567890;     // This value is within the range of int
      int bigSum = 8234567890;  // error: this value is outside the range of int
      int intRate = 6%;         // error: no percent sign
      int pay = $1234;          // error: no dollar sign
      int product = 1,234,567;  // error: no grouping commas
      Một chữ int có thể đứng trước dấu cộng ( +) hoặc dấu trừ ( -), theo sau là chữ số. Không dấu phẩy hoặc biểu tượng đặc biệt (ví dụ $%hoặc không gian) được phép (ví dụ 1,234,567$123và 12%không hợp lệ).
      Bạn có thể sử dụng tiền tố '0'(không) để biểu thị một giá trị bằng số nguyên trong bát phân và tiền tố '0x'(hoặc '0X') cho một giá trị ở dạng thập lục phân, ví dụ:
      int number1 = 1234;   // The usual decimal
      int number2 = 01234;  // Octal 1234, Decimal 2322
      int number3 = 0017;   // Octal 17, Decimal 15
      int number4 = 0x1abc; // Hexadecimal 1ABC, decimal 15274
      Từ JDK 7, bạn có thể sử dụng tiền tố ' 0b' hoặc ' 0B' để chỉ định một giá trị bằng số nguyên trong nhị phân. Bạn cũng được phép sử dụng dấu gạch dưới ( _) để chia các chữ số thành các nhóm để cải thiện khả năng đọc. Nhưng bạn phải bắt đầu và kết thúc bằng chữ bằng một chữ số, không được gạch dưới. Ví dụ,
      // JDK 7
      int number1 = 0b01010000101000101101000010100010;
      int number2 = 0b0101_0000_1010_0010_1101_0000_1010_0010;  // break the bits with underscore
      int number3 = 2_123_456;  // break the decimal digits with underscore
      int number4 = _123_456;   // error: cannot begin or end with underscore
      Một long nghĩa đen ngoài intphạm vi yêu cầu một hậu tố 'L'hoặc 'l'(tránh chữ thường 'l', có thể bị nhầm lẫn với số một '1'), ví dụ 123456789012L-9876543210lVí dụ,
      long sum = 123;                // Within the "int" range, no need for suffix 'L'
      long bigSum = 1234567890123L;  // Outside "int" range, suffix 'L' needed
      Không có hậu tố là cần thiết cho bytevà nghĩa shortđen. Nhưng bạn chỉ có thể sử dụng các giá trị trong phạm vi được phép. Ví dụ,
      byte smallNumber1 = 123;        // This is within the range of byte [-128, 127]
      byte smallNumber2 = -1234;      // error: this value is out of range
      
      short midSizeNumber1 = -12345;  // This is within the range of short [-32768, 32767]
      short midSizeNumber2 = 123456;  // error: this value is out of range
      Floating-point (doublefloat) literals
      Một số bằng chữ có dấu thập phân, chẳng hạn như 55.66 và -33.44, được coi là một double mặc định. Bạn cũng có thể thể hiện chúng trong ký hiệu khoa học, ví dụ như, 1.2e3-5.5E-6, nơi hoặc biểu thị số mũ trong cơ sở của 10 Bạn có thể đặt trước phần phân đoạn hoặc số mũ với một cộng ( +) hoặc trừ ( -dấu hiệu). Giá trị số mũ được giới hạn ở số nguyên. Không nên có không gian hoặc các ký tự khác trong số.
      Bạn được nhắc nhở rằng các số dấu phẩy động được lưu trữ ở dạng khoa học , trong đó (Phân số) và (Số mũ) được lưu trữ riêng.Fx2EFE
      Bạn có thể tùy ý sử dụng hậu tố 'd'hoặc 'D'để biểu thị nghĩa double đen.
      Bạn PHẢI sử dụng hậu tố 'f'hoặc 'F'cho nghĩa đen float ,vd -1.2345FVí dụ,
      float average = 55.66;    // error: RHS is a double. Need suffix 'f' for float.
      float average = 55.66F;   // float literal needs suffix 'f' or 'F'
      
      float rate = 1.2e-3;    // error: RHS is a double. Need suffix 'f' for float.
      float rate = 1.2e-3f;   // float literal needs suffix 'f' or 'F'
      Character (char) Literals and Escape Sequences
      Một in char chữ (chẳng hạn như chữ cái, chữ số và các ký hiệu đặc biệt) được viết bởi bao quanh các nhân vật với một cặp dấu nháy đơn , ví dụ 'A''z''0''9''$', và '@'Các char chữ đặc biệt (như tab, dòng mới) được thể hiện bằng cách sử dụng cái gọi là chuỗi thoát (sẽ được mô tả sau).
      Trong Java, chars được biểu diễn bằng Unicode 16 bit. Nhân vật có thể in cho chữ cái tiếng Anh ( a-zA-Z), chữ số ( 0-9) và biểu tượng ( +-@, vv) được giao cho mã số 32-126 (20H-7EH), như lập bảng dưới đây (được sắp xếp theo số thập phân và hệ thập lục phân).
      Dec0123456789
      3SP!"#$%&'
      4()*+,-./01
      523456789:;
      6<=>?@ABCDE
      7FGHIJKLMNO
      8PQRSTUVWXY
      9Z[\]^_`abc
      10defghijklm
      11nopqrstuvw
      12xyz{|}~

      Hex0123456789ABCDEF
      2SP!"#$%&'()*+,-./
      30123456789:;<=>?
      4@ABCDEFGHIJKLMNO
      5PQRSTUVWXYZ[\]^_
      6`abcdefghijklmno
      7pqrstuvwxyz{|}~
      Trong Java, một char có thể được coi là số nguyên cơ bản của nó trong phạm vi [0, 65535]hoạt động số học. Nói cách khác, char và số nguyên có thể hoán đổi cho nhau trong các phép toán số học. Bạn có thể coi a char là một int,bạn cũng có thể gán giá trị nguyên trong phạm vi của [0, 65535]một charbiến. Ví dụ,
      char letter = 'a';                 // Same as 97
      char anotherLetter = 98;           // Same as the letter 'b'
                                         // You can assign an integer in the range of [0, 65535] to char
      System.out.println(letter);        // 'a' printed
      System.out.println(anotherLetter); // 'b' printed instead of the number, because the type is char
      anotherLetter += 2;                // 100 or 'd'
      System.out.println(anotherLetter); // 'd' printed
      Các ký tự đặc biệt được biểu thị bằng cái gọi là chuỗi thoát , bắt đầu bằng dấu gạch chéo ngược ( \) theo sau là một mẫu, ví dụ: \tcho tab, \ncho dòng mới. Trình tự thoát thường được sử dụng là:
      Escape
      Sequence
      DescriptionUnicode
      (Decimal)
      Unicode
      (Hex)
      \tTab90009H
      \nNewline (or Line-feed)10000AH
      \rCarriage-return13000DH
      \"Double-quote (Needed to be used inside double-quoted String)--
      \'Single-quote (Needed to be used inside single-quoted char, i.e., '\'')--
      \\Back-slash (Needed as back-slash is given a special meaning)--
      \uhhhhUnicode number hhhh (in hex), e.g., \u60a8 is 您, \u597d is 好-hhhhH
      Ví dụ,
      char tabChar = '\t';          // tab
      char anotherTabChar = 9;      // Code number 9 is tab
      char newlineChar = '\n';      // newline, code number 10
      char backSlashChar = '\\';    // Since back-slash is given a special meaning,
                                    // to write a back-slash, use double back-slash
      char singleQuoteChar = '\'';  // Need to use escape sequence to resolve conflict
      char doubleQuoteChar = '"';   // No conflict. No need for escape sequence
      System.out.println("A tab " + tabChar + " before this; end with two newlines!" + newlineChar + newlineChar);
      String Literals and Escape Sequences
      String là một chuỗi các ký tự. Một String nghĩa đen bao gồm không hoặc có nhiều ký tự được bao quanh bởi một cặp dấu ngoặc kép . Ví dụ như,
      String directionMsg = "Turn Right";
      String greetingMsg = "Hello";
      String statusMsg = "";        // An empty string
      Bạn cần sử dụng một chuỗi thoát cho các ký tự không thể in đặc biệt, chẳng hạn như dòng mới ( \n) và tab ( \t). Bạn cũng cần sử dụng chuỗi thoát cho trích dẫn kép ( \") và dấu gạch chéo ngược ( \\) do xung đột. Ví dụ như,
      String str1 = "hello\tworld\n";    // tab and newline
      String str2 = "a double quoted \"hello\"";
      String str3 = "1 back-slash \\, another 2 back-slashes \\\\";
      String str1 = "A \"string\" nested \\inside\\ a string"   // A "string" nested \inside\ a string
      String str2 = "Hello, \u60a8\u597d!"   // "Hello, 您好!"
      Trích dẫn đơn ( ') bên trong a String không yêu cầu trình tự thoát vì không có sự mơ hồ, ví dụ:
      String str3 = "Hi, I'm a string!"      // Single quote OK
      Điều quan trọng cần lưu ý là \thoặc \"là MỘT ký tự duy nhất, KHÔNG PHẢI LÀ HAI!
      Bài tập: Viết chương trình in hình động vật sau bằng cách sử dụng System.out.println()Lưu ý rằng bạn cần sử dụng các chuỗi thoát để in một số ký tự, ví dụ: \"for "\\for \.
                '__'
                (oo)
        +========\/
       / || %%% ||
      *  ||-----||
         ""     ""
      End-of-Line (EOL)
      Dòng mới ( 0AH) và Vận chuyển trở lại ( 0DH), được biểu thị bằng chuỗi thoát \n, và \rtương ứng, được sử dụng làm dấu phân cách dòng (hoặc cuối dòng hoặc EOL ) cho các tệp văn bản. Hãy lưu ý rằng Unix và macOS sử dụng \n0AH) làm EOL, trong khi Windows sử dụng \r\n0D0AH).
      boolean Literals
      There are only two boolean literals, i.e., true and false. For example,
      boolean done = true;
      boolean gameOver = false;
      
      boolean isValid;
      isValid = false;
      Example on Literals
      /**
       * Test literals for various primitive types
       */
      public class LiteralTest {
         public static void main(String[] args) {
            String name = "Tan Ah Teck"; // String is double-quoted
            char gender = 'm';           // char is single-quoted
            boolean isMarried = true;    // boolean of either true or false
            byte numChildren = 8;        // Range of byte is [-127, 128]
            short yearOfBirth = 1945;    // Range of short is [-32767, 32768]. Beyond byte
            int salary = 88000;          // Beyond the ranges of byte and short
            long netAsset = 8234567890L; // Need suffix 'L' for long. Beyond int
            double weight = 88.88;       // With fractional part
            float gpa = 3.88f;           // Need suffix 'f' for float
      
            // println() can be used to print value of any type
            System.out.println("Name is: " + name);
            //Name is: Tan Ah Teck
            System.out.println("Gender is: " + gender);
            //Gender is: m
            System.out.println("Is married is: " + isMarried);
            //Is married is: true
            System.out.println("Number of children is: " + numChildren);
            //Number of children is: 8
            System.out.println("Year of birth is: " + yearOfBirth);
            //Year of birth is: 1945
            System.out.println("Salary is: " + salary);
            //Salary is: 88000
            System.out.println("Net Asset is: " + netAsset);
            //Net Asset is: 8234567890
            System.out.println("Weight is: " + weight);
            //Weight is: 88.88
            System.out.println("GPA is: " + gpa);
            //GPA is: 3.88
         }
      }

      3.8  var - Local Variable Type Inference (JDK 10)

      JDK 10 giới thiệu một cách mới để khai báo các biến thông qua một từ khóa mới var, ví dụ,
      var v1 = 0;        // type inferred to "int"
      var v2 = 0.0;      // type inferred to "double"
      var v3 = 1.0f;     // type inferred to "float"
      var v4 = '0';      // type inferred to "char"
      var v5 = "hello";  // type inferred to "String"
      //var v6;          //compilation error: cannot use 'var' on variable without initializer
      Rõ ràng, bạn cần khởi tạo biến, để trình biên dịch có thể suy ra kiểu của nó.

      4.  Basic Operations

      4.1  Arithmetic Operators

      Java supports the following binary/unary arithmetic operations:
      OperatorModeUsageDescriptionExamples
      +Binary
      Unary
      x + y
      +x
      Addition
      Unary positive
      1 + 2 ⇒ 3
      1.1 + 2.2 ⇒ 3.3
      -Binary
      Unary
      x - y
      -x
      Subtraction
      Unary negate
      1 - 2 ⇒ -1
      1.1 - 2.2 ⇒ -1.1
      *Binaryx * yMultiplication2 * 3 ⇒ 6
      3.3 * 1.0 ⇒ 3.3
      /Binaryx / yDivision1 / 2 ⇒ 0
      1.0 / 2.0 ⇒ 0.5
      %Binaryx % yModulus (Remainder)5 % 2 ⇒ 1
      -5 % 2 ⇒ -1
      5.5 % 2.2 ⇒ 1.1
      Các toán tử này thường là các toán tử infix nhị phân , nghĩa là chúng có hai toán hạng với toán tử ở giữa các toán hạng (ví dụ 11 + 12:). Tuy nhiên, '-'và '+'cũng có thể được hiểu là toán tử tiền tố "phủ định" và "dương" , với toán tử ở phía trước toán hạng. Ví dụ như,
      int number = -9;
      number = -number;      // Unary negate
      

      4.2  Arithmetic Expressions

      Trong lập trình, biểu thức số học sau:
      JavaBasics_ArithaturesExpression.png
      phải được viết là (1+2*a)/3 + (4*(b+c)*(5-d-e))/f - 6*(7/g+h)Bạn không thể bỏ qua dấu nhân ( *) như trong Toán học.
      Quy tắc ưu tiên
      Giống như Toán học:
      1. Dấu ngoặc đơn ()có độ ưu tiên cao nhất và có thể được sử dụng để thay đổi thứ tự đánh giá.
      2. Unary '-'(phủ định) và '+'(dương) có quyền ưu tiên cao hơn tiếp theo.
      3. Phép nhân ( *), phép chia ( /) và mô đun ( %) có cùng mức ưu tiên. Chúng được ưu tiên hơn phép cộng ( +) và phép trừ ( -). Ví dụ, 1+2*3-4/5+6%7được hiểu là 1+(2*3)-(4/5)+(6%7).
      4. Trong cùng một mức độ ưu tiên (nghĩa là cộng / trừ và nhân / chia / mô đun), biểu thức được ước tính từ trái sang phải (được gọi là liên kết trái ). Ví dụ, 1+2-3+4được đánh giá là ((1+2)-3)+4, và 1*2%3/4là ((1*2)%3)/4.

        4.3  Type Conversion in Arithmetic Operations

        Chương trình của bạn thường chứa dữ liệu của nhiều loại, ví dụ, count và sum là intaverage và gpa là double, và message là một StringDo đó, điều quan trọng là phải hiểu cách Java xử lý các loại trong các chương trình của bạn.
        Các toán tử số học ( +-*/%) chỉ áp dụng đối với các loại số nguyên thủy : byteshortintlongfloatdouble, và char. Chúng không áp dụng cho boolean.
        Toán tử cùng loại của int , long , float , double
        Nếu cả hai toán hạng là intlongfloathay double, các phép tính số học nhị phân được thực hiện trong loại đó, và đánh giá một giá trị của loại hình đó, ví dụ,
        • int ⊕ int ⇒ int, Nơi biểu thị một toán tử số học nhị phân như +-*/%.
        • long ⊕ long ⇒ long
        • float ⊕ float ⇒ float
        • double ⊕ double ⇒ double
        phép chia int
        Điều quan trọng là phải ghi chú int phân chia tạo ra một int, tức là int / int ⇒ int, với kết quả bị cắt bớt . Ví dụ: 1/2 ⇒ 0int), nhưng 1.0/2.0 ⇒ 0.5double / double ⇒ double).
        Các toán tử cùng loại của byte , short , char : Chuyển đổi thành int
        Nếu các toán hạng BOTH là byteshorthoặc char, các hoạt động nhị phân được thực hiện intvà ước tính giá trị của intcharđược coi là một số nguyên của số Unicode cơ bản của nó trong phạm vi [0, 65535]Đó là,
        • byte ⊕ byte ⇒ int ⊕ int ⇒ int, Nơi biểu thị một toán tử số học nhị phân như +-*/%.
        • short ⊕ short ⇒ int ⊕ int ⇒ int
        • char ⊕ char ⇒ int ⊕ int ⇒ int
        Xin lưu ý rằng KHÔNG có phép toán số học nào được thực hiện trong byteshorthoặc char.
        Ví dụ như,
        byte b1 = 5, b2 = 9, b3;
        // byte + byte -> int + int -> int 
        b3 = b1 + b2;            // lỗi: RHS là "int", không thể gán cho LHS của "byte" 
        b3 = (byte) (b1 + b2);   // Cần truyền kiểu rõ ràng (sẽ được thảo luận sau)
        Tuy nhiên, nếu các nhà khai thác số học hợp chất ( +=-=*=/=%=) (sẽ được thảo luận sau) được sử dụng, kết quả được tự động chuyển đổi sang các LHS. Ví dụ,
        byte b1 = 5, b2 = 9;
        b2 + = b1;     // Kết quả là "int", nhưng tự động chuyển đổi thành "byte"
        Phép toán số học hỗn hợp
        Nếu hai toán hạng thuộc về các loại khác nhau , giá trị của loại nhỏ hơn sẽ tự động được chuyển sang loại lớn hơn (được gọi là đúc kiểu ẩn ). Hoạt động sau đó được thực hiện trong loại lớn hơn và được đánh giá thành giá trị trong loại lớn hơn .
        • byteshortHoặc charlà lần đầu tiên thăng inttrước khi so sánh với các loại toán hạng khác. (Trong Java, không có thao tác nào được thực hiện trong byteshorthoặc char.)
        • Thứ tự khuyến mãi là : int ⇒ long ⇒ float ⇒ double.
        Ví dụ như,
        1. int / double ⇒ double / double ⇒ doubleVì thế,1/2 ⇒ 0, 1.0/2.0 ⇒ 0.5, 1.0/2 ⇒ 0.5, 1/2.0 ⇒ 0.5
        2. 9 / 5 * 20.1 ⇒ (9 / 5) * 20.1 ⇒ 1 * 20.1 ⇒ 1.0 * 20.1 ⇒ 20.1 (Bạn có thể không mong đợi câu trả lời này!)
        3. char '0' + int 2 ⇒ int 48 + int 2 ⇒ int 50(Kết quả là một int, cần phải được gửi lại một cách rõ ràng char '2'nếu muốn.)
        4. char ⊕ float ⇒ int ⊕ float ⇒ float ⊕ float ⇒ float
        5. byte ⊕ double ⇒ int ⊕ double ⇒ double ⊕ double ⇒ double
        Tóm tắt: Quy tắc chuyển đổi loại cho hoạt động nhị phân
        Các quy tắc khuyến mãi loại cho các hoạt động nhị phân có thể được tóm tắt như sau:
        1. Nếu một trong các toán hạng là double, toán hạng khác được thăng cấp lên double;
        2. khác nếu một trong các toán hạng là float, toán hạng khác được thăng cấp lên float;
        3. khác nếu một trong các toán hạng là long, toán hạng khác được thăng cấp lên long;
        4. khác cả hai toán hạng được thăng cấp lên int.
        Tóm tắt: Quy tắc chuyển đổi loại cho hoạt động đơn phương
        Các quy tắc khuyến mãi loại cho các hoạt động đơn nguyên (ví dụ: phủ định '-') có thể được tóm tắt như sau:
        1. Nếu toán hạng là doublefloatlonghay int, không có chương trình khuyến nghị;
        2. khác các toán hạng được byteshortchar, các toán hạng được thăng chức int.

          4.4  More on Arithmetic Operators

          Toán tử Modulus (phần còn lại)
          Để đánh giá phần còn lại cho các toán hạng âm và dấu phẩy động, thực hiện phép trừ lặp lại cho đến khi giá trị tuyệt đối của phần còn lại nhỏ hơn giá trị tuyệt đối của toán hạng thứ hai.
          Ví dụ,
          • -5 % 2 ⇒ -3 % 2 ⇒ -1
          • 5.5 % 2.2 ⇒ 3.3 % 2.2 ⇒ 1.1
          Số mũ?
          Java không có toán tử mũ. ^Toán tử biểu thị độc quyền hoặc KHÔNG, số mũ). Bạn cần sử dụng phương thức JDK Math.exp(x, y)để tính mỹ yhoặc viết mã của riêng bạn.

          4.5  Overflow/Underflow

          Nghiên cứu đầu ra của chương trình sau:
          /**
           * Illustrate "int" overflow
           */
          public class OverflowTest {
             public static void main(String[] args) {
                // Range of int is [-2147483648, 2147483647]
                int i1 = 2147483647;        // maximum int
                System.out.println(i + 1);  //-2147483648 (overflow)
                System.out.println(i + 2);  //-2147483647 (overflow)
                System.out.println(i + 3);  //-2147483646 (overflow)
                System.out.println(i * 2);  //-2 (overflow)
                System.out.println(i * i);  //1 (overflow)
                
                int i2 = -2147483648;         // minimum int
                System.out.println(i2 - 1);   //2147483647 (overflow)
                System.out.println(i2 - 2);   //2147483646 (overflow)
                System.out.println(i2 * i2);  //0 (overflow)
             }
          }
          Trong các phép toán số học, giá trị kết quả sẽ bao quanh nếu nó vượt quá phạm vi của nó (nghĩa là tràn). Thời gian chạy Java KHÔNG đưa ra thông báo lỗi / cảnh báo nhưng tạo ra kết quả không chính xác .
          Mặt khác, phép chia số nguyên tạo ra một số nguyên bị cắt cụt và dẫn đến cái gọi là dòng dưới . Ví dụ, 1/2cho 0, thay vì 0.5Một lần nữa, thời gian chạy Java KHÔNG đưa ra thông báo lỗi / cảnh báo, nhưng tạo ra kết quả không chính xác .
          Điều quan trọng cần lưu ý là việc kiểm tra tràn / tràn là trách nhiệm của lập trình viên . tức là công việc của bạn !!!
          Tại sao máy tính không gắn cờ tràn / tràn là lỗi? Điều này là do thiết kế cũ khi bộ xử lý rất chậm. Kiểm tra tràn / tràn tiêu tốn năng lượng tính toán. Ngày nay, bộ xử lý nhanh. Tốt hơn là yêu cầu máy tính kiểm tra tràn / tràn (nếu bạn thiết kế một ngôn ngữ mới), bởi vì rất ít người mong đợi kết quả như vậy.
          Để kiểm tra tràn số học (được gọi là mã hóa an toàn ) là tẻ nhạt. Google cho "INT32-C. Đảm bảo rằng các thao tác trên số nguyên đã ký không dẫn đến tràn" @ www.securecoding.cert.org.

          4.6  More on Integer vs. Floating-Point Numbers

          Số nguyên ( byteshortintlong) là chính xác (chính xác). Nhưng floatvà doublekhông chính xác nhưng gần đúng. Nghiên cứu kết quả của chương trình sau:
          /**
           * Test preciseness for int/float/double
           */
          public class TestPreciseness {
             public static void main(String[] args) {
                // doubles are NOT precise
                System.out.println(2.2 + 4.4);       //6.6000000000000005
                System.out.println(6.6 - 2.2 - 4.4); //-8.881784197001252E-16 (NOT Zero!)
                // Compare two doubles
                System.out.println((6.6) == (2.2 + 4.4));  //false
           
                // int is precise, float/double are NOT!
                int i1 = 123456789;
                System.out.println(i1*10); //1234567890 (exact within the range)
          
                float f1 = 123456789.0f;   // float keeps 6-7 significant digits
                System.out.println(f1);    //1.23456792E8 (=123456792 close but not exact)
                System.out.println(f1*10); //1.23456794E9 (=1234567940)
             }
          }
          Luôn luôn sử dụng intnếu bạn không cần phần phân đoạn, mặc dù doublecũng có thể đại diện cho hầu hết các số nguyên (ví dụ 1.02.03.0). Điều này là do:
          • intlà hiệu quả hơn (nhanh hơn) so với doubletrong các hoạt động số học.
          • 32 bit intchiếm ít không gian bộ nhớ hơn 64 bit double.
          • intlà chính xác (chính xác) trong việc thể hiện TẤT CẢ các số nguyên trong phạm vi của nó. doublelà một xấp xỉ - KHÔNG phải TẤT CẢ các giá trị nguyên có thể được biểu diễn bằng double.

            4.7  Type Casting

            Trong Java, bạn sẽ nhận được một bộ sưu tập "lỗi: loại không phù hợp: có thể chuyển đổi tổn hao từ double|float|longđể int" nếu bạn cố gắng gán một doublefloathoặc longgiá trị của một intbiến. Điều này là do phần phân đoạn sẽ bị cắt và mất. Ví dụ,
            // Assign a "double" value to an "int" variable
            double d = 3.5;
            int i = d;        //Compilation error: incompatible types: possible lossy conversion from double to int
            
            // Assign a "float" value to an "int" variable
            int sum = 55.66f; //Compilation error: incompatible types: possible lossy conversion from float to int
            
            // Assign a "long" value to an "int" variable
            long lg = 123;
            int count = lg;   //Compilation error: incompatible types: possible lossy conversion from long to int
            Explicit Type-Casting and Type-Casting Operator
            Để gán một doublegiá trị cho một intbiến, bạn cần phải gọi cái gọi là ép kiểu - theo hình thức - để hoạt động trên toán hạng và trả về một cắt ngắn giá trị trong Nói cách khác, bạn nói với trình biên dịch mà bạn có ý thức thực hiện việc cắt ngắn và bạn hoàn toàn nhận thức được "chuyển đổi mất mát có thể". Sau đó, bạn có thể gán giá trị rút gọn cho biến. Ví dụ,(int)doubleOperanddoubleintintint
            double d = 3.5;
            int i;
            i = (int)d;    // Cast "double" value of 3.5 to "int" 3. Assign the resultant value 3 to i
                           // Casting from "double" to "int" truncates.
            Kiểu truyền là một hoạt động cần một toán hạng. Nó hoạt động trên toán hạng của nó và trả về một giá trị tương đương trong loại được chỉ định. Cú pháp là:
            (type)variable    // e.g., (int)height
            (type)literal     // e.g., (int)55.66
            Có hai kiểu truyền kiểu trong Java:
            1. Ép kiểu rõ ràng thông qua một toán tử đúc kiểu, như được mô tả ở trên, và
            2. Ép kiểu ngầm định được thực hiện bởi trình biên dịch tự động, nếu không mất độ chính xác.
            Kiểu đúc ngầm định trong bài tập
            Đúc kiểu rõ ràng là không cần thiết nếu bạn gán một intgiá trị cho một doublebiến, bởi vì không có sự mất độ chính xác. Trình biên dịch sẽ thực hiện việc truyền kiểu tự động (nghĩa là truyền kiểu ẩn). Ví dụ,,
            int i = 3;
            double d;
            d = i;           // OK, no explicit type casting required
                             // d = 3.0
            d = (double)i;   // Explicit type casting operator used here
            double aDouble = 55;   // Compiler auto-casts int 55 to double 55.0
            double nought = 0;     // Compiler auto-casts int 0 to double 0.0
                                   // int 0 and double 0.0 are different.
            Sơ đồ sau đây cho thấy thứ tự đúc kiểu ngầm định được thực hiện bởi trình biên dịch. Quy tắc là thúc đẩy loại nhỏ hơn thành loại lớn hơn để tránh mất độ chính xác, được gọi là chuyển đổi mở rộng. Chuyển đổi thu hẹp yêu cầu phân loại kiểu rõ ràng để thông báo cho trình biên dịch rằng bạn biết về sự mất độ chính xác có thể có. Lưu ý rằng charđược coi là một số nguyên trong phạm vi [0, 65535]booleangiá trị không thể được phân loại (nghĩa là được chuyển đổi thành không boolean).
            JavaBasics_ImplicitTypeCastingPrimitives.png
            Ví dụ : Giả sử bạn muốn tìm trung bình (in double) của các số nguyên đang chạy từ 1và 100Nghiên cứu mã sau đây:
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            /** Compute the average of running numbers 1 to 100 */
            public class Average1To100 {
               public static void main(String[] args) {
                  int sum = 0;
                  double average;
                  for (int number = 1; number <= 100; ++number) {
                     sum += number;      // Final sum is int 5050
                  }
                  average = sum / 100;   // Won't work (average = 50.0 instead of 50.5)
                  System.out.println("Average is " + average);  //Average is 50.0
               }
            }
            Ví dụ : Giả sử bạn muốn tìm trung bình (in double) của các số nguyên đang chạy từ 1và 100Nghiên cứu mã sau đây:
            average = (double)sum / 100;     // Cast sum from int to double before division, double / int -> double / double -> double
            average = sum / (double)100;     // Cast 100 from int to double before division, int / double -> double / double -> double
            average = sum / 100.0;           // int / double -> double / double -> double
            average = (double)(sum / 100);   // Won't work. why?

            4.8  Compound Assignment Operators

            Bên cạnh toán tử gán đơn giản thông thường ( =) được mô tả trước đó, Java cũng cung cấp cái gọi là toán tử gán gán ghép như được liệt kê:
            OperationModeUsageDescriptionExample
            =Binaryvar = exprAssignment
            Assign the LHS value to the RHS variable
            x = 5;
            +=Binaryvar += expr
            same as: var = var + expr
            Compound addition and assignmentx += 5;same as: x = x + 5
            -=Binaryvar -= expr
            same as: var = var - expr
            Compound subtraction and assignmentx -= 5;same as: x = x - 5
            *=Binaryvar *= expr
            same as: var = var * expr
            Compound multiplication and assignmentx *= 5;same as: x = x * 5
            /=Binaryvar /= expr
            same as: var = var / expr
            Compound division and assignmentx /= 5;same as: x = x / 5
            %=Binaryvar %= expr
            same as: var = var % expr
            Compound modulus (remainder) and assignmentx %= 5;same as: x = x % 5
            Một sự khác biệt tinh tế giữa đơn giản và khai thác hợp chất là trong byteshortcharhoạt động nhị phân. Ví dụ như,
            byte b1 = 5, b2 = 8, b3;
            b3 = (byte)(b1 + b2);    // byte + byte -> int + int -> int, need to explicitly cast back to "byte"
            b3 = b1 + b2;            // error: RHS is int, cannot assign to byte
            b1 += b2;                // implicitly casted back to "byte"
            
            char c1 = '0', c2;
            c2 = (char)(c1 + 2);     // char + int -> int + int -> int, need to explicitly cast back to "char"
            c2 = c1 + 2;             // error: RHS is int, cannot assign to char
            c1 += 2;                 // implicitly casted back to "char"

            4.9  Increment/Decrement

            Java hỗ trợ các unary toán tử số học: increment ( ++) và giảm một ( --) cho tất cả các loại số nguyên thủy ( byteshortcharintlongfloatvà double, ngoại trừ boolean). Các toán tử unary tăng / giảm có thể được đặt trước toán hạng (tiền tố) hoặc sau toán hạng (postfix). Những nhà khai thác đã được giới thiệu trong C ++ để viết tắt x=x+1cho x++hay ++x.
            OperatorModeUsageDescriptionExample
            ++
            (Increment)
            Unary Prefix
            Unary Postfix
            ++x
            x++
            Increment the value of the operand by 1.
            x++ or ++x is the same as x += 1 or x = x + 1
            int x = 5;
            x++; // x is 6
            ++x; // x is 7
            --
            (Decrement)
            Unary Prefix
            Unary Postfix
            --x
            x--
            Decrement the value of the operand by 1.
            x-- or --x is the same as x -= 1 or x = x - 1
            int y = 6;
            y--; // y is 5
            --y; // y is 4
            Gia số ( ++) và giảm ( --) hoạt động trên toán hạng duy nhất của nó và lưu kết quả trở lại toán hạng của nó. Ví dụ: ++xlấy x, tăng và lưu kết quả trở lại x.
            Trong Java, có 4 cách để tăng / giảm một biến:
            int x = 5;
            // 4 ways to increment by 1
            x = x + 1;  // x is 6
            x += 1;     // x is 7
            x++;        // x is 8
            ++x;        // x is 9
            // 4 ways to decrement by 1
            x = x - 1;  // x is 8
            x -= 1;     // x is 7
            x--;        // x is 6
            --x;        // x is 5
            Không giống như các toán tử unary khác (chẳng hạn như phủ nhận ( -)) trong đó khuyến khích byteshortvà charđể int, thặng dư và sụt lần không thúc đẩy toán hạng của nó vì không có nhu cầu như vậy.
            Toán tử đơn nguyên tăng / giảm có thể được đặt trước toán hạng (tiền tố) hoặc sau toán hạng (hậu tố), có thể ảnh hưởng đến kết quả.
            • Nếu các toán tử này được sử dụng bởi chính chúng (độc lập) trong một câu lệnh (ví dụ : x++; hoặc ++x;), kết quả là CÙNG cho các toán tử trước và sau toán tử. Xem ví dụ trên.
            • Nếu ++hoặc --liên quan đến một hoạt động khác trong câu lệnh SAME, ví dụ, y = x++;hoặc y = ++x;khi có hai thao tác trong cùng một câu lệnh: gán và tăng, thì trước hoặc sau khi đặt hàng rất quan trọng để chỉ định thứ tự của hai thao tác này, như được lập bảng dưới đây:
              OperatorDescriptionExampleSame As
              ++var
              (Pre-Increment)
              Tăng var và trả về var tăng cho hoạt động khác trong cùng một câu lệnh.y = ++x;x = x + 1;
              y = x;
              var++
              (Post-Increment)
              Trả về giá trị cũ của var cho hoạt động khác trong cùng một câu lệnh, sau đó tăng var.y = x++;oldX = x; 
              x = x + 1; 
              y = oldX;
              --var
              (Pre-Decrement)
              Giảm var và trả về var decremented cho hoạt động khác trong cùng một câu lệnh.y = --x;x = x - 1; 
              y = x;
              var--
              (Post-Decrement)
              Trả về giá trị cũ của var cho hoạt động khác trong cùng một câu lệnh, sau đó giảm var.y = x--;oldX = x; 
              x = x - 1; 
              y = oldX;
              For examples,
              // Two operations in the statement: increment and assignment
              x = 5;
              y = ++x;   // Increment x (=6), then assign x to y (=6). (++x returns x+1)
              x = 5;
              y = x++;   // Assign x to y (=5), then increment x (=6). (x++ returns the oldX)
              // After the operations, x gets the SAME value, but the other operation has different outcomes
              
              // Two operations in the statement: increment and println()
              x = 5;
              System.out.println(++x);  // Increment x (=6), then print x (=6). (++x returns x+1)
              x = 5;
              System.out.println(x++);  // Print x (=5), then increment x (=6). (x++ returns the oldX)
              
              Ghi chú:
              • Toán tử tiền tố (ví dụ, ++i) có thể hiệu quả hơn toán tử tiền tố (ví dụ i++:)?!
              • Là i=i++gì Hãy thử nó!

                4.10  Relational and Logical Operators

                Rất thường xuyên, bạn cần so sánh hai giá trị trước khi quyết định hành động được thực hiện, ví dụ: nếu dấu lớn hơn hoặc bằng 50, hãy in "PASS!".
                Java cung cấp sáu toán tử so sánh (hoặc toán tử quan hệ ). Tất cả các toán tử này là toán tử nhị phân (có hai toán hạng) và trả về booleangiá trị là truehoặc false.
                OperatorModeUsageDescriptionExample (x=5, y=8)
                ==Binaryx == yEqual to(x == y) ⇒ false
                !=Binaryx != yNot Equal to(x != y) ⇒ true
                >Binaryx > yGreater than(x > y) ⇒ false
                >=Binaryx >= yGreater than or equal to(x >= 5) ⇒ true
                <Binaryx < yLess than(y < 8) ⇒ false
                <=Binaryx <= yLess than or equal to(y <= 8) ⇒ true
                Xin lưu ý rằng các toán tử so sánh là các toán tử infix nhị phân , hoạt động trên hai toán hạng với toán tử ở giữa các toán hạng, ví dụ : x <= 100Nó không hợp lệ để viết 1 < x < 100(hoạt động không nhị phân). Thay vào đó, bạn cần phải thoát ra khỏi hai biểu thức  so sánh nhị phân x > 1x < 100 và liên kết bằng toán tử logic AND, ví dụ (x > 1) && (x < 100), nơi && biểu thị toán tử AND kết hợp hai điều kiện. 
                Java cung cấp bốn toán tử logic, chỉ hoạt động trên boolean các toán hạng, theo thứ tự ưu tiên giảm dần, như sau:
                OperatorModeUsageDescriptionExample
                !Unary!xLogical NOT
                &&Binaryx && yLogical AND
                ||Binaryx || yLogical OR
                ^Binaryx ^ yLogical Exclusive-OR (XOR)
                Các bảng chân lý như sau:
                NOT (!)truefalse
                Resultfalsetrue

                AND (&&)truefalse
                truetruefalse
                falsefalsefalse

                OR (||)truefalse
                truetruetrue
                falsetruefalse

                XOR (^)truefalse
                truefalsetrue
                falsetruefalse
                Examples:
                // Return true if x is between 0 and 100 (inclusive)
                (x >= 0) && (x <= 100)
                // wrong to use 0 <= x <= 100
                  
                // Return true if x is outside 0 and 100 (inclusive)
                (x < 0) || (x > 100)
                // or
                !((x >= 0) && (x <= 100))
                 
                // Return true if year is a leap year
                // A year is a leap year if it is divisible by 4 but not by 100, or it is divisible by 400.
                ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)
                Bài tập: Nghiên cứu chương trình sau, và giải thích đầu ra của nó.
                /**
                 * Test relational and logical operators
                 */
                public class RelationalLogicalOpTest {
                   public static void main(String[] args) {
                      int age = 18;
                      double weight = 71.23;
                      int height = 191;
                      boolean married = false;
                      boolean attached = false;
                      char gender = 'm';
                      
                      System.out.println(!married && !attached && (gender == 'm'));  //true
                      System.out.println(married && (gender == 'f'));  //false
                      System.out.println((height >= 180) && (weight >= 65) && (weight <= 80));  //true
                      System.out.println((height >= 180) || (weight >= 90));  //true
                   }
                }
                Viết một biểu thức cho tất cả nam giới chưa kết hôn, tuổi từ 21 đến 35, với chiều cao trên 180 và cân nặng từ 70 đến 80.
                Bài tập: Đưa ra yearmonth(1-12) và day(1-31), viết booleanbiểu thức trả về truengày trước ngày 15 tháng 10 năm 1582 (ngày giới hạn lịch Gregorian).
                Năm: (year < 1582) || (year == 1582 && month < 10) || (year == 1582 && month == 10 && day < 15)
                So sánh bình đẳng ==
                Bạn có thể sử dụng ==để so sánh hai số nguyên ( byteshortintlong) và charNhưng KHÔNG sử dụng ==để so sánh hai số dấu phẩy động ( floatvà double) vì chúng KHÔNG chính xác. Để so sánh các số có dấu phẩy động, hãy đặt ngưỡng cho sự khác biệt của chúng, ví dụ:
                public class FloatComparisonTest {
                   public static void main(String[] args) {
                      // floating-point numbers are NOT precise
                      double d1 = 2.2 + 4.4;
                      double d2 = 6.6;
                      System.out.println(d1 == d2);  //false
                      System.out.println(d1);        //6.6000000000000005
                
                      // Set a threshold for comparison with ==
                      final double EPSILON = 1e-7;
                      System.out.println(Math.abs(d1 - d2) < EPSILON);  //true
                   }
                }
                Bạn cũng KHÔNG THỂ sử dụng ==để so sánh hai String vì String là đối tượng. Bạn cần sử dụng str1.equals(str2)thay thế. Điều này sẽ được bàn đến sau.
                Ưu tiên khai thác logic
                Các ưu tiên từ cao nhất đến thấp nhất là: '!'(unary), '^''&&''||'. Nhưng khi nghi ngờ, hãy sử dụng dấu ngoặc đơn!
                System.out.println(true || true && false);    //true (same as below)
                System.out.println(true || (true && false));  //true
                System.out.println((true || true) && false);  //false
                 
                System.out.println(false && true ^ true);     //false (same as below)
                System.out.println(false && (true ^ true));   //false
                System.out.println((false && true) ^ true);   //true
                Hoạt động ngắn mạch
                Toán tử nhị phân AND ( &&) và OR ( ||) được gọi là toán tử ngắn mạch, có nghĩa là toán hạng phải sẽ không được đánh giá nếu kết quả có thể được xác định bởi toán hạng trái. Ví dụ, false && rightOperand cho false và true || rightOperand cho true mà không đánh giá toán hạng bên phải. Điều này có thể có hậu quả bất lợi nếu bạn dựa vào toán hạng bên phải để thực hiện một số thao tác nhất định, ví dụ false && (++i < 5) nhưng ++i sẽ không được đánh giá.

                4.11  String and '+' Concatenation Operator

                Trong Java, '+'là một toán tử đặc biệt. Nó bị quá tải . Quá tải có nghĩa là nó thực hiện các hoạt động khác nhau tùy thuộc vào các loại toán hạng của nó.
                • Nếu cả hai toán hạng là số ( byteshortintlongfloatdoublechar), '+'thực hiện bình thường Ngoài ra . Ví dụ như,
                • 1 + 2 ⇒ 3   // int + int ⇒ int
                  1.2 + 2.2 ⇒ 3.4   // double + double ⇒ double
                  1 + 2.2 ⇒ 1.0 + 2.2 ⇒ 3.2  // int + double ⇒ double + double ⇒ double
                  '0' + 2 ⇒ 48 + 2 ⇒ 50   // char + int ⇒ int + int ⇒ int (need to cast back to char '2')
                • Nếu cả hai toán hạng là Strings, '+' nối hai Strings và trả về kết nối StringVí dụ như,
                  "Hello" + "world" ⇒ "Helloworld"
                  "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
                • Nếu một trong các toán hạng là a Stringvà cái kia là số, toán hạng số sẽ được chuyển đổi thành Stringvà hai Strings được nối với nhau, ví dụ
                  "The number is " + 5 ⇒ "The number is " + "5" ⇒ "The number is 5"
                  "The average is " + average + "!" (suppose average=5.5) ⇒ "The average is " + "5.5" + "!" ⇒ "The average is 5.5!"
                  "How about " + a + b (suppose a=1, b=1) ⇒ "How about 1" + b ⇒ "How about 11" (left-associative)
                  "How about " + (a + b) (suppose a=1, b=1) ⇒ "How about " + 2 ⇒ "How about 2"
                Chúng tôi sử dụng Stringtoán tử ghép nối '+'thường xuyên trong print()và println()để tạo ra đầu ra mong muốn StringVí dụ như,
                System.out.println("The sum is: " + sum);   // Value of "sum" converted to String and concatenated
                System.out.println("The square of " + input + " is " + squareInput);

                5.  Flow Control


                Có ba cấu trúc điều khiển luồng cơ bản - tuần tự , có điều kiện (hoặc quyết định ) và vòng lặp (hoặc lặp ), như minh họa dưới đây.
                structure constructs

                5.1  Sequential Flow Control

                flow_sequential.gif
                Một chương trình là một chuỗi các hướng dẫn thực hiện lần lượt từng bước một theo cách có thể dự đoán được. Luồng tuần tự là dòng phổ biến nhất và đơn giản, trong đó các câu lệnh lập trình được thực thi theo thứ tự chúng được viết - từ trên xuống dưới theo cách tuần tự.





                5.2  Conditional Flow Control

                Có vài loại điều kiện cơ bản, if-thenif-then-elsenested-ifswitch-case-default, và conditional expression.
                if-then and if-then-else
                SyntaxExampleFlowchart
                // if-then
                if (booleanTest) {
                   trueBlock;
                }
                // next statement
                
                
                
                
                 
                
                 
                int mark = 80;
                if (mark >= 80) {
                   System.out.println("Well Done!");
                   System.out.println("Keep it up!");
                }
                System.out.println("Life goes on!);
                
                double temperature = 80.1;
                if (temperature > 80) {
                   System.out.println("Too Hot!");
                }
                System.out.println("yummy!"); 
                Flowchart_IfThen.png
                // if-then-else
                if (booleanTest) {
                   trueBlock;
                } else {
                   falseBlock;
                }
                // next statement
                
                
                
                
                
                 
                 
                 
                 
                int mark = 50;     // Assume that mark is [0, 100]
                if (mark >= 50) {  // [50, 100]
                   System.out.println("Congratulation!");
                   System.out.println("Keep it up!");
                } else {           // [0, 49]
                   System.out.println("Try Harder!");
                }
                System.out.println("Life goes on!");
                
                double temperature = 80.1;
                if (temperature > 80) {
                   System.out.println("Too Hot!");
                } else {
                   System.out.println("Too Cold!");
                }
                System.out.println("yummy!");
                Flowchart_IfElse.png
                Braces:Tuy nhiên, tôi khuyên bạn nên giữ dấu ngoặc nhọn để cải thiện khả năng đọc của chương trình, ngay cả khi chỉ có một câu lệnh trong khối.
                // if-then
                int absValue = -5;
                if (absValue < 0) absValue = -absValue;   // Only one statement in the block, can omit { }
                 
                int min = 0, value = -5;
                if (value < min) {     // More than one statements in the block, need { }
                   min = value;
                   System.out.println("Found new min");
                }
                 
                // if-then-else
                int mark = 50;
                if (mark >= 50) 
                   System.out.println("PASS");   // Only one statement in the block, can omit { }
                else {                           // More than one statements in the block, need { }
                   System.out.println("FAIL");
                   System.out.println("Try Harder!");
                }
                
                // Harder to read without the braces
                int number1 = 8, number2 = 9, absDiff;
                if (number1 > number2) absDiff = number1 - number2;
                else absDiff = number2 - number1;
                Java không cung cấp một cú pháp riêng cho lồng nhau-if (ví dụ: với các từ khóa như ifelseif), nhưng hỗ trợ lồng nhau-if với các câu lệnh if-if lồng nhau, được diễn giải như dưới đây. Lưu ý rằng bạn cần đặt một khoảng trống giữa else và ifViết elseif gây ra lỗi cú pháp.
                Nested-if
                SyntaxExampleFlowchart
                // nested-if
                if (booleanTest1) {
                   block1;
                } else if (booleanTest2) {
                   block2;
                } else if (booleanTest3) {
                   block3;
                } else if (booleanTest4) {
                   ......
                } else {
                   elseBlock;
                }
                // next statement
                
                
                
                
                
                    
                
                
                int mark = 62;  // Assume that mark is [0, 100]
                if (mark >= 80) {           // [80, 100]
                   System.out.println("A");
                } else if (mark >= 65) {    // [65, 79]
                   System.out.println("B");
                } else if (mark >= 50) {    // [50, 64]
                   System.out.println("C");
                } else {                    // [0, 49]
                   System.out.println("F");
                }
                System.out.println("Life goes on!");
                
                double temperature = 61;
                if (temperature > 80) {        // > 80
                   System.out.println("Too Hot!");
                } else if (temperature > 75) { // (75, 80]
                   System.out.println("Just right!");
                } else {                       // <= 75
                   System.out.println("Too Cold!");
                }
                System.out.println("yummy!");
                Flowchart_NestedIf.png
                Tuy nhiên bạn cũng nên dùng các cặp {} để cho cú pháp rõ ràng và mạch lạc. 
                if ( booleanTest1 ) {
                   block1;
                } else {   // This else-block contains a if-else statement
                   if ( booleanTest2 ) {
                      block2;
                   } else {  // This else-block also contains a if-else statement
                      if (booleanTest3) {
                         block3;
                      } else {  // This else-block also contains a if-else statement
                         if ( booleanTest4 ) {
                            ......
                         } else {
                            elseBlock;
                         }
                      }
                   }
                }
                // This alignment is hard to read!
                Flowchart_NestedIf_Interpretation
                Để dễ đọc, nên căn chỉnh câu lệnh if-if như được viết trong cú pháp / ví dụ.
                Lưu ý rằng các khối là độc quyền trong một câu lệnh if lồng nhau; chỉ một trong các khối sẽ được thực thi. Ngoài ra, có hai cách viết lồng nhau - ví dụ:

                // Assume that mark is [0, 100]
                if (mark >= 80) {           // [80, 100]
                   System.out.println("A");
                } else if (mark >= 65) {    // [65, 79]
                   System.out.println("B");
                } else if (mark >= 50) {    // [50, 64]
                   System.out.println("C");
                } else {                    // [0, 49]
                   System.out.println("F");
                }
                // OR
                if (mark < 50) {            // [0, 49]
                   System.out.println("F");
                } else if (mark < 65) {     // [50, 64]
                   System.out.println("C");
                } else if (mark < 80) {     // [65, 79]
                   System.out.println("B");
                } else {                    // [80, 100]
                   System.out.println("A");
                }
                Nested-if vs. Sequential-if
                Nghie cứu đoạn code sau:
                // Assume mark is between 0 and 100
                // This "sequential-if" works but NOT efficient!
                // Try mark = 81, which will run thru ALL the if's.
                int mark = 81;
                if (mark > 80) {  // [81, 100]
                   grade = 'A';
                }
                if (mark > 65 && mark <= 80) {  // [66, 80]
                   grade = 'B';
                }
                if (mark >= 50 && mark <= 65) { // [50, 65]
                   grade = 'C';
                }
                if (mark < 50) {  // [0, 49]
                   grade = 'F';
                }
                
                // This "nested-if" is BETTER
                // Try mark = 81, which only run thru only the first if.
                int mark = 81;
                if (mark > 80) {   // [81, 100]
                   grade = 'A';
                } else if (mark > 65 && mark <= 80) {  // [66, 80]
                   grade = 'B';
                } else if (mark >= 50 && mark <= 65) { // [50, 65]
                   grade = 'C';
                } else {
                   grade = 'F';    // [0, 49]
                }
                
                // This "nested-if" is the BEST with fewer tests
                int mark = 81;
                if (mark > 80) {         // [81, 100]
                   grade = 'A';
                } else if (mark > 65) {  // [66, 80]
                   grade = 'B';
                } else if (mark >= 50) { // [50, 65]
                   grade = 'C';
                } else {                 // [0, 49]
                   grade = 'F';
                }
                switch-case-default
                SyntaxExampleFlowchart
                // switch-case-default
                switch (selector) {
                   case value1:
                      block1; break;
                   case value2:
                      block2; break;
                   case value3:
                      block3; break;
                   ......
                   case valueN:
                      blockN; break;
                   default: // not the above
                      defaultBlock;
                }
                // next statement
                
                // Selector Types:
                // byte, short, int,
                // char, String
                
                
                
                
                
                
                
                
                 
                // Print number in word
                int number = 3;
                switch (number) {   // "int" selector
                   case 1:   // "int" value
                      System.out.println("ONE"); break;
                   case 2:
                      System.out.println("TWO"); break;
                   case 3:
                      System.out.println("THREE"); break;
                   default:
                      System.err.println("OTHER");
                }
                
                // Select arithmetic operation
                char operator = '*';
                int num1 = 5, num2 = 8, result;
                switch (operator) {   // "char" selector
                   case '+':   // "char" value
                      result = num1 + num2; break;
                   case '-': 
                      result = num1 - num2; break;
                   case '*': 
                      result = num1 * num2; break;
                   case '/': 
                      result = num1 / num2; break;
                   default:
                      System.out.println("Unknown operator);
                }
                Flowchart_SwitchCase.png
                switch-case-default" là một thay thế cho "lồng nhau if" cho các thử nghiệm giá trị cố định (nhưng không áp dụng cho các thử nghiệm phạm vi ). Bạn có thể sử dụng một intbyteshort, hoặc charbiến như trường hợp-selector , nhưng KHÔNG longfloatdoublevà booleanJDK 1.7 hỗ trợ Stringnhư bộ chọn trường hợp.
                Trong một switch-case tuyên bố, một break tuyên bố là cần thiết cho từng trường hợp. Nếu breakbị thiếu, thực thi sẽ chảy qua trường hợp sau, thường là một lỗi. Tuy nhiên, chúng ta có thể sử dụng thuộc tính này để xử lý bộ chọn nhiều giá trị. Ví dụ,
                // Converting Phone keypad letter to digit
                char inChar = 'x';
                switch (inChar) {
                   case 'a': case 'b': case 'c':   // 'a' and 'b' (without break) fall thru 'c'
                      System.out.print(2); break;
                   case 'd': case 'e': case 'f':
                      System.out.print(3); break;
                   case 'g': case 'h': case 'i':
                      System.out.print(4); break;
                   case 'j': case 'k': case 'l':
                      System.out.print(5); break;
                   ......
                   default:
                      System.out.println("Invalid Input");
                }
                Conditional Expression ( ... ? ... : ... )
                Một toán tử có điều kiện là một toán tử ternary (3 toán hạng), ở dạng Tùy thuộc vào , nó đánh giá và trả về giá trị của hoặc .booleanExpr ? trueExpr : falseExprbooleanExprtrueExprfalseExpr
                SyntaxExamples
                // Conditional Expression
                booleanExpr ? trueExpr : falseExpr
                  // An expression that returns
                  // the value of trueExpr
                  // or falseExpr
                
                
                
                
                
                
                
                
                
                
                
                
                
                 
                 
                int num1 = 9, num2 = 8, max;
                max = (num1 > num2) ? num1 : num2;  // RHS returns num1 or num2
                // same as
                if (num1 > num2) {
                   max = num1;
                } else {
                   max = num2;
                }
                
                int value = -9, absValue;
                absValue = (value > 0) ? value : -value;  // RHS returns value or -value
                // same as
                if (value > 0) absValue = value;
                else absValue = -value;
                
                int mark = 48;
                System.out.println((mark >= 50) ? "PASS" : "FAIL");  // Return "PASS" or "FAIL"
                // same as
                if (mark >= 50) System.out.println("PASS");
                else System.out.println("FAIL");
                
                5.3  Exercises on Getting Started and Conditional

                LINK

                5.4  Loop Flow Control

                Chúng ta có ba loại vòng lặp cơ bản:  forwhile-do, and do-while.
                SyntaxExampleFlowchart
                // while-do loop
                while (booleanTest) {
                   body;
                }
                // next statement
                 
                
                 
                
                
                
                
                
                
                
                
                
                 
                 
                 
                // Sum from 1 to upperbound
                int sum = 0, upperbound = 100;
                int number = 1;   // init
                while (number <= upperbound) {
                   // number = 1, 2, 3, ..., upperbound for each iteration
                   sum += number;
                   ++number;      // update
                }
                System.out.println("sum is: " + sum);
                
                // Factorial of n (=1*2*3*...*n)
                int n = 5;
                int factorial = 1;
                int number = 1;   // init
                while (number <= n) {
                   // num = 1, 2, 3, ..., n for each iteration
                   factorial *= number;
                   ++num;      // update
                }
                System.out.println("factorial is: " + factorial);
                Flowchart_While.png
                // do-while loop
                do {
                   body;
                }
                while (booleanTest);
                // next statement
                   // Need a semi-colon to
                   // terminate do-while statement
                
                
                
                
                
                
                
                
                
                 
                 
                 
                // Sum from 1 to upperbound
                int sum = 0, upperbound = 100;
                int number = 1;   // init
                do {
                   // number = 1, 2, 3, ..., upperbound for each iteration
                   sum += number;
                   ++number;      // update
                } while (number <= upperbound);
                System.out.println("sum is: " + sum);
                 
                // Factorial of n (=1*2*3*...*n)
                int n = 5;
                int factorial = 1;
                int number = 1;   // init
                do {
                   // num = 1, 2, 3, ..., n for each iteration
                   factorial *= number;
                   ++number;      // update
                } while (number <= n);
                System.out.println("factorial is: " + factorial);
                Flowchart_DoWhile.png
                // for-loop
                for (init; booleanTest; update) {
                   body;
                }
                // next statement
                 
                
                 
                
                
                
                
                
                 
                 
                 
                // Sum from 1 to upperbound
                int sum = 0, upperbound = 100;
                for (int number = 1; number <= upperbound; ++number) {
                   // num = 1, 2, 3, ..., upperbound for each iteration
                   sum += number;
                }
                System.out.println("sum is: " + sum);
                
                // Factorial of n (=1*2*3*...*n)
                int n = 5;
                int factorial = 1;
                for (int number = 1; number <= n; ++number) {
                   // number = 1, 2, 3, ..., n for each iteration
                   factorial *= number;
                }
                System.out.println("factorial is: " + factorial);
                Flowchart_For.png
                Sự khác biệt giữa while-do và do-while nằm trong thứ tự của cơ thể và thử nghiệm . Trong khi làm , kiểm tra được thực hiện đầu tiên. Cơ thể sẽ được thực hiện nếu thử nghiệm là đúng và quá trình lặp lại. Trong do-while , cơ thể được thực thi và sau đó được thực hiện. Hãy lưu ý rằng phần thân của do-while được thực thi ít nhất một lần (1+); nhưng phần thân của while-do có thể bằng 0 (0+). Tương tự, cơ thể của vòng lặp for có thể không thực thi (0+). test
                For-loop là một tốc ký cho while-do với ít dòng mã hơn. Đây là vòng lặp được sử dụng phổ biến nhất đặc biệt nếu số lần lặp lại được biết đến. Nhưng cú pháp của nó khó hiểu hơn. Hãy chắc chắn rằng bạn hiểu for-loop bằng cách đi qua biểu đồ và ví dụ.
                Chỉ số vòng / Biến số của Loop
                Một vòng lặp thường được điều khiển bởi một chỉ số hoặc biến đếm . Ví dụ,
                // Sum from 1 to upperbound using for-loop
                int sum = 0
                int upperbound = 100;
                for (int number = 1; number <= upperbound; ++number) {  // number = 1, 2, 3, ..., upperbound for each iteration
                   sum += num;
                }
                
                // Sum from 1 to upperbound using while-loop
                int sum = 0
                int upperbound = 100;
                int number = 1;
                while (number <= upperbound) {  // number = 1, 2, 3, ..., upperbound for each iteration
                   sum += number;
                   ++number;
                }
                Trong ví dụ trên, biến number đóng vai trò như các chỉ số biến, trong đó có trên các giá trị 123, ..., upperboundcho mỗi lần lặp của vòng lặp. Bạn cần tăng / giảm / sửa đổi biến chỉ số một cách rõ ràng (ví dụ: thông qua ++number). Mặt khác, vòng lặp trở thành một vòng lặp vô tận, vì thử nghiệm (number <= upperbound)sẽ trả về cùng một kết quả cho cùng một giá trị number.
                Quan sát rằng for-loop là một tốc ký của vòng lặp while. Cả vòng lặp for và vòng lặp while đều có cùng một tập hợp các câu lệnh, nhưng vòng lặp for sắp xếp lại các câu lệnh.
                Đối với for-loop, biến chỉ mục numberđược khai báo bên trong vòng lặp và do đó chỉ có sẵn bên trong vòng lặp. Bạn không thể truy cập vào biến sau vòng lặp, vì nó bị phá hủy sau vòng lặp. Mặt khác, đối với while-loop, biến chỉ số numbercó sẵn bên trong và bên ngoài vòng lặp.
                Đối với for-loop, bạn có thể chọn khai báo biến chỉ mục bên trong vòng lặp hoặc bên ngoài vòng lặp. Chúng tôi khuyên bạn nên khai báo nó bên trong vòng lặp, để giữ cho vòng đời của biến này đến nơi cần thiết và không còn nữa.
                [TODO] GIF hoạt hình ??
                Mã ví dụ: Tổng và trung bình của số nguyên đang chạy
                Chương trình sau đây tính tổng các số nguyên đang chạy từ một cấp dưới nhất định đến cấp trên. Cũng tính trung bình của họ.
                /**
                 * Sum the running integers from lowerbound to an upperbound.
                 * Also compute the average.
                 */
                public class SumAverageRunningNumbers {
                   public static void main(String[] args) {
                      // Declare variables
                      int sum = 0;       // store the accumulated sum
                      int lowerbound = 1;
                      int upperbound = 1000;
                      double average;
                
                      // Use a for-loop to accumulate the sum
                      for (int number = lowerbound; number <= upperbound; ++number) {
                         // number = lowerbound, lowerbound+1, lowerbound+2, ..., upperbound for each iteration
                         sum += number;
                      }
                      average = (double)sum / (upperbound - lowerbound + 1);   // need to cast int to double first
                      // Print results
                      System.out.println("The sum from " + lowerbound + " to " + upperbound + " is: " + sum);
                      //The sum from 1 to 1000 is: 500500
                      System.out.println("The average is: " + average);
                      //The average is: 500.5
                
                      // Sum only the ODD numbers
                      int count = 0;     // counts of odd numbers
                      sum = 0;           // reset sum for accumulation again
                      // Adjust the lowerbound to the next odd number if it is a even number
                      if (lowerbound % 2 == 0) {
                         lowerbound++;
                      }
                      // Use a for-loop to accumulate the sum with step size of 2
                      for (int number = lowerbound; number <= upperbound; number += 2) {
                         // number = lowerbound, lowerbound+2, lowerbound+4, ..., (<=)upperbound for each iteration
                         ++count;
                         sum += number;
                      }
                      average = (double)sum / count;
                      System.out.println("The sum of odd numbers is: " + sum);
                      //The sum of odd numbers is: 250000
                      System.out.println("The average of odd numbers is: " + average);
                      //The average of odd numbers is: 500.0
                   }
                }
                Sử dụng cờ boolean để điều khiển vòng lặp
                Bên cạnh việc sử dụng biến chỉ số để điều khiển vòng lặp, một cách phổ biến khác để điều khiển vòng lặp là thông qua booleancờ.
                Ví dụ: Dưới đây là một ví dụ về việc sử dụng while-do với booleancờ. Các booleancờ được khởi tạo để falseđảm bảo rằng các vòng lặp được nhập vào.
                // Game loop
                boolean gameOver = false;
                while (!gameOver) {
                   // play the game
                   ......
                   // Update the game state 
                   // Set gameOver to true if appropriate to exit the game loop
                   if ( ...... ) {
                      gameOver = true;    // exit the loop upon the next iteration test
                   }
                }
                Ví dụ: Giả sử rằng chương trình của bạn nhắc nhở người sử dụng cho một số từ 1để 10, và kiểm tra đầu vào hợp lệ. Vòng lặp do-while với booleancờ có thể phù hợp hơn vì nó nhắc nhập ít nhất một lần và lặp lại nhiều lần nếu đầu vào không hợp lệ.
                // Input with validity check
                boolean isValid = false;
                int number;
                do {
                  // prompt user to enter an int between 1 and 10
                  ......
                  // if the number entered is valid, set done to exit the loop
                  if (number >= 1 && number <= 10) {
                     isValid = true;    // exit the loop upon the next iteration test
                     // Do the operations
                     ......
                  } else {
                     // Print error message and repeat (isValid remains false)
                     ......
                  }
                } while (!isValid);     // Repeat for invalid input
                for-loop with Comma Separator
                You could place more than one statement in the init and update, separated with commas. For example,
                // for (init; test; update) { ...... }
                for (int row = 0, col = 0; row < SIZE; ++row, ++col) {
                   // Process diagonal elements (0,0), (1,1), (2,2),... 
                   ......
                }
                The test, however, must be a boolean expression that returns a boolean true or false.

                5.5  Terminating Program

                System.exit (int exitCode ) : Bạn có thể gọi phương thứcđể chấm dứt chương trình và trả lại điều khiển cho Java Runtime. Theo quy ước, mã trả về bằng 0 biểu thị chấm dứt bình thường; trong khi khác khôngcho thấy sự chấm dứt bất thường . Ví dụ,System.exit(int exitCode)exitCode
                if (errorCount > 10) {
                   System.out.println("too many errors");
                   System.exit(1);  // Terminate the program with abnormal exit code of 1
                }
                Câu lệnh return : Bạn cũng có thể sử dụng returncâu lệnh "" trong main()phương thức để chấm dứt main()điều khiển và trả lại điều khiển cho Java Runtime. Ví dụ,
                public static void main(String[] args) {
                   ...
                   if (errorCount > 10) {
                      System.out.println("too many errors");
                      return;  // Terminate and return control to Java Runtime from main()
                   }
                   ...
                }

                5.6  Exercises on Decision and Loop

                LINK

                6.  Input/Output

                6.1  Formatted Output via "printf()" (JDK 5)

                System.out.print()và println()không cung cấp định dạng đầu ra, chẳng hạn như kiểm soát số lượng khoảng trắng để in intvà số vị trí thập phân cho a double.
                Java SE 5 đã giới thiệu một phương pháp mới có tên gọi printf()cho định dạng đầu ra (mà được mô hình hóa sau khi C Ngôn ngữ của printf()). printf()có dạng sau:
                printf ( formattingString , arg1 , arg2 , arg3 , ...);
                Chuỗi định dạng chứa cả văn bản bình thường và cái gọi là Định dạng định dạng s. Các văn bản thông thường (bao gồm cả khoảng trắng) sẽ được in như hiện tại. Các chỉ định định dạng, ở dạng " ", sẽ được thay thế bằng các đối số theo sau , thường là theo cách một đối một và tuần tự. Một công cụ xác định định dạng bắt đầu bằng a và kết thúc bằng , ví dụ, cho số nguyên, cho số dấu phẩy động ( và ), cho và cho Một tùy chọn có thể được chèn vào giữa để chỉ định độ rộng trường. Tương tự, một tùy chọn có thể được sử dụng để kiểm soát căn chỉnh, phần đệm và các tùy chọn khác. Ví dụ như,%[flags][width]conversionCodeformattingString'%'conversionCode%d%ffloatdouble%cchar%sStringwidthflags
                • %d, %αd: số nguyên được in trong không gian α (α là tùy chọn), căn phải. Nếu bỏ qua α, số lượng khoảng trắng là độ dài của số nguyên.
                • %s, %αs: Chuỗi được in trong không gian α (α là tùy chọn), căn phải. Nếu bỏ qua α, số lượng khoảng trắng là độ dài của chuỗi (để vừa với chuỗi).
                • %f, %α.βf, %.βf: Số dấu phẩy động ( floatvà double) được in trong không gian α với digits chữ số thập phân (α và là tùy chọn). Nếu bỏ qua α, số lượng khoảng trắng là độ dài của số dấu phẩy động.
                • %n: một dòng mới dành riêng cho hệ thống (Windows sử dụng "\r\n", Unix và macOS "\n").
                  Examples:
                  ExampleOutput
                  // Without specifying field-width
                  System.out.printf("Hi,|%s|%d|%f|,@xyz%n", "Hello", 123, 45.6);
                  Hi,|Hello|123|45.600000|,@xyz
                   
                  // Specifying the field-width and decimal places for double
                  System.out.printf("Hi,|%6s|%6d|%6.2f|,@xyz%n", "Hello", 123, 45.6);
                  Hi,| Hello|   123| 45.60|,@xyz
                    
                  // Various way to format integers:
                  // flag '-' for left-align, '0' for padding with 0
                  System.out.printf("Hi,|%d|%5d|%-5d|%05d|,@xyz%n", 111, 222, 333, 444);
                  Hi,|111|  222|333  |00444|,@xyz
                  
                    
                  // Various way to format floating-point numbers:
                  // flag '-' for left-align
                  System.out.printf("Hi,|%f|%7.2f|%.2f|%-7.2f|,@xyz%n", 11.1, 22.2, 33.3, 44.4);
                  Hi,|11.100000|  22.20|33.30|44.40  |,@xyz
                  
                   
                  // To print a '%', use %% (as % has special meaning)
                  System.out.printf("The rate is: %.2f%%.%n", 1.2);
                  The rate is: 1.20%.
                   
                  Lưu ý rằng printf()không chuyển con trỏ đến dòng tiếp theo sau khi in. Bạn cần in rõ ràng một ký tự dòng mới (thông qua %n) ở cuối chuỗi định dạng để đưa con trỏ đến dòng tiếp theo, nếu muốn, như trong các ví dụ trên.
                  Có nhiều định dạng định dạng hơn trong Java. Tham khảo Tài liệu JDK để biết các mô tả chi tiết (@ https://docs.oracle.com/javase/10/docs/api/java/util/Formatter.html cho JDK 10).
                  (Cũng lưu ý rằng printf()hãy lấy một số lượng đối số (hoặc varargs ) khác nhau, đây là một tính năng mới được giới thiệu trong JDK 5 để hỗ trợ printf())

                  6.2  Input From Keyboard via "Scanner" (JDK 5)

                  Java, giống như tất cả các ngôn ngữ khác, hỗ trợ ba luồng đầu vào / đầu ra System.intiêu chuẩn (thiết bị đầu vào tiêu chuẩn), System.out(thiết bị đầu ra tiêu chuẩn) và System.err(thiết bị lỗi tiêu chuẩn). Cái System.inđược mặc định là bàn phím; trong khi System.outvà System.errđược mặc định cho bảng điều khiển hiển thị. Chúng có thể được chuyển hướng đến các thiết bị khác, ví dụ, việc chuyển hướng System.errđến tệp đĩa để lưu các thông báo lỗi này là khá phổ biến .
                  Bạn có thể đọc đầu vào từ bàn phím thông qua System.in(thiết bị đầu vào tiêu chuẩn).
                  JDK 5 đã giới thiệu một lớp mới được gọi Scannertrong gói java.utilđể đơn giản hóa đầu vào được định dạng (và một phương thức mới printf()cho đầu ra được định dạng được mô tả trước đó). Bạn có thể xây dựng một Scannerđể quét đầu vào từ System.in(bàn phím), và các phương pháp sử dụng như nextInt()nextDouble()next()để phân tích tiếp theo intdoublevà Stringtoken (giới hạn bởi không gian màu trắng của trống, tab và newline).
                  import java.util.Scanner;    // Needed to use the Scanner
                  /**
                   * Test input scanner
                   */
                  public class ScannerTest {
                     public static void main(String[] args) {
                        // Declare variables
                        int num1;
                        double num2;
                        String str;
                        // Construct a Scanner named "in" for scanning System.in (keyboard)
                        Scanner in = new Scanner(System.in);
                  
                        // Read inputs from keyboard 
                        System.out.print("Enter an integer: ");  // Show prompting message
                        num1 = in.nextInt();         // Use nextInt() to read an int
                        System.out.print("Enter a floating point: ");  // Show prompting message
                        num2 = in.nextDouble();      // Use nextDouble() to read a double
                        System.out.print("Enter a string: ");  // Show prompting message
                        str  = in.next();            // Use next() to read a String token, up to white space
                  
                        // Formatted output via printf()
                        System.out.printf("%s, Sum of %d & %.2f is %.2f%n", str, num1, num2, num1+num2);
                   
                        // close the input
                        in.close();
                     }
                  }
                  Bạn cũng có thể sử dụng phương pháp nextLine()để đọc trong toàn bộ dòng, bao gồm cả khoảng trắng, nhưng không bao gồm dòng mới kết thúc.
                  /**
                   * Test Scanner's nextLine()
                   */
                  import java.util.Scanner;    // Needed to use the Scanner
                  public class ScannerNextLineTest {
                     public static void main(String[] args) {
                        Scanner in = new Scanner(System.in);
                        System.out.print("Enter a string (with space): ");
                        // Use nextLine() to read entire line including white spaces, 
                        //   but excluding the terminating newline.
                        String str  = in.nextLine();        
                        System.out.printf("%s%n", str);
                        in.close();
                     }
                  }
                  Cố gắng không trộn nextLine()và nextInt()|nextDouble()|next()trong một chương trình (vì bạn có thể cần phải xóa dòng mới từ bộ đệm đầu vào).
                  Các Scannerhỗ trợ nhiều định dạng đầu vào khác. Kiểm tra trang tài liệu JDK, dưới mô-đun java.base⇒ gói java.utillớp ScannerPhương thức (@ https://docs.oracle.com/javase/10/docs/api/java/util/Scanner.html cho JDK 10).

                  6.3  Code Example: Prompt User for Two Integers and Print their Sum

                  Chương trình sau đây nhắc người dùng cho hai số nguyên và in tổng của chúng. Ví dụ như,
                  Enter first integer: 8
                  Enter second integer: 9
                  The sum is: 17
                  import java.util.Scanner;   // For keyboard input
                  /**
                   * 1. Prompt user for 2 integers
                   * 2. Read inputs as "int"
                   * 3. Compute their sum in "int"
                   * 4. Print the result
                   */
                  public class Add2Integer {  // Save as "Add2Integer.java"
                     public static void main (String[] args) {
                        // Declare variables
                        int number1, number2, sum;
                        Scanner in = new Scanner(System.in);  // Scan the keyboard for input
                  
                        // Put up prompting messages and read inputs as "int"
                        System.out.print("Enter first integer: ");  // No newline for prompting message
                        number1 = in.nextInt();                     // Read next input as "int"
                        System.out.print("Enter second integer: ");
                        number2 = in.nextInt();
                  
                        // Compute sum
                        sum = number1 + number2;
                  
                        // Display result
                        System.out.println("The sum is: " + sum);   // Print with newline
                  
                        // Close Scanner
                        in.close();
                     }
                  }

                  6.4  Code Example: Income Tax Calculator

                  Thuế suất thuế thu nhập lũy tiến được quy định như sau:
                  Taxable IncomeRate (%)
                  First $20,0000
                  Next $20,00010
                  Next $20,00020
                  The remaining30
                  Ví dụ, giả sử rằng thu nhập chịu thuế là $85000, thuế thu nhập phải nộp là $20000*0% + $20000*10% + $20000*20% + $25000*30%.
                  Viết một chương trình được gọi là IncomeTaxCalculatorđọc thu nhập chịu thuế (in int). Chương trình sẽ tính thuế thu nhập phải nộp (bằng double); và in kết quả làm tròn đến 2 chữ số thập phân.
                  Enter the taxable income: $41234
                  The income tax payable is: $2246.80
                  
                  Enter the taxable income: $67891
                  The income tax payable is: $8367.30
                  
                  Enter the taxable income: $85432
                  The income tax payable is: $13629.60
                  
                  Enter the taxable income: $12345
                  The income tax payable is: $0.00
                  import java.util.Scanner;   // For keyboard input
                  /**
                   * 1. Prompt user for the taxable income in integer.
                   * 2. Read input as "int".
                   * 3. Compute the tax payable using nested-if in "double".
                   * 4. Print the values rounded to 2 decimal places.
                   */
                  public class IncomeTaxCalculator {
                     public static void main(String[] args) {
                        // Declare constants first (variables may use these constants)
                        final double TAX_RATE_ABOVE_20K = 0.1;
                        final double TAX_RATE_ABOVE_40K = 0.2;
                        final double TAX_RATE_ABOVE_60K = 0.3;
                  
                        // Declare variables
                        int taxableIncome;
                        double taxPayable;
                        Scanner in = new Scanner(System.in);
                  
                        // Prompt and read inputs as "int"
                        System.out.print("Enter the taxable income: $");
                        taxableIncome = in.nextInt();
                  
                        // Compute tax payable in "double" using a nested-if to handle 4 cases
                        if (taxableIncome <= 20000) {         // [0, 20000]
                           taxPayable = 0;
                        } else if (taxableIncome <= 40000) {  // [20001, 40000]
                           taxPayable = (taxableIncome - 20000) * TAX_RATE_ABOVE_20K;
                        } else if (taxableIncome <= 60000) {  // [40001, 60000]
                           taxPayable = 20000 * TAX_RATE_ABOVE_20K
                                        + (taxableIncome - 40000) * TAX_RATE_ABOVE_40K;
                        } else {                              // >=60001
                           taxPayable = 20000 * TAX_RATE_ABOVE_20K
                                        + 20000 * TAX_RATE_ABOVE_40K
                                        + (taxableIncome - 60000) * TAX_RATE_ABOVE_60K;
                        }
                  
                        // Alternatively, you could use the following nested-if conditions
                        // but the above follows the table data
                        //if (taxableIncome > 60000) {          // [60001, ]
                        //   ......
                        //} else if (taxableIncome > 40000) {   // [40001, 60000]
                        //   ......
                        //} else if (taxableIncome > 20000) {   // [20001, 40000]
                        //   ......
                        //} else {                              // [0, 20000]
                        //   ......
                        //}
                  
                        // Print result rounded to 2 decimal places
                        System.out.printf("The income tax payable is: $%.2f%n", taxPayable);
                        in.close();  // Close Scanner
                     }
                  }

                  6.5  Code Example: Income Tax Calculator with Sentinel

                  Dựa trên ví dụ trước, viết chương trình được gọi IncomeTaxCalculatorSentinelsẽ lặp lại các phép tính cho đến khi người dùng nhập -1Ví dụ,
                  Enter the taxable income: $41000
                  The income tax payable is: $2200.00
                  Enter the taxable income: $62000
                  The income tax payable is: $6600.00
                  Enter the taxable income: $73123
                  The income tax payable is: $9936.90
                  Enter the taxable income: $84328
                  The income tax payable is: $13298.40
                  Enter the taxable income: $-1
                  bye!
                  Giá trị -1được gọi là giá trị sentinel . (Trong lập trình, giá trị sentinel , còn được gọi là giá trị cờ, giá trị chuyến đi, giá trị giả mạo, giá trị tín hiệu hoặc dữ liệu giả, là một giá trị đặc biệt sử dụng sự hiện diện của nó làm điều kiện chấm dứt.)
                  import java.util.Scanner;   // For keyboard input
                  /**
                   * 1. Prompt user for the taxable income in integer.
                   * 2. Read input as "int".
                   * 3. Compute the tax payable using nested-if in "double".
                   * 4. Print the values rounded to 2 decimal places.
                   * 5. Repeat until user enter -1.
                   */
                  public class IncomeTaxCalculatorSentinel {
                     public static void main(String[] args) {
                        // Declare constants first (variables may use these constants)
                        final double TAX_RATE_ABOVE_20K = 0.1;
                        final double TAX_RATE_ABOVE_40K = 0.2;
                        final double TAX_RATE_ABOVE_60K = 0.3;
                        final int SENTINEL = -1;    // Terminating value for input
                  
                        // Declare variables
                        int taxableIncome;
                        double taxPayable;
                        Scanner in = new Scanner(System.in);
                  
                        // Read the first input to "seed" the while loop
                        System.out.print("Enter the taxable income: $");
                        taxableIncome = in.nextInt();
                  
                        while (taxableIncome != SENTINEL) {
                           // Compute tax payable in "double" using a nested-if to handle 4 cases
                           if (taxableIncome > 60000) {
                              taxPayable = 20000 * TAX_RATE_ABOVE_20K
                                           + 20000 * TAX_RATE_ABOVE_40K
                                           + (taxableIncome - 60000) * TAX_RATE_ABOVE_60K;
                           } else if (taxableIncome > 40000) {
                              taxPayable = 20000 * TAX_RATE_ABOVE_20K
                                           + (taxableIncome - 40000) * TAX_RATE_ABOVE_40K;
                           } else if (taxableIncome > 20000) {
                              taxPayable = (taxableIncome - 20000) * TAX_RATE_ABOVE_20K;
                           } else {
                              taxPayable = 0;
                           }
                  
                           // Print result rounded to 2 decimal places
                           System.out.printf("The income tax payable is: $%.2f%n", taxPayable);
                  
                           // Read the next input
                           System.out.print("Enter the taxable income: $");
                           taxableIncome = in.nextInt();
                           // Repeat the loop body, only if the input is not the SENTINEL value.
                           // Take note that you need to repeat these two statements inside/outside the loop!
                        }
                        System.out.println("bye!");
                        in.close();  // Close Scanner
                     }
                  }
                  Ghi chú:
                  1. Mẫu  để xử lý đầu vào với giá trị sentinel (kết thúc) như sau
                  1. // Get first input to "seed" the while loop
                    input = ......;
                    while (input != SENTINEL) {
                        // Process input
                        ......
                        ......
                        // Get next input and repeat the loop
                        input = ......;    // Need to repeat these statements
                    }
                    ......

                  6.6  Code Example: Guess A Number

                  Đoán một số từ 0 đến 99.
                  import java.util.Scanner;
                  /**
                   * Guess a secret number between 0 and 99.
                   */
                  public class NumberGuess {
                     public static void main(String[] args) {
                        // Define variables
                        int secretNumber;     // Secret number to be guessed
                        int numberIn;         // The guessed number entered
                        int trialNumber = 0;  // Number of trials so far
                        boolean done = false; // boolean flag for loop control
                        Scanner in = new Scanner(System.in);
                     
                        // Set up the secret number: Math.random() generates a double in [0.0, 1.0)
                        secretNumber = (int)(Math.random()*100);
                  
                        // Use a while-loop to repeatedly guess the number until it is correct
                        while (!done) {
                           ++trialNumber;
                           System.out.print("Enter your guess (between 0 and 99): ");
                           numberIn = in.nextInt();
                           if (numberIn == secretNumber) {
                              System.out.println("Congratulation");
                              done = true;
                           } else if (numberIn < secretNumber) {
                              System.out.println("Try higher");
                           } else {
                              System.out.println("Try lower");
                           }
                        }
                        System.out.println("You got in " + trialNumber +" trials");
                        in.close();
                     }
                  }
                  Ghi chú:
                  1. Chương trình trên sử dụng booleancờ để điều khiển vòng lặp, theo mẫu mã sau :
                  1. boolean done = false;
                    
                    while (!done) {
                       if (......) {
                           done = true;   // exit the loop upon the next iteration
                           .....
                       }
                       ......   // done remains false. repeat loop
                    }

                  6.7  Exercises on Decision/Loop with Input

                  LINK

                  6.8  Input from Text File via "Scanner" (JDK 5)

                  Khác với chức năng quét System.in(bàn phím), bạn có thể kết nối của bạn Scannerđể quét bất kỳ nguồn đầu vào, chẳng hạn như một tập tin trên đĩa hoặc một ổ cắm mạng , và sử dụng cùng một tập hợp các phương pháp nextInt()nextDouble()next()nextLine()để phân tích tiếp theo intdoubleStringvà dòng. Ví dụ,
                  Scanner in = new Scanner(new File("in.txt"));  // Construct a Scanner to scan a text file
                  // Use the same set of methods to read from the file
                  int anInt = in.nextInt();         // next String
                  double aDouble = in.nextDouble(); // next double
                  String str = in.next();           // next int
                  String line = in.nextLine();      // entire line
                  Để mở một tệp qua , bạn cần xử lý cái gọi là , tức là tệp bạn đang cố mở không thể tìm thấy. Nếu không, bạn không thể biên dịch chương trình của bạn. Có hai cách để xử lý ngoại lệ này: ném hoặc thử bắt .new File(filename)FileNotFoundException
                  /**
                   * Input from File.
                   * Technique 1: Declare "throws FileNotFoundException" in the enclosing main() method
                   */
                  import java.util.Scanner;               // Needed for using Scanner
                  import java.io.File;                    // Needed for file operation
                  import java.io.FileNotFoundException;   // Needed for file operation
                  public class TextFileScannerWithThrows {
                     public static void main(String[] args)
                            throws FileNotFoundException {  // Declare "throws" here
                        int num1;
                        double num2;
                        String name;
                        Scanner in = new Scanner(new File("in.txt"));  // Scan input from text file
                        num1 = in.nextInt();      // Read int
                        num2 = in.nextDouble();   // Read double
                        name = in.next();         // Read String
                        System.out.printf("Hi %s, the sum of %d and %.2f is %.2f%n", name, num1, num2, num1+num2);
                        in.close();
                     }
                  }
                  Để chạy chương trình trên, hãy tạo một tệp văn bản in.txtcó tên là :
                  1234
                  55.66
                  Paul
                  /**
                   * Input from File.
                   * Technique 2: Use try-catch to handle exception
                   */
                  import java.util.Scanner;               // Needed for using Scanner
                  import java.io.File;                    // Needed for file operation
                  import java.io.FileNotFoundException;   // Needed for file operation
                  public class TextFileScannerWithCatch {
                     public static void main(String[] args) {
                        int num1;
                        double num2;
                        String name;
                        try {                                // try these statements
                           Scanner in = new Scanner(new File("in.txt"));
                           num1 = in.nextInt();      // Read int
                           num2 = in.nextDouble();   // Read double
                           name = in.next();         // Read String
                           System.out.printf("Hi %s, the sum of %d and %.2f is %.2f%n", name, num1, num2, num1+num2);
                           in.close();
                        } catch (FileNotFoundException ex) {  // catch and handle the exception here
                           ex.printStackTrace();              // print the stack trace
                        }
                     }
                  }

                  6.9  Formatted Output to Text File

                  Java SE 5.0 cũng giới thiệu cái gọi là Formatterđầu ra được định dạng (giống như Scannerđối với đầu vào được định dạng). Formattercó một phương thức gọi là format()Các format()phương pháp có cú pháp tương tự như printf(), ví dụ, nó có thể sử dụng định dạng specifiers để xác định định dạng của các đối số. Một lần nữa, bạn cần phải xử lý FileNotFoundException.
                  /**
                   * Output to File.
                   * Technique 1: Declare "throws FileNotFoundException" in the enclosing main() method
                   */
                  import java.io.File;
                  import java.util.Formatter;             // <== note
                  import java.io.FileNotFoundException;   // <== note
                  public class TextFileFormatterWithThrows {
                    public static void main(String[] args)
                        throws FileNotFoundException {   // <== note
                      // Construct a Formatter to write formatted output to a text file 
                      Formatter out = new Formatter(new File("out.txt"));
                      // Write to file with format() method (similar to printf())
                      int num1 = 1234;
                      double num2 = 55.66;
                      String name = "Paul";
                      out.format("Hi %s,%n", name);
                      out.format("The sum of %d and %.2f is %.2f%n", num1, num2, num1 + num2);
                      out.close();                 // Close the file
                      System.out.println("Done");  // Print to console
                    }
                  }
                  Chạy chương trình trên và kiểm tra kết quả đầu ra trong tệp văn bản " out.txt".
                  /**
                   * Output to File.
                   * Technique 2: Use try-catch to handle exception
                   */
                  import java.io.File;
                  import java.util.Formatter;           // <== note
                  import java.io.FileNotFoundException; // <== note
                  
                  public class TextFileFormatterWithCatch {
                     public static void main(String[] args) {
                        try {    // try the following statements
                           // Construct a Formatter to write formatted output to a text file
                           Formatter out = new Formatter(new File("out.txt"));
                           // Write to file with format() method (similar to printf())
                           int num1 = 1234;
                           double num2 = 55.66;
                           String name = "Pauline";
                           out.format("Hi %s,%n", name);
                           out.format("The sum of %d and %.2f is %.2f%n", num1, num2, num1 + num2);
                           out.close();                // Close the file
                           System.out.println("Done"); // Print to console
                        } catch (FileNotFoundException ex) {  // catch the exception here
                           ex.printStackTrace();       // Print the stack trace
                        }
                     }
                  }

                  6.10  Input via a Dialog Box

                  Input via JOptionPane
                  Bạn cũng có thể nhận đầu vào từ người dùng thông qua hộp thoại đồ họa, sử dụng JOptionPanelớp. Ví dụ, chương trình sau sẽ nhắc người dùng nhập bán kính hình tròn và tính diện tích.

                  1
                  2
                  3
                  4
                  5
                  6
                  7
                  8
                  9
                  10
                  11
                  12
                  13
                  14
                  15
                  /**
                   * Input via a Dialog box
                   */
                  import javax.swing.JOptionPane;   // Needed to use JOptionPane
                  public class JOptionPaneTest {
                     public static void main(String[] args) {
                        String radiusStr;
                        double radius, area;
                        // Read input String from dialog box
                        radiusStr = JOptionPane.showInputDialog("Enter the radius of the circle");
                        radius = Double.parseDouble(radiusStr);   // Convert String to double
                        area = radius*radius*Math.PI;
                        System.out.println("The area is " + area);
                     }
                  }
                  Phân tích chương trình:
                  • Trong Dòng 4, importcâu lệnh là cần thiết để sử dụng JOptionPane.
                  • Trong Dòng 10, chúng tôi sử dụng phương thức JOptionPane.showInputDialog(promptMessage)để nhắc người dùng về một đầu vào, trả về đầu vào là a String.
                  • Dòng 11 chuyển đổi đầu vào Stringthành a double, sử dụng phương thức Double.parseDouble().

                    6.11  java.io.Console (JDK 1.6)

                    Java SE 6 đã giới thiệu một java.io.Consolelớp mới để đơn giản hóa đầu vào / đầu ra dựa trên ký tự đến / từ bảng điều khiển hệ thống. NHƯNG, Consolelớp không chạy trong IDE (như Eclipse / NetBeans) !!!
                    Để sử dụng Consolelớp mới , trước tiên bạn sử dụng System.console()để truy xuất Consoleđối tượng tương ứng với bảng điều khiển hệ thống hiện tại.
                    Console con = System.console();
                    Sau đó, bạn có thể sử dụng các phương pháp như readLine()để đọc một dòng. Bạn có thể tùy chọn bao gồm một thông điệp nhắc nhở với định dạng specifiers (ví dụ %d%s) trong thông điệp nhắc.
                    String inLine = con.readLine();
                    String msg = con.readLine("Enter your message: ");        // readLine() with prompting message
                    String msg = con.readLine("%s, enter message: ", name);   // Prompting message with format specifier
                    Bạn có thể sử dụng con.printf()cho đầu ra được định dạng với các chỉ định định dạng như %d%sBạn cũng có thể kết nối Consoleđến một Scannercho định dạng đầu vào, ví dụ, phân tích nguyên thủy như intdoubleví dụ,
                    Scanner in = new Scanner(con.reader());  // Use Scanner to scan the Console
                    // Use the Scanner's methods such as nextInt(), nextDouble() to parse primitives 
                    int anInt = in.nextInt();
                    double aDouble = in.nextDouble();
                    String str = in.next();
                    String line = in.nextLine();
                    Thí dụ:
                    /*
                     * Testing java.io.Console class
                     */
                    import java.io.Console;
                    import java.util.Scanner;
                    public class ConsoleTest {
                       public static void main(String[] args) {
                          Console con = System.console();   // Retrieve the Console object
                          // Console class does not work in Eclipse/NetBeans
                          if (con == null) {
                              System.err.println("Console Object is not available.");
                              System.exit(1);
                          }
                       
                          // Read a line with a prompting message
                          String name = con.readLine("Enter your Name: ");
                          con.printf("Hello %s%n", name);
                          // Use the console with Scanner for parsing primitives
                          Scanner in = new Scanner(con.reader());
                          con.printf("Enter an integer: ");
                          int anInt = in.nextInt();
                          con.printf("The integer entered is %d%n", anInt);
                          con.printf("Enter a floating point number: ");
                          double aDouble = in.nextDouble();
                          con.printf("The floating point number entered is %f%n", aDouble);
                          in.close();
                       }
                    }
                    Các Consolelớp học cũng cung cấp một bình an toàn cho nhập mật khẩu thông qua phương pháp readPassword()Phương pháp này vô hiệu hóa tiếng vang đầu vào và giữ mật khẩu char[]thay vì a StringViệc char[]chứa mật khẩu có thể và nên được ghi đè, xóa nó khỏi bộ nhớ ngay khi không còn cần thiết. (Hãy nhớ lại rằng Stringchúng là bất biến và không thể ghi đè. Khi cần lâu hơn, chúng sẽ được thu gom rác tại một trường hợp không xác định.)
                    import java.io.Console;
                    import java.util.Arrays;
                    /**
                     * Inputting password via Console
                     */
                    public class ConsolePasswordTest {
                       static String login;
                       static char[] password;
                       
                       public static void main(String[] args) {
                          Console con = System.console();
                          if (con == null) {
                             System.err.println("Console Object is not available.");
                             System.exit(1);
                          }
                       
                          login = con.readLine("Enter your login Name: ");
                          password = con.readPassword("Enter your password: ");
                          if (checkPassword(login, password)) {
                             Arrays.fill(password, ' ');  // Remove password from memory
                             // Continue ...
                       
                          }
                       }
                       
                       static boolean checkPassword(String login, char[] password) {
                           return true;
                       }
                    }

                    7.  Writing Correct and Good Programs

                    Điều quan trọng là viết các chương trình tạo ra kết quả chính xác. Nó cũng quan trọng để viết các chương trình mà những người khác (và chính bạn ba ngày sau đó) có thể hiểu, để các chương trình có thể được duy trì. Tôi gọi những chương trình này là những chương trình tốt - một chương trình tốt không chỉ là một chương trình chính xác.
                    Dưới đây là những gợi ý:
                    • Thực hiện theo quy ước được thiết lập để mọi người có cùng cơ sở hiểu biết. Để lập trình bằng Java, bạn PHẢI đọc " Quy ước mã cho ngôn ngữ lập trình Java ".
                    • Định dạng và bố cục của mã nguồn với các vết lõm, khoảng trắng và đường trắng thích hợp. Sử dụng 3 hoặc 4 khoảng trắng để thụt lề và các dòng trống để tách các phần mã.
                    • Chọn tên tốt mà là tự mô tả và có ý nghĩa, ví dụ như, rowcolsizexMaxnumStudentsKhông sử dụng tên vô nghĩa, chẳng hạn như abcdTránh các tên bảng chữ cái đơn (dễ gõ hơn nhưng thường vô nghĩa), ngoại trừ các tên phổ biến như x yzcho tọa độ và icho chỉ mục.
                    • Cung cấp ý kiến ​​để giải thích các khái niệm quan trọng cũng như nổi bật. Nhận xét mã của bạn một cách tự do.
                    • Viết tài liệu chương trình của bạn trong khi viết chương trình của bạn.
                    • Tránh không có cấu trúc cấu trúc, chẳng hạn như breakvà continue, đó là khó có thể làm theo.
                    • Sử dụng phông chữ "không gian đơn" (như Consolas, Courier New, Courier) để viết / hiển thị chương trình của bạn.
                    Người ta ước tính rằng trong suốt vòng đời của một chương trình, 20 phần trăm nỗ lực sẽ đi vào việc tạo và kiểm tra mã ban đầu, và 80 phần trăm nỗ lực sẽ được đưa vào bảo trì và nâng cao tiếp theo. Viết các chương trình tốt theo các quy ước tiêu chuẩn là rất quan trọng trong việc duy trì và nâng cao tiếp theo !


                    7.1  Programming Errors: Compilation, Runtime and Logical Errors

                    Nhìn chung có ba loại lỗi lập trình:
                    1. Lỗi biên dịch (hoặc Lỗi cú pháp ): Chương trình không thể biên dịch. Điều này có thể được khắc phục dễ dàng bằng cách kiểm tra các thông báo lỗi biên dịch. Ví dụ như
                    1. // System instead of Sys
                      Sys.out.print("Hello");
                      error: package Sys does not exist
                      Sys.out.print("Hello");
                         ^
                         
                      // Missing semi-colon
                      System.out.print("Hello")
                      error: ';' expected
                      System.out.print("Hello")
                                               ^
                    2. Lỗi runtime : Chương trình có thể biên dịch, nhưng không chạy thành công. Điều này cũng có thể được khắc phục dễ dàng, bằng cách kiểm tra các thông báo lỗi thời gian chạy. Ví dụ như
                      // Divide by 0 Runtime error
                      int count = 0, sum = 100, average;
                      average = sum / count;
                      Exception in thread "main" java.lang.ArithmeticException: / by zero
                      
                      // Wrong conversion code, %d for integer
                      System.out.printf("The sum is: %d%n", 1.23);
                      Exception in thread "main" java.util.IllegalFormatConversionException: d != java.lang.Double
                    3. Lỗi logic : Chương trình có thể biên dịch và chạy, nhưng tạo ra kết quả không chính xác (luôn luôn hoặc đôi khi). Đây là lỗi khó khắc phục nhất vì không có thông báo lỗi - bạn phải dựa vào việc kiểm tra đầu ra. Thật dễ dàng để phát hiện nếu chương trình luôn tạo ra đầu ra sai. Rất khó để sửa nếu chương trình tạo ra kết quả chính xác hầu hết các lần, nhưng đôi khi kết quả không chính xác. Ví dụ,
                      // Can compile and run, but give wrong result – sometimes!
                      if (mark > 50) {
                         System.out.println("PASS");
                      } else {
                         System.out.println("FAIL");
                      }
                      Loại lỗi này là rất nghiêm trọng nếu nó không bị bắt trước khi sản xuất. Viết chương trình tốt giúp giảm thiểu và phát hiện các lỗi này. Một chiến lược thử nghiệm tốt là cần thiết để xác định tính đúng đắn của chương trình. Kiểm thử phần mềm là một chủ đề nâng cao nằm ngoài phạm vi hiện tại của chúng tôi.

                    7.2  Cách Gỡ Lỗi Hiệu Quả

                    Dưới đây là các kỹ thuật sửa lỗi phổ biến:
                    1. Nhìn chằm chằm vào màn hình! Thật không may, không có gì sẽ bật lên ngay cả khi bạn nhìn chằm chằm đến mức như thôi miên cái màn hình =)) sẽ không có ông bụt nào hiện lên đâu :P. Tuy nhiên khi nhìn thì bạn hãy đọc nó, đọc lỗi là việc đầu tiên bạn cần làm. Khi có lỗi, thì thay vì chạy ngay đi tìm cách sửa lại code, thì hãy dừng lại và đọc lỗi :) 
                    2. Nghiên cứu các thông báo lỗi! Hãy đọc kỹ thông báo lỗi, vì trong thông báo đó thường chỉ ra loại lỗi bạn đang gặp phải, và lỗi sinh ra ở dòng bao nhiêu. Vậy trước khi gỡ được lỗi, chúng ta cần hiểu lỗi đã ;) đúng không nào?  Vậy nhé, thay vì nhìn chằm chằm vào màn hình, hãy cố gắng đọc và hiểu lỗi đó. 
                    3. Chèn printf tại các vị trí thích hợp để hiển thị kết quả trung gian. Đây là cách làm đơn giản, thô sơ nhưng khá hiệu quả với người mới bắt đầu. Chèn lệnh printf để in ra giá trị của biến, hoặc đơn giản để hiển thị thông báo là chương trình đã chạy tới đoạn này. Lần theo các lệnh printf (các thông báo), bạn sẽ hiểu code mình bắt đầu bị sai từ đoạn nào. Từ đó, bạn sẽ phán đoán tốt hơn vị trí chính xác gây ra lỗi. Hiểu được lỗi, tìm được vị trí gây ra lỗi ... Việc còn lại là sửa thôi ;) 
                    4. Sử dụng một trình gỡ lỗi (debug)Đây là phương tiện hiệu quả nhất. Theo dõi thực hiện chương trình từng bước và xem giá trị của các biến và đầu ra. Để debug file hiệu quả thì các bạn có các việc sau cần làm:
                      1. Đặt break point vào các dòng code mà bạn nghi rằng nó gây ra lỗi. 
                      2. Hãy chạy file của bạn với chế độ Run with Debug. 
                      3. Sau đi dùng các phím chức năng phù hợp để Step Over, Step Into, Focus Step Into , Variables 
                      4. Với việc dùng các công cụ này, bạn sẽ thấy được tiến trình code chạy qua từng dòng đặt break point, tại mỗi break point bạn có thể xem chi tiết giá trị các biến, từ đó bạn sẽ có cách fix bug phù hợp. 
                      5. Với mỗi IDE đều có trình Debug đi kèm, vậy bạn có thể tìm kiếm để học nhanh cách Debug của IDE bạn đang dùng. Bạn có thể lướt qua tutorial này, nếu bạn đang dùng IDEA là IntelliJ  Tutorial: Debug your first Java application ;) 
                    5. Ngoài ra, bạn có thể sử dụng Các công cụ nâng cao như profiler (việc này là cần thiết để kiểm tra rò rỉ bộ nhớ và sử dụng phương thức).
                    6. Thực hiện kiểm tra chương trình để xóa sạch các lỗi logic. "Viết tetrước, trước khi viết chương trình".

                      7.3  Exercises on Decision/Loop with Input

                      LINK

                      7.4  Testing Your Program for Correctness

                      Làm thế nào để đảm bảo rằng chương trình của bạn luôn tạo ra kết quả chính xác, 100% số lần? Không thể thử tất cả các kết quả có thể xảy ra, ngay cả đối với một chương trình đơn giản để thêm hai số nguyên (vì có quá nhiều kết hợp của hai số nguyên). Kiểm thử chương trình thường liên quan đến một tập hợp các trường hợp kiểm thử đại diện, được thiết kế để bắt tất cả các lớp lỗi. Kiểm tra chương trình nằm ngoài phạm vi của bài viết này.

                      8.  More on Loops - Nested-Loops, break & continue

                      8.1  Nested Loops

                      Các vòng lặp lồng nhau là cần thiết để xử lý dữ liệu 2 chiều (hoặc N chiều), chẳng hạn như in các mẫu 2D. Một vòng lặp lồng nhau có dạng sau:
                      for (...; ...; ...) {     // outer loop
                         // Before running the inner loop
                         ......
                         for (...; ...; ...) {  // inner loop
                            ......
                         }
                         // After running the inner loop
                         ......
                      } 
                      Flowchart_NestedForLoop.png

                      8.2  Code Examples: Print Square Pattern

                      Chương trình sau đây nhắc người dùng về kích thước của mẫu và in một mẫu hình vuông bằng cách sử dụng các vòng lặp lồng nhau. Ví dụ,
                      Enter the size: 5
                      * * * * *
                      * * * * *
                      * * * * *
                      * * * * *
                      * * * * *
                      1
                      2
                      3
                      4
                      5
                      6
                      7
                      8
                      9
                      10
                      11
                      12
                      13
                      14
                      15
                      16
                      17
                      18
                      19
                      20
                      21
                      22
                      23
                      24
                      25
                      26
                      27
                      import java.util.Scanner;
                      /**
                       * Prompt user for the size; and print Square pattern
                       */
                      public class PrintSquarePattern {
                         public static void main (String[] args) {
                            // Declare variables
                            int size;    // size of the pattern to be input
                            Scanner in = new Scanner(System.in);
                      
                            // Prompt user for the size and read input as "int"
                            System.out.print("Enter the size: ");
                            size = in.nextInt();
                      
                            // Use nested-loop to print a 2D pattern
                            // Outer loop to print ALL the rows
                            for (int row = 1; row <= size; row++) {
                               // Inner loop to print ALL the columns of EACH row
                               for (int col = 1; col <= size; col++) {
                                  System.out.print("* ");
                               }
                               // Print a newline after all the columns
                               System.out.println();
                            }
                            in.close();
                         }
                      }
                      Chương trình này chứa hai vòng lặp for lồng nhau . Vòng lặp bên trong được sử dụng để in một hàng " ", tiếp theo là in một dòng mới. Vòng lặp bên ngoài lặp lại vòng lặp bên trong để in tất cả các hàng.
                      Mẫu mã: In các mẫu 2D
                      Mẫu  để in các mẫu 2D như sau. Tôi khuyên bạn nên sử dụng rowvà colnhư các biến vòng lặp tự giải thích, thay vì ivà jxvà y.
                      for (int row = 1; row <= size; row++) {   // outer loop for rows
                         ......  // before each row
                         for (int col = 1; col <= size; col++) {   // inner loop for columns
                            if (......) {
                               System.out.print(......);    // without newline
                            } else {
                               System.out.print(......);
                            }
                         }
                         ......  // after each row
                         System.out.println();  // Print a newline after all the columns
                      }

                      8.3  Code Examples: Print Checker Board Pattern

                      Giả sử bạn muốn in mẫu này thay thế (trong chương trình được gọi PrintCheckerPattern):
                      Enter the size: 6
                      * * * * * *
                       * * * * * *
                      * * * * * *
                       * * * * * *
                      * * * * * *
                       * * * * * *
                      Bạn cần in một không gian bổ sung cho các hàng số chẵn. Bạn có thể làm như vậy bằng cách thêm câu lệnh sau vào vòng lặp bên trong.
                      if ((row % 2) == 0) {   // print a leading space for even-numbered rows
                         System.out.print(" ");
                      }

                      8.4  Code Example: Print Multiplication Table

                      Chương trình sau sẽ nhắc người dùng về kích thước và in bảng nhân như sau:
                      Enter the size: 10
                       * |   1   2   3   4   5   6   7   8   9  10
                      --------------------------------------------
                       1 |   1   2   3   4   5   6   7   8   9  10
                       2 |   2   4   6   8  10  12  14  16  18  20
                       3 |   3   6   9  12  15  18  21  24  27  30
                       4 |   4   8  12  16  20  24  28  32  36  40
                       5 |   5  10  15  20  25  30  35  40  45  50
                       6 |   6  12  18  24  30  36  42  48  54  60
                       7 |   7  14  21  28  35  42  49  56  63  70
                       8 |   8  16  24  32  40  48  56  64  72  80
                       9 |   9  18  27  36  45  54  63  72  81  90
                      10 |  10  20  30  40  50  60  70  80  90 100
                      import java.util.Scanner;
                      /**
                       * Prompt user for the size and print the multiplication table.
                       */
                      public class PrintTimeTable {
                         public static void main(String[] args) {
                            // Declare variables
                            int size;   // size of table to be input
                            Scanner in = new Scanner(System.in);
                      
                            // Prompt for size and read input as "int"
                            System.out.print("Enter the size: ");
                            size = in.nextInt();
                      
                            // Print header row
                            System.out.print(" * |");
                            for (int col = 1; col <= size; ++col) {
                               System.out.printf("%4d", col);
                            }
                            System.out.println();  // End row with newline
                            // Print separator row
                            System.out.print("----");
                            for (int col = 1; col <= size; ++col) {
                               System.out.printf("%4s", "----");
                            }
                            System.out.println();  // End row with newline
                      
                            // Print body using nested-loops
                            for (int row = 1; row <= size; ++row) {  // outer loop
                               System.out.printf("%2d |", row);      // print row header first
                               for (int col = 1; col <= size; ++col) {  // inner loop
                                  System.out.printf("%4d", row*col);
                               }
                               System.out.println();  // print newline after all columns
                            }
                         }
                      }

                      8.5  Exercises on Nested Loops with Input

                      LINK

                      8.6  break and continue - Interrupting Loop Flow

                      Các break vi phạm tuyên bố ra và lối thoát hiểm hiện tại (trong cùng) vòng lặp.
                      Câu continue lệnh hủy bỏ lần lặp hiện tại và tiếp tục đến lần lặp tiếp theo của vòng lặp hiện tại (trong cùng).
                      break và continue là những cấu trúc nghèo nàn vì chúng khó đọc và khó theo dõi. Chỉ sử dụng chúng nếu thực sự cần thiết.
                      Endless loop
                      Vòng lặp vô tận
                      for ( ; ; ) { body }được biết đến như là một vòng lặp for trống , với câu lệnh trống để khởi tạo, kiểm tra và xử lý hậu kỳ. Phần thân của vòng lặp for trống sẽ thực thi liên tục (vòng lặp vô hạn). Bạn cần sử dụng một breakcâu lệnh để thoát ra khỏi vòng lặp.
                      Tương tự, và là những vòng lặp vô tận.while (true) { body }do { body } while (true)
                      for (;;) {
                         ......    // Need break inside the loop body
                      }
                      
                      while (true) {
                         ......   // Need break inside the loop body
                      }
                      
                      do {
                         ......   // Need break inside the loop body
                      } while (true);
                      Vòng lặp vô tận thường là một sai lầm đặc biệt đối với các lập trình viên mới. Bạn cần thoát ra khỏi vòng lặp thông qua một breakcâu lệnh bên trong thân vòng lặp ..
                      Ví dụ ( ngắt ): Chương trình sau liệt kê các số không nguyên tố giữa 2 và một số trên.
                      /**
                       * List all non-prime numbers between 2 and an upperbound
                       */
                      public class NonPrimeList {
                         public static void main(String[] args) {
                            int upperbound = 100;
                            for (int number = 2; number <= upperbound; ++number) {
                               // Not a prime, if there is a factor between 2 and sqrt(number)
                               int maxFactor = (int)Math.sqrt(number);
                               for (int factor = 2; factor <= maxFactor; ++factor) {
                                  if (number % factor == 0) {   // Factor?
                                     System.out.println(number + " is NOT a prime");
                                     break;   // A factor found, no need to search for more factors
                                  }
                               }
                            }
                         }
                      }
                      Thay vào đó, hãy viết lại chương trình trên để liệt kê tất cả các số nguyên tố. Một booleancờ được gọi isPrimeđược sử dụng để chỉ ra liệu dòng điện numbercó phải là số nguyên tố hay không. Sau đó nó được sử dụng để kiểm soát việc in ấn.
                      /**
                       * List all prime numbers between 2 and an upperbound
                       */
                      public class PrimeListWithBreak {
                         public static void main(String[] args) {
                            int upperbound = 100;
                            for (int number = 2; number <= upperbound; ++number) {
                               // Not a prime, if there is a factor between 2 and sqrt(number)
                               int maxFactor = (int)Math.sqrt(number);
                               boolean isPrime = true;  // boolean flag to indicate whether number is a prime
                               for (int factor = 2; factor <= maxFactor; ++factor) {
                                  if (number % factor == 0) {   // Factor?
                                     isPrime = false;   // number is not a prime
                                     break;   // A factor found, no need to search for more factors
                                  }
                               }
                               if (isPrime) System.out.println(number + " is a prime");
                            }
                         }
                      }
                      Hãy viết lại chương trình trên mà không sử dụng breakcâu lệnh. Một whilevòng lặp được sử dụng (được điều khiển bởi booleancờ) thay vì forvòng lặp với break.
                      /**
                       * List all prime numbers between 2 and an upperbound
                       */
                      public class PrimeList {
                         public static void main(String[] args) {
                            int upperbound = 100;
                            for (int number = 2; number <= upperbound; ++number) {
                               // Not prime, if there is a factor between 2 and sqrt of number
                               int maxFactor = (int)Math.sqrt(number);
                               boolean isPrime = true;
                               int factor = 2;
                               while (isPrime && factor <= maxFactor) {
                                  if (number % factor == 0) {   // Factor of number?
                                      isPrime = false;
                                  }
                                  ++factor;
                               }
                               if (isPrime) System.out.println(number + " is a prime");
                            }
                         }
                      }
                      Example (continue):
                      // Sum 1 to upperbound, exclude 11, 22, 33,...
                      int upperbound = 100;
                      int sum = 0;
                      for (int number = 1; number <= upperbound; ++number) {
                         if (number % 11 == 0) continue;  // Skip the rest of the loop body, continue to the next iteration
                         sum += number;
                      }
                      
                      // It is better to re-write the loop as:
                      for (int number = 1; number <= upperbound; ++number) {
                         if (number % 11 != 0) sum += number;
                      }
                      Example (break and continue): Study the following program.
                      /**
                       * A mystery series created using break and continue
                       */
                      public class MysterySeries {
                         public static void main(String[] args) {
                            int number = 1;
                            while(true) {
                               ++number;
                               if ((number % 3) == 0) continue;
                               if (number == 133) break;
                               if ((number % 2) == 0) {
                                  number += 3;
                               } else {
                                  number -= 3;
                               }
                               System.out.print(number + " ");
                            }
                         }
                      }
                      // Can you figure out the output?
                      // break and continue are hard to read, use it with great care!
                      Labeled break
                      Trong một vòng lặp lồng nhau, breakcâu lệnh phá vỡ vòng lặp trong cùng và tiếp tục vào vòng lặp bên ngoài. Đôi khi, cần phải phá vỡ tất cả các vòng lặp (hoặc nhiều vòng lặp). Điều này là vụng về để đạt được với booleancờ, nhưng có thể được thực hiện dễ dàng thông qua cái gọi là nhãn