Architecture diagram
suspension
If only one logical judgment statement is connected, this statement will be connected with the nearest logical judgment statement, such as system. Out. Println ("none zero!") in the following example; Will be connected under the if structure, which is called suspension
while(iter < 10)
if(iter != 0)
System.out.println("none-zero!");
Errors often occur when the logic expressed by the indentation does not match the actual program execution logic
For example, in the following equation, when a is not greater than 1, the developer wants to assign b to 20, but the suspension feature of else statement is actually connected to the nearest logical judgment statement if (a > 1), so b will be assigned to 20 only when a is greater than 5. Indentation has no impact on the execution of the program
int a = -1;
int b = 0;
if(a > 1)
if(a > 5)
b = 1;
else
b = 10;
System.out.println("b = " + b);
Importance of braces
In fact, braces can be omitted when there is only one statement in the logical judgment. If the statement is also a logical judgment statement, the principle can continue to apply
For example, the following program. However, for the sake of readability, avoid nesting too many unnecessary logical structures
int a = 5;
if(a > 0)
if(a > 1)
if(a > 2)
if(a > 3)
if(a > 4)
System.out.println("hi");
If we add an else statement under each logical judgment and change the value of a, who is it actually hanging under?
Because the statements under logical judgment can be interpreted as if(...) {}, we can see that the nested if statements in the program example can actually be regarded as only one statement if(...){if(...) {...}}
The judgment of else statement is still allocated to the nearest logical judgment formula according to the characteristics of suspension. If the logical judgment formula has been allocated, else statement will be allocated like the previous layer
The following program types are commonly known as "wave fist" (see its shape). When actually writing programs, we should think about how to reduce the nesting level
int a = 11;
if(a > 0)
if(a > 10)
if(a > 20)
if(a > 30)
if(a > 40)
System.out.println("hi");
else
System.out.println("40");
else
System.out.println("0");
else
System.out.println("20");
else
System.out.println("10");
else
System.out.println("0");
Let's convert the above program into pseudo code. In fact, the following else statement can be imagined as a queue waiting for the queue crowd assigned to the above if statement
/*Treat as a single statement*/
if(...) // A
if(...) // B
if(...) // C
if(...) // D
if(...) // E
// do something
else // Assigned to E
System.out.println("...");
else // Assigned to D
System.out.println("...");
else // Assigned to C
System.out.println("...");
else // Assigned to B
System.out.println("...");
else // Assigned to A
System.out.println("...");
Therefore, the actual output results are:
20
If the developer does formatting such as indentation at the beginning of the design, the logical judgment of the program is easy to handle, otherwise it's really terrible... But anyway, try to add braces when writing the program, whether there is only one statement or not
Adding parentheses can make it easier for subsequent developers to understand the program logic and avoid program errors. For example, the following programs actually have two problems
- If (a > 5) can only hang one statement, that is, Sytem.out.println("a is greater than 5"); It will be executed anyway
- else statement must hang after if statement, but Sytem.out.println("a is greater than 5"); An error occurred because it does not belong to an IF statement
int a = 4;
if(a > 5)
Sytem.out.println("a Greater than 0");
Sytem.out.println("a Greater than 5");
else
Sytem.out.println("a Not more than 5");
Safer approach → it won't take you much valuable time (cherish the time of subsequent developers to debug) 🙏)
int a = 4;
if(a > 5){
Sytem.out.println("a Greater than 0");
Sytem.out.println("a Greater than 5");
}
else{
Sytem.out.println("a Not more than 5");
}
The compiler will treat the contents in braces as a statement, which is equivalent to hanging a statement under logical judgment, so let's take another example. The following two program structures are actually the same
for (int i=0; i<5; i++){
for (int j=0; j<5; j++){
for (int k=0; k<5; k++){
// do something
}
}
}
for(int i=0; i<5; i++)
for(int j=0; j<5; j++)
for(int k=0; k<5; k++){
// do something
}
null statement
When a semicolon is added directly to the end of a logical judgment statement, a so-called null statement is generated, that is, the logical judgment statement you write does nothing, and its function is the same as that of the curly braces added above
If the while statement encounters a null statement, it will encounter infinite loops. Similarly, if the for loop does not have a good exit mechanism, it is easy to get stuck in the infinite loop
For example, the following statements actually have null statement s, and only if statements can exit safely
if(i == 3);
while(iter != myobj.gain());
System.out.println("I'm here!");;
for(i=0;;i++);
Integer and brin
C/C + + does not have the so-called true Boolean value, so it uses non-0 and 0 instead. Therefore, we often see that integers are used as the basis for true or false in logical judgment statements
However, in java, boolean type cannot operate with other types. Therefore, statements such as if, while, do while, and for need to avoid mixed integer and Boolean judgment
For example, the following error program code
public static void main(String[] args){
int a=10, b=15, c=20, d=25;
if(a>b && b>c){
System.out.println("1. Successful execution");
}
else if((++d >= a--) == 1){ // boolean cannot be compared with an integer
System.out.println("2. Successful execution");
}
else{
System.out.println(3. Successful execution);
}
}
Use floating point for judgment
When actually writing programs, try not to use floating-point numbers for judgment. Although the following programs can run smoothly, the actual printed value is not equal to the judgment value, because there will be more or less errors in the operation and assignment of floating-point numbers. Try to use integer or other variable types as the basis for judgment
public class MathDemo {
public static void main(String[] args) {
float c=123456789.123456789f;
if(c > 123456789.123456789f){
System.out.println("c > 123456789.123456789");
}
else if(c == 123456789.123456789f){// DANGER
System.out.println("c == 123456789.123456789");
}
else{
System.out.println("c < 123456789.123456789");
}
System.out.println(c);
}
}
Data type judgment principle
Data types available for comparison
- int
- long
- double
- float
- char
- String
In principle, as long as it can pass through Automatic type conversion The matching variable types can be compared with each other. However, generally, they are compared between the same data types
int i = 6; long l = 18l; double d = 6.0d; float f = 6.0f; char ch = 'a'; String s = "a"; boolean b = true; /*Comparison between integers*/ System.out.println(i > l); // false /*Comparison between floating point numbers*/ System.out.println(f == d); // true /*Comparison between integers and floating point numbers*/ System.out.println(i == d); // true System.out.println(l > f); // true /*Between integer and character*/ System.out.println(i > ch); // false System.out.println(l > ch); // false /*Integers, floating point numbers, and characters cannot be compared with strings*/ System.out.println(i > s); System.out.println(d > s); System.out.println(ch == l); /*Boolean type cannot be compared with any type*/ System.out.println(i > b); System.out.println(l > b); System.out.println(f > b); System.out.println(d > b); System.out.println(ch > b); System.out.println(s > b);
case down problem
If the break statement is not filled in the case of the switch statement, the Execution Authority will automatically execute another case downward until a break is encountered
For example, in the following switch case, after annotating all break s, all expressions below the current case will be executed
int a = 100;
switch(a/10){
case 10:
case 9:
System.out.println("A");
// break;
case 8:
case 7:
System.out.println("B");
// break;
case 6:
System.out.println("C");
// break;
default:
System.out.println("fail,");
// break;
}
Output results:
A B C fail,
When the program executes output at the same time under multiple different conditions, you may wish to check whether the case of the stwich statement is correctly filled in the break statement
Output type of switch
The values of expressions after JDK7.0 can be basic data types byte, short, int, char, and String, but the data type in the switch judgment must be consistent with the variable type after case, otherwise an exception will be thrown during program execution
The variable type of the expression after switch cannot be long, float, double or Boolean. Remember the precision of floating point numbers, so it is not suitable for judgment in switch statements. Brin has a better understanding of the problem that can be solved with if without using switch structure
As for long, it is quite special. See whether the long type will be added in the subsequent java updates. It is not supported at present
Scanner s = new Scanner(System.in);
System.out.print("Input string str: ");
String str = s.next();
switch(str){
case "apple":
System.out.println("Apple");
break;
case "banana":
System.out.println("Banana");
break;
case "watermelon":
System.out.println("watermelon");
break;
case "papaya":
System.out.println("Papaya");
break;
default:
System.out.println("There is no such fruit");
break;
}
Expression for
Let's first look at the order in which the for statement is executed. Take the following code as an example
First, int n=1 is an initialization statement to assign a value to the local variable n (or other declared variables). This statement will be executed only once
Next, judge whether the variable meets the condition n < 5. If it is true, enter the loop
After completing the statement in the loop, the local variable n will be incremented by N + +, and then judge whether it meets n < 5. If it is true, enter the loop again, otherwise exit the for loop. The subsequent loop processing is the part of the loop
for(int n=1; n<5; n++){
// do something
}
As like as two peas, we can see that the expression logic of for is presented in while way, which is believed to be better understood. As seen in the following pseudo code, the functions of the two logical judgments are exactly the same.
for(int i=100; (i%5 == 0)&(i > 8); i=i-8){
System.out.println("i = " + i);
}
int i = 100;
while((i%5 == 0)&(i > 8)){
System.out.println("i = " + i);
i -= 8;
}
The output results are:
i = 100
Omit expression
The three judgements of the for loop can be omitted, and the default is true after the second one is omitted
For example, omitting the first expression is equivalent to removing the initialization function. If you want the program to run normally, you need to initialize the variables
int i = 0;
for(; i<5; i++){
System.out.println("hi");
}
Omitting the second judgment is equivalent to omitting the condition for leaving the for loop, so that the first semicolon is always true, which will make the program unable to jump out of the loop
If you do not want the program to become an infinite loop, you can write a conditional statement to execute the jump in the loop
int a = 0;
for(int i=0;;i++){
if(i>10)
break;
a++;
}
System.out.println("a = " + a);
Omitting the third expression is equivalent to removing the variable operation that will be performed later in the loop. This expression will submit the operation result to the second judgment expression to arbitrate whether to enter the loop again
Omitting this item may also cause infinite loop, because the judgment variable has not changed since initialization, so an expression must be added to the loop body to execute correctly
for(int i=0; i<50;){
if(i%2 == 0){
System.out.println("even!");
i += 7;
}
}
Omit three expressions, which are expressed as an infinite loop, which is equivalent to a while(1) loop
for(;;){}
while(1){}
Fill in multiple judgements in for
In addition to the second judgment, the first and third judgment can be extended
For example, the following program initializes i and j at the same time and performs operation on these two variables, but there will only be j < Q for exit loop condition, which cannot be extended
int i, j;
int p = 0, q = 8;
for(i = 0, j = 0; j < q; --i, j++){
System.out.println("i = " + i + ", j = " + j);
}
Output results:
i = 0, j = 0 i = -1, j = 1 i = -2, j = 2 i = -3, j = 3 i = -4, j = 4 i = -5, j = 5 i = -6, j = 6 i = -7, j = 7
Interested friends can use the extended function of for loop to write some code. For example, the following code refers to printing a 99 multiplication table using a for loop loop
But remember not to do this when actually writing programs Hey 😎
for(int i=1, j=1; j<10; i=(i==9 ? (++j/j) : i+1)){
System.out.print(i + " * " + j + " = " + i*j + (i==9 ? '\n' : ", "));
}
Output results:
1 * 1 = 1, 2 * 1 = 2, 3 * 1 = 3, 4 * 1 = 4, 5 * 1 = 5, 6 * 1 = 6, 7 * 1 = 7, 8 * 1 = 8, 9 * 1 = 9 1 * 2 = 2, 2 * 2 = 4, 3 * 2 = 6, 4 * 2 = 8, 5 * 2 = 10, 6 * 2 = 12, 7 * 2 = 14, 8 * 2 = 16, 9 * 2 = 18 1 * 3 = 3, 2 * 3 = 6, 3 * 3 = 9, 4 * 3 = 12, 5 * 3 = 15, 6 * 3 = 18, 7 * 3 = 21, 8 * 3 = 24, 9 * 3 = 27 1 * 4 = 4, 2 * 4 = 8, 3 * 4 = 12, 4 * 4 = 16, 5 * 4 = 20, 6 * 4 = 24, 7 * 4 = 28, 8 * 4 = 32, 9 * 4 = 36 1 * 5 = 5, 2 * 5 = 10, 3 * 5 = 15, 4 * 5 = 20, 5 * 5 = 25, 6 * 5 = 30, 7 * 5 = 35, 8 * 5 = 40, 9 * 5 = 45 1 * 6 = 6, 2 * 6 = 12, 3 * 6 = 18, 4 * 6 = 24, 5 * 6 = 30, 6 * 6 = 36, 7 * 6 = 42, 8 * 6 = 48, 9 * 6 = 54 1 * 7 = 7, 2 * 7 = 14, 3 * 7 = 21, 4 * 7 = 28, 5 * 7 = 35, 6 * 7 = 42, 7 * 7 = 49, 8 * 7 = 56, 9 * 7 = 63 1 * 8 = 8, 2 * 8 = 16, 3 * 8 = 24, 4 * 8 = 32, 5 * 8 = 40, 6 * 8 = 48, 7 * 8 = 56, 8 * 8 = 64, 9 * 8 = 72 1 * 9 = 9, 2 * 9 = 18, 3 * 9 = 27, 4 * 9 = 36, 5 * 9 = 45, 6 * 9 = 54, 7 * 9 = 63, 8 * 9 = 72, 9 * 9 = 81
The problem of while(i == i+1)
Please think about such a problem. How much should i be assigned to make the following while loop become infinite loop
while(i == i + 1){}
This problem is bound to involve the question of what variables will be equal to themselves after adding 1 in java official document Gives a very clear answer
The (positive and negative) infinite value or a very large value of a floating-point number is still equal to itself after addition and subtraction with a finite value or an infinite value equal to its own sign
Therefore, we set the floating-point number to positive and negative infinity, and found that we can set the while() judgment to infinite loop
float i = Float.POSITIVE_INFINITY; // Positive infinity
// float i = Float.NEGATIVE_INFINITY; // Negative infinity
// double i = Double.POSITIVE_INFINITY; // double type can also be used
while(i == i + 1){}
In addition, the accuracy of floating-point numbers has a minimum limit, that is, when floating-point variables are assigned a very large value, addition and subtraction will not affect the original value
For example, adding 1 to the minimum value of float is actually equal to itself
float i = -Float.MAX_VALUE;
while(i == i + 1){}
Or manually assign a very large positive and negative constant to get the same effect
float i = 9999999999999f;
while(i == i + 1){}
For the minimum value of floating point numbers, refer to the previous article