Bài đăng nổi bật


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. Việc nghiên cứu các library (thư viện có sẵn) có thể khó khăn vì nó thực sự rất lớn, nhưng việc chúng ta làm quen và tìm hiểu nó là điều cần thiết để phát triển các ứng dụng. 
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 :)  

9.  String và char operations

9.1  char Arithmetic Operations

Nhớ lại rằng bạn đã từng biết tới bảng mã ASCII khi học C. Java cũng tương tự: 
  • Trong Java, mỗi cái charđược biểu thị bằng số Unicode 16 bit. Ví dụ, char '0'được biểu thị bằng mã số 48( 30H), char '1'bởi 49( 31H), char 'A'bởi 65( 41H). char 'a'bởi 97( 61H). Hãy lưu ý rằng char '0'KHÔNG int 0, char '1'KHÔNG int 1.
  • chars có thể tham gia vào các hoạt động số học. A charđược coi là cơ sở của nó int(trong phạm vi [0, 65535]) trong các phép toán số học. Nói cách khác, charvà intcó thể thay thế cho nhau. char '0' ⇔ int 48, char '1' ⇔ int 49, char 'A' ⇔ int 65,char 'a' ⇔ int 97 . Ví dụ như,
  • char c1 = '0';     // Code number 48
char c2 = 'A';     // Code number 65
char c3;

// char <-> int (interchangeable)
System.out.println((int)c1);   // Print int 48
System.out.println((int)c2);   // Print int 65
c3 = 97;                       // Code number for 'a'
System.out.println(c3);        // Print char 'a'
System.out.println((char)97);  // Print char 'a'
  • Trong các phép toán số học, char(và byte, và short) trước tiên được chuyển đổi thành int. Trong Java, phép tính số học chỉ được thực hiện tại int, long, float, hoặc double; KHÔNG trong byte, shortvà char.
  • Do đó, char ⊕ char ⇒ int ⊕ int ⇒ intnơi ⊕biểu thị một hoạt động số học nhị phân (ví dụ như +, -, *, /và %). Bạn có thể cần phải đưa kết quả rõ ràng inttrở lạichar . Ví dụ như,
  • char c1 = '0';     // Code number 48
char c2 = 'A';     // Code number 65
char c3;

// char + char -> int + int -> int
//c3 = c1 + c2;           // error: RHS evaluated to "int", cannot assign to LHS of "char"
c3 = (char)(c1 + c2);     // Need explicit type casting, return char 'q' (code number 113)
System.out.println(c3);       // Print 'q', as c3 is a char
System.out.println(c1 + c2);  // Print int 113
System.out.println((char)(c1 + c2));  // Print char 'q'
  • Tương tự , char ⊕ int ⇒ int ⊕ int ⇒ int. Bạn có thể cần phải rõ ràng bỏ kết quả inttrở lại char. Ví dụ như
    char c1 = '0';     // Code number 48
char c2 = 'A';     // Code number 65
char c3;

// char + int -> int + int -> int
//c3 = c1 + 5;            // error: RHS evaluated to "int", cannot assign to LHS of "char"
c3 = (char)(c1 + 5);      // Need explicit type casting, return char '5' (code number 53)
System.out.println(c3);      // Print '5', as c3 is a char
System.out.println(c1 + 5);  // Print int 53

// Print the code number for 'a' to 'z'
for (int codeNum = 'a'; codeNum <= 'z'; ++codeNum) {
   System.out.println((char)codeNum + ": " + codeNum);
}
  • Tuy nhiên, đối với các toán tử kết hợp (ví dụ như +=, -=, *=, /=, %=), việc đánh giá được thực hiện theo int , nhưng kết quả được đúc trở lại LHS tự động. Ví dụ như,
    char c4 = '0';           // Code number 48
c4 += 5;                 // Automatically cast back to char '5'
System.out.println(c4);  // Print char '5'
  • Đối với tăng ( ++) và giảm ( --) của char(và byte, và short), không có khuyến mãi nào int. Ví dụ như,
    // Print char '0' to '9' via increment
for (char c = '0'; c <= '9'; ++c) {   // ++c remains as "char"
   System.out.println(c);
}

9.2  Converting char to int

Bạn có thể chuyển đổi char '0'để '9'để int 0đến 9bằng cách trừ charvới các cơ sở '0', ví dụ '8' - '0' ⇒ 8.
Đó là, giả sử clà một chargiữa '0'và '9', (c - '0')là tương ứng int 0với 9.
Chương trình sau minh họa cách chuyển đổi một ký tự thập lục phân ( 0-9, A-Fhoặc a-f) thành số thập phân tương đương ( 0-15), bằng cách trừ đi cơ sở thích hợp char.
// Converting a hex char (0-9|A-F|a-f) to its equivalent decimal (0-15)
char hexChar = 'a';
int dec;

if (hexChar >= '0' && hexChar <= '9') {
   dec = hexChar - '0';        // int 0-9
} else if (hexChar >= 'A' && hexChar <= 'F') {
   dec = hexChar - 'A' + 10;   // int 10-15
} else if (hexChar >= 'a' && hexChar <= 'f') {
   dec = hexChar - 'a' + 10;   // int 10-15
} else {
   dec = -1;   // to overcome variable have not been initialized error
   System.out.println("Invalid hex char");
}
System.out.println(hexChar + ": " + dec);

9.3  String Operations

Nhất thường được sử dụng Stringphương pháp này như sau, giả sử rằng str, str1, str2là Stringcác biến:
  • str.length(): trả về độ dài của str.
  • str.charAt(int index): trả lại chartại indexvị trí của str. Hãy lưu ý rằng indexbắt đầu tại 0, và lên đến str.length()-1.
  • str1.equals(str2): để so sánh nội dung của str1và str2. Lưu ý rằng bạn không thể sử dụng "str1 == str2"để so sánh hai Strings. Điều này là do " ==" chỉ áp dụng cho các loại nguyên thủy, nhưng Stringkhông phải là loại nguyên thủy.
Ví dụ như,
String str = "Java is cool!";
System.out.println(str.length());       // return int 13
System.out.println(str.charAt(2));      // return char 'v'
System.out.println(str.charAt(5));      // return char 'i'
 
// Comparing two Strings
String anotherStr = "Java is COOL!";
System.out.println(str.equals(anotherStr));           // return boolean false
System.out.println(str.equalsIgnoreCase(anotherStr)); // return boolean true
System.out.println(anotherStr.equals(str));           // return boolean false
System.out.println(anotherStr.equalsIgnoreCase(str)); // return boolean true
// (str == anotherStr) to compare two Strings is WRONG!!!
Để kiểm tra tất cả các phương thức có sẵn cho String, hãy mở Tài liệu JDK ⇒ Chọn "Tài liệu API" Nhấp vào "FRAMES" (menu trên cùng) Từ "Mô-đun" (ngăn trên cùng bên trái), chọn " java.base" Từ " java.baseGói" (trên cùng bên trái khung), chọn " java.lang" Từ "Lớp" (khung dưới cùng bên trái), chọn " String" chọn "TÓM TẮT" "PHƯƠNG PHÁP" (khung bên phải) (@ https://docs.oracle.com/javase/10/docs /api/java/lang/String.html cho JDK 10).
Ví dụ như,
String str = "Java is cool!";
System.out.println(str.length());            // return int 13
System.out.println(str.charAt(2));           // return char 'v'
System.out.println(str.substring(0, 3));     // return String "Jav"
System.out.println(str.indexOf('a'));        // return int 1
System.out.println(str.lastIndexOf('a'));    // return int 3
System.out.println(str.endsWith("cool!"));   // return boolean true
System.out.println(str.toUpperCase());       // return a new String "JAVA IS COOL!"
System.out.println(str.toLowerCase());       // return a new String "java is cool!"

9.4  Converting String to Primitive

Chuỗi thành int / byte / short / long
Bạn có thể sử dụng các phương thức dựng sẵn JDK để chuyển đổi một hàm chứa số nguyên hợp lệ (ví dụ: " ") thành một (ví dụ :). Thời gian chạy kích hoạt a nếu chuỗi đầu vào không chứa một số nguyên hợp lệ (ví dụ: " "). 
Ví dụ, Integer.parseInt(anIntStr)String1234int1234NumberFormatExceptionabc

String inStr = "5566";
int number = Integer.parseInt(inStr);   // number <- 5566
// Input to Integer.parseInt() must be a valid integer literal
//number = Integer.parseInt("abc");     // Runtime Error: NumberFormatException
Similarly, you could use methods Byte.parseByte(aByteStr), Short.parseShort(aShortStr), Long.parseLong(aLongStr) to convert a String containing a valid byte, short or long literal to the primitive type.

String to double/float

Bạn cũng có thể dùng Double.parseDouble(aDoubleStr) hoặc Float.parseFloat(aFloatStr) để đổi một String sang double or float, e.g.
String inStr = "55.66";
float aFloat = Float.parseFloat(inStr);         // aFloat <- 55.66f
double aDouble = Double.parseDouble("1.2345");  // aDouble <- 1.2345
aDouble = Double.parseDouble("1.2e-3");         // aDouble <- 0.0012
// Input to Integer.parseInt() must be a valid double literal
//aDouble = Double.parseDouble("abc");          // Runtime Error: NumberFormatException

String to char

Bạn cũng có thể dung aStr.charAt(index) để extract một ký tự từ chuỗi String, trong đó index băt đầu 0 cho tới aStr.length()-1, e.g.,
// Extract each char
String msg = "Hello, world";
char msgChar;
for (int idx = 0; idx < msg.length(); ++idx) {
   msgChar = msg.charAt(idx);
   // Do something about the extracted char
   .......
}

String to boolean

Bạn cũng có thể dùng Boolean.parseBoolean(aBooleanStr)để chuyển đổi giá trị String "true" or "false" sang boolean true or false, e.g.,
String boolStr = "true";
boolean done = Boolean.parseBoolean(boolStr);   // done <- true
boolean valid = Boolean.parseBoolean("false");  // valid <- false

9.5  Converting Primitive to String

Để chuyển đổi một nguyên thủy thành a String, bạn có thể:
  1. Sử dụng +toán tử '' để ghép nối nguyên thủy với một khoảng trống String "" .
  2. Sử dụng các phương thức tích hợp JDK , áp dụng cho tất cả các nguyên hàm.String.valueOf(aPrimitve)
  3. Sử dụng các toString()phương thức của lớp wrapper tương ứng, chẳng hạn như , , , vvInteger.toString(anInt)Double.toString(aDouble)Character.toString(aChar)Boolean.toString(aBoolean)
Ví dụ như,
// Using String concatenation operator '+' with an empty String (applicable to ALL primitive types)
String str1 = 123 + "";    // int 123 -> String "123"
String str2 = 12.34 + "";  // double 12.34 -> String "12.34"
String str3 = 'c' + "";    // char 'c' -> String "c"
String str4 = true + "";   // boolean true -> String "true"
 
// Using String.valueOf(aPrimitive) (applicable to ALL primitive types)
String str5 = String.valueOf(12345);   // int 12345 -> String "12345"
String str6 = String.valueof(true);    // boolean true -> String "true"
String str7 = String.valueOf(55.66);   // double 55.66 -> String "55.66"
 
// Using toString() for each primitive type
String str8 = Integer.toString(1234);   // int 1234 -> String "1234"
String str9 = Double.toString(1.23);    // double 1.23 -> String "1.23"
String str10 = Character.toString('z'); // char 'z' -> String "z"

9.6  Formatting String - String.format()

Hãy nhớ lại rằng bạn có thể sử dụng printf()để tạo một chuỗi được định dạng và gửi nó đến bảng điều khiển hiển thị, ví dụ:
System.out.printf("Hi, %d, %.1f%n", 11, 22.22);   // Send the formatted String to console
Có một hàm tương tự được gọi là String.format()trả về chuỗi được định dạng, thay vì gửi đến bàn điều khiển, ví dụ:
String str = String.format("%.1f", 1.234);   // Returns a String "1.2" (for further operations)
String.format()có dạng tương tự như printf().

9.7  Code Example: Reverse String

Chương trình sau sẽ nhắc người dùng một chuỗi và in chuỗi đầu vào theo thứ tự ngược lại. Ví dụ như,
Enter a String: abcdefg
The reverse is: gfedcba
import java.util.Scanner;
/**
 * Prompt user for a string; and print the input string in reverse order.
 */
public class ReverseString {
   public static void main(String[] args) {
      // Declare variables
      String inStr;   // input String
      int inStrLen;   // length of the input String
      Scanner in = new Scanner(System.in);

      // Prompt and read input as "String"
      System.out.print("Enter a String: ");
      inStr = in.next();
      inStrLen = inStr.length();

      System.out.print("The reverse is: ");
      // Use a for-loop to extract each char in reverse order
      for (int inCharIdx = inStrLen - 1; inCharIdx >= 0; --inCharIdx) {
         System.out.print(inStr.charAt(inCharIdx));
      }
      System.out.println();
      in.close();
  }
}


9.8  Exercises on String and char operations

LINK

10.  Arrays

Giả sử rằng bạn muốn tìm trung bình của các nhãn hiệu cho một lớp là 30 sinh viên, bạn chắc chắn không muốn để tạo ra 30 biến: mark1, mark2, ..., mark30. Thay vào đó, Bạn có thể sử dụng một biến duy nhất, được gọi là một mảng , với 30 phần tử (hoặc các mục).
Mảng là một tập hợp các phần tử cùng loại , được xác định bởi một cặp dấu ngoặc vuông [ ]. Để sử dụng một mảng, bạn cần:
  1. Khai báo mảng với tên và kiểu . Sử dụng tên số nhiều cho mảng, ví dụ marks, rows, numbers. Tất cả các yếu tố của mảng thuộc về cùng một loại.
  2. Phân bổ mảng bằng newtoán tử hoặc thông qua khởi tạo , ví dụ:
  1. int[] marks;  // Declare an int array named "marks"
              // "marks" is assigned to a special value called "null" before allocation
int marks[];  // Same as above, but the above syntax recommended
marks = new int[5];   // Allocate 5 elements via the "new" operator
// Declare and allocate a 20-element array in one statement via "new" operator
int[] factors = new int[20];
// Declare, allocate a 6-element array thru initialization
int[] numbers = {11, 22, 33, 44, 55, 66}; // size of array deduced from the number of items
Khi một mảng được xây dựng thông qua newtoán tử, tất cả các phần tử được khởi tạo thành giá trị mặc định của chúng, ví dụ: 0for int, 0.0for double, falsefor booleanvà nullcho các đối tượng. [Không giống như C / C ++, không khởi tạo nội dung mảng.]
Khi một mảng được khai báo nhưng không được phân bổ, nó có một giá trị đặc biệt được gọi null.

10.1  Array Index - Chỉ Số Mảng

Bạn có thể tham khảo một phần tử của một mảng thông qua một chỉ mục (hoặc chỉ mục ) được đặt trong dấu ngoặc vuông [ ]. Chỉ số mảng của Java bắt đầu bằng zero ( 0). Ví dụ, giả sử rằng markslà một intmảng của 5 yếu tố, sau đó 5 yếu tố là: marks[0], marks[1], marks[2], marks[3], và marks[4].
int[] marks = new int[5];   // Declare & allocate a 5-element int array
// Assign values to the elements
marks[0] = 95;
marks[1] = 85;
marks[2] = 77;
marks[3] = 69;
marks[4] = 66;
// Retrieve elements of the array
System.out.println(marks[0]);
System.out.println(marks[3] + marks[4]);

10.2  Array's length

Để tạo một mảng, bạn cần biết trước chiều dài (hoặc kích thước ) của mảng và phân bổ tương ứng. Khi một mảng được tạo, độ dài của nó được cố định và không thể thay đổi trong thời gian chạy. Đôi khi, thật khó để xác định độ dài của một mảng (ví dụ: có bao nhiêu sinh viên?). Tuy nhiên, bạn cần ước tính độ dài và phân bổ giới hạn trên. Giả sử bạn đặt độ dài thành 30 (đối với một lớp sinh viên) và có 31 sinh viên, bạn cần phân bổ một mảng mới (có độ dài 31), sao chép mảng cũ sang mảng mới và xóa mảng cũ. Nói cách khác, độ dài của một mảng không thể được điều chỉnh động trong thời gian chạy. Đây có lẽ là nhược điểm chính của việc sử dụng một mảng. (Có các cấu trúc khác có thể được điều chỉnh động.)
Trong Java, độ dài của mảng được giữ trong một biến liên quan được gọi lengthvà có thể được truy xuất bằng cách sử dụng " arrayName.length", ví dụ:
int[] factors = new int[5];       // Declare and allocate a 5-element int array
int numFactors = factors.length;  // numFactor is 5
array
The index of an array is between 0 and arrayName.length - 1.
Chỉ số của một mảng là giữa 0và arrayName.length - 1.
Không giống như các ngôn ngữ như C / C ++, Java thực hiện kiểm tra ràng buộc chỉ mục mảng trong thời gian chạy . Nói cách khác, đối với mỗi tham chiếu đến một phần tử mảng, chỉ mục được kiểm tra đối với mảng length. Nếu chỉ mục nằm ngoài phạm vi [0, arrayName.length-1], Java Runtime sẽ báo hiệu một ngoại lệ được gọi ArrayIndexOutOfBoundException. Điều quan trọng cần lưu ý là việc kiểm tra mảng liên kết chỉ số tiêu thụ năng lượng tính toán, chắc chắn sẽ làm chậm quá trình xử lý. Tuy nhiên, những lợi ích đạt được về mặt kỹ thuật phần mềm tốt vượt trội về tốc độ.

10.3  Array and Loop

Mảng làm việc chặt chẽ với các vòng lặp. Bạn có thể xử lý tất cả các phần tử của một mảng thông qua một vòng lặp, ví dụ,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
 * Find the mean and standard deviation of numbers kept in an array
 */
public class MeanSDArray {
   public static void main(String[] args) {
      // Declare variable
      int[] marks = {74, 43, 58, 60, 90, 64, 70};
      int sum = 0;
      int sumSq = 0;
      double mean, stdDev;
 
      // Compute sum and square-sum using loop
      for (int i = 0; i < marks.length; ++i) {
         sum += marks[i];
         sumSq += marks[i] * marks[i];
      }
      mean = (double)sum / marks.length;
      stdDev = Math.sqrt((double)sumSq / marks.length - mean * mean);
 
      // Print results
      System.out.printf("Mean is: %.2f%n", mean);
      System.out.printf("Standard deviation is: %.2f%n", stdDev);
   }
}

10.4  Enhanced for-loop (or "for-each" Loop) (JDK 5)

JDK 5 introduces a new loop syntax known as enhanced for-loop (or for-each loop) to facilitate processing of arrays and collections. It takes the following syntax:
SyntaxExample
for (type item : anArray) {
   body ;
}
  // type must be the same as the
  // anArray's type
 

 
int[] numbers = {8, 2, 6, 4, 3};
int sum = 0, sumSq = 0;
for (int number : numbers) {   // for each int number in int[] numbers
   sum += number;
   sumSq += number * number;
}
System.out.println("The sum is: " + sum);
System.out.println("The square sum is: " + sumSq);
Vòng lặp này sẽ được đọc là "cho mỗi phần tử trong mảng ...". Vòng lặp thực thi một lần cho mỗi phần tử trong mảng, với giá trị của phần tử được sao chép vào biến khai báo. Vòng lặp for-every thuận tiện để chuyển đổi tất cả các phần tử của một mảng. Nó đòi hỏi ít dòng mã hơn, loại bỏ bộ đếm vòng lặp và chỉ mục mảng và dễ đọc hơn. Tuy nhiên, đối với mảng các kiểu nguyên thủy (ví dụ: mảng ints), nó chỉ có thể đọc các phần tử và không thể sửa đổi nội dung của mảng. Điều này là do giá trị của mỗi phần tử được sao chép vào biến của vòng lặp, thay vì làm việc trên bản sao gốc của nó.
Trong nhiều tình huống, bạn chỉ muốn chuyển qua mảng và đọc từng phần tử. Đối với những trường hợp này, vòng lặp for nâng cao được ưa thích và khuyên dùng hơn các cấu trúc vòng lặp khác.

10.5  Code Example: Read and Print Array

Chương trình sau sẽ nhắc người dùng về độ dài và tất cả các thành phần của một mảng và in mảng đó dưới dạng [a0, a1, ..., an]. Ví dụ như,
Enter the number of items: 5
Enter the value of all items (separated by space): 7 9 1 6 2
The values are: [7, 9, 1, 6, 2]
import java.util.Scanner;
/**
 * Prompt user for the length and all the elements of an array; and print [a1, a2, ..., an]
 */
public class ReadPrintArray {
   public static void main(String[] args) {
      // Declare variables
      int numItems;
      int[] items;   // Declare array name, to be allocated after numItems is known
      Scanner in = new Scanner(System.in);

      // Prompt for a non-negative integer for the number of items;
      // and read the input as "int". No input validation.
      System.out.print("Enter the number of items: ");
      numItems = in.nextInt();

      // Allocate the array
      items = new int[numItems];

      // Prompt and read the items into the "int" array, only if array length > 0
      if (items.length > 0) {
         System.out.print("Enter the value of all items (separated by space): ");
         for (int i = 0; i < items.length; ++i) {
            items[i] = in.nextInt();
         }
      }

      // Print array contents, need to handle first item and subsequent items differently
      System.out.print("The values are: [");
      for (int i = 0; i < items.length; ++i) {
         if (i == 0) {
            // Print the first item without a leading commas
            System.out.print(items[0]);
         } else {
            // Print the subsequent items with a leading commas
            System.out.print(", " + items[i]);
         }
      }
      System.out.println("]");
      in.close();
   }
}

Arrays.toString() (JDK 5)

JDK 5 provides an built-in methods called Arrays.toString(anArray), which returns a String in the form [a0, a1, ..., an]. You need to import java.util.Arrays. For examples,
import java.util.Arrays;   // Needed to use Arrays.toString()
/**
 * Use Arrays.toString() to print an array in the form of [a1, a2, ..., an]
 */
public class TestArrayToString {
   public static void main(String[] args) {
      // Declare and allocate test arrays
      int[] a1 = {6 ,1, 3, 4, 5};   // Allocate via initialization
      int[] a2 = {};                // Empty array with length = 0
      double[] a3 = new double[1];  // One-Element array, init to 0.0

      System.out.println(Arrays.toString(a1));  //[6, 1, 3, 4, 5]
      System.out.println(Arrays.toString(a2));  //[]
      System.out.println(Arrays.toString(a3));  //[0.0]
      a3[0] = 2.2;
      System.out.println(Arrays.toString(a3));  //[2.2]
   }
}

10.6  Code Example: Horizontal and Vertical Histograms

Chương trình sau đây sẽ nhắc người dùng về số lượng sinh viên và cấp độ của từng sinh viên. Sau đó, nó in biểu đồ, ở dạng ngang và dọc, như sau:
Enter the grade for student 1: 98
Enter the grade for student 2: 100
Enter the grade for student 3: 9
Enter the grade for student 4: 3
Enter the grade for student 5: 56
Enter the grade for student 6: 58
Enter the grade for student 7: 59
Enter the grade for student 8: 87

 0-  9: **
10- 19:
20- 29:
30- 39:
40- 49:
50- 59: ***
60- 69:
70- 79:
80- 89: *
90-100: **

                                      *
   *                                  *                           *
   *                                  *                    *      *
  0-9   10-19  20-29  30-39  40-49  50-59  60-69  70-79  80-89  90-100
import java.util.Scanner;
import java.util.Arrays;   // for Arrays.toString()
/**
 * Print the horizontal and vertical histograms of grades.
 */
public class GradesHistograms {
   public static void main(String[] args) {
      // Declare variables
      int numStudents;
      int[] grades;  // Declare array name, to be allocated after numStudents is known
      int[] bins = new int[10];  // int array of 10 histogram bins for 0-9, 10-19, ..., 90-100
      Scanner in = new Scanner(System.in);

      // Prompt and read the number of students as "int"
      System.out.print("Enter the number of students: ");
      numStudents = in.nextInt();

      // Allocate the array
      grades = new int[numStudents];

      // Prompt and read the grades into the int array "grades"
      for (int i = 0; i < grades.length; ++i) {
         System.out.print("Enter the grade for student " + (i + 1) + ": ");
         grades[i] = in.nextInt();
      }
      // Print array for debugging
      System.out.println(Arrays.toString(grades));

      // Populate the histogram bins
      for (int grade : grades) {
         if (grade == 100) {   // Need to handle 90-100 separately as it has 11 items.
            ++bins[9];
         } else {
            ++bins[grade/10];
         }
      }
      // Print array for debugging
      System.out.println(Arrays.toString(bins));

      // Print the horizontal histogram
      // Rows are the histogram bins[0] to bins[9]
      // Columns are the counts in each bins[i]
      for (int binIdx = 0; binIdx < bins.length; ++binIdx) {
         // Print label
         if (binIdx != 9) {  // Need to handle 90-100 separately as it has 11 items
            System.out.printf("%2d-%3d: ", binIdx*10, binIdx*10+9);
         } else {
            System.out.printf("%2d-%3d: ", 90, 100);
         }
         // Print columns of stars
         for (int itemNo = 0; itemNo < bins[binIdx]; ++itemNo) {  // one star per item
            System.out.print("*");
         }
         System.out.println();
      }

      // Find the max value among the bins
      int binMax = bins[0];
      for (int binIdx = 1; binIdx < bins.length; ++binIdx) {
         if (binMax < bins[binIdx]) binMax = bins[binIdx];
      }

      // Print the Vertical histogram
      // Columns are the histogram bins[0] to bins[9]
      // Rows are the levels from binMax down to 1
      for (int level = binMax; level > 0; --level) {
         for (int binIdx = 0; binIdx < bins.length; ++binIdx) {
            if (bins[binIdx] >= level) {
               System.out.print("   *   ");
            } else {
               System.out.print("       ");
            }
         }
         System.out.println();
      }
      // Print label
      for (int binIdx = 0; binIdx < bins.length; ++binIdx) {
         System.out.printf("%3d-%-3d", binIdx*10, (binIdx != 9) ? binIdx * 10 + 9 : 100);
            // Use '-' flag for left-aligned
      }
      System.out.println();

      in.close();  // Close the Scanner
   }
}

Ghi chú:

  1. Chúng tôi sử dụng hai mảng trong bài tập này, một mảng để lưu trữ các lớp của học sinh (có độ dài numStudents) và mảng còn lại để lưu trữ số lượng biểu đồ (độ dài 10).
  2. Chúng tôi sử dụng một 10-element intmảng gọi là bins, để giữ đếm histogram cho lớp của [0, 9], [10, 19], ..., [90, 100]. Hãy lưu ý rằng có 101các lớp giữa [0, 100]và thùng cuối cùng có 11các lớp (thay vì 10 cho phần còn lại). Các binschỉ số của là grade/10, ngoại trừ gradecủa 100.

10.7  Multi-Dimensional Array

Trong Java, bạn có thể khai báo một mảng các mảng. Ví dụ như:
int grid[][] = new int[12][8];   // a 12×8 grid of int
grid[0][0] = 8;
grid[1][1] = 5;
System.out.println(grid.length);      // 12
System.out.println(grid[0].length);   // 8
System.out.println(grid[11].length);  // 8
Trong ví dụ trên, gridlà một mảng gồm 12 phần tử. Mỗi phần tử ( grid[0]đến grid[11]) là một intmảng 8 phần tử . Nói cách khác, gridlà "mảng 12 phần tử" của "mảng int 8 phần tử". Do đó, grid.lengthcho 12và grid[0].lengthcho 8.
public class Array2DTest {
   public static void main(String[] args) {
      int[][] grid = new int[12][8];   // A 12x8 grid, in [row][col] or [y][x]
      int numRows = grid.length;       // 12
      int numCols = grid[0].length;    // 8
   
      // Fill in grid
      for (int row = 0; row < numRows; ++row) {
         for (int col = 0; col < numCols; ++col) {
            grid[row][col] = row*numCols + col + 1;
         }
      }
   
      // Print grid
      for (int row = 0; row < numRows; ++row) {
         for (int col = 0; col < numCols; ++col) {
            System.out.printf("%3d", grid[row][col]);
         }
         System.out.println();
      }
   }
}
Array_MultiDimensional.png
Nói chính xác, Java không hỗ trợ mảng đa chiều trực tiếp. Đó là, nó không hỗ trợ cú pháp grid[3, 2]như một số ngôn ngữ. Hơn nữa, có thể các mảng trong một mảng có độ dài khác nhau.
Hãy lưu ý rằng cách đúng để xem "mảng mảng" như được hiển thị, thay vì coi nó như một bảng 2D, ngay cả khi tất cả các mảng có cùng độ dài.
Ví dụ,

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
public class Array2DWithDifferentLength {
   public static void main(String[] args) {
      int[][] grid = {
         {1, 2},
         {3, 4, 5},
         {6, 7, 8, 9}
      };
 
      // Print grid
      for (int y = 0; y < grid.length; ++y) {
         for (int x = 0; x < grid[y].length; ++x) {
            System.out.printf("%2d", grid[y][x]);
         }
         System.out.println();
      }
 
      // Another 2D array
      int[][] grid1 = new int[3][];
      grid1[0] = new int[2];
      grid1[1] = new int[3];
      grid1[2] = new int[4];
 
      // Print grid - all elements init to 0
      for (int y = 0; y < grid1.length; ++y) {
         for (int x = 0; x < grid1[y].length; ++x) {
            System.out.printf("%2d", grid1[y][x]);
         }
         System.out.println();
      }
   }
}

11.  Methods (Functions)

11.1  Why Methods?

Đôi khi, một phần mã nhất định phải được sử dụng nhiều lần. Thay vì viết lại mã nhiều lần, tốt hơn là đặt chúng vào "chương trình con" và "gọi" "chương trình con" này nhiều lần - để dễ bảo trì và hiểu. Chương trình con được gọi là phương thức (trong Java) hoặc hàm (trong C / C ++).
Lợi ích của việc sử dụng các phương pháp là:
  1. Phân chia và chinh phục : Xây dựng chương trình từ các phần hoặc thành phần đơn giản, nhỏ. Mô đun hóa chương trình thành các nhiệm vụ độc lập.
  2. Tránh lặp lại mã : Rất dễ sao chép và dán, nhưng khó duy trì và đồng bộ hóa tất cả các bản sao.
  3. Tái sử dụng phần mềm : Bạn có thể sử dụng lại các phương thức trong các chương trình khác, bằng cách đóng gói chúng vào mã thư viện (hoặc API).

    11.2  Using Methods

    Hai bên tham gia vào việc sử dụng một phương thức: một người gọi , người gọi (hoặc gọi ) phương thức và phương thức được gọi.
    Quá trình là:
    1. Người gọi gọi một phương thức và truyền đối số cho phương thức.
    2. Phương pháp:
      1. nhận được các đối số được thông qua bởi người gọi,
      2. thực hiện các hoạt động được lập trình được xác định trong phần thân của phương thức và
      3. trả về một kết quả cho người gọi
    3. Người gọi nhận được kết quả và tiếp tục các hoạt động của nó.
    Ví dụ: Giả sử rằng chúng ta cần đánh giá diện tích của một vòng tròn nhiều lần, tốt hơn là viết một phương thức được gọi getArea()và sử dụng lại nó khi cần.
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    public class EgMethodGetArea {
   // The entry main method
   public static void main(String[] args) {
      double r = 1.1, area, area2;
      // Call (Invoke) method getArea() and return
      area = getArea(r);
      System.out.println("area is " + area);
      // Call method getArea() again and return
      area2 = getArea(2.2);
      System.out.println("area 2 is " + area2);
      // Call method getArea() one more time and return
      System.out.println("area 3 is " + getArea(3.3));
   }
 
   // Method getArea() Definition.
   // Compute and return the area (in double) of circle given its radius (in double).
   public static double getArea(double radius) {
      return radius * radius * Math.PI;
   }
}
    Method.png
    The expected outputs are:
    area is 3.8013271108436504
area 2 is 15.205308443374602
area 3 is 34.21194399759284
    Trong ví dụ trên, một phương thức có thể sử dụng lại được gọi getArea()được xác định, nhận một đối số doubletừ người gọi, thực hiện phép tính và trả về doublekết quả cho người gọi. Trong main(), chúng ta gọi getArea()các phương thức ba lần, mỗi lần với một tham số khác nhau.
    Lưu ý rằng có một sự chuyển điều khiển từ người gọi sang phương thức được gọi và từ phương thức trở lại người gọi, như được minh họa.
    Method.pngMethod Definition Syntax

    Cú pháp cho định nghĩa phương thức như sau:
    public static returnValueType methodName(arg-1-type arg-1, arg-2-type arg-2,... ) {
   body ;
}
    // Examples
// Return circle's area given its radius
public static double getArea(double radius) {
   return radius * radius * Math.PI;
}

// Return maximum among two given integers
public static int max(int number1, int number2) {
   if (number1 > number2) {
      return number1;
   } else {
      return number2;
   }
}
    Lưu ý rằng bạn cần chỉ định loại đối số và giá trị trả về trong định nghĩa phương thức.

    Calling Methods

    Để gọi một phương thức, chỉ cần sử dụng . Ví dụ, để gọi các phương thức trên:methodName(arguments)
    // Calling getArea()
double area1 = getArea(1.1);  // with literal as argument
double r2 = 2.2;
double area2 = getArea(r2);   // with variable as argument
double r3 = 3.3;
System.out.println("Area is: " + area(r3));

// Calling max()
int result1 = max(5, 8);
int i1 = 7, i2 = 9;
int result2 = max(i1, i2);
System.out.println("Max is: " + max(15, 16));
    Lưu ý rằng bạn cần chỉ định loại trong định nghĩa phương thức, nhưng không phải trong khi gọi.

    Method Naming Convention

    Tên của một phương thức sẽ là một động từ hoặc cụm động từ (hành động), bao gồm một hoặc nhiều từ. Từ đầu tiên là chữ thường, trong khi phần còn lại được viết hoa ban đầu (gọi là trường hợp lạc đà ). Ví dụ, getArea(), setRadius(), moveDown(), isPrime(),, vv
    Another Example:
    /** Example of Java Method definition and invocation */
public class EgMinMaxMethod {
   // The entry main() method
   public static void main(String[] args) {
      int a = 6, b = 9, max, min;
      max = max(a, b);  // invoke method max() with arguments
      min = min(a, b);  // invoke method min() with arguments
      System.out.println(max + "," + min);
   
      System.out.println(max(5, 8)); // invoke method max()
      System.out.println(min(5, 8)); // invoke method min()
   }

   // The max() method returns the maximum of two given int
   public static int max(int number1, int number2) {
      if (number1 > number2) {
         return number1;
      } else {
         return number2;
      }
   }

   // The min() method returns the minimum of two given int
   public static int min(int number1, int number2) {
      return (number1 < number2) ? number1 : number2;
   }
}

    11.3  The "return" statement

    Bên trong thân phương thức, bạn có thể sử dụng một returncâu lệnh để trả về một giá trị (của returnValueTypekhai báo trong chữ ký của phương thức) để trả về một giá trị cho người gọi. Cú pháp là:
    return aReturnValue;   // of returnValueType declared in method's signature
return;                // return nothing (or void)

    11.4  The "void" Return-Type

    Giả sử rằng bạn cần một phương thức để thực hiện một số hành động nhất định (ví dụ: in) mà không cần trả lại giá trị cho người gọi, bạn có thể khai báo loại giá trị trả về của nó là void. Trong phần thân của phương thức, bạn có thể sử dụng return;câu lệnh "" mà không có giá trị trả về để trả lại quyền điều khiển cho người gọi. Trong trường hợp này, returntuyên bố là tùy chọn. Nếu không có returncâu lệnh nào , toàn bộ cơ thể sẽ được thực thi và điều khiển trả về cho người gọi ở cuối cơ thể.
    Lưu ý rằng đó main()là một phương thức có loại giá trị trả về là void. main()được gọi bởi thời gian chạy Java, thực hiện các hành động được xác định trong phần thân và không trả lại gì cho thời gian chạy Java.

    11.5  Actual Parameters vs. Formal Parameters

    Hãy nhớ lại rằng một phương thức nhận các đối số từ người gọi của nó, thực hiện các hành động được xác định trong phần thân của phương thức và trả về một giá trị (hoặc không có gì) cho người gọi.
    Trong ví dụ trên, biến được (double radius)khai báo trong chữ ký của getArea(double radius)được gọi là tham số chính thức . Phạm vi của nó là trong cơ thể của phương thức. Khi phương pháp này được gọi bởi một người gọi, người gọi phải cung cấp cái gọi là tham số thực tế s hoặc tranh cãi , có giá trị sau đó được sử dụng cho việc tính toán thực tế. Ví dụ: khi phương thức được gọi thông qua " area1=getArea(radius1)", radius1là tham số thực tế, với giá trị là 1.1.

    11.6  Code Example: Magic Number

    The following program contains a boolean method called isMagic(int number), which returns true if the given number contains the digit 8, e.g., 18, 108, and 1288. The signature of the method is:
    public static boolean isMagic(int number);
    It also provides the main() method to test the isMagic(). For example,
    Enter a positive integer: 1288
1288 is a magic number

Enter a positive integer: 1234567
1234567 is not a magic number
    import java.util.Scanner;
/**
 * This program contains a boolean method called isMagic(int number), which tests if the
 * given number contains the digit 8.
 */
public class MagicNumber {
   public static void main(String[] args) {
      // Declare variables
      int number;
      Scanner in = new Scanner(System.in);

      // Prompt and read input as "int"
      System.out.print("Enter a positive integer: ");
      number = in.nextInt();

      // Call isMagic() to test the input
      if (isMagic(number)) {
         System.out.println(number + " is a magic number");
      } else {
         System.out.println(number + " is not a magic number");
      }
      in.close();
   }

   /**
    * Check if the given int contains the digit 8, e.g., 18, 82, 1688.
    * @param  number The given integer
    * @return        true if number contains the digit 8
    * @Precondition  number > 0 (i.e., a positive integer)
    */
   public static boolean isMagic(int number) {
      boolean isMagic = false;   // shall change to true if found a digit 8

      // Extract and check each digit
      while (number > 0) {
         int digit = number % 10;   // Extract the last digit
         if (digit == 8) {
            isMagic = true;
            break;  // only need to find one digit 8
         }
         number /= 10;   // Drop the last digit and repeat
      }
      return isMagic;
   }
}
    Take note of the proper documentation comment for the method.

    11.7  Code Example: int Array Methods

    The following program contains various method for int array with signatures as follows:
    public static void print(int[] array);      // Print [a1, a2, ...., an]
public static int min(int[] array);         // Return the min of the array
public static int sum(int[] array);         // Return the sum of the array
public static double average(int[] array);  // Return the average of the array
    It also contains the main() method to test all the methods. For example,
    Enter the number of items: 5
Enter the value of all items (separated by space): 8 1 3 9 4
The values are: [8, 1, 3, 9, 4]
The min is: 1
The sum is: 25
The average (rounded to 2 decimal places) is: 5.00
    import java.util.Scanner;
/**
 * Test various int[] methods.
 */
public class IntArrayMethodsTest {
   public static void main(String[] args) {
      // Declare variables
      int numItems;
      int[] items;  // Declare array name, to be allocated after numItems is known
      Scanner in = new Scanner(System.in);

      // Prompt for a non-negative integer for the number of items;
      // and read the input as "int". No input validation.
      System.out.print("Enter the number of items: ");
      numItems = in.nextInt();

      // Allocate the array
      items = new int[numItems];

      // Prompt and read the items into the "int" array, if array length > 0
      if (items.length > 0) {
         System.out.print("Enter the value of all items (separated by space): ");
         for (int i = 0; i < items.length; ++i) {
            items[i] = in.nextInt();
         }
      }

      // Test the methods
      System.out.print("The values are: ");
      print(items);
      System.out.println("The min is: " + min(items));
      System.out.println("The sum is: " + sum(items));
      System.out.printf("The average (rounded to 2 decimal places) is: %.2f%n", average(items));
      in.close();
   }

   /**
    * Prints the given int array in the form of [x1, x2, ..., xn]
    * @param  array   The given int array
    * @Postcondition  Print output as side effect
    */
   public static void print(int[] array) {
      System.out.print("[");
      for (int i = 0; i < array.length; ++i) {
         System.out.print((i == 0) ? array[i] : ", " + array[i]);
      }
      System.out.println("]");
   }

   /**
    * Get the min of the given int array
    * @param  array  The given int array
    * @return        The min value of the given array
    */
   public static int min(int[] array) {
      int min = array[0];
      for (int i = 1; i < array.length; ++i) {
         if (array[i] < min) min = array[i];
      }
      return min;
   }

   /**
    * Get the sum of the given int array
    * @param  array  The given int array
    * @return        The sum of the given array
    */
   public static int sum(int[] array) {
      int sum = 0;
      for (int item: array) sum += item;
      return sum;
   }

   /**
    * Get the average of the given int array
    * @param  array  The given int array
    * @return        The average of the given array
    */
   public static double average(int[] array) {
      return (double)(sum(array)) / array.length;
   }
}

    11.8  Pass-by-Value for Primitive-Type Parameters

    Trong Java, khi một đối số của kiểu nguyên thủy được truyền vào một phương thức, một bản sao được tạo và chuyển vào phương thức. Phương thức được gọi hoạt động trên bản sao nhân bản và không thể sửa đổi bản sao gốc. Điều này được gọi là pass-by-value .
    Ví dụ,
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    public class PassByValueTest {
   public static void main(String[] args) {
      int number = 8, result;
      System.out.println("In caller, before calling the method, number is: " + number);  // 8
      result = increment(number); // invoke method with primitive-type parameter
      System.out.println("In caller, after calling the method, number is: " + number);   // 8
      System.out.println("The result is " + result);  // 9
   }
 
   // Return number + 1
   public static int increment(int number) {
      System.out.println("Inside method, before operation, number is " + number); // 8
      ++number;  // change the parameter
      System.out.println("Inside method, after operation, number is " + number);  // 9
      return number;
   }
}
    Ghi chú:
    1. Mặc dù có một biến được gọi numbertrong cả phương thức main()và increment()phương thức, có hai bản sao riêng biệt - một bản có sẵn main()và một bản khác có sẵn increment()- xảy ra có cùng tên. Bạn có thể thay đổi tên của một trong hai, mà không ảnh hưởng đến chương trình.

      11.9  Pass-by-Reference for Arrays and Objects

      Như đã đề cập, đối với các tham số kiểu nguyên thủy, một bản sao được sao chép được tạo và truyền vào phương thức. Do đó, phương thức không thể sửa đổi các giá trị trong trình gọi. Nó được gọi là pass-by-value.
      Đối với mảng (và đối tượng - sẽ được mô tả trong chương sau), tham chiếu mảng được truyền vào phương thức và phương thức có thể sửa đổi nội dung của các phần tử của mảng. Nó được gọi là tham chiếu qua. Ví dụ,
      import java.util.Arrays;  // for Arrays.toString()
public class PassByReferenceTest {
   public static void main(String[] args) {
      int[] testArray = {9, 5, 6, 1, 4};
      System.out.println("In caller, before calling the method, array is: "
            + Arrays.toString(testArray));   // [9, 5, 6, 1, 4]
      // Invoke method with an array parameter
      increment(testArray);
      System.out.println("In caller, after calling the method, array is: "
            + Arrays.toString(testArray));   // [10, 6, 7, 2, 5]
   }

   // Increment each of the element of the given int array
   public static void increment(int[] array) {
      System.out.println("Inside method, before operation, array is "
           + Arrays.toString(array));   // [9, 5, 6, 1, 4]
      // Increment each elements
      for (int i = 0; i < array.length; ++i) ++array[i];
      System.out.println("Inside method, after operation, array is "
           + Arrays.toString(array));   // [10, 6, 7, 2, 5]
   }
}

      11.10  Varargs - Method with Variable Number of Formal Arguments (JDK 5)

      Trước JDK 5, một phương thức phải được khai báo với một số đối số chính thức cố định . Giống như C printf(), có số lượng đối số thay đổi , không thể được thực hiện. Mặc dù bạn có thể sử dụng một mảng để truyền một số lượng đối số khác nhau, nhưng nó không gọn gàng và đòi hỏi một số nỗ lực lập trình.
      JDK 5 giới thiệu các đối số biến (hoặc varargs) và cú pháp mới " Type...". Ví dụ,
      public PrintWriter printf(String format, Object... args)
public PrintWriter printf(Local l, String format, Object... args)
      Varargs chỉ có thể được sử dụng cho đối số cuối cùng. Ba dấu chấm ( ...) chỉ ra rằng đối số cuối cùng có thể được truyền dưới dạng một mảng hoặc dưới dạng một chuỗi các đối số được phân tách bằng dấu phẩy. Trình biên dịch tự động gói các varargs thành một mảng. Sau đó, bạn có thể truy xuất và xử lý từng đối số này bên trong phần thân của phương thức dưới dạng một mảng. Có thể truyền varargs dưới dạng một mảng, vì Java duy trì độ dài của mảng trong một biến liên quan length.
      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
      public class VarargsTest {
   // A method which takes a variable number of arguments (varargs)
   public static void doSomething(String... strs) {
      System.out.print("Arguments are: ");
      for (String str : strs) {
         System.out.print(str + ", ");
      }
      System.out.println();
   }
 
   // A method which takes exactly two arguments
   public static void doSomething(String s1, String s2) {
      System.out.println("Overloaded version with 2 args: " + s1 + ", " + s2);
   }
 
   // Cannot overload with this method - crash with varargs version
   // public static void doSomething(String[] strs)
 
   // Test main() method
   // Can also use String... instead of String[]
   public static void main(String... args) {
      doSomething("Hello", "world", "again", "and", "again");
      doSomething("Hello", "world");
 
      String[] strs = {"apple", "orange"};
      doSomething(strs);  // invoke varargs version
   }
}
        Ghi chú:
        • Nếu bạn xác định một phương thức có một varargs String..., bạn không thể xác định một phương thức bị quá tải cần một String[].
        • "varargs" sẽ được kết hợp cuối cùng trong số các phương thức quá tải. Cái varargsMethod(String, String), cụ thể hơn, được khớp trước varargsMethod(String...).
        • Từ JDK 5, bạn cũng có thể khai báo main()phương thức của mình là
      • :
        public static void main(String... args) { .... }  // JDK 5 varargs

      11.11  Implicit Type-Casting for Method's Parameters

      Một phương thức lấy doubletham số có thể chấp nhận bất kỳ kiểu nguyên thủy số nào, chẳng hạn như inthoặc float. Điều này là do đúc kiểu ngầm được thực hiện. Tuy nhiên, một phương thức lấy inttham số không thể chấp nhận doublegiá trị. Điều này là do việc tạo kiểu ngầm định luôn là một chuyển đổi mở rộng nhằm tránh mất độ chính xác. Một kiểu đúc rõ ràng là cần thiết để thu hẹp chuyển đổi. Đọc " Đúc kiểu " trên các quy tắc chuyển đổi.

      11.12  Method Overloading

      Trong Java, một phương thức (của một tên phương thức cụ thể) có thể có nhiều hơn một phiên bản, mỗi phiên bản hoạt động trên một bộ tham số khác nhau - được gọi là nạp chồng phương thức . Các phiên bản sẽ được phân biệt bởi số lượng, loại hoặc thứ tự của các tham số.

      Example 1

      /** Testing Method Overloading */
public class AverageMethodOverloading {
   public static void main(String[] args) {
      System.out.println(average(8, 6));     // invoke version 1
      System.out.println(average(8, 6, 9));  // invoke version 2
      System.out.println(average(8.1, 6.1)); // invoke version 3
      System.out.println(average(8, 6.1));
           // int 8 autocast to double 8.0, invoke version 3
      //average(1, 2, 3, 4)  // Compilation Error - no such method
   }

   // Version 1 takes 2 int's
   public static int average(int n1, int n2) {
      System.out.println("version 1");
      return (n1 + n2)/2;  // int
   }

   // Version 2 takes 3 int's
   public static int average(int n1, int n2, int n3) {
      System.out.println("version 2");
      return (n1 + n2 + n3)/3;   // int
   }

   // Version 3 takes 2 doubles
   public static double average(double n1, double n2) {
      System.out.println("version 3");
      return (n1 + n2)/2.0;  // double
   }
}
      The expected outputs are:
      version 1
7
version 2
7
version 3
7.1
version 3
7.05

      Example 2: Arrays

      Giả sử bạn cần một phương pháp để tính tổng các yếu tố cho int[], short[], float[]và double[], bạn cần phải viết tất cả các phiên bản quá tải - không có phím tắt.
      /** Testing Array Method Overloading */
public class SumArrayMethodOverloading {
   public static void main(String[] args) {
      int[] a1 = {9, 1, 2, 6, 5};
      System.out.println(sum(a1));     // invoke version 1
      double[] a2 = {1.1, 2.2, 3.3};
      System.out.println(sum(a2));     // invoke version 2
      float[] a3 = {1.1f, 2.2f, 3.3f};
      //System.out.println(sum(a3));   // error - float[] is not casted to double[]
   }

   // Version 1 takes an int[]
   public static int sum(int[] array) {
      System.out.println("version 1");
      int sum = 0;
      for (int item : array) sum += item;
      return sum;  // int
   }

   // Version 2 takes a double[]
   public static double sum(double[] array) {
      System.out.println("version 2");
      double sum = 0.0;
      for (double item : array) sum += item;
      return sum;  // double
   }
}

      11.13  "boolean" Methods

      Đọc hiểu và phân tích đoạn code sau 
      1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
      /**
 *  Testing boolean method (method that returns a boolean value)
 */
public class BooleanMethodTest {
   // This method returns a boolean value
   public static boolean isOdd(int number) {
      if (number % 2 == 1) {
         return true;
      } else {
         return false;
      }
   }
 
   public static void main(String[] args) {
      System.out.println(isOdd(5));  // true
      System.out.println(isOdd(6));  // false
      System.out.println(isOdd(-5)); // false
   }
}

      Tags

      Post a Comment

      إرسال تعليق

      أحدث أقدم