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

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

 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

  1. 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
  2. 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

  1. 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
  2. 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ị
  1. Điều quan trọng là chọn một tên tự mô tả và phản ánh chặt chẽ ý nghĩa của biến, 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
  2. 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ì?)
  3. 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. )
  4. Sử dụng danh từ số ít và số nhiều một cách thận trọng để phân biệt giữa 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

  1. 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),
  2. 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

  1. Số nguyên và số dấu phẩy động được biểu diễn và lưu trữ khác nhau
  2. Số nguyên và số dấu phẩy động được vận hành khác nhau
Số nguyên và số dấu phẩy động được biểu diễn và lưu trữ trong bộ nhớ máy tính như thế nào?

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<=>?@ABCDE7FGHIJKLMNO8PQRSTUVWXY9Z[\]^_`abc10defghijklm11nopqrstuvw12xyz{|}~Hex0123456789ABCDEF2SP!"#$%&'()*+,-./30123456789:;<=>?4@ABCDEFGHIJKLMNO5PQRSTUVWXYZ[\]^_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

  1. 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á
  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);
     }
    
    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
  3. 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
  4. 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,

  1. boolean done = true;
    boolean gameOver = false;
    
    boolean isValid;
    isValid = false;
    1407. Do đó,
    boolean done = true;
    boolean gameOver = false;
    
    boolean isValid;
    isValid = false;
    1408
  2. 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. )
  3. 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. )
  4. boolean done = true;
    boolean gameOver = false;
    
    boolean isValid;
    isValid = false;
    1414
  5. 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

  1. 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;
  2. 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;
  3. 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;
  4. 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

  1. 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;
  2. 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

  1. Truyền kiểu rõ ràng thông qua toán tử truyền kiểu, như được mô tả ở trên và
  2. 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
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ú

  1. 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ú

  1. 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

  1. Compilation Error (or Syntax Error). The program cannot compile. This can be fixed easily by checking the compilation error messages. For examples,
  2. 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,
  3. 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

  1. Stare at the screen. Unfortunately, nothing will pop-up even if you stare at it extremely hard
  2. Study the error messages. Do not close the console when error occurs and pretending that everything is fine. This helps most of the times
  3. 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
  4. Use a graphic debugger. This is the most effective means. Trace program execution step-by-step and watch the value of variables and outputs
  5. Advanced tools such as profiler (needed for checking memory leak and method usage)
  6. 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

  1. 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.
  2. 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ể

  1. 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
  2. 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
  3. 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ú

  1. 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
  2. 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
  3. 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)
  4. 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
  5. 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
  6. 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ú

  1. 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
  2. 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)
  3. 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
    1. 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
    2. 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
  4. 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

  1. 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
  2. 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ú
  1. 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)
  2. 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
  1. 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
  2. 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
    1. 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
    2. 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
  1. We use modulus/divide algorithm to get the hex digits (
    java Xxx
    
    205) in reserve order. See "Number System Conversion"
  2. 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

  1. 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
  2. Avoid repeating code. It is easy to copy and paste, but hard to maintain and synchronize all the copies
  3. 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

  1. The caller invokes a method and passes arguments to the method
  2. 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
  3. 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ú

  1. 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ú

  1. 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
  2. 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

  1. 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
  2. The bitwise NOT (or bit inversion) operator is represented as '~', which is different from logical NOT (
    java Xxx
    
    569)
  3. 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)
  4. 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 .