Tăng mỗi ký tự trong chuỗi thêm 1 C++

Question

Bất cứ khi nào bạn nhận được một phương pháp không thanh lịch, điều đầu tiên, hãy cố gắng chia logic của bạn thành logic nhỏ hơn

Nội dung chính

Basic Syntaxes
Variables and Types
Các loại nguyên thủy và java Xxx 05
Hoạt động cơ bản
Kiểm soát lưu lượng
Input/Output
Writing Correct and Good Programs
More on Loops - Nested-Loops, "Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"88 & java Xxx 063
java Xxx 05 and java Xxx 09 operations
Phương thức (Chức năng)
Command-Line Arguments
(Advanced) Bitwise Operations
Can you increment characters in C?
Can we increment character in Java?

 private static bool isMaxChar(this char ch)
 {
     return ch == '9' || ch == 'z' || ch == 'Z';
 }

 public static char Increment(this char ch)
 {
     if (Char.IsDigit(ch))
         return (char)((ch + 1 - '0') % 10 + '0');
     if (Char.IsLower(ch))
         return (char)((ch + 1 - 'a') % 26 + 'a');
     if (Char.IsUpper(ch))
         return (char)((ch + 1 - 'A') % 26 + 'A');

     return ch;
 }

bằng cách sử dụng các phương thức trợ giúp ở trên, mã của bạn sẽ rõ ràng và thanh lịch hơn

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

Tôi đã viết bài kiểm tra đơn vị và chạy mã ở trên và nó cho kết quả giống như mã của bạn

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

This chapter explains the basic syntaxes of the Java programming language. I shall assume that you have written some simple Java programs. Otherwise, read "Introduction To Java Programming for First-time Programmers"

To be proficient in a programming language, you need to master two things

The syntax of the programming language. Not too difficult to learn a small set of keywords and syntaxes. For examples, JDK 1. 8 has 48 keywords; C11 has 44, and C++11 has 73
The Application Program Interface (API) libraries associated with the language. Bạn không muốn tự viết mọi thứ từ đầu. Thay vào đó, bạn có thể sử dụng lại code có sẵn trong thư viện. Học thư viện có thể khó khăn vì nó thực sự rất lớn, đang phát triển và có thể tự tồn tại như một ngôn ngữ lập trình khác

The first few sections are a bit boring, as I have to explain the basic concepts with some details

You may also try the "Exercises on Java Basics"

Basic Syntaxes

Steps in Writing a Java Program

The steps in writing a Java program is illustrated as follows

Step 1. Write the source code

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

6 using a programming text editor (such as Sublime Text, Atom, Notepad++, Textpad, gEdit) or an IDE (such as Eclipse or NetBeans)

Step 2. Compile the source code

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

6 into Java portable bytecode

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

8 using the JDK Compiler by issuing command

javac Xxx.java

Step 3. Run the compiled bytecode

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

8 with the input to produce the desired output, using the Java Runtime by issuing command

java Xxx

Java Program Template

You can use the following template to write your Java programs. Choose a meaningful "Classname" that reflects the purpose of your program, and write your programming statements inside the body of the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 method. Don't worry about the other terms and keywords now. I will explain them in due course. Provide comments in your program

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

0

A Sample Program Illustrating Sequential, Decision and Loop Constructs

Below is a simple Java program that demonstrates the three basic programming constructs. sequential, loop, and conditional. Read "Introduction To Java Programming for First-time Programmers" if you need help in understanding this program

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

1

The expected outputs are

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

2

Comments

Comments are used to document and explain your code and your program logic. Comments are not programming statements. They are ignored by the compiler and have no consequences to the program execution. Nevertheless, comments are VERY IMPORTANT for providing documentation and explanation for others to understand your programs (and also for yourself three days later)

There are two kinds of comments in Java

Nhận xét nhiều dòng. begins with a

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

1 and ends with a

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

2, and can span multiple lines.

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

3 is a special documentation comment. These comment can be extracted to produce documentation

End-of-Line (Single-Line) Comment. begins with
```
"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
```
4 and lasts till the end of the current line

I recommend that you use comments liberally to explain and document your code

During program development, instead of deleting a chunk of statements irrevocably, you could comment-out these statements so that you could get them back later, if needed

Statements and Blocks

Statement. A programming statement is the smallest independent unit in a program, just like a sentence in the English language. It performs a piece of programming action. A programming statement must be terminated by a semi-colon (

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

5), just like an English sentence ends with a period. (Why not ends with a period like an English sentence? This is because period crashes with decimal point - it is challenging for the dumb computer to differentiate between period and decimal point in the early days of computing. )

For examples,

Block. A block is a group of programming statements surrounded by a pair of curly braces

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

6. All the statements inside the block is treated as one single unit. Blocks are used as the body in constructs like class, method, if-else and loop, which may contain multiple statements but are treated as one unit (one body). There is no need to put a semi-colon after the closing brace to end a compound statement. Empty block (i. e. , no statement inside the braces) is permitted

For examples,

White Spaces and Formatting Source Code

White Spaces. Blank, tab and newline are collectively called white spaces

You need to use a white space to separate two keywords or tokens to avoid ambiguity, e. g. ,

Java, like most of the programming languages, ignores extra white spaces. That is, multiple contiguous white spaces are treated as a single white space. Additional white spaces and extra lines are ignored, e. g. ,

Formatting Source Code. As mentioned, extra white spaces are ignored and have no computational significance. However, proper indentation (with tabs and blanks) and extra empty lines greatly improves the readability of the program. This is extremely important for others (and yourself three days later) to understand your programs

For example, the following one-line hello-world program works. But can you read and understand the program?

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

9

Braces. Java's convention is to place the beginning brace at the end of the line, and to align the ending brace with the start of the statement. Pair-up the { } properly. Unbalanced { } is one of the most common syntax errors for beginners

Indentation. Indent each level of the body of a block by an extra 3 or 4 spaces according to the hierarchy of the block. Don't use tab because tab-spaces is editor-dependent

"Code is read much more often than it is written. " Hence, you have to make sure that your code is readable (by others and yourself 3 days later), by following convention and recommended coding style

Variables and Types

Variables - Name, Type and Value

Computer programs manipulate (or process) data. A variable is used to store a piece of data for processing. It is called variable because you can change the value stored

More precisely, a variable is a named storage location, that stores a value of a particular data type. In other words, a variable has a name, a type and stores a value

Một biến có tên (còn gọi là mã định danh), e. g. ,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

7,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

8,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

9,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

30 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

31. The name is needed to uniquely identify and reference each variable. You can use the name to assign a value to the variable (e. g. ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

32) và để truy xuất giá trị được lưu trữ (e. g. ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

33)

Biến có kiểu dữ liệu. Các kiểu dữ liệu Java thường được sử dụng là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. có nghĩa là cho số nguyên (số nguyên) chẳng hạn như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

35 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

36

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37. có nghĩa là đối với số dấu phẩy động (số thực) có dấu thập phân tùy chọn và phần phân số, chẳng hạn như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

38,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

39,

java Xxx

00 hoặc

java Xxx

01, trong đó

java Xxx

02 hoặc

java Xxx

03 biểu thị số mũ của cơ số

java Xxx

04

```
java Xxx
```
05. dành cho các văn bản như
```
java Xxx
```
06 và
```
java Xxx
```
07.
```
java Xxx
```
05 được đặt trong một cặp dấu ngoặc kép
```
java Xxx
```
09. dành cho một ký tự đơn lẻ, chẳng hạn như
```
java Xxx
```
10,
```
java Xxx
```
11. Một
```
java Xxx
```
09 được bao quanh bởi một cặp dấu nháy đơn

Trong Java, bạn cần khai báo tên và kiểu biến trước khi sử dụng biến. Ví dụ như,

Biến có thể lưu 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 biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 có thể lưu trữ một giá trị số nguyên chẳng hạn như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

35, nhưng KHÔNG lưu trữ số dấu phẩy động chẳng hạn như

java Xxx

15 hoặc chuỗi chẳng hạn như

java Xxx

06

Khái niệm về kiểu đã đượ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 (
```
java Xxx
```
17's và
```
java Xxx
```
18's). Loại xác định kích thước và bố cục của dữ liệu, phạm vi giá trị của dữ liệu và tập hợp các thao tác có thể được áp dụng

Sơ đồ sau đây minh họa ba loại biến.

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 và

java Xxx

05. Biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 lưu trữ một số nguyên (hoặc số nguyên hoặc số điểm cố định);

Mã định danh (hoặc Tên)

Cần có một mã định danh để đặ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 đối với số nhận dạng

Mã định danh là một chuỗi ký tự, có độ dài bất kỳ, bao gồm chữ hoa và chữ thường
```
java Xxx
```
25, chữ số
```
java Xxx
```
26, dấu gạch dưới (
```
java Xxx
```
27) và ký hiệu đô la (
```
java Xxx
```
28)
Khoảng trắng (trống, tab, dòng mới) và các ký tự đặc biệt khác (chẳng hạn như ________ 829, ________ 830, ________ 831, _______ 832,
```
java Xxx
```
33,
```
java Xxx
```
34, dấu phẩy, v.v. ) không được cho phép. Hãy lưu ý rằng không được phép để trống và gạch ngang (
```
java Xxx
```
30), tôi. e. , "
```
java Xxx
```
36" và "______837" không phải là tên hợp lệ. (Điều này là do trống tạo ra hai mã thông báo và dấu gạch ngang gặp sự cố với dấu trừ. )
Mã định danh phải bắt đầu bằng chữ cái
```
java Xxx
```
25 hoặc dấu gạch dưới (
```
java Xxx
```
27). Nó không thể bắt đầu bằng một chữ số
```
java Xxx
```
26 (vì điều đó có thể gây nhầm lẫn với một số). Số nhận dạng bắt đầu bằng ký hiệu đô la (
```
java Xxx
```
28) được dành riêng cho các thực thể do hệ thống tạo

Mã định danh không thể là từ khóa dành riêng hoặc chữ dành riêng (e. g. ,

java Xxx

42,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

java Xxx

45,

java Xxx

46,

java Xxx

47,

java Xxx

48,

java Xxx

49,

java Xxx

50)

Mã định danh phân biệt chữ hoa chữ thường. Một
```
java Xxx
```
51 KHÔNG phải là một
```
java Xxx
```
52, và KHÔNG phải là một
```
java Xxx
```
53

ví dụ.

java Xxx

54,

java Xxx

55,

java Xxx

56,

java Xxx

57 là các định danh hợp lệ. Nhưng

java Xxx

58,

java Xxx

59,

java Xxx

60,

java Xxx

61 KHÔNG phải là số nhận dạng hợp lệ

thận trọng. Các 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ợ (e. g. , trong Java và C/C++), hoặc sẽ đặt ra cho bạn nhiều thử thách hơn

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

Tên biến là một danh từ hoặc một 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ừ. Chữ đầu viết thường, các chữ còn lại viết hoa. Ví dụ:

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

7,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

8,

java Xxx

64,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

31,

java Xxx

66,

java Xxx

67,

java Xxx

68,

java Xxx

69 và

java Xxx

70. Quy ước này còn được gọi là trường hợp lạc đà

khuyến nghị

Đ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, e. g. ,

java Xxx

71 hoặc

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

31, nhưng không phải là

java Xxx

73 hoặc

java Xxx

74, để lưu trữ số học sinh. Sử dụng chữ viết tắt là được

Không sử dụng những tên vô nghĩa như
```
java Xxx
```
75,
```
java Xxx
```
76,
```
java Xxx
```
77,
```
java Xxx
```
78,
```
java Xxx
```
79,
```
java Xxx
```
80,
```
java Xxx
```
73,
```
java Xxx
```
82,
```
java Xxx
```
83,
```
java Xxx
```
84,
```
java Xxx
```
85,
```
java Xxx
```
86 (mục đích của bài tập này là gì?) và
```
java Xxx
```
87 (Ví dụ này nói về cái gì?)
Tránh các tên có một chữ cái như
```
java Xxx
```
78,
```
java Xxx
```
79,
```
java Xxx
```
80,
```
java Xxx
```
75,
```
java Xxx
```
76,
```
java Xxx
```
77, dễ gõ hơn nhưng thường vô nghĩa. Ngoại lệ là các tên phổ biến như
```
java Xxx
```
74,
```
java Xxx
```
95,
```
java Xxx
```
96 cho tọa độ,
```
java Xxx
```
78 cho chỉ mục. Tên dài khó gõ hơn, nhưng hãy tự ghi lại chương trình của bạn. (Tôi khuyên bạn nên dành thời gian luyện tập đánh máy đôi khi. )
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 biến số ít và số nhiều. Ví dụ: bạn có thể sử dụng biến
```
java Xxx
```
98 để chỉ một số hàng và biến
```
java Xxx
```
99 để 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)

Sự định nghĩa 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 bộ nhớ có kích thước có khả năng chứa một giá trị của loại

Cú phápExampleint sum;
trung bình nhân đôi;
Trạng thái chuỗiMsg;int number, count;
tổng nhân đôi, chênh lệch . 14169265;
String helloMsg, gameOverMsg;
int magicNumber = 99;
double pi = 3.14169265;
Chuỗi helloMsg = "xin chào,";
int sum = 0, product = 1;
double height = 1. 2, chiều dài = 3. 45;
Chuỗi lời chàoMsg = "xin chào. ", quitMsg = "tạm biệt. ";

lưu ý rằng

Một biến được khai báo với kiểu. Một khi kiểu của một biến được khai báo, nó chỉ có thể lưu trữ một giá trị thuộc kiểu cụ thể đó. Ví dụ: một biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 chỉ có thể chứa số nguyên (chẳng hạn như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

35) và KHÔNG chứa số dấu phẩy động (chẳng hạn như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

002) hoặc chuỗi văn bản (chẳng hạn như

java Xxx

06)

Mỗi biến chỉ được khai báo một lần vì định danh 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
Không thể thay đổi kiểu của biến trong chương trình khi nó đã được khai báo
Một câu lệnh khai báo biến bắt đầu bằng một kiểu và chỉ có tác dụng với kiểu đó. Nói cách khác, bạn không thể khai báo các biến có hai kiểu khác nhau trong một câu lệnh khai báo.
Java là một ngôn ngữ kiểu tĩnh. Điều này có nghĩa là loại được giải quyết tại thời điểm biên dịch và không bao giờ thay đổi

Hằng số (_______1004 biến)

Hằng là biến không thể thay đổi (immutable), được khai báo với từ khóa

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

004. Bạn chỉ có thể gán giá trị cho các biến cuối cùng MỘT LẦN. 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ư

Quy ước đặt tên không đổi. Sử dụng các từ viết hoa, nối với dấu gạch dưới. Ví dụ:

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

006,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

007 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

008

Biểu thức

Một biểu thức là sự kết hợp của các toán tử (chẳng hạn như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

010) và toán hạng (biến hoặc ký tự), có thể được đánh giá để mang lại một giá trị duy nhất thuộc một loại nhất định

Ví dụ,

Bài tập (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

011)

Một câu lệnh gán đánh giá RHS (Phía bên phải) và gán giá trị kết quả cho biến của LHS (Phía bên trái)

Cú pháp của câu lệnh gán là

Cú phápExampleint number;
number = 9;int sum = 0, number = 8;
sum = sum + number;

Câu lệnh gán nên được diễn giải theo cách này. Biểu thức trên RHS trước tiên được đánh giá để tạo ra một giá trị kết quả (được gọi là giá trị r hoặc giá trị phải). Giá trị r sau đó được gán cho biến ở phía bên trái (LHS) hoặc giá trị l. 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ư,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

012 là Phân công, KHÔNG Bình đẳng

Trong Java, ký hiệu bằng _______1012 được gọi là toán tử gán. Ý nghĩa của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

012 trong 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 giữa RHS và LHS. RHS phải là một giá trị bằng chữ hoặc một biểu thức đánh giá một giá trị;

Lưu ý rằng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

015 hợp lệ (và thường được sử dụng) trong lập trình. Nó đánh giá biểu thức RHS

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

016 và gán giá trị kết quả cho biến LHS

java Xxx

74. Mặt khác,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

015 là bất hợp pháp trong Toán học

Mặc dù

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

019 được cho phép trong Toán học, nhưng 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 "

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

020", "

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

021" hoặc "

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

022" làm toán tử gán để tránh nhầm lẫn với đẳng thức

Các loại nguyên thủy và java Xxx 05

In Java, there are two broad categories of data types

Các loại nguyên thủy (e. g. ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37),

Các loại tài liệu tham khảo (e. g. , đối tượng và mảng)

Chúng ta sẽ mô tả các loại nguyên thủy ở đây. Chúng ta sẽ đề cập đến các loại tham chiếu (lớp và đối tượng) trong các chương sau về "Lập trình hướng đối tượng"

Các loại nguyên thủy tích hợp

TYPEDESCRIPTIONbyteInteger số nguyên có dấu 8 bit
Phạm vi là ____1026số nguyên có dấu 16 bit ngắn
Phạm vi là ____1027int số nguyên có dấu 32 bit
The range is

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

028 (≈9 digits, ±2G)long64-bit signed integer
The range is

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

029 (≈19 digits)floatFloating-Point
Number
F x 2E32-bit single precision floating-point number
(

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

0306-7 significant decimal digits, in the range of

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

031)double64-bit double precision floating-point number
(

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

03014-15 significant decimal digits, in the range of

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

033)charCharacter
Represented in 16-bit Unicode

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

034 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

035.
Có thể được coi là số nguyên trong phạm vi

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036 trong các phép toán số học.
(Không giống như C/C++, sử dụng mã ASCII 8-bit. )booleanBinary
Lấy giá trị theo nghĩa đen là

java Xxx

48 hoặc

java Xxx

49.
Kích thước của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 không được xác định trong đặc tả Java, nhưng yêu cầu ít nhất một bit.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s được sử dụng trong thử nghiệm trong quyết định và vòng lặp, không áp dụng cho các hoạt động số học.
(Không giống như C/C++, sử dụng số nguyên

java Xxx

17 cho giá trị sai và giá trị khác 0 cho giá trị đúng. )

Kiểu nguyên thủy được tích hợp sẵn trong ngôn ngữ để đạt hiệu quả tối đa, cả về không gian và hiệu suất tính toán.

Java có tám kiểu nguyên thủy, như được liệt kê trong bảng trên

Có bốn loại số nguyên. 8-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042, 16-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043, 32-bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 và 64-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045. Chúng là các số nguyên có dấu trong biểu diễn phần bù của 2 và có thể chứa giá trị số nguyên bằng 0, dương và âm trong 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

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 và độ chính xác kép 64 bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37. Chúng được thể hiện bằng ký hiệu khoa học của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

048 trong đó phân số (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

049) và số mũ (

java Xxx

03) được lưu trữ riêng biệt (như được chỉ định bởi tiêu chuẩn IEEE 754). Hãy lưu ý rằng không phải tất cả các số thực đều có thể được biểu diễn bằng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37. Điều này là do có vô số số thực ngay cả trong một phạm vi nhỏ chẳng hạn như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

053, 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 được xấp xỉ với biểu diễn gần nhất của chúng

Loại

java Xxx

09 đại diện cho một ký tự đơn, chẳng hạn như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056,

java Xxx

10. Trong Java,

java Xxx

09 được biểu diễn bằng Unicode 16 bit (ở định dạng UCS-2) để hỗ trợ quốc tế hóa (i18n). Một

java Xxx

09 có thể được coi là một số nguyên trong phạm vi của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036 trong các phép toán số học. Ví dụ, ký tự

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

062 (thập phân) hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

063 (thập lục phân);

Java giới thiệu một loại nhị phân mới có tên là "

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039", loại này nhận giá trị bằng chữ là

java Xxx

48 hoặc

java Xxx

49.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s được sử dụng trong thử nghiệm trong quyết định và vòng lặp. Chúng không áp dụng được cho các phép tính số học (chẳng hạn như phép cộng và phép nhân)

Số nguyên so với. Số dấu phẩy động

Trong lập trình máy tính, số nguyên (chẳng hạn như 123, -456) và số dấu phẩy động (chẳng hạn như 1. 23, -4. 56, 1. 2e3, -4. 5e-6) HOÀN TOÀN khác nhau

Số nguyên và số dấu phẩy động được biểu diễn và lưu trữ khác nhau
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?

Các số nguyên được biểu diễn dưới dạng lược đồ phần bù 2 như minh họa. Bit quan trọng nhất được gọi là Sign Bit (________ 1074), trong đó _________ 1075 đại diện cho số nguyên dương và ________ 1076 đạ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, e. g. , nếu

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

077 (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043),

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

079 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

080. Số nguyên âm yêu cầu chuyển đổi bổ sung của 2

Các số dấu phẩy động được biểu diễn dưới dạng khoa học của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

048, trong đó Phân số (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

049) và Số mũ (

java Xxx

03) được lưu trữ riêng. Ví dụ, để lưu trữ

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

084;

Để 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. Số nguyên được xử lý trong CPU (Bộ xử lý trung tâm), trong khi số dấu phẩy động được xử lý trong FPU (Bộ đồng xử lý dấu phẩy động)

Hoạt động số nguyên là thẳng về phía trước. Ví dụ, phép cộng số nguyên được thực hiện như minh họa

Mặt khác, phép cộng dấu phẩy động rất phức tạp, như minh họa

Rõ ràng là các phép toán số nguyên (chẳng hạ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 biểu diễn chính xác. Ví dụ:

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 32 bit có thể biểu thị TẤT CẢ các số nguyên từ

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

090 đến

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

091 mà khô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ó vô số số dấu phẩy động trong bất kỳ khoảng nào (e. g. , giữa 0. 1 đến 0. 2). Không phải TẤT CẢ các số đều có thể được biểu diễn bằng độ chính xác hữu hạn (32-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 hoặc 64-bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37)

Bạn cần coi số nguyên và số Dấu phẩy động là hai loại DISTINCT trong lập trình

Sử dụng số nguyên nếu có thể (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 cần có phần phân số

Sự miêu tả dữ liệu

Đọc "Biểu diễn dữ liệu - Số nguyên, số dấu phẩy động và ký tự" nếu bạn muốn hiểu cách các số và ký tự được biểu diễn bên trong bộ nhớ máy tính

Tóm lại, điều quan trọng cần lưu ý là

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 khác với

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

18,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042

java Xxx

18,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043

java Xxx

18,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

103,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

103 và

java Xxx

05

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

107. Chúng được thể hiện khác nhau trong bộ nhớ máy tính, với độ chính xác và diễn giải khác nhau. Chúng cũng được xử lý khác nhau. Ví dụ như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042

java Xxx

18 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

110 (8-bit)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043

java Xxx

18 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

113 (16-bit)

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

18 is

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

116 (32-bit)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045

java Xxx

18 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

119 (64-bit)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

103 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

122 (32-bit)

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

103 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

125 (64-bit)

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

128 (16-bit) (số Unicode 49)

java Xxx

05

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

107 là một đối tượng phức tạp (nhiều bit)

Có một sự khác biệt tinh tế giữa

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

17 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

134 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

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

116 không thể được giải thích trừ khi bạn biết loại của nó (hoặc biểu diễn của nó)

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 có thể được sử dụng để in giá trị lớn nhất, nhỏ nhất và độ dài bit của các kiểu nguyên thủy. Ví dụ: kích thước tối đa, tối thiểu và bit của

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 được giữ trong các hằng số tích hợp sẵn

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

137,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

138,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

139

Một loại quan trọng hơn -

java Xxx

05

Bên cạnh 8 kiểu nguyên thủy, một kiểu quan trọng và thường được sử dụng khác là

java Xxx

05. Một

java Xxx

05 là một chuỗi các ký tự (văn bản) chẳng hạn như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

143.

java Xxx

05 không phải là kiểu nguyên thủy (điều này sẽ được giải thích sau)

Trong Java, một

java Xxx

09 là một ký tự đơn được đặt trong dấu nháy đơn (e. g. , ________ 1056, ________ 1055, ________ 1148); . g. ,

java Xxx

06)

Ví dụ,

Lựa chọn kiểu dữ liệu cho các biến

Là một lập trình viên, BẠN cần quyết định loại biến sẽ được sử dụng trong chương trình của mình. Hầu hết thời gian, quyết định là trực quan. Ví dụ: sử dụng kiểu số nguyên để đếm và số nguyê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 thuộc các loại KHÁC NHAU

Quy tắc ngón tay cái để chọn loại dữ liệu

Đối với số, hãy sử dụng 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ù các số dấu phẩy động bao gồm các số nguyên (e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

103,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

155,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

156), số dấu phẩy động là số gần đúng (không chính xác) và yêu cầu nhiều tài nguyên hơn (tính toán và lưu trữ) cho các thao tác

Mặc dù có 4 kiểu số nguyên. 8-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042, 16-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043, 32-bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 và 64-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045, chúng ta sẽ sử dụng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 cho các số nguyên nói chung. Chỉ sử dụng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 nếu bạn có lý do chính đáng để chọn độ chính xác cụ thể đó

Trong số đó có hai loại dấu chấm động. 32-bit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 và 64-bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, chúng ta sẽ sử dụng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 nói chung. Chỉ sử dụng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 nếu bạn muốn tiết kiệm dung lượng lưu trữ và không cần độ chính xác của

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

java Xxx

09,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 và

java Xxx

05 có cách sử dụng cụ thể

Ví dụ (Tên và loại biến). Paul đã mua một chiếc máy tính xách tay mới mang nhãn hiệu "thần tượng", với bộ vi xử lý tốc độ 2. 66GHz, RAM 8 GB, ổ cứng 500 GB, màn hình 15 inch, giá 1760 USD. 55. 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 bảo dưỡng tại chỗ nhưng không chọn bảo hành mở rộng. Xác định các kiểu dữ liệu và đặt tên cho các biến

Các tên và loại biến có thể là

Bài tập (Tên và loại biến). Bạn được yêu cầu phát triển một phần mềm cho một 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 (e. g. , B. Sc. , B. A. ), năm học, điểm trung bình trung bình, có/không trợ cấp học phí, có/không phải là học giả. Each student is assigned a unique 8-digit number as id.
Bạn được yêu cầu xác định các biến, đặt tên phù hợp cho từng biến và chọn loại phù hợp. Viết các câu lệnh khai báo biến như trong ví dụ trên.

Literals cho các loại nguyên thủy và

java Xxx

05

Hằng số theo nghĩa đen hoặc theo nghĩa đen là một giá trị hằng số cụ thể, chẳng hạn như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

35,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

36,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

17616,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

177,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

178,

java Xxx

10,

java Xxx

06, đượ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; . Chúng được gọi là nghĩa đen vì chúng xác định giá trị của chúng theo nghĩa đen và rõ ràng. Chúng tôi gọi nó là nghĩa đen để phân biệt nó với một biến

Số nguyên (

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042) chữ

Một số nguyên, chẳng hạn như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

35 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

36, được coi là một

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 theo mặc định. Ví dụ,

Một chữ

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 có thể đứng trước dấu cộng (

java Xxx

29) hoặc dấu trừ (

java Xxx

30), theo sau là chữ số. Không có dấu phẩy hoặc ký hiệu đặc biệt (e. g. ,

java Xxx

28,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

192, hoặc dấu cách) được phép (e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

193,

java Xxx

56 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

195 không hợp lệ)

Bạn có thể sử dụng tiền tố

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 (không) để biểu thị giá trị số nguyên theo hệ bát phân và tiền tố

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

197 (hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

198) cho giá trị theo hệ thập lục phân, e. g. ,

Từ JDK 7, bạn có thể sử dụng tiền tố '

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

199' hoặc '

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

200' để chỉ định một giá trị số nguyên ở dạng nhị phân. Bạn cũng được phép sử dụng dấu gạch dưới (

java Xxx

27) để chia các chữ số thành các nhóm 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ữ số, không phải dấu gạch dưới. Ví dụ,

Một chữ

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 bên ngoài phạm vi

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 yêu cầu hậu tố

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

204 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

205 (tránh chữ thường

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

205, có thể bị nhầm lẫn với số một

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095), e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

208,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

209. Ví dụ,

Không cần hậu tố cho

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 theo nghĩa đen. Nhưng bạn chỉ có thể sử dụng các giá trị trong phạm vi cho phép. Ví dụ,

Dấu phẩy động (

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046) chữ

Một số bằng chữ có dấu thập phân, chẳng hạn như

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

214 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

215, được coi là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 theo mặc định. Bạn cũng có thể diễn đạt chúng bằng ký hiệu khoa học, e. g. ,

java Xxx

00,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

218, trong đó

java Xxx

02 hoặc

java Xxx

03 biểu thị số mũ trong cơ số 10. Bạn có thể đặt dấu cộng (_______ 829) hoặc dấu trừ (_______ 830) trước phần phân số của số mũ. Giá trị số mũ được giới hạn ở số nguyên. Không được có khoảng trắng hoặc các ký tự khác trong số

Bạn được nhắc rằng các số dấu phẩy động được lưu trữ ở dạng khoa học của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

048, trong đó

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

049 (Phân số) và

java Xxx

03 (Số mũ) được lưu trữ riêng

Bạn có thể tùy chọn sử dụng hậu tố

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

226 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

227 để biểu thị

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 chữ

Bạn PHẢI sử dụng hậu tố

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

229 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

230 cho

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 chữ, e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

232. Ví dụ,

Nhân vật (

java Xxx

09) Literals và Escape Sequences

Một chữ

java Xxx

09 có thể in được (chẳng hạn như chữ cái, chữ số và ký hiệu đặc biệt) được viết bằng cách kèm theo ký tự với một cặp dấu nháy đơn, e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

236,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

238,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

148 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

240. Các ký tự

java Xxx

09 đặc biệt (chẳng hạn như tab, dòng mới) được biểu diễn bằng cách sử dụng cái gọi là chuỗi thoát (sẽ được mô tả sau)

Trong Java, các

java Xxx

09 được biểu diễn bằng Unicode 16-bit. Các ký tự in được cho chữ cái tiếng Anh (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

243,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

244), chữ số (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

245) và ký hiệu (

java Xxx

29,

java Xxx

30,

java Xxx

33, v.v. ) được gán cho mã số 32-126 (20H-7EH), như bảng dưới đây (sắp xếp theo hệ thập phân và hệ thập lục phân)

Dec01234567893SP!"#$%&'4()*+,-./01523456789:;6<=>[email protected][\]^_`abc10defghijklm11nopqrstuvw12xyz{|}~Hex0123456789ABCDEF2SP!"#$%&'()*+,-./30123456789:;<=>[email protected][\]^_6`abcdefghijklmno7pqrstuvwxyz{|}~

Trong Java, một

java Xxx

09 có thể được coi là số nguyên cơ bản của nó trong phạm vi của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036 trong các phép toán số học. Nói cách khác,

java Xxx

09 và số nguyên có thể hoán đổi cho nhau trong các phép tính số học. Bạn có thể coi một

java Xxx

09 là một

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

253, bạn cũng có thể gán một giá trị số nguyên trong khoảng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036 cho một biến

java Xxx

09. Ví dụ,

Các ký tự đặc biệt được biểu diễn bằng cái gọi là chuỗi thoát, bắt đầu bằng dấu gạch chéo ngược (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

256) theo sau là một mẫu, e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

257 cho tab,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

258 cho dòng mới. Các trình tự thoát thường được sử dụng là

Escape
SequenceDescriptionUnicode
(Decimal)Unicode
(Hex)\tTab90009H\nNewline (hoặc Line-feed . e. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

261)--\Dấu gạch chéo ngược (Cần thiết vì dấu gạch chéo ngược có ý nghĩa đặc biệt)--\uhhhhSố Unicode

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

262 (ở dạng hex), e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

263 is 您,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

264 is 好-hhhhH

For examples,

java Xxx

05 Literals và Escape Sequences

Một

java Xxx

05 là một chuỗi các ký tự. Một chữ ________ 805 bao gồm 0 hoặc nhiều ký tự được bao quanh bởi một cặp dấu ngoặc kép. Ví dụ như,

Bạn cần sử dụng một chuỗi thoát cho các ký tự đặc biệt không in được, chẳng hạn như dòng mới (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

258) và tab (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

257). Bạn cũng cần sử dụng chuỗi thoát cho dấu ngoặc kép (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

270) và dấu gạch chéo ngược (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

271) do xung đột. Ví dụ như,

Dấu nháy đơn (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

272) bên trong

java Xxx

05 không yêu cầu trình tự thoát vì không có sự mơ hồ, e. g. ,

Điều quan trọng cần lưu ý là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

257 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

270 là MỘT ký tự đơn, KHÔNG PHẢI HAI

Tập thể dục. Viết chương trình in hình con vật sau sử dụng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

276. Hãy lưu ý rằng bạn cần sử dụng các chuỗi thoát để in một số ký tự, e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

270 cho

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

278,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

271 cho

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

256

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

14

Cuối Dòng (EOL)

Dòng mới (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

281) và Carriage-Return (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

282), được biểu thị bằng chuỗi thoát lần lượt là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

258 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

284, đượ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

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

258 (______1281) làm EOL, trong khi Windows sử dụng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

287 (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

288)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 Nghĩa đen

Chỉ có hai

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 chữ, tôi. e. ,

java Xxx

48 và

java Xxx

49. Ví dụ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

Ví dụ về chữ

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

293 - Suy luận kiểu biến cục bộ (JDK 10)

JDK 10 giới thiệu một cách mới để khai báo biến thông qua từ khóa mới

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

293, ví dụ:

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ó

Hoạt động cơ bản

toán tử số học

Java hỗ trợ các phép toán số học nhị phân/đơn hạng sau

Toán tửModeUsageDes mô tảVí dụ+Nhị phân
Phép cộng đơn nguyên

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

295
Dương đơn vị

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

296-Nhị phân
Phép trừ đơn nguyên

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

297
. 0 / 2. 0 ⇒ 0. 5%Nhị phân

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

902Modulus (Phần còn lại)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

903
1.0 / 2.0 ⇒ 0.5%Binary

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

902Modulus (Remainder)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

903

Các toán tử này thường là các toán tử trung tố nhị phân, i. e. , they take two operands with the operator in between the operands (e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

904). Tuy nhiên,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

010 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 cũng có thể được hiểu là toán tử tiền tố "phủ định" và "dương" đơn hạng, với toán tử ở phía trước toán hạng. Ví dụ như,

biểu thức số học

Trong lập trình, biểu thức số học sau

phải được viết là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

907. Bạn không thể bỏ dấu nhân (

java Xxx

31) như trong môn Toán

Quy định về quyền ưu tiên

Thích Toán học

Dấu ngoặc đơn

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

909 có mức độ ưu tiên cao nhất và có thể được sử dụng để thay đổi thứ tự đánh giá

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

010 đơn nguyên (phủ định) và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 (dương tính) có mức độ ưu tiên cao hơn tiếp theo

Phép nhân (

java Xxx

31), phép chia (

java Xxx

32) và mô đun (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

192) có cùng mức độ ưu tiên. Chúng được ưu tiên hơn phép cộng (

java Xxx

29) và phép trừ (

java Xxx

30). Ví dụ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

917 được hiểu là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

918

Trong cùng một mức độ ưu tiên (i. e. , cộng/trừ và nhân/chia/mô đun), biểu thức được đánh giá từ trái sang phải (được gọi là liên kết trái). Ví dụ:

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

919 được đánh giá là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

920 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

921 là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

922

Loại chuyển đổi trong hoạt động số học

Chương trình của bạn thường chứa dữ liệu thuộc nhiều loại, chẳng hạn như. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

923 và ________ 1924 là ________ 234, ________ 1926 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

927 là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, và _______ 1929 là

java Xxx

05. Do đó, điều quan trọng là phải hiểu cách Java xử lý các loại trong chương trình của bạn.

Các toán tử số học (

java Xxx

29,

java Xxx

30,

java Xxx

31,

java Xxx

32,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

192) chỉ áp dụng cho các kiểu số nguyên thủy.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 và

java Xxx

09. Chúng không áp dụng cho

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039

Toán tử cùng loại của

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

Nếu CẢ HAI toán hạng là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 hoặc

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, thì các phép toán số học nhị phân được thực hiện trong loại đó và đánh giá thành giá trị của loại đó, i. e. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

952, trong đó

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

953 biểu thị một toán tử số học nhị phân như

java Xxx

29,

java Xxx

30,

java Xxx

31,

java Xxx

32,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

192

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

959

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

960

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

961

Phòng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

Điều quan trọng cần lưu ý là bộ phận

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 tạo ra một

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, tôi. e. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

965

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, với kết quả bị cắt ngắn. Ví dụ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

967 (

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34), nhưng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

969 (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

970)

Toán hạng cùng loại của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

java Xxx

09. Chuyển đổi thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

Nếu CẢ HAI toán hạng là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 hoặc

java Xxx

09, thì các phép toán nhị phân được thực hiện trong

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 và đánh giá thành giá trị của

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. Một

java Xxx

09 được coi là một số nguyên của số Unicode cơ bản của nó trong phạm vi

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036. Đó là,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

982, trong đó

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

953 biểu thị một toán tử số học nhị phân như

java Xxx

29,

java Xxx

30,

java Xxx

31,

java Xxx

32,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

192

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

989

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

990

Hãy lưu ý rằng KHÔNG phép toán số học nào được thực hiện trong

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 hoặc

java Xxx

09

For examples,

Tuy nhiên, nếu các toán tử số học phức hợp (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

994,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

995,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

996,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

997,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

998) (sẽ được thảo luận sau) được sử dụng, thì kết quả sẽ tự động được chuyển đổi thành LHS. Ví dụ,

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 thăng cấp thành loại lớn hơn (được gọi là ép kiểu ẩn). The operation is then carried out in the larger type, and evaluated to a value in the larger type

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 hoặc

java Xxx

09 lần đầu tiên được thăng cấp thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 trước khi so sánh với loại của toán hạng khác. (Trong Java, không có hoạt động nào được thực hiện trong

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 hoặc

java Xxx

09. )

Thứ tự khuyến mãi là.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1406

For examples,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1407. Do đó,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1408

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1409 (Chắc bạn không ngờ câu trả lời này. )

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1410 (Kết quả là một

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, cần chuyển rõ ràng về

java Xxx

09

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1413 nếu muốn. )

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1414

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1415

Bản tóm tắt. Quy tắc chuyển đổi loại cho hoạt động nhị phân

Các quy tắc tăng loại cho các hoạt động nhị phân có thể được tóm tắt như sau

Nếu một trong các toán hạng là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, thì toán hạng kia được thăng cấp thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37;

mặt khác nếu một trong các toán hạng là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046, thì toán hạng kia được thăng cấp thành

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046;

mặt khác nếu một trong các toán hạng là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045, thì toán hạng kia được thăng cấp thành

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045;

mặt khác cả hai toán hạng được thăng cấp thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

Bản tóm tắt. Quy tắc chuyển đổi loại cho hoạt động đơn nguyên

Các quy tắc khuyến mãi loại cho các hoạt động đơn nguyên (e. g. , phủ định

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

010) có thể được tóm tắt như sau

Nếu toán hạng là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 hoặc

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 thì không có khuyến mãi;

mặt khác toán hạng là

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

java Xxx

09, toán hạng được thăng cấp thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

Tìm hiểu thêm về Toán tử số học

Toán tử Modulus (Phần còn lại)

Để đánh giá phần còn lại cho toán hạng âm và dấu phẩy động, hãy 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ụ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1432

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1433

Số mũ?

Java không có toán tử số mũ. (Toán tử

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1434 biểu thị loại trừ-hoặc, KHÔNG phải số mũ). Bạn cần sử dụng phương pháp JDK

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1435 để đánh giá mức tăng của

java Xxx

74 đối với sức mạnh của

java Xxx

95;

Tràn/Chảy tràn

Nghiên cứu đầu ra của chương trình sau

In arithmetic operations, the resultant value wraps around if it exceeds its range (i. e. , tràn ra). 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 ngắn và dẫn đến cái gọi là dòng dưới. Ví dụ:

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1438 cho

java Xxx

17, thay vì

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1440. Mộ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ôi. e. , công việc của bạn

Tại sao máy tính không báo lỗi tràn/tràn là lỗi? . Kiểm tra tràn/tràn tiêu tốn năng lượng tính toán. Ngày nay, bộ vi xử lý rất 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), vì í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. mã hóa an toàn. chứng chỉ. tổ chức

Thông tin thêm về Số nguyên so với. Số dấu phẩy động

Số nguyên (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045) là số chính xác (exact). Nhưng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 không chính xác nhưng gần đúng. Nghiên cứu kết quả của chương trình sau

Luôn sử dụng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 nếu bạn không cần phần phân số, mặc dù

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 cũng có thể đại diện cho hầu hết các số nguyên (e. g. ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

103,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

155,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

156). Điều này là do

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 hiệu quả hơn (nhanh hơn) so với

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 trong các phép tính số học

32-bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 chiếm ít dung lượng bộ nhớ hơn 64-bit

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 chính xác (chính xác) trong việc biểu diễn TẤT CẢ các số nguyên trong phạm vi của nó.

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 là một giá trị gần đúng - KHÔNG PHẢI TẤT CẢ các giá trị số nguyên đều có thể được biểu thị bằng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

loại đúc

Trong Java, bạn sẽ gặp lỗi biên dịch ". loại không tương thích. chuyển đổi mất mát có thể xảy ra từ

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1459 thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34" nếu bạn cố gắng gán giá trị

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 cho một biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. Điều này là do phần phân số sẽ bị cắt bớt và bị mất. Ví dụ,

Toán tử đúc kiểu và đúc kiểu rõ ràng

Để gán giá trị

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 cho một biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, bạn cần gọi cái gọi là toán tử ép kiểu - ở dạng

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1467 - để hoạt động trên toán hạng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 và trả về một giá trị bị cắt bớt trong

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. Nói cách khác, bạn nói với trình biên dịch rằng bạn thực hiện việc cắt ngắn một cách có ý thức và bạn hoàn toàn nhận thức được "sự chuyển đổi mất dữ liệu có thể xảy ra". Sau đó, bạn có thể gán giá trị

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 bị cắt ngắn cho biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. For example,

Truyền kiểu là một thao tác lấy 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 đã chỉ định. Cú pháp là

Có hai loại ép kiểu trong Java

Truyền kiểu rõ ràng thông qua toán tử truyền kiểu, như được mô tả ở trên và
Việc truyền kiểu ngầm định được thực hiện bởi trình biên dịch một cách tự động, nếu không làm giảm độ chính xác

Truyền kiểu ngầm định trong bài tập

Không bắt buộc phải truyền kiểu rõ ràng nếu bạn gán giá trị

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 cho biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, vì không làm mất độ chính xác. Trình biên dịch sẽ tự động thực hiện ép kiểu (i. e. , truyền kiểu ẩn). Ví dụ,,

Sơ đồ sau đây cho thấy thứ tự ép kiểu ẩn được thực hiện bởi trình biên dịch. Quy tắc là tăng 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. Thu hẹp chuyển đổi yêu cầu truyền kiểu rõ ràng để thông báo cho trình biên dịch rằng bạn biết về khả năng mất độ chính xác có thể xảy ra. Hãy lưu ý rằng

java Xxx

09 được coi là một số nguyên trong phạm vi của

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036. Giá trị

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 không thể được nhập kiểu (i. e. , được chuyển đổi thành không phải ______1039)

Thí dụ. Giả sử bạn muốn tìm giá trị trung bình (trong

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37) của các số nguyên đang chạy từ

java Xxx

18 và

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1480. Nghiên cứu đoạn mã sau

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

926 của

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1482 không chính xác. Điều này là do cả

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

924 và

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1480 đều là

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. Kết quả của

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1486 là một

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, sau đó được chuyển hoàn toàn thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 và gán cho biến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

926. Để có câu trả lời đúng, bạn có thể làm một trong hai

Toán tử gán hợp chất

Bên cạnh toán tử gán đơn thông thường (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

011) được mô tả trước đó, Java cũng cung cấp cái gọi là toán tử gán phức hợp như được liệt kê

OperationModeUsageDescriptionExample=Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1492Assignment
Gán giá trị LHS cho biến RHS

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1493+=Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1494
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1495Phép cộng và phép gán

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1496
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1497-=Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1498
same as.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1499Compound subtraction and assignment

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

00
same as.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

01*=Nhị phân____302
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

03Phép nhân và phép gán

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

04
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

05/=Nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

06
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

07Phân chia hợp chất và phép gán

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

08
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

09%=Nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

10
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

11Mô đun hợp chất (phần dư) và phép gán

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

12
giống như.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

13

Một sự khác biệt tinh tế giữa các toán tử đơn giản và phức hợp là trong các phép toán nhị phân

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

java Xxx

09. Ví dụ như,

Tăng giảm

Java hỗ trợ các toán tử số học đơn nguyên này. tăng (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

17) và giảm (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

18) cho tất cả các loại số nguyên thủy (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

java Xxx

09,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, ngoại trừ

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039). Các toán tử một ngôi 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ác toán tử này đã được giới thiệu trong C++ để viết tắt

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

27 thành

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

28 hoặc

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

29

OperatorModeUsageDescriptionExample++
(Increment)Unary Prefix
Unary Postfix

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

30Tăng giá trị của toán hạng lên 1.
______328or

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

29 giống như

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

33or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

015--
(Decrement)Unary Prefix
Unary Postfix

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

35Giảm giá trị của toán hạng đi 1.
______336or

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

37 giống như

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

38or

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

39

Số tăng (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

17) và số giảm (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

18) 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ụ:

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

29 truy xuất 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

Không giống như toán tử một ngôi khác (chẳng hạn như phủ định (

java Xxx

30)) thúc đẩy

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 và

java Xxx

09 thành

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, phần tăng và phần giảm 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ử một ngôi 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ố), điều này có thể ảnh hưởng đến kết quả

Nếu các toán tử này được sử dụng riêng (độc lập) trong một câu lệnh (e. g. ,
```
boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;
```
28; . Xem các ví dụ trên
Nếu
```
boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;
```
17 hoặc
```
boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;
```
18 liên quan đến một hoạt động khác trong câu lệnh CÙNG, e. g. ,
```
boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;
```
52 hoặc
```
boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;
```
53 khi có hai thao tác trong cùng một câu lệnh. gán và tăng, sau đó đặt hàng trước hoặc sau là điều 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)Increment var và trả về var tăng
cho thao tác khác trong cùng một câu lệnh.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

53

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

55var++
(Tăng sau)Trả về giá trị cũ của var cho thao tác khác
trong cùng một câu lệnh, sau đó tăng var.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

52

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

57--var
(Giảm trước)Giảm var và trả lại var
đã giảm cho thao tác khác trong cùng một câu lệnh.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

58

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

59var--
(Post-Decrement)Return the old value of var for the other operation
in the same statement, then decrement var.

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

60

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

61

For examples,

ghi chú

Toán tử tiền tố (e. g. ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

62) có thể hiệu quả hơn toán tử hậu tố (e. g. ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

63)?

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

64 là gì?

Toán tử quan hệ và logic

Rất thường xuyên, bạn cần so sánh hai giá trị trước khi quyết định thực hiện hành động, e. g. nếu dấu lớn hơn hoặc bằng 50, hãy in "ĐẠT. "

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 đều là toán tử nhị phân (có hai toán hạng) và trả về giá trị

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 của

java Xxx

48 hoặc

java Xxx

49

Toán tửModeUsageMô tảVí dụ (x=5, y=8)==Nhị phân____368Bằng với

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

69. =Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

70Không bằng

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

71>Nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

72Lớn hơn

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

73>=Nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

74Lớn hơn hoặc bằng

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

75boolean done = true; boolean gameOver = false; boolean isValid; isValid = false;76Nhỏ hơn

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

77<=Nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

78Nhỏ hơn hoặc bằng

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

79

Lưu ý rằng các toán tử so sánh là các toán tử trung tố 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, e. g. ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

80. Không hợp lệ để viết

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

81 (hoạt động không nhị phân). Thay vào đó, bạn cần tách hai phép toán so sánh nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

82,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

83 và nối với toán tử logic AND, i. e. ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

84, trong đó

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

85 biểu thị toán tử AND

Java cung cấp bốn toán tử logic, chỉ hoạt động trên toán hạng

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039, theo thứ tự ưu tiên giảm dần, như sau

Toán tửChế độSử dụngMô tảVí dụ. Unary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

87Logical NOT&&Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

88Logic AND. Nhị phân

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

89Logic OR^Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

90Logical Exclusive-OR (XOR)

Các bảng sự thật như sau

KHÔNG PHẢI

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

91truefalseResultfalsetrue
VÀ

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

92truefalsetruetruefalsefalsefalsefalse
HOẶC

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

93truefalsetruetruetruetruefalsetruefalse
XOR

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

94truefalsetruefalsetruefalsetruefalse

ví dụ

Tập thể dục. Nghiên cứu chương trình sau và giải thích đầu ra của nó

Viết biểu thức cho tất cả nam giới chưa lập gia đình, tuổi từ 21 đến 35, với chiều cao trên 180 và cân nặng từ 70 đến 80

Tập thể dục. Cho trước

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

95,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

96 (1-12) và

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

97 (1-31), hãy viết biểu thức

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 trả về

java Xxx

48 cho các ngày trước ngày 15 tháng 10 năm 1582 (ngày chuyển tiếp theo lịch Gregorian)

Ans.

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

00

So sánh bình đẳng

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

01

Bạn có thể sử dụng

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

01 để so sánh hai số nguyên (________ 1042, ________ 1043, ______ 234, ________ 1045) và

java Xxx

09. Nhưng KHÔNG sử dụng

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

01 để so sánh hai số dấu phẩy động (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 và

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37) vì chúng KHÔNG chính xác. Để so sánh các số dấu phẩy động, hãy đặt ngưỡng cho sự khác biệt của chúng, e. g. ,

Bạn cũng KHÔNG THỂ sử dụng

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

01 để so sánh hai

java Xxx

05 vì

java Xxx

05 là đối tượng. Bạn cần sử dụng

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

14 để thay thế. Điều này sẽ được giải thích sau

Ưu tiên toán tử logic

Thứ tự ưu tiên từ cao nhất đến thấp nhất là.

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

15 (đơn vị),

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

16,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

17,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

18'. Nhưng khi nghi ngờ, hãy sử dụng dấu ngoặc đơn

Hoạt động ngắn mạch

Toán tử nhị phân AND (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

85) và OR (

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

20) được gọi là toán tử ngắn mạch, nghĩa là toán hạng bên 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 bên trái. Ví dụ,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

21gives

java Xxx

49and

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

23give

java Xxx

48mà 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, chẳng hạn như. g.

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

25nhưng

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

62 sẽ không được đánh giá

Toán tử ghép nối

java Xxx

05 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009

Trong Java,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 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 loại toán hạng của nó

Nếu cả hai toán hạng đều là số (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

java Xxx

09), thì

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 thực hiện phép cộng thông thường. Ví dụ như,

Nếu cả hai toán hạng đều là

java Xxx

05, thì

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 sẽ nối hai

java Xxx

05 và trả về kết quả là

java Xxx

05. Ví dụ, ____9

Nếu một trong các toán hạng là

java Xxx

05 và toán hạng kia là số, thì toán hạng số sẽ được chuyển đổi thành

java Xxx

05 và hai

java Xxx

05 được nối với nhau, e. g. ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

3

Chúng tôi sử dụng toán tử nối

java Xxx

05

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009 thường xuyên trong

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

47 và

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

48 để tạo ra kết quả mong muốn

java Xxx

05. Ví dụ như,

Kiểm soát lưu lượng

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 lại), như minh họa bên dưới

Kiểm soát luồng tuần tự

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

Conditional Flow Control

There are a few types of conditionals, if-then, if-then-else, nested-if, switch-case-default, and conditional expression

java Xxx

45-then and

java Xxx

45-then-

java Xxx

46

SyntaxExampleFlowchart

java Xxx

0

Braces. You could omit the braces

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

6, if there is only one statement inside the block. For example,

However, I recommend that you keep the braces to improve the readability of your program, even if there is only one statement in the block

Nested-

java Xxx

45

SyntaxExampleFlowchart

Java does not provide a separate syntax for nested-if (e. g. , with keywords like

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

55,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

56), but supports nested-if with nested if-else statements, which is interpreted as below. Take note that you need to put a space between

java Xxx

46 and

java Xxx

45. Writing

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

56 causes a syntax error.

However, for readability, it is recommended to align the nest-if statement as written in the syntax/examples

Take note that the blocks are exclusive in a nested-if statement; only one of the blocks will be executed. Also, there are two ways of writing nested-if, for example,

Dangling-

java Xxx

46 Problem

The "dangling-

java Xxx

46" problem can be illustrated as follows

The

java Xxx

46 clause in the above code is syntactically applicable to both the outer-

java Xxx

45 and the inner-

java Xxx

45, causing the dangling-

java Xxx

46 problem

Java compiler resolves the dangling-

java Xxx

46 problem by associating the

java Xxx

46 clause with the innermost-

java Xxx

45 (i. e. , the nearest-

java Xxx

45). Hence, the above code shall be interpreted as

Dangling-

java Xxx

46 can be prevented by applying explicit parentheses. For example, if you wish to associate the

java Xxx

46 clause with the outer-

java Xxx

45, do this

Nested-

java Xxx

45 vs. Sequential-

java Xxx

45

Study the following code

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

75

SyntaxExampleFlowchart

"

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

75" is an alternative to the "nested-

java Xxx

45" for fixed-value tests (but not applicable for range tests). You can use an

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043, or

java Xxx

09 variable as the case-selector, but NOT

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039. JDK 1. 7 supports

java Xxx

05 as the case-selector.

In a

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

87 statement, a

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 statement is needed for each of the cases. If

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 is missing, execution will flow through the following case, which is typically a mistake. However, we could use this property to handle multiple-value selector. For example,

Conditional Expression ( .

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

90 .

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

91 . )

A conditional operator is a ternary (3-operand) operator, in the form of

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

92. Depending on the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

93, it evaluates and returns the value of

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

94 or

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

95

Conditional expression is a short-hand for

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

96. But you should use it only for one-liner, for readability

Exercises on Getting Started and Conditional

LINK

Loop Flow Control

Again, there are a few types of loops. for, while-do, and do-while

The difference between while-do and do-while lies in the order of the body and test. In while-do, the test is carried out first. The body will be executed if the test is true and the process repeats. In do-while, the body is executed and then the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

97 is carried out. Take note that the body of do-while is executed at least once (1+); but the body of while-do is possibly zero (0+). Similarly, the for-loop's body could possibly not executed (0+)

For-loop is a shorthand for while-do with fewer lines of code. It is the most commonly-used loop especially if the number of repetitions is known. But its syntax is harder to comprehend. Make sure that you understand for-loop by going through the flow-chart and examples

Loop's Index/Counter Variable

A loop is typically controlled by an index or counter variable. For example,

In the above examples, the variable

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

98 serves as the index variable, which takes on the values

java Xxx

18,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

300,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

301, . ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

302 for each iteration of the loop. You need to increase/decrease/modify the index variable explicitly (e. g. , via

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

303). Otherwise, the loop becomes an endless loop, as the test

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

304 will return the same outcome for the same value of

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

98

Observe that for-loop is a shorthand of while-loop. Both the for-loop and while-loop have the same set of statements, but for-loop re-arranges the statements

For the

java Xxx

47-loop, the index variable

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

98 is declared inside the loop, and therefore is only available inside the loop. You cannot access the variable after the loop, as It is destroyed after the loop. On the other hand, for the

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

308-loop, the index variable

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

98 is available inside and outside the loop

For the

java Xxx

47-loop, you can choose to declare the index variable inside the loop or outside the loop. We recommend that you declare it inside the loop, to keep the life-span of this variable to where it is needed, and not any longer

[TODO] Animated GIF??

Code Example. Sum and Average of Running Integers

Chương trình sau tính tổng các số nguyên đang chạy từ một giới hạn dưới cho trước tới một giới hạn trên. Also compute their average

Sử dụng cờ

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 để kiểm soát vòng lặp

Besides using an index variable for loop control, another common way to control the loop is via a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag

Thí dụ. Below is an example of using while-do with a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag. The

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag is initialized to

java Xxx

49 to ensure that the loop is entered

Example. Suppose that your program prompts user for a number between

java Xxx

18 to

java Xxx

04, and checks for valid input. A do-while loop with a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag could be more appropriate as it prompts for input at least once, and repeat again and again if the input is invalid

java Xxx

47-loop with Comma Separator

You could place more than one statement in the init and update, separated with commas. For example,

The test, however, must be a boolean expression that returns a boolean

java Xxx

48 or

java Xxx

49

Terminating Program

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

322. You could invoke the method

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

322 to terminate the program and return the control to the Java Runtime. By convention, return code of zero indicates normal termination; while a non-zero

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

324 indicates abnormal termination. For example,

The

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

325 statement. You could also use a "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

325" statement in the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 method to terminate the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 and return control back to the Java Runtime. For example,

Exercises on Decision and Loop

LINK

Input/Output

Formatted Output via "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329" (JDK 5)

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

330 and

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

48 do not provide output formatting, such as controlling the number of spaces to print an

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 and the number of decimal places for a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37

Java SE 5 introduced a new method called

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329 for formatted output (which is modeled after C Language's

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329).

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329 takes the following form

java Xxx

1

Formatting-string contains both normal texts and the so-called Format Specifiers. Normal texts (including white spaces) will be printed as they are. Format specifiers, in the form of "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

337", will be substituted by the arguments following the

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

338, usually in a one-to-one and sequential manner. A format specifier begins with a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

339 and ends with the

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

340, e. g. ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

341 for integer,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

342 for floating-point number (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37),

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

345 for

java Xxx

09 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

347 for

java Xxx

05. An optional

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

349 can be inserted in between to specify the field-width. Similarly, an optional

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

350 can be used to control the alignment, padding and others. For examples,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

351. integer printed in α spaces (α is optional), right-aligned. If α is omitted, the number of spaces is the length of the integer

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

352. String printed in α spaces (α is optional), right-aligned. If α is omitted, the number of spaces is the length of the string (to fit the string)

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

353. Floating point number (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37) printed in α spaces with β decimal digits (α and β are optional). If α is omitted, the number of spaces is the length of the floating-point number

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

356. a system-specific new line (Windows uses

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

357, Unix and macOS

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

358)

ví dụ

ExampleOutput

java Xxx

2

java Xxx

3

java Xxx

4

java Xxx

5

java Xxx

6

Take note that

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329 does not advance the cursor to the next line after printing. You need to explicitly print a newline character (via

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

356) at the end of the formatting-string to advance the cursor to the next line, if desires, as shown in the above examples

There are many more format specifiers in Java. Refer to JDK Documentation for the detailed descriptions (@ https. //docs. oracle. com/javase/10/docs/api/java/util/Formatter. html for JDK 10)

(Also take note that

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329 take a variable number of arguments (or varargs), which is a new feature introduced in JDK 5 in order to support

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329)

Input From Keyboard via "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363" (JDK 5)

Java, like all other languages, supports three standard input/output streams.

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

364 (standard input device),

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

365 (standard output device), and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

366 (standard error device). The

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

364 is defaulted to be the keyboard; while

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

365 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

366 are defaulted to the display console. They can be re-directed to other devices, e. g. , it is quite common to redirect

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

366 to a disk file to save these error message

You can read input from keyboard via

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

364 (standard input device)

JDK 5 introduced a new class called

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 in package

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

373 to simplify formatted input (and a new method

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329 for formatted output described earlier). You can construct a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 to scan input from

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

364 (keyboard), and use methods such as

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

377,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

378,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

379 to parse the next

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 and

java Xxx

05 token (delimited by white space of blank, tab and newline)

You can also use method

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

383 to read in the entire line, including white spaces, but excluding the terminating newline

Try not to mix

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

383 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

385 in a program (as you may need to flush the newline from the input buffer)

The

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 supports many other input formats. Check the JDK documentation page, under module

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

387 ⇒ package

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

373 ⇒ class

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 ⇒ Method (@ https. //docs. oracle. com/javase/10/docs/api/java/util/Scanner. html for JDK 10)

Code Example. Prompt User for Two Integers and Print their Sum

The following program prompts user for two integers and print their sum. For examples,

java Xxx

7

Code Example. Income Tax Calculator

The progressive income tax rate is mandated as follows

Taxable IncomeRate (%)First $20,0000Next $20,00010Next $20,00020The remaining30

For example, suppose that the taxable income is

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

390, the income tax payable is

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

391

Write a program called

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

392 that reads the taxable income (in

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34). The program shall calculate the income tax payable (in

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37); and print the result rounded to 2 decimal places

java Xxx

8

Code Example. Income Tax Calculator with Sentinel

Based on the previous example, write a program called

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

395 which shall repeat the calculations until user enter

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

396. For example,

java Xxx

9

The

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

396 is known as the sentinel value. (In programming, a sentinel value, also referred to as a flag value, trip value, rogue value, signal value, or dummy data, is a special value which uses its presence as a condition of termination. )

ghi chú

The coding pattern for handling input with sentinel (terminating) value is as follows

Code Example. Guess A Number

Guess a number between 0 and 99

ghi chú

The above program uses a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag to control the loop, in the following coding pattern

Exercises on Decision/Loop with Input

LINK

Nhập từ tệp văn bản qua "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363" (JDK 5)

Other than scanning

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

364 (keyboard), you can connect your

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 to scan any input sources, such as a disk file or a network socket, and use the same set of methods

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

377,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

378,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

379,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

383 to parse the next

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

java Xxx

05 and line. For example,

To open a file via

java Xxx

009, you need to handle the so-called

java Xxx

010, i. e. , không thể tìm thấy tệp mà bạn đang cố mở. Otherwise, you cannot compile your program. Có hai cách để xử lý ngoại lệ này. ném hoặc thử bắt

To run the above program, create a text file called

java Xxx

011 containing

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

00

Formatted Output to Text File

Java SE 5. 0 also introduced a so-called

java Xxx

012 for formatted output (just like

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 for formatted input). A

java Xxx

012 has a method called

java Xxx

015. The

java Xxx

015 method has the same syntax as

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329, i. e. , it could use format specifiers to specify the format of the arguments. Again, you need to handle the

java Xxx

010

Run the above program, and check the outputs in text file "

java Xxx

019"

Input via a Dialog Box

You can also get inputs from users via a graphical dialog box, using the

java Xxx

020 class. For example, the following program prompts the user to enter the radius of a circle, and computes the area

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

01

Dissecting the Program

In Line 4, the
```
java Xxx
```
021 statement is needed to use the
```
java Xxx
```
020
In Line 10, we use the method
```
java Xxx
```
023 to prompt users for an input, which returns the input as a
```
java Xxx
```
05

Line 11 converts the input

java Xxx

05 to a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, using the method

java Xxx

027

java Xxx

028 (JDK 1. 6)

Java SE 6 introduced a new

java Xxx

028 class to simplify character-based input/output to/from the system console. BUT, the

java Xxx

030 class does not run under IDE (such as Eclipse/NetBeans)

To use the new

java Xxx

030 class, you first use

java Xxx

032 to retrieve the

java Xxx

030 object corresponding to the current system console

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

02

You can then use methods such as

java Xxx

034 to read a line. You can optionally include a prompting message with format specifiers (e. g. ,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

341,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

347) in the prompting message

You can use

java Xxx

037 for formatted output with format specifiers such as

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

341,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

347. You can also connect the

java Xxx

030 to a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363 for formatted input, i. e. , parsing primitives such as

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37, for example,

Example

The

java Xxx

030 class also provides a secure mean for password entry via method

java Xxx

045. This method disables input echoing and keep the password in a

java Xxx

046 instead of a

java Xxx

05. The

java Xxx

046 containing the password can be and should be overwritten, removing it from memory as soon as it is no longer needed. (Recall that

java Xxx

05s are immutable and cannot be overwritten. When they are longer needed, they will be garbage-collected at an unknown instance. )

Writing Correct and Good Programs

It is important to write programs that produce the correct results. It is also important to write programs that others (and you yourself three days later) can understand, so that the programs can be maintained. I call these programs good programs - a good program is more than a correct program

Here are the suggestions

Follow established convention so that everyone has the same basis of understanding. To program in Java, you MUST read the "Code Convention for the Java Programming Language"
Format and layout of the source code with appropriate indents, white spaces and white lines. Use 3 or 4 spaces for indent, and blank lines to separate sections of code

Choose good names that are self-descriptive and meaningful, e. g. ,

java Xxx

98,

java Xxx

051,

java Xxx

052,

java Xxx

66,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

31. Do not use meaningless names, such as

java Xxx

75,

java Xxx

76,

java Xxx

77,

java Xxx

058. Avoid single-alphabet names (easier to type but often meaningless), except common names likes x,

java Xxx

95,

java Xxx

96 for coordinates and

java Xxx

78 for index

Provide comments to explain the important as well as salient concepts. Comment your code liberally
Write your program documentation while writing your programs

Avoid unstructured constructs, such as

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 and

java Xxx

063, which are hard to follow

Use "mono-space" fonts (such as Consolas, Courier New, Courier) for writing/displaying your program

It is estimated that over the lifetime of a program, 20 percent of the effort will go into the original creation and testing of the code, and 80 percent of the effort will go into the subsequent maintenance and enhancement. Writing good programs which follow standard conventions is critical in the subsequent maintenance and enhancement

Programming Errors. Compilation, Runtime and Logical Errors

There are generally three classes of programming errors

Compilation Error (or Syntax Error). The program cannot compile. This can be fixed easily by checking the compilation error messages. For examples,
Runtime Error. The program can compile, but fail to run successfully. This can also be fixed easily, by checking the runtime error messages. For examples,
Logical Error. The program can compile and run, but produces incorrect results (always or sometimes). This is the hardest error to fix as there is no error messages - you have to rely on checking the output. It is easy to detect if the program always produces wrong output. It is extremely hard to fix if the program produces the correct result most of the times, but incorrect result sometimes. For example, This kind of errors is very serious if it is not caught before production. Writing good programs helps in minimizing and detecting these errors. A good testing strategy is needed to ascertain the correctness of the program. Software testing is an advanced topics which is beyond our current scope

Debugging Programs

Here are the common debugging techniques

Stare at the screen. Unfortunately, nothing will pop-up even if you stare at it extremely hard
Study the error messages. Do not close the console when error occurs and pretending that everything is fine. This helps most of the times
Insert print statements at appropriate locations to display the intermediate results. It works for simple toy program, but it is neither effective nor efficient for complex program
Use a graphic debugger. This is the most effective means. Trace program execution step-by-step and watch the value of variables and outputs
Advanced tools such as profiler (needed for checking memory leak and method usage)
Perform program testing to wipe out the logical errors. "Write test first, before writing program"

Exercises on Decision/Loop with Input

LINK

Testing Your Program for Correctness

How to ensure that your program always produces correct result, 100% of the times? It is impossible to try out all the possible outcomes, even for a simple program for adding two integers (because there are too many combinations of two integers). Program testing usually involves a set of representative test cases, which are designed to catch all classes of errors. Program testing is beyond the scope of this writing

More on Loops - Nested-Loops, "Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"88 & java Xxx 063

Nested Loops

Nested loops are needed to process 2-dimensional (or N-dimensional) data, such as printing 2D patterns. A nested-for-loop takes the following form

Code Examples. Print Square Pattern

Chương trình sau 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. For example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

03

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

04

This program contains two nested for-loops. The inner loop is used to print a row of "

java Xxx

31", which is followed by printing a newline. 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ã hóa. In mẫu 2D

Mẫu mã hóa để in các mẫu 2D như sau. I recommend using

java Xxx

98 and

java Xxx

051 as the loop variables which is self-explanatory, instead of

java Xxx

78 and

java Xxx

79,

java Xxx

74 and

java Xxx

95

Code Examples. Print Checker Board Pattern

Suppose that you want to print this pattern instead (in program called

java Xxx

073)

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

05

You need to print an additional space for even-number rows. You could do so by adding the following statement before the inner loop

Code Example. Print Multiplication Table

The following program prompts user for the size, and print the multiplication table as follows

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

06

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

07

TRY

Write programs called

java Xxx

074, which prompts user for the size and prints each these patterns.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

08Hints.
The equations for major and opposite diagonals are

java Xxx

075and

java Xxx

076. Decide on what to print above and below the diagonal.

Write programs called

java Xxx

077, which prompts user for the size and prints each of these patterns.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

09

Exercises on Nested Loops with Input

LINK

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 and

java Xxx

063 - Interrupting Loop Flow

The

java Xxx

080 statement breaks out and exits the current (innermost) loop

The

java Xxx

081 statement aborts the current iteration and continue to the next iteration of the current (innermost) loop

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 and

java Xxx

063 are poor structures as they are hard to read and hard to follow. Use them only if absolutely necessary

Endless loop

java Xxx

084 is known as an empty for-loop, with empty statement for initialization, test and post-processing. The body of the empty for-loop will execute continuously (infinite loop). You need to use a

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 statement to break out the loop

Similar,

java Xxx

086 and

java Xxx

087 are endless loops

Endless loop is typically a mistake especially for new programmers. You need to break out the loop via a

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 statement inside the loop body

Example (

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88). The following program lists the non-prime numbers between 2 and an upperbound

Let's rewrite the above program to list all the primes instead. A

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag called

java Xxx

091 is used to indicate whether the current

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

98 is a prime. It is then used to control the printing

Let's rewrite the above program without using

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 statement. A

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

308 loop is used (which is controlled by the

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag) instead of

java Xxx

47 loop with

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88

Example (

java Xxx

063)

Example (

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 and

java Xxx

063). Study the following program

Labeled

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88

In a nested loop, the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 statement breaks out the innermost loop and continue into the outer loop. At times, there is a need to break out all the loops (or multiple loops). This is clumsy to achieve with

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag, but can be done easily via the so-called labeled

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88. You can add a

java Xxx

105 to a loop in the form of

java Xxx

106. For example,

Labeled

java Xxx

063

In a nested loop, similar to labeled

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88, you can use labeled continue to continue into a specified loop. For example,

Again, labeled

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88 and

java Xxx

063 are not structured and hard to read. Use them only if absolutely necessary

Example (Labeled

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

88). Suppose that you are searching for a particular number in a 2D array

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

10

java Xxx 05 and java Xxx 09 operations

java Xxx

09 Arithmetic Operations

Recall that

In Java, each

java Xxx

09 is represented by a 16-bit Unicode number. For examples,

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 is represented by code number

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

062 (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

063),

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 by

java Xxx

122 (

java Xxx

123),

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056 by

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

065 (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

066).

java Xxx

09

java Xxx

10 by

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

068 (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

069). Take note that

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 is NOT

java Xxx

134,

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 is NOT

java Xxx

137

java Xxx

09s can take part in arithmetic operations. A

java Xxx

09 is treated as its underlying

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 (in the range of

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

036) in arithmetic operations. In other words,

java Xxx

09 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 are interchangeable.

java Xxx

144,

java Xxx

145,

java Xxx

146,

java Xxx

147. For examples,

In arithmetic operations,

java Xxx

09 (and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042, and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043) is first converted to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. In Java, arithmetic operations are only carried out in

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046, or

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37; NOT in

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043, and

java Xxx

09

Hence,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

990, where

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

953 denotes an binary arithmetic operation (such as

java Xxx

29,

java Xxx

30,

java Xxx

31,

java Xxx

32 and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

192). You may need to explicitly cast the resultant

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 back to

java Xxx

09. For examples,

Similar,

java Xxx

168. You may need to explicitly cast the resultant

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 back to

java Xxx

09. For examples,

However, for compound operators (such as

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

994,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

995,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

996,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

997,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

998), the evaluation is carried out in

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, but the result is casted back to the LHS automatically. For examples,

For increment (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

17) and decrement (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

18) of

java Xxx

09 (and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042, and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043), there is no promotion to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. For examples,

Converting

java Xxx

09 to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

You can convert

java Xxx

09

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

238 to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

17 to

java Xxx

190 by subtracting the

java Xxx

09 with the base

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055, e. g. ,

java Xxx

193

That is, suppose

java Xxx

77 is a

java Xxx

09 between

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 and

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

238,

java Xxx

198 is the corresponding

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

17 to

java Xxx

190

The following program illustrates how to convert a hexadecimal character (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

245,

java Xxx

203 or

java Xxx

204) to its decimal equivalent (

java Xxx

205), by subtracting the appropriate base

java Xxx

09

Hoạt động của

java Xxx

05

The most commonly-used

java Xxx

05 methods are as follows, suppose that

java Xxx

209,

java Xxx

210,

java Xxx

211 are

java Xxx

05 variables

```
java Xxx
```
213. return the length of the
```
java Xxx
```
209
```
java Xxx
```
215. return the
```
java Xxx
```
09 at the
```
java Xxx
```
217 position of the
```
java Xxx
```
209. Take note that
```
java Xxx
```
217 begins at
```
java Xxx
```
17, and up to
```
java Xxx
```
221
```
"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
```
14. for comparing the contents of
```
java Xxx
```
210 and
```
java Xxx
```
211. Hãy lưu ý rằng bạn không thể sử dụng
```
java Xxx
```
225 để so sánh hai
```
java Xxx
```
05. This is because "
```
"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
```
01" is only applicable to primitive types, but
```
java Xxx
```
05 is not a primitive type

For examples,

Để kiểm tra tất cả các phương pháp có sẵn cho

java Xxx

05, hãy mở Tài liệu JDK ⇒ Chọn "Tài liệu API" ⇒ Nhấp vào "KHUNG" (menu trên cùng) ⇒ Từ "Mô-đun" (ngăn trên cùng bên trái), chọn "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

387" ⇒ Từ "Gói

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

387" ( . //docs. tiên tri. com/javase/10/docs/api/java/lang/String. html cho JDK 10)

For examples,

Chuyển đổi

java Xxx

05 sang Nguyên thủy

java Xxx

05 đến

java Xxx

236

Bạn có thể sử dụng các phương thức có sẵn của JDK

java Xxx

237 để chuyển đổi một

java Xxx

05 chứa một số nguyên hợp lệ (e. g. , "

java Xxx

239") thành một

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 (e. g. ,

java Xxx

239). Bộ thực thi kích hoạt một

java Xxx

242 nếu chuỗi đầu vào không chứa một số nguyên hợp lệ (e. g. , "

java Xxx

54"). Ví dụ,

Tương tự như vậy, bạn có thể sử dụng các phương pháp

java Xxx

244,

java Xxx

245,

java Xxx

246 để chuyển đổi một

java Xxx

05 chứa một ký tự

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 hợp lệ sang kiểu nguyên thủy

java Xxx

05 đến

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37/

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046

Bạn có thể sử dụng

java Xxx

254 hoặc

java Xxx

255 để chuyển đổi một

java Xxx

05 (có chứa một dấu chấm động bằng chữ) thành một

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 hoặc

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046, e. g

java Xxx

05 đến

java Xxx

09

Bạn có thể sử dụng

java Xxx

261 để trích xuất ký tự riêng lẻ từ một

java Xxx

05, trong đó

java Xxx

263 bắt đầu từ

java Xxx

17 và lên đến

java Xxx

265, e. g. ,

java Xxx

05 đến

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039

Bạn có thể sử dụng phương pháp

java Xxx

268 để chuyển đổi chuỗi "

java Xxx

48" hoặc "

java Xxx

49" thành

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039

java Xxx

48 hoặc

java Xxx

49, e. g. ,

Chuyển đổi nguyên thủy thành

java Xxx

05

Để chuyển đổi một nguyên thủy thành một

java Xxx

05, bạn có thể

Sử dụng toán tử '
```
java Xxx
```
29' để nối nguyên hàm với một số trống
```
java Xxx
```
277
Sử dụng các phương thức tích hợp JDK
```
java Xxx
```
278, có thể áp dụng cho tất cả các phương thức nguyên thủy
Sử dụng các phương thức
```
java Xxx
```
279 của lớp trình bao bọc tương ứng, chẳng hạn như
```
java Xxx
```
280,
```
java Xxx
```
281,
```
java Xxx
```
282,
```
java Xxx
```
283, v.v.

For examples,

Định dạng

java Xxx

05s -

java Xxx

285

Nhớ lại rằng bạn có thể sử dụng

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329 để tạo một chuỗi được định dạng và gửi nó đến bảng điều khiển hiển thị, e. g. ,

Có một chức năng tương tự được gọi là

java Xxx

285 trả về chuỗi đã định dạng, thay vì gửi tới bàn điều khiển, e. g. ,

java Xxx

285 có dạng giống như

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329

Mã ví dụ. Chuỗi đảo ngược

Chương trình sau 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ư,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

11

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

12

Mã ví dụ. Xác thực chuỗi nhị phân

Chương trình sau nhắc người dùng nhập một chuỗi và kiểm tra xem đầu vào có phải là một chuỗi nhị phân hợp lệ hay không, chỉ bao gồm

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 và

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095. Ví dụ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

13

Phiên bản 1. With a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 flag

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

14

Version 2

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

15

This version, although shorter, are harder to read, and harder to maintain

Code Example. Binary to Decimal (Bin2Dec)

The following program prompts user for a binary string, and converts into its equivalent decimal number. For example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

16

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

17

ghi chú

The conversion formula is.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

18

We use

java Xxx

293 to extract each individual

java Xxx

09 from the

java Xxx

295. The

java Xxx

296 begins at zero, and increases from left-to-right. On the other hand, the exponent number increases from right-to-left, as illustrated in the following example.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

19

This code uses
```
java Xxx
```
297 as the loop index, and computes the
```
java Xxx
```
296 for
```
java Xxx
```
299 using the relationship
```
java Xxx
```
300. You could also use the
```
java Xxx
```
296 as the loop index (see next example)

We use the built-in function

java Xxx

302 to compute the exponent, which takes two

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37s and return a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37. We need to explicitly cast the resultant

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 back to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 for

java Xxx

307

There are 3 cases to handle.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 (add to

java Xxx

307),

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 (valid but do nothing for multiply by

java Xxx

17) and other (error). We can write the nested-if as follows, but that is harder to read

You can use

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

363's

java Xxx

313 method to read an

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 in the desired

java Xxx

315. Try reading a binary number (radix of 2) and print its decimal equivalent. For example,

Code Example. Hexadecimal to Decimal (Hex2Dec)

The following program prompts user for a hexadecimal string and converts into its equivalent decimal number. For example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

20

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

21

ghi chú

The conversion formula is.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

22

In this example, we use the
```
java Xxx
```
316 as the loop index, and compute the exponent via the relationship
```
java Xxx
```
317 (See the illustration in the earlier example)

You could write a big

java Xxx

318 of 23

java Xxx

319s (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

245,

java Xxx

203,

java Xxx

204, and other). But take note how they are reduced to 5 cases

To convert

java Xxx

323

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

238 to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

18 to

java Xxx

190, we subtract the

java Xxx

323 by the base

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055

Similarly, to convert

java Xxx

323

java Xxx

10 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

229 (or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

230) to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

04 to

java Xxx

338, we subtract the

java Xxx

323 by the base

java Xxx

10 (or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056) and add

java Xxx

04

You may use
```
java Xxx
```
343 to convert the input string to lowercase to further reduce the number of cases. But You need to keep the original
```
java Xxx
```
05 for output in this example (otherwise, you could use
```
java Xxx
```
345 directly)

Exercises on

java Xxx

05 and

java Xxx

09 operations

LINK

Arrays

Suppose that you want to find the average of the marks for a class of 30 students, you certainly do not want to create 30 variables.

java Xxx

348,

java Xxx

349, . ,

java Xxx

350. Instead, You could use a single variable, called an array, with 30 elements (or items)

An array is an ordered collection of elements of the same type, identified by a pair of square brackets

java Xxx

351. To use an array, you need to

Declare the array with a name and a type. Use a plural name for array, e. g. ,
```
java Xxx
```
352,
```
java Xxx
```
99,
```
java Xxx
```
354. All elements of the array belong to the same type
Allocate the array using
```
java Xxx
```
355 operator, or through initialization, e. g. ,

When an array is constructed via the

java Xxx

355 operator, all the elements are initialized to their default value, e. g. ,

java Xxx

17 for

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

134 for

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37,

java Xxx

49 for

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039, and

java Xxx

50 for objects. [Unlike C/C++, which does NOT initialize the array contents. ]

When an array is declared but not allocated, it has a special value called

java Xxx

50

Array Index

You can refer to an element of an array via an index (or subscript) enclosed within the square bracket

java Xxx

351. Java's array index begins with zero (

java Xxx

17). For example, suppose that

java Xxx

352 is an

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 array of 5 elements, then the 5 elements are.

java Xxx

369,

java Xxx

370,

java Xxx

371,

java Xxx

372 và

java Xxx

373

Array's

java Xxx

374

To create an array, you need to known the length (or size) of the array in advance, and allocate accordingly. Khi một mảng được tạo, độ dài của nó là 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 (e. g. , có bao nhiêu học sinh?). 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 là 30 (cho một lớp sinh viên) và có 31 sinh viên, bạn cần cấp phát 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ó những 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 kết có tên là

java Xxx

374 và có thể được truy xuất bằng cách sử dụng "

java Xxx

376", e. g. ,

Chỉ số của một mảng nằm trong khoảng từ

java Xxx

17 đến

java Xxx

378

Không giống như các ngôn ngữ như C/C++, Java thực hiện kiểm tra giới hạn chỉ số 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

java Xxx

374 của mảng. Nếu chỉ mục nằm ngoài phạm vi của

java Xxx

380, Java Runtime sẽ báo hiệu một ngoại lệ có tên là

java Xxx

381. It is important to note that checking array index-bound consumes computation power, which inevitably slows down the processing. However, the benefits gained in terms of good software engineering out-weight the slow down in speed

Array and Loop

Arrays works hand-in-hand with loops. You can process all the elements of an array via a loop, for example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

23

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

This loop shall be read as "for each element in the array. ". The loop executes once for each element in the array, with the element's value copied into the declared variable. The for-each loop is handy to transverse all the elements of an array. It requires fewer lines of code, eliminates the loop counter and the array index, and is easier to read. However, for array of primitive types (e. g. , array of

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34s), it can read the elements only, and cannot modify the array's contents. This is because each element's value is copied into the loop's variable, instead of working on its original copy

In many situations, you merely want to transverse thru the array and read each of the elements. For these cases, enhanced for-loop is preferred and recommended over other loop constructs

Code Example. Read and Print Array

The following program prompts user for the length and all the elements of an array, and print the array in the form of

java Xxx

383. For examples,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

24

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

25

java Xxx

384 (JDK 5)

JDK 5 provides an built-in methods called

java Xxx

385, which returns a

java Xxx

05 in the form

java Xxx

383. You need to

java Xxx

388. For examples,

Code Example. Horizontal and Vertical Histograms

The following program prompts user for the number of students, and the grade of each student. It then print the histogram, in horizontal and vertical forms, as follows

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

26

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

27

ghi chú

We use two arrays in this exercise, one for storing the grades of the students (of the length

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

31) and the other to storing the histogram counts (of length

java Xxx

04)

We use a

java Xxx

04-element

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 arrays called

java Xxx

393, to keep the histogram counts for grades of

java Xxx

394,

java Xxx

395, . ,

java Xxx

396. Take note that there are

java Xxx

397 grades between

java Xxx

398, and the last bin has

java Xxx

399 grades (instead of 10 for the rest). The

java Xxx

393's index is

java Xxx

401, except

java Xxx

402 of

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1480

Code Example. Hexadecimal to Binary (

java Xxx

404)

The following program prompts user for a hexadecimal string and convert it to its binary equivalence. For example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

28

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

29

Notes

We keep the binary string corresponding to hex digit

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

230 in an array with indexes of

java Xxx

205, used as look-up table

We extract each

java Xxx

323, find its array index (

java Xxx

205), and retrieve the binary string from the array based on the index

To convert

java Xxx

323

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

095 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

238 to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

18 to

java Xxx

190, we subtract the

java Xxx

323 by the base

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

055

Similarly, to convert

java Xxx

323

java Xxx

10 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

229 (or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056 to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

230) to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

java Xxx

04 to

java Xxx

338, we subtract the

java Xxx

323 by the base

java Xxx

10 (or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

056) and add

java Xxx

04

Code Example. Decimal to Hexadecimal (

java Xxx

430)

The following program prompts user for an integer, reads as

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34, and prints its hexadecimal equivalent. For example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

90

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

91

Notes

We use modulus/divide algorithm to get the hex digits (
```
java Xxx
```
205) in reserve order. See "Number System Conversion"
We look up the hex digit
```
java Xxx
```
433 from an array using index
```
java Xxx
```
205

Exercises on Arrays

LINK

Multi-Dimensional Array

In Java, you can declare an array of arrays. For examples

In the above example,

java Xxx

435 is an array of 12 elements. Mỗi phần tử (

java Xxx

436 đến

java Xxx

437) là một mảng 8 phần tử

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34. In other words,

java Xxx

435 is a "12-element array" of "8-element int arrays". Hence,

java Xxx

440 gives

java Xxx

441 and

java Xxx

442 gives

java Xxx

443

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

92

Nói chính xác, Java không hỗ trợ trực tiếp mảng đa chiều. That is, it does not support syntax like

java Xxx

444 like some languages. Furthermore, it is possible that the arrays in an array-of-arrays have different length.

Take note that the right way to view the "array of arrays" is as shown, instead of treating it as a 2D table, even if all the arrays have the same length

Ví dụ,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

93

Phương thức (Chức năng)

Why Methods?

At times, a certain portion of code has to be used many times. Instead of re-writing the code many times, it is better to put them into a "subroutine", and "call" this "subroutine" many time - for ease of maintenance and understanding. Subroutine is called method (in Java) or function (in C/C++)

The benefits of using methods are

Divide and conquer. Xây dựng chương trình từ các phần hoặc thành phần nhỏ, đơn giản. Modularize the program into self-contained tasks
Avoid repeating code. It is easy to copy and paste, but hard to maintain and synchronize all the copies
Software Reuse. You can reuse the methods in other programs, by packaging them into library code (or API)

Using Methods

Two parties are involved in using a method. a caller, who calls (or invokes) the method, and the method called

The process is

The caller invokes a method and passes arguments to the method
The method
1. receives the arguments passed by the caller,
2. performs the programmed operations defined in the method's body, and
3. returns a result back to the caller
The caller receives the result, and continue its operations

Example. Suppose that we need to evaluate the area of a circle many times, it is better to write a method called

java Xxx

445, and re-use it when needed

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

94

The expected outputs are.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

95

In the above example, a reusable method called

java Xxx

445 is defined, which receives an argument in

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 from the caller, performs the calculation, and return a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 result to the caller. In the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0, we invoke

java Xxx

445 methods thrice, each time with a different parameter

Take note that there is a transfer of control from the caller to the method called, and from the method back to the caller, as illustrated

Tracing Method Invocation

You can trace method operations under Eclipse/NetBeans (Refer to the the Eclipse/NetBeans How-to article)

Step Over. Treat the method call as one single step
Step Into. Step into the method, so that you can trace the operations of the method
Step Out. Complete the current method and return to the caller
Set "Breakpoints" inside the method, and "resume" running to the next breakpoint

Method Definition Syntax

The syntax for method definition is as follows

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

96

Take note that you need to specify the type of the arguments and the return value in method definition

Calling Methods

To call a method, simply use

java Xxx

451. For examples, to call the above methods

Take note that you need to specify the type in the method definition, but not during invocation

Method Naming Convention

A method's name shall be a verb or verb phrase (action), comprising one or more words. The first word is in lowercase, while the rest are initial-capitalized (called camel-case). For example,

java Xxx

445,

java Xxx

453,

java Xxx

454,

java Xxx

455, etc

Another Example

The "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

325" statement

Inside the method body, you could use a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

325 statement to return a value (of the

java Xxx

458 declared in the method's signature) to return a value back to the caller. The syntax is

The "

java Xxx

459" Return-Type

Suppose that you need a method to perform certain actions (e. g. , printing) without a need to return a value to the caller, you can declare its return-value type as

java Xxx

459. In the method's body, you could use a "

java Xxx

461" statement without a return value to return control to the caller. In this case, the

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

325 statement is optional. If there is no

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

325 statement, the entire body will be executed, and control returns to the caller at the end of the body

Notice that

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 is a method with a return-value type of

java Xxx

459.

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 is called by the Java runtime, perform the actions defined in the body, and return nothing back to the Java runtime

Actual Parameters vs. Formal Parameters

Recall that a method receives arguments from its caller, performs the actions defined in the method's body, and return a value (or nothing) to the caller

In the above example, the variable

java Xxx

467 declared in the signature of

java Xxx

468 is known as formal parameter. Its scope is within the method's body. When the method is invoked by a caller, the caller must supply so-called actual parameters or arguments, whose value is then used for the actual computation. For example, when the method is invoked via "

java Xxx

469",

java Xxx

470 is the actual parameter, with a value of

java Xxx

471

Code Example. Con số kỳ diệu

The following program contains a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 method called

java Xxx

473, which returns

java Xxx

48 if the given

java Xxx

475 contains the digit

java Xxx

443, e. g. , 18, 108, and 1288. The signature of the method is

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

97

It also provides the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 method to test the

java Xxx

478. For example,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

98

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

99

Lưu ý nhận xét tài liệu thích hợp cho phương pháp

Mã ví dụ.

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 Array Methods

The following program contains various method for

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 array with signatures as follows

It also contains the main() method to test all the methods. For example,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

140

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

141

Pass-by-Value for Primitive-Type Parameters

In Java, when an argument of primitive type is pass into a method, a copy is created and passed into the method. The invoked method works on the cloned copy, and cannot modify the original copy. This is known as pass-by-value

Ví dụ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

142

ghi chú

Although there is a variable called

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

98 in both the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 and

java Xxx

483 method, there are two distinct copies - one available in

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 and another available in

java Xxx

483 - happen to have the same name. You can change the name of either one, without affecting the program

Pass-by-Reference for Arrays and Objects

As mentioned, for primitive-type parameters, a cloned copy is made and passed into the method. Hence, the method cannot modify the values in the caller. It is known as pass-by-value

For arrays (and objects - to be described in the later chapter), the array reference is passed into the method and the method can modify the contents of array's elements. It is known as pass-by-reference. For example,

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

Before JDK 5, a method has to be declared with a fixed number of formal arguments. C-like

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

329, which take a variable number of argument, cannot not be implemented. Although you can use an array for passing a variable number of arguments, it is not neat and requires some programming efforts

JDK 5 introduces variable arguments (or varargs) and a new syntax "

java Xxx

487". For example,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

143

Varargs can be used only for the last argument. The three dots (

java Xxx

488) indicate that the last argument may be passed as an array or as a sequence of comma-separated arguments. The compiler automatically packs the varargs into an array. You could then retrieve and process each of these arguments inside the method's body as an array. It is possible to pass varargs as an array, because Java maintains the length of the array in an associated variable

java Xxx

374

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

144

ghi chú

If you define a method that takes a varargs
```
java Xxx
```
490, you cannot define an overloaded method that takes a
```
java Xxx
```
491
"varargs" will be matched last among the overloaded methods.
```
java Xxx
```
492, cụ thể hơn, được so khớp trước
```
java Xxx
```
493

From JDK 5, you can also declare your

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 method as

Implicit Type-Casting for Method's Parameters

A method that takes a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 parameter can accept any numeric primitive type, such as

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046. This is because implicit type-casting is carried out. However, a method that take a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 parameter cannot accept a

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 value. This is because the implicit type-casting is always a widening conversion which prevents loss of precision. An explicit type-cast is required for narrowing conversion. Read "Type-Casting" on the conversion rules

Method Overloading

In Java, a method (of a particular method name) can have more than one versions, each version operates on different set of parameters - known as method overloading. The versions shall be differentiated by the numbers, types, or orders of the parameters

Example 1

The expected outputs are

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

145

Example 2. Arrays

Suppose you need a method to compute the sum of the elements for

java Xxx

500,

java Xxx

501,

java Xxx

502 and

java Xxx

503, you need to write all overloaded versions - there is no shortcut

ghi chú

Unlike primitives, where

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 would be autocasted to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37 during method invocation,

java Xxx

500 is not casted to

java Xxx

503

To handle all the 7 primitive number type arrays, you need to write 7 overloaded versions to handle each array types

"

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039" Methods

A

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 method returns a

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 value to the caller

Suppose that we wish to write a method called

java Xxx

511 to check if a given number is odd

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

146

This seemingly correct code produces

java Xxx

49 for

java Xxx

513, because

java Xxx

514 is

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

396 instead of

java Xxx

18. You may rewrite the condition

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

147

The above produces the correct answer, but is poor. For boolean method, you can simply return the resultant

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039 value of the comparison, instead of using a conditional statement, as follow

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

148

Mathematical Methods

JDK provides many common-used Mathematical methods in a class called

java Xxx

518. The signatures of some of these methods are

The

java Xxx

518 class also provide two constants

To check all the available methods, open JDK API documentation ⇒ select module "

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

387" ⇒ select package "

java Xxx

232" ⇒ select class "

java Xxx

518" ⇒ choose method (@ https. //docs. oracle. com/javase/10/docs/api/java/lang/Math. html for JDK 10)

For examples,

Exercises on Methods

LINK

Command-Line Arguments

Java's

java Xxx

523 method takes an argument.

java Xxx

524, i. e. , a

java Xxx

05 array named

java Xxx

526. Điều này được gọi là "đối số dòng lệnh", tương ứng với phần bổ sung do người dùng cung cấp khi chương trình java được gọi. For example, a Java program called

java Xxx

527 could be invoked with additional command-line arguments as follows (in a "cmd" shell)

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

149

Each argument, i. e. ,

java Xxx

528,

java Xxx

529 and

java Xxx

530, is a

java Xxx

05. Java runtime packs all the arguments into a

java Xxx

05 array and passes into the

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

0 method as

java Xxx

526. For this example,

java Xxx

526 has the following properties

Mã ví dụ.

java Xxx

527

The program

java Xxx

527 reads three parameters form the command-line, two integers and an arithmetic operator (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

009,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

010,

java Xxx

540, or

java Xxx

541), and performs the arithmetic operation accordingly. For example,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

0

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1

Bài tập về đối số dòng lệnh

LINK

(Advanced) Bitwise Operations

Bitwise Logical Operations

Bitwise operators perform operations on one or two operands on a bit-by-bit basis, as follows, in descending order of precedences

OperatorModeUsageDescriptionExample~Unary

java Xxx

542Bitwise NOT (inversion)&Binary

java Xxx

543Bitwise AND. Binary

java Xxx

544Bitwise OR^Binary

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

90Bitwise XOR

Example

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

2

Compound operator

java Xxx

546,

java Xxx

547 and

java Xxx

548 are also available, e. g. ,

java Xxx

549 is the same as

java Xxx

550

lưu ý rằng

java Xxx

551,

java Xxx

552 and

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

16 are applicable when both operands are integers (

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 and

java Xxx

09) or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s. When both operands are integers, they perform bitwise operations. When both operands are

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s, they perform logical AND, OR, XOR operations (i. e. , same as logical

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

85,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

20 and

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1434). They are not applicable to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37. On the other hand, logical AND (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

85) and OR (

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

20) are applicable to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s only

The bitwise NOT (or bit inversion) operator is represented as '~', which is different from logical NOT (
```
java Xxx
```
569)

The bitwise XOR is represented as

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

16, which is the same as logical XOR (

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

1434)

The operators' precedence is in this order.

java Xxx

572,

java Xxx

551,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

16,

java Xxx

552,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

17,

java Xxx

577. For example,

Bitwise operations are powerful and yet extremely efficient. [Example on advanced usage. ]

Bit-Shift Operations

Bit-shift operators perform left or right shift on an operand by a specified number of bits. Right-shift can be either signed-extended (

java Xxx

578) (padded with signed bit) or unsigned-extended (

java Xxx

579) (padded with zeros). Left-shift is always padded with zeros (for both signed and unsigned)

OperatorModeUsageDescriptionExample<java Xxx 580Left-shift and padded with zeros>>Binary

java Xxx

581Right-shift and padded with sign bit (signed-extended right-shift)>>>Binary

java Xxx

582Right-shift and padded with zeros (unsigned-extended right-shift)

Since all the Java's integers (byte, short, int and long) are signed integers, left-shift << and right-shift >> operators perform signed-extended bit shift. Signed-extended right shift >> pads the most significant bits with the sign bit to maintain its sign (i. e. , padded with zeros for positive numbers and ones for negative numbers). Operator >>> (introduced in Java, not in C/C++) is needed to perform unsigned-extended right shift, which always pads the most significant bits with zeros. There is no difference between the signed-extended and unsigned-extended left shift, as both operations pad the least significant bits with zeros

Example

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

3

As seen from the example, it is more efficient to use sign-right-shift to perform division by 2, 4, 8. (power of 2), as integers are stored in binary

[More example on advanced usage. ]

Types and Bitwise Operations

The bitwise operators are applicable to integral primitive types.

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045 and

java Xxx

09.

java Xxx

09 is treated as unsigned 16-bit integer. There are not applicable to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

046 and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

37. The

java Xxx

551,

java Xxx

552,

"Hello" + "world" ⇒ "Helloworld"
"Hi" + ", " + "world" + "!" ⇒ "Hi, world!"

16, when apply to two

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s, perform logical operations. Bit-shift operators are not applicable to

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

039s

Giống như các phép toán số học nhị phân

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

042,

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

043 and

java Xxx

09 operands are first promoted to

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34

If both the operands are of the same type (

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34 or

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045), they are evaluated in that type and returns a result of that type

If the operands are of different types, the smaller operand (

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

34) is promoted to the larger one (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045). It then operates on the larger type (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045) and returns a result in the larger type (

 public static string Increment(this String str)
 {
     var charArray = str.ToCharArray();
     for (int i = charArray.Length - 1; i >= 0; i--)
     {
         char originalChar = charArray[i];
         charArray[i] = charArray[i].Increment();

         if (!originalChar.isMaxChar() && char.IsLetterOrDigit(originalChar))
                break; // break when update the first alphanumeric char and it's not a max char  
     }
     return new string(charArray);
 }

045)

Algorithms

Before writing a program to solve a problem, you have to first develop the steps involved, called algorithm, and then translate the algorithm into programming statements. This is the hardest part in programming, which is also hard to teach because the it involves intuition, knowledge and experience

An algorithm is a step-by-step instruction to accomplice a task, which may involve decision and iteration. It is often expressed in English-like pseudocode, before translating into programming statement of a particular programming language. There is no standard on how to write pseudocode - simply write something that you, as well as other people, can understand the steps involved, and able to translate into a working program

Algorithm for Prime Testing

Ancient Greek mathematicians like Euclid and Eratosthenes (around 300-200 BC) had developed many algorithms (or step-by-step instructions) to work on prime numbers. By definition, a prime is a positive integer that is divisible by one and itself only

To test whether a number

java Xxx

74 is a prime number, we could apply the definition by dividing

java Xxx

74 by 2, 3, 4, . , up to

java Xxx

608. If no divisor is found, then

java Xxx

74 is a prime number. Since divisors come in pair, there is no need to try all the factors until x-1, but up to

java Xxx

610

TRY. translate the above pseudocode into a Java program called

java Xxx

611

Algorithm for Perfect Numbers

A positive integer is called a perfect number if the sum of all its proper divisor is equal to its value. For example, the number

java Xxx

612 is perfect because its proper divisors are

java Xxx

18,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

300, and

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

301, and

java Xxx

616; but the number

java Xxx

04 is not perfect because its proper divisors are

java Xxx

18,

[Theory]
[InlineData("a", "b")]
[InlineData("z", "a")]
[InlineData("c", "d")]

[InlineData("az", "ba")]
[InlineData("a9", "b0")]

[InlineData("a1a", "a1b")]
[InlineData("AAA", "AAB")]
[InlineData("abc", "abd")]

[InlineData("H98", "H99")]
[InlineData("H99", "I00")]
[InlineData("a99", "b00")]
[InlineData("I00", "I01")]
[InlineData("azz", "baa")]

[InlineData("bl9Zz", "bm0Aa")]

[InlineData("zzz", "aaa")]
[InlineData("ZZZ", "AAA")]
[InlineData("999", "000")]
[InlineData("z99", "a00")]

[InlineData("__a__", "__b__")]
[InlineData("__z__", "__a__")]
public void stringIncremental(string input, string expected)
{
    string result = input.Increment();
    Assert.Equal(result, expected);

}

[Theory]
[InlineData('a', 'b')]
[InlineData('z', 'a')]
[InlineData('c', 'd')]
[InlineData('k', 'l')]

[InlineData('A', 'B')]
[InlineData('Z', 'A')]
[InlineData('G', 'H')]
[InlineData('K', 'L')]

[InlineData('1', '2')]
[InlineData('9', '0')]
[InlineData('0', '1')]
[InlineData('5', '6')]

[InlineData('%', '%')]
[InlineData('-', '-')]
[InlineData('_', '_')]
[InlineData('/', '/')]
public void charIncremental(char input, char expected)
{
    char result = input.Increment();
    Assert.Equal(result, expected);
}

```

300, and

java Xxx

620, and

java Xxx

621. Other perfect numbers are

java Xxx

622,

java Xxx

623,

The following algorithm can be used to test for perfect number

TRY. translate the above pseudocode into a Java program called

java Xxx

624

Algorithm on Computing Greatest Common Divisor (GCD)

Another early algorithm developed by ancient Greek mathematician Euclid (300 BC) is to find the Greatest Common Divisor (GCD) (or Highest Common Factor (HCF)) of two integers. By definition,

java Xxx

625 is the largest factor that divides both

java Xxx

75 and

java Xxx

76

Assume that

java Xxx

75 and

java Xxx

76 are positive integers and

java Xxx

630, the Euclidean algorithm is based on these two properties

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

4

Ví dụ,

boolean done = true;
boolean gameOver = false;

boolean isValid;
isValid = false;

5

The Euclidean algorithm is as follows

Before explaining the algorithm, suppose we want to exchange (or swap) the values of two variables

java Xxx

74 and

java Xxx

95. Explain why the following code does not work

To swap the values of two variables, we need to define a temporary variable as follows

Let us look into the Euclidean algorithm,

java Xxx

633, if

java Xxx

76 is

java Xxx

17. Otherwise, we replace

java Xxx

75 by

java Xxx

76;

java Xxx

76 by

java Xxx

639, and compute

java Xxx

640. Repeat the process until the second term is

java Xxx

17. Try this out on pencil-and-paper to convince yourself that it works

Can you increment characters in C?

Yes, you can apply the ++ increment operator to an object of type char , with the expected results in most cases. char c = 42; c++; printf("c = %d\n", c); // prints 43.

Can we increment character in Java?

The increment and decrement operators can also be used on char variables to get the next or preceding Unicode character .

Tăng mỗi ký tự trong chuỗi thêm 1 C++

Basic Syntaxes

Steps in Writing a Java Program

Java Program Template

A Sample Program Illustrating Sequential, Decision and Loop Constructs

Comments

Statements and Blocks

White Spaces and Formatting Source Code

Variables and Types

Variables - Name, Type and Value

Mã định danh (hoặc Tên)

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

khuyến nghị

Sự định nghĩa biến

Hằng số (_______1004 biến)

Biểu thức

Các loại nguyên thủy và java Xxx 05

Các loại nguyên thủy tích hợp

Số nguyên so với. Số dấu phẩy động

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?

Số nguyên và số dấu phẩy động được vận hành như thế nào?

Bạn cần coi số nguyên và số Dấu phẩy động là hai loại DISTINCT trong lập trình

Sử dụng số nguyên nếu có thể (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 cần có phần phân số

Sự miêu tả dữ liệu

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

Một loại quan trọng hơn - java Xxx 05

Lựa chọn kiểu dữ liệu cho các biến

Quy tắc ngón tay cái để chọn loại dữ liệu

Literals cho các loại nguyên thủy và java Xxx 05

Nhân vật (java Xxx 09) Literals và Escape Sequences

java Xxx 05 Literals và Escape Sequences

Cuối Dòng (EOL)

Ví dụ về chữ

Hoạt động cơ bản

toán tử số học

biểu thức số học

Quy định về quyền ưu tiên

Loại chuyển đổi trong hoạt động số học

Phép toán số học hỗn hợp

Bản tóm tắt. Quy tắc chuyển đổi loại cho hoạt động nhị phân

Bản tóm tắt. Quy tắc chuyển đổi loại cho hoạt động đơn nguyên

Tìm hiểu thêm về Toán tử số học

Toán tử Modulus (Phần còn lại)

Số mũ?

Tràn/Chảy tràn

Thông tin thêm về Số nguyên so với. Số dấu phẩy động

loại đúc

Toán tử đúc kiểu và đúc kiểu rõ ràng

Truyền kiểu ngầm định trong bài tập

Toán tử gán hợp chất

Tăng giảm

Toán tử quan hệ và logic

So sánh bình đẳng "Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"01

Ưu tiên toán tử logic

Hoạt động ngắn mạch

Kiểm soát lưu lượng

Kiểm soát luồng tuần tự

Conditional Flow Control

java Xxx 45-then and java Xxx 45-then-java Xxx 46

Nested-java Xxx 45

Dangling-java Xxx 46 Problem

Nested-java Xxx 45 vs. Sequential-java Xxx 45

"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"75

Conditional Expression ( . "Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"90 . "Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"91 . )

Exercises on Getting Started and Conditional

Loop Flow Control

Loop's Index/Counter Variable

Code Example. Sum and Average of Running Integers

java Xxx 47-loop with Comma Separator

Terminating Program

Exercises on Decision and Loop

Input/Output

ví dụ

Code Example. Prompt User for Two Integers and Print their Sum

Code Example. Income Tax Calculator

Code Example. Income Tax Calculator with Sentinel

Code Example. Guess A Number

Exercises on Decision/Loop with Input

Formatted Output to Text File

Input via a Dialog Box

Một loại quan trọng hơn -
java Xxx
05

Literals cho các loại nguyên thủy và
java Xxx
05

Nhân vật (
java Xxx
09) Literals và Escape Sequences

java Xxx
05 Literals và Escape Sequences

So sánh bình đẳng
"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
01

java Xxx
45-then and
java Xxx
45-then-
java Xxx
46

Nested-
java Xxx
45

Dangling-
java Xxx
46 Problem

Nested-
java Xxx
45 vs. Sequential-
java Xxx
45

"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
75

Conditional Expression ( .
"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
90 .
"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
91 . )

java Xxx
47-loop with Comma Separator

java Xxx
028 (JDK 1. 6)

"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
88 and
java Xxx
063 - Interrupting Loop Flow

Labeled
"Hello" + "world" ⇒ "Helloworld" "Hi" + ", " + "world" + "!" ⇒ "Hi, world!"
88

Labeled
java Xxx
063

java Xxx
09 Arithmetic Operations

Hoạt động của
java Xxx
05

Chuyển đổi
java Xxx
05 sang Nguyên thủy

java Xxx
05 đến
java Xxx
236

java Xxx
05 đến
java Xxx
09

Chuyển đổi nguyên thủy thành
java Xxx
05

Định dạng
java Xxx
05s -
java Xxx
285

Exercises on
java Xxx
05 and
java Xxx
09 operations

Array's
java Xxx
374

java Xxx
384 (JDK 5)

Code Example. Hexadecimal to Binary (
java Xxx
404)

Code Example. Decimal to Hexadecimal (
java Xxx
430)