流程控制语句
Java中的控制语句与其他语言基本大同小异，主要分为：顺序结构、选择结构和循环结构三类。
个人的理解方法是把控制语句翻译成中文的意思，方便理解其逻辑(仅供参考)
- 顺序结构即先执行a后执行b的逻辑
- 选择结构即如果…则…的逻辑
- 循环结构即如果…则继续…的逻辑
顺序结构就很好理解自上而下，逐条运行；
选择结构则需要有一个判断，如果判断成立则运行判断语句块里的语句，不成立则跳出；
循环结构同样需要一个判断，如果符合这个判断则就循环运行循环体里的语句，不符合就跳出循环。
三种逻辑结构相互支撑，构成了各种奇妙复杂的算法，无论多难的算法究其根本都是以它们来表达，以下主要记录选择结构以及循环结构的基础以及要点。
选择结构
选择结构分为：1.if单选择结构；2.if-else双选择结构；3.if-else if-else多选择结构；4.switch多选择结构
- 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！");
- 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！");
}
}
}
对于以上代码我们只需要在单选择结构的基础上加一个语句块，以此来完善逻辑。
- 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！");
}
}
}
- 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循环即直到型循环结构。
- 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。
- 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先执行循环体，后执行布尔表达式判断，所以不管布尔值表达式结果如何，循环体都至少会被执行一次！
- 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循环都是可以相互替换的，所以在实际使用中，往往根据需求来选择使用的循环结构。
- 嵌套循环
嵌套循环即在一个循环语句内部再嵌套一个或者多个循环，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中常用的转义字符
| 转义序列 | 功能描述 |
|---|---|
| \r | 回车符，将光标定位到当前行的开头，不会跳到下一行 |
| \n | 换行符，换到下一行的开头 |
| \t | 制表符，将光标移到下一个制表符的位置，就像在文档中用Tab键一样 |
| \b | 退格符号，就像键盘上的 Backspace键 |
| \f | 换页符号，切换到下一页 |
| \’ | 单引号字符，如果直接使用‘则会报错，所以使用转义字符解决这一问题 |
| \" | 双引号字符，如果直接使用"则会报错，所以使用转义字符解决这一问题 |
| \\ | 在java代码中的反斜杠\)是转义字符，因此需要表示字面意义上的\，就需要使用双反斜杠（\\） |
| \ddd | 八进制字符串 |
| \xddd | 十六进制字符串 |
| \udddd | 十六进制Unicode双字节字符串 |
递归结构
上面说了所有的复杂算法都是以三种逻辑结构相互支撑来表达的，递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。
递归包含了递归头和递归体
递归头定义了什么时候不调用自身方法，如果没有递归头程序就会陷入死循环
递归体定义了什么时候需要调用自身方法
例如，使用递归算法来实现阶乘：
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）。基线条件是递归程序的 最底层位置，在此位置时没有必要再进行操作，可以直接返回一个结果。所有递归程序都必须至少拥有一个基线条件，而且必须确保它们最终会达到某个基线条件；否则，程序将永远运行下去，直到程序缺少内存或者栈空间。
利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。
