21天学会Java之(Java SE第二篇):流程控制语句、Java中常用的转义字符、递归结构

分手后的思念是犯贱 2023-07-17 09:51 7阅读 0赞

### 文章目录 ###

*   *  流程控制语句
     *   *   *  选择结构
             *  循环结构
             *  break语句和continue语句
     *  Java中常用的转义字符
     *  递归结构

## 流程控制语句 ##

Java中的控制语句与其他语言基本大同小异，主要分为：顺序结构、选择结构和循环结构三类。  
*个人的理解方法是把控制语句翻译成中文的意思，方便理解其逻辑(仅供参考)*

1.  顺序结构即先执行a后执行b的逻辑
2.  选择结构即如果…则…的逻辑
3.  循环结构即如果…则继续…的逻辑

顺序结构就很好理解自上而下，逐条运行；  
选择结构则需要有一个判断，如果判断成立则运行判断语句块里的语句，不成立则跳出；  
循环结构同样需要一个判断，如果符合这个判断则就循环运行循环体里的语句，不符合就跳出循环。  
三种逻辑结构相互支撑，构成了各种奇妙复杂的算法，无论多难的算法究其根本都是以它们来表达，以下主要记录选择结构以及循环结构的基础以及要点。

#### 选择结构 ####

选择结构分为：1.if单选择结构；2.if-else双选择结构；3.if-else if-else多选择结构；4.switch多选择结构

1.  **if单选择结构**  
    语法形式：

if(布尔表达式){
        
        语句块;
    }

if语句中首先对布尔表达式进行判断如果结果为真则执行语句块内容。  
例如，用if单选择结构来判断给定的数值是否大于100：

public class IfTest{
        
    	public static void main(String[] args) {
        
    		int a=100;
    		if (a>100) {
        
    			System.out.println("a大于100！");
    		}
    	}
    }

首先我们有一个int类型的变量a，给它赋值为100；然后执行布尔表达式`a>100`，其结果为false，则就不会执行`System.out.println("a大于100！");`

1.  **if-else双选择结构**  
    语法形式：

if(布尔表达式){
        
        语句块1;
    }else{
        
        语句块2;
    }

if-else语句中首先对布尔表达式进行判断如果结果为真则执行语句块1的内容，否则则执行语句块2内容。  
例如，用if-else双选择结构来判断对于给定数值大于100或者不大于100：

public class If_elseTest{
        
    	public static void main(String[] args) {
        
    		int a=100;
    		if (a>100) {
        
    			System.out.println("a大于100！");
    		}else{
        
                System.out.println("a不大于100！");
            }
    	}
    }

对于以上代码我们只需要在单选择结构的基础上加一个语句块，以此来完善逻辑。

1.  **if-else if-else多选择结构**  
    语法形式：

if(布尔表达式1) {
        
    	语句块1;
    }else if(布尔表达式2) {
        
    	语句块2;
    }……
    else if(布尔表达式n){
        
        语句块n;
    }else {
        
        语句块n+1;
    }

if-else if-else语句可以有多个布尔表达式，以及多个语句块。具体运行规则即布尔表达式1为真，结果为真则运行语句块1，否则判断布尔表达式2是否为真，如果为真即运行语句块2，以此类推，如果布尔表达式1~n都为假则运行语句块n+1。  
例如，用if-else if-else多选择结构来判断对于给定数值大于、等于或小于100：

public class If_elseif_elseTest{
        
    	public static void main(String[] args) {
        
    		int a=100;
    		if (a>100) {
        
    			System.out.println("a大于100！");
    		}else if(a<100){
        
                System.out.println("a小于100！");
            }else{
        
                System.out.println("a等于100！");
            }
    	}
    }

1.  switch多选择结构  
    语法形式：

switch (表达式) {
        
    case 值1: 
    	语句序列1;
    	[break];
    case 值2:
    	语句序列2;
    	[break];
    ……
    [default:
     	默认语句;]
    }

switch语句会根据表达式的值从对应的case处开始执行，一直到执行到break语句`break语句不需要每个case里都写，但是这样会继续执行下一句语句，所以一般情况下每个case里都会写上`或者执行完switch语句，如果表达式的值与所有的case中的值都不匹配执行default语句(default语句可以不写，这样所有的值都不匹配的话则跳出switch语句)  
例如，用switch多选择结构判断给定的日期是星期几：

public class SwitchTest {
        
    	public static void main(String[] args) {
        
    		String week="星期日";
    		switch (week) {
        
    		case "星期日":
    			System.out.println("今天是星期日");
    			break;
    		case "星期一":
    			System.out.println("今天是星期一");
    			break;
    		case "星期二":
    			System.out.println("今天是星期二");
    			break;
    		case "星期三":
    			System.out.println("今天是星期三");
    			break;
    		case "星期四":
    			System.out.println("今天是星期四");
    			break;
    		case "星期五":
    			System.out.println("今天是星期五");
    			break;
    		case "星期六":
    			System.out.println("今天是星期六");
    			break;
    		//可以不写
    //		default :
    //			System.out.println("请输入正确的日期");
    		}
    	}
    }

如以上例子，给定一个日期星期日，与`case "星期日":`匹配则运行了`System.out.println("今天是星期日");`，且碰到了`break;`，则输出结果：今天是星期日。而如果把该语句里所有break都去除掉则运行结果则会出现以下结果:

今天是星期日
    今天是星期一
    今天是星期二
    今天是星期三
    今天是星期四
    今天是星期五
    今天是星期六

所以在实际使用中，我们一般都会根据逻辑在case中加入break语句

#### 循环结构 ####

循环结构分为：1.while循环；2.do-while循环；3.for循环；4.嵌套循环，主要为当型和直到型两种类型。  
当型即当布尔表达式为真时，则反复执行循环体，当布尔表达式为假时则结束循环；while循环和for循环即是当型循环结构。  
直到型即先执行循环体，然后判断布尔表达式，如果布尔表达式结果为真则继续循环执行语句块，直到布尔表达式结果为假时则停止循环；do-while循环即直到型循环结构。

1.  **while循环**  
    语法形式：

while(布尔表达式){
        
        循环体;
    }

例如，用while语句计算1-100的总和：

public class WhileTest {
        
        public static void main(String[] args) {
        
            int sum=0;
            int i=1;
            while(i<=100){
        
                sum+=i;
                i++;
            }
            System.out.println(num);
        }
    }

刚开始给定一个计数的变量sum赋值0，一个计数变量i赋值1，然后执行循环结构的布尔表达式`i<=100`，结果为true执行循环体`sum+=i;i++;`的语句，直到i=101时不满足布尔表达式条件后跳出循环，依照顺序结构往下执行`System.out.println(num);`语句，得到1-100的和结果为5050。

1.  **do-while循环**  
    语法形式：

do{
        
        循环体;
    }while(布尔表达式);

同样使用do-while语句计算1-100的和：

public class Do_whileTest {
        
        public static void main(String[] args) {
        
            int sum=0;
            int i=1;
            do {
        
                sum+=i;
                i++;
            }while (i<=100);
            System.out.println(sum);
        }
    }

与while循环不同的是do-while先执行循环体，后执行布尔表达式判断，**所以不管布尔值表达式结果如何，循环体都至少会被执行一次！**

1.  **for循环**  
    语法形式：

for(初始表达式;布尔表达式;迭代因子){
        
        循环体;
    }

使用for语句计算1-100的和：

public class ForTest {
        
        public static void main(String[] args) {
        
            int num=0;
            for (int i=1;i<=100;i++){
        
                num+=i;
            }
            System.out.println(num);
        }
    }

与while和do-while循环一样，给予整数型变量num和i，以上三个例子表明while，do-while和for循环都是可以相互替换的，所以在实际使用中，往往根据需求来选择使用的循环结构。

1.  **嵌套循环**

嵌套循环即在一个循环语句内部再嵌套一个或者多个循环，while，do-while和for循环可以任意的嵌套  
例如，用嵌套循环打印99乘法表：

public class MultiplicationTable {
        
        public static void main(String[] args) {
        
            for (int i = 1; i <=9 ; i++) {
          //用第一个for循环打印出9行
                for (int j = 1; j <= i ; j++) {
          //用第二个for循环打印出列
                    int value=i*j;  //计算i*j的值
                    System.out.print(i+"*"+j+"="+value+"\t");  //用字符串连接符,"\t"为制表符的转义字符(跳到下个tab位置)
                }
                System.out.println();  //使用第二个for循环打印完每一行的结果后，换行
            }
        }
    }

得出结果：

1*1=1	
    2*1=2	2*2=4	
    3*1=3	3*2=6	3*3=9	
    4*1=4	4*2=8	4*3=12	4*4=16	
    5*1=5	5*2=10	5*3=15	5*4=20	5*5=25	
    6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36	
    7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49	
    8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64	
    9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

#### break语句和continue语句 ####

在任何的循环结构语句的主体部分中都可以使用break和continue语句控制循环的流程。  
break用于跳出循环，不执行循环中剩余的语句。  
continue用于跳出一次循环，继续执行下次是否循环的判断。

## Java中常用的转义字符 ##

<table> 
 <thead> 
  <tr> 
   <th align="center">转义序列</th> 
   <th align="center">功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">\r</td> 
   <td align="center">回车符，将光标定位到当前行的开头，不会跳到下一行</td> 
  </tr> 
  <tr> 
   <td align="center">\n</td> 
   <td align="center">换行符，换到下一行的开头</td> 
  </tr> 
  <tr> 
   <td align="center">\t</td> 
   <td align="center">制表符，将光标移到下一个制表符的位置，就像在文档中用Tab键一样</td> 
  </tr> 
  <tr> 
   <td align="center">\b</td> 
   <td align="center">退格符号，就像键盘上的 Backspace键</td> 
  </tr> 
  <tr> 
   <td align="center">\f</td> 
   <td align="center">换页符号，切换到下一页</td> 
  </tr> 
  <tr> 
   <td align="center">\’</td> 
   <td align="center">单引号字符，如果直接使用‘则会报错，所以使用转义字符解决这一问题</td> 
  </tr> 
  <tr> 
   <td align="center">\"</td> 
   <td align="center">双引号字符，如果直接使用"则会报错，所以使用转义字符解决这一问题</td> 
  </tr> 
  <tr> 
   <td align="center">\\</td> 
   <td align="center">在java代码中的反斜杠\)是转义字符，因此需要表示字面意义上的\，就需要使用双反斜杠（\\）</td> 
  </tr> 
  <tr> 
   <td align="center">\ddd</td> 
   <td align="center">八进制字符串</td> 
  </tr> 
  <tr> 
   <td align="center">\xddd</td> 
   <td align="center">十六进制字符串</td> 
  </tr> 
  <tr> 
   <td align="center">\udddd</td> 
   <td align="center">十六进制Unicode双字节字符串</td> 
  </tr> 
 </tbody> 
</table>

## 递归结构 ##

上面说了所有的复杂算法都是以三种逻辑结构相互支撑来表达的，递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。  
递归包含了递归头和递归体  
递归头定义了什么时候不调用自身方法，如果没有递归头程序就会陷入死循环  
递归体定义了什么时候需要调用自身方法  
例如，使用递归算法来实现阶乘：

public class Recursion {
        
        public static void main(String[] args) {
        
            System.out.println(factorial(10));
        }
        public static long factorial(int num){
        
            if (num==1){
          //递归头
                return 1;
            }else{
          //递归体
                //实现num*num-1*...*2*1，到num=1时则会执行return 1;语句不在执行else后的语句
                return num*factorial(num-1);  //num!=num*factorial(num-1)
            }
        }
    }

可见，只要初始值大于零，这个函数就能够终止。停止的位置称为基线条件（base case）。基线条件是递归程序的 最底层位置，在此位置时没有必要再进行操作，可以直接返回一个结果。所有递归程序都必须至少拥有一个基线条件，而且必须确保它们最终会达到某个基线条件；否则，程序将永远运行下去，直到程序缺少内存或者栈空间。  
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。