1~8章总结

IF选择结构

学习完一些数据类型之后如（基本数据类型: 整数int,long小数double,float和单个字符:char）(还有个引用数据类型：String记住一定要大写)和布尔类型:boolean只能存储真(true)或假(flase).另外还学习了一些运算符，包括算术运算符，赋值运算符及关系运算符。

前两章中，我们编写的程序总是从程序入口开始，按顺序执行每一条语句，知道执行完最后一条语句，但是生活中经常需要进行条件判断，根据判断结果决定是否做一件事情。if-else 主要解决只有两种可能结果的问题下面请大家看代码：

IF选择结构语法

public class Demo{
    public static void main(String[]args){
        //语句1；
        //语句2；
        if(条件){//只能放boolean值满足就输出大括号的
            //语句3；
        }else{//不满足则执行大括号里面的
            //语句4；
        }        
    }
}

上面这个是模板，大家应该有点不懂吧，下面我给大家看下

IF选择结构流程图：

多重if选择结构

但不过有些问题，我们可以确定使用单个IF选择结构无法完成。那么可以使用多个if选择结构来实现。但是条件写起来也很麻烦。Java中还有一种if选择结构的形式:多重if选择结构。多重if选择结构在解决需要判断的条件是连续的区间时有很大的优势。多重if选择结构不是多个基本if选择结构简单的排列在一起，

多重if选择结构语法具体如下：

if(条件1){
    //条件1成立时语句
}else if(条件2){
    //条件2成立时语句
}else if(条件3){
    //条件3成立时语句
}else{
    //条件1,2,3都不成立时语句
}

多重if选择结构到底如何执行呢？首先程序判断条件1，如果成立，则执行代码块1，然后直接跳出这个多重if选择结构，执行它后面的代码。这种情况下，代码块2和代码块3都不会被执行。如果条件1不成立，则判断条件2.如果条件2成立，则执行代码块2，然后跳出这个多重if选择结构，执行它后面的代码块，然后跳出这个多重if选择结构，执行她后面的代码。这种情况下，代码块1和代码块3不会被执行，如果条件2也不成立，则代码块1和代码块2都不执行，直接执行代码块3.

• 多重if结构 主要解决有多种可能结果的问题永远只执行其中一个分支
• 其中，else if块可以有多个，需要几个else if块完全取决与需要。
• else块最多有一个或没有，else块必须要放在else if快之后。

还有一些符号能让你更好的使用if选择结构进行判断：

运 算 符	汉 语 名 称	表 达 式	说 明
&&	与，并且	条件1&&条件2	两个条件同时为真，则结果为真
||	或，或者	条件1||条件2	两个条件一个为真，则结果为真
!	非	非	条件为真时结果为假，条件假则为真

多重if选择结构示例

public class ScoreAssess{
	public static void main(){
		int score = 70;				//考试成绩
        if(score >= 80){			//考试成绩>=80
            System.out.println("良好");
        }else if(score >= 60){		//80>考试成绩>=60
            System.out.println("中等");
        }else{						//考试成绩<60
            System.out.println("差");
        }
	}
}

看上面代码考试成绩70分不满足条件1所以不执行第一个代码快，则继续往下面判断:可以看出它满足条件2则执行条件2后面大括号里面的代码块所以输出中等；然后跳出这个多重if选择结构。

流程图：

嵌套if选择结构：

学校举行运动会，百米赛跑成绩在10秒以内的所有学生有资格进决赛，根据性别分为男子组和女子组。首先要判断是否能够进决赛，在确定进入决赛的情况下，在判断是进入男子组，还是进入女子组。这就需要使用嵌套if选择结构来解决。

嵌套if选择结构流程图:

怎么使用嵌套if选择结构:

那么现在我们就使用嵌套if选择结构解决这个问题:

import java.util.Scanner;
public class Zhang{
    public static void mian(String[]args){
        Scanner input = new Scanner(System.in);
        System.out.print("请输入比赛成绩(s)");
        double score = input.nextDouble();
        System.out.println("请输入性别");
        String gender = input.next();
        if(score<=10){
            if(gender.equals("男")){
                System.out.println("进入男子组决赛！");
            }else if(gender.equals("女")){
                System.out.println("进入女子组决赛");
            }
        }else{
            system.out.println("淘汰!")
        }
    }
}

嵌套if选择结构注意事项：

• 只有当满足外层if选择结构的条件时，才会判断内层if的条件。
• else总是与他前面最近的那个缺少else的if配置。

if结构书写规范如下:

• 为了使if结构更加清晰，应该吧每个if或else包含的代码块用大括号括起来。
• 相匹配的一对if和else应该左对齐。
• 内层的if结构相对于外层的if结构要有一定的缩进。

switch选择结构

学习了基本的if选择结构，多重if选择结构和嵌套if选择结构，能够使用if选择结构解决分支问题。那么我跟大家出个题目吧:

韩燕参加计算机编程大赛：

如果获得第一名，将参加麻省理工大学组织的一个月夏令营；

如果获得第二名，将奖励惠普笔记本电脑一部；

如果获得第三民，将奖励移动硬盘一个；

否则，没有任何奖励。

这个问题可以用多重if选择结构来解决。的确，使用多重if选择结构完全可以解决，代码如

public class ScoreAssess{
	public static void main(){
		int mingCi = 3;				
        if(mingCi == 1){			
            System.out.println("参加麻省理工大学组织的一个月夏令营");
        }else if(mingCi == 2){		
            System.out.println("奖励惠普笔记本电脑一部");
        }else if(mingCi == 3){						
            System.out.println("奖励移动硬盘一个");
        }else{
            System.out.println("没有奖励");
        }
	}
}

虽然解决了这个问题，可是看上去很烦琐。这个问题跟前面的问题比起来有什么不同？显然这个问题是等值的判断，之前的问题是区间判断。对此Java提供了另一种结构，可以方便的解决等职判断问题，这就是switch选择结构.

什么是switch选择结构:switch选择结构可以更好的解决等值判断问题

switch选择结构语法:

switch(表达式){
	case 常量1：
        //代码块1;
        break;
    case 常量2：
        //代码块2;
        break;
    case 常量3：
        //代码块3;
        break;
        .......
    default:
        //代码块n;
        break;
}

这里switch，case，default，break都是Java的关键字。

switch选择结构用到了四个关键字，下面将一一介绍。

• switch：表示“开关”，这个开关就是switch关键字后面小括号里表达式的值，jdk1.7后switch语句小括号里可以是int，short,byte,char，枚举类型,String类型表达式。
• case：“情况，情形”，case后可以是是int，short,byte,char，枚举类型,String类型，通常是一个固定的值。case块可以有多个，顺序可以改变，但是每个case后常量的值必须各不相同。
• default：表示“默认”，及其他情况都不满足。但是default后面要紧跟冒号。default块和case块的先后顺序可以变动，不会影响程序执行的结果。通常，default块放在末尾，也可以省略。
• break：表示“停止”，及跳出当前结构。

知道了switch选择结构的语法，那么它的执行过程是怎样的呢？具体如下所述。

并计算并获得switch后面的小括号里的表达式或变量的值，然后将计算结果顺序与每个case后的常量比较，当二者相等时，执行这个case块中的代码；当遇到break时，就跳出switch选择结构，执行switch选择结构之后的代码。如果没有任何一个case后的常量与switch后的小括号中的值相等，则执行switch末尾部分的的default块中的代码。

如何使用switch选择结构

了解switch选择结构的语法及它的执行过程之后，下面就来用switch选择结构解决等值判断的问题看下面代码：

public class ScoreAssess{
	public static void main(){
		int mingCi = 1;				
        switch(mingCi){
            case 1:
            	System.out.println("参加麻省理工大学组织的一个月夏令营");
                break;
            case 2:
            	System.out.println("奖励惠普笔记本电脑一部");
       			break;
            case 3:    
            	System.out.println("奖励移动硬盘一个");
        		break;
            default:    
            	System.out.println("没有奖励");
                break;
        }
	}
}

可见，括号中的mingCi的值为一，与第一个case块中的常量值匹配，因此执行他后面的代码，输出"参加麻省理工大学组织的一个月夏令营"，然后执行“break”执行结果时跳出整个switch选择结构。

与上面那个多重if比起来用switch看起来更清晰一些，他们完成的功能其实是完全一样的。但是，并非所有的多重if选择结构都可以用switch选择结构代替。通过观察，可以看出，switch选择结构的条件只能是等值的判断，而且只能是整型或字符型的等值判断。也就是说，switch选择结构只能用于一个字符的情况，并且每一个case后面的常量值都不同。而多重if选择结构既可以用于判断条件是等值的情况，也可以用于判断条件是区间的情况。

注意：

• 虽然break语句可以是省略的，但是省略后会带来一些问题。省略break的后果的如下：当某个case后的常量值与switch后的小括号中的值相匹配时，执行该case块的代码，后面的case就不再进行条件判断，而直接执行后面所有case块中的代码，值到遇到break结束。所以在编写switch选择结构时不要忘记在每个case块后加上一个break；用来跳出switch选择结构。
• 每个case后的代码块可以有多个语句，既可以有一组语句，而且不需要用“{}”括号起来。case和default后都有一个冒号，不能漏写，否则编译不通过。对于每个case的结尾，都要想一想是否需要从这里跳出整个switch选择结构。如果需要，一定不要忘记写“break”。
• 在case后面的代码块中，break语句可以省略的，还可以让多个case执行同一语句。例如，在下面的代码中，当变量day的值为1，3，5时，都将输出“奇数!";当变量day的值为2，4，6时，都将输出“偶数！”。

int num = 3;
switch(num){
    case 1:
    case 3:
    case 5:
        system.out.println("奇数");
        break;
    case 2:
    case 4:
    case 6:
        system.out.println("偶数");
        break;
}

选择结构小结

到此，大家会发现多重if选择结构和switch选择结构很相似，它们都是用来处理多分支条件的结构，但是switch选择结构只能用于等值条件判断的情况。

循环结构

while循环

当程序需要重复执行一段代码时，使用循环结构。循环结构的特点是在给定的条件成立时，反复执行一段代码，直到条件不成立。
Java中有三种循环结构：

• while循环
• do-while循环
• for循环

while循环语法：

while循环先判断循环条件，条件为true，则执行循环体，条件为false，则一次也不执行循环体
注意：循环条件为true，如果没有在{}里面改变循环条件的话，会出现死循环。

使用while循环结构解决问题的步骤如下：

• 分析循环条件和循环操作。

• 套用while语法写出代码。

• 检查循环能否退出。

  注意：

  使用while循环结构解决问题时，一定要注意检查循环能否退出，及避免出现"死循环"现象。

//变量初始化
while(循环条件){
    //循环体；
    //迭代；
}

public class whileDemo2{
	public static void main(String[]args){
		int i = 1;
		while(i<=100){
			 system.out.println("第"+i+"遍好好学习，天天向上!");
            i++;
		}
	}
}

这个代码运行后会输出100遍的"好好学习，天天向上!"

while循环结构执行顺序一般如下：

1. 声明并初始化循环变量。
2. 判断循环条件是否满足，如果满足则执行循环操作；否则退出循环。
3. 执行完循环操作后，再次判断循环条件，决定继续执行循环或退出循环

实际上，while循环结构如果第一次判断循环条件就不满足，则会直接跳出循环，循环操作一遍都不会执行。这时while循环结构的一个特点：先判断后执行。

while语法流程图：

do-while循环

do-while循环语法：

do-while循环先执行一次循环体，再判断循环条件，条件为true，则继续执行循环体，直到条件为false退出循环
注意：循环条件为true，如果没有在{}里面改变循环条件的话，会出现死循环。

//变量初始化
do{
    //循环体；
    //改变循环条件；
}while(循环条件);

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

上面这个代码时算出1至100的和。下面我们来说说do—while循环的执行顺序一般如下:

1. 声明并初始化循环变量。
2. 执行一遍循环操作。
3. 判断循环条件，如果循环条件满足，则循环继续执行，否则退出循环。

• do—while循环的特点是：先执行，再判断。
• 根据do—while循环的执行过程可以看出，循环操作至少执行一遍。

do—while循环流程图:

程序调试

什么是程序调试

"调试"这个词在生活中也经常听到，如电器调试，仪表调试。生活中的调试一般是指初装电器或电器出现问题时排除故障的过程，首先发现问题所在，然后调整电器的某些设置，最后使其达到正常的运行状态。在程序设计领域，调试的概念预期类似，但又有不同。

为了找出程序中的问题所在，希望程序在需要的地方暂停，以便查看运行到这里时变量的值。还希望但不运行程序，跟踪程序的运行流程，观察哪条语句执行了，哪条语句没有执行。

满足暂停程序，观察变量和逐条执行语句等功能的工具和方法总称为程序调试。

程序调试的步骤:

1. 分析错误，设置断点。
2. 启动调试，单步执行。

在调试中，按F5键和F6键都是单步执行，它们的区别如下：

• 按F5键"单步执行"，会进入本行代码内部执行，如进入方法内部.
• 按F6键"单步跳过"，仅执行本行代码，执行完则跳到下一行代码。

for循环：

for循环语法

先观察示例1

public class whileDemo2{
	public static void main(String[]args){
		int i = 1;
		while(i<=100){
			 system.out.println("第"+i+"遍好好学习，天天向上!");
            i++;
		}
	}
}

public class whileDemo2{
	public static void main(String[]args){		
		for(int i = 1;i<=100;i++){
			 system.out.println("第"+i+"遍好好学习，天天向上!");            
		}
	}
}

通过运行程序，我们可以看到示例1和示例2的输出结果是一样的，但示例2的代码看起来更加简洁。因此，在解决有固定循环次数的问题时，可以首选for循环结构。下面就来介绍for循环结构。

什么是for循环结构

循环语句的主要作用是反复执行一段代码，直到满足一定的条件位置。总结一下，可以吧循环结构分为四个部分。

初始部分：设置循环的初始状态，如设置记录循环次数的变量i为1；

循环体：重复执行的代码，即输出"好好学习天天向上！"

迭代部分：下一次循环开始前要执行的部分，在while循环结构中它作为循环体的一部分，如使用"i++";进行循环次数的累加。

循环条件：判断是否继续循环的条件，如使用"i<=100"判断循环次数是否已经达到100。

在for循环结构中，这几个部分同样必不可少，不然循环就会出行错误。for循环的一般格式如下

for(表达式1;表达式2;表达式3){
			 //循环体            
		}

表达式	形式	功能	举例
表达式1	赋值语句	循环结构的初始部分，微循环变量初始值	int i=1
表达式2	条件语句	循环结构的循环条件	i<=100
表达式3	赋值语句	循环结构的迭代部分，通常用来修改循环变量的值	i++

for循环流程图

三种循环结构的区别

三种循环各有特点，各有适用情况：

执行顺序

• while是先判断条件，再执行循环体
• do-while是先执行次循环体，再判断条件
• for也是先判断条件，再执行循环体

适用情况

不能确定循环次数，用while

至少循环一次，用do-while

确定循环次数，用for

Java支持3种类型的跳转语句：

• break语句

• continue语句

  break语句

  break语句只出现在循环或是switch中，break语句在循环中的作用是跳出循环，在switch中的语句是跳出switch。
  示例：

  public class Demo {
      public static void main(String[] args) {
          for (int i = 1; i < 10; i++) {
              if(i == 4){
                  break;  //i==4为true时跳出循环
              }
              System.out.print(i);//输出123
          }
      }
  }
  
  

  continue语句

  continue语句只出现在循环中，作用是强制循环返回，就是让循环结束本次循环直接进入下一次循环。
  示例：

  public class Demo {
      public static void main(String[] args) {
          for (int i = 1; i < 10; i++) {
              if(i == 4){
                  continue;   //i==4为true时结束本次循环直接进入下一次循环
              }
              System.out.print(i);  //输出12356789
          }
      }
  }
  
  

循环小结

执行顺序不同。

• while循环结构：先进行条件判断，再执行循环体。如果条件不成立，退出循环。
• do—while循环结构:先执行循环体，在进行条件判断，循环体至少执行一次。
• for循环结构:先执行初始化部分，在进行条件判断，然后执行循环体，最后进行迭代部分的计算。如果田间不成立，跳出循环。

适用情况不同。

在解决问题时，对于循环次数确定的情况，通常选用for循环结构；对于循环次数不确定的情况，通常选用while和do—while循环结构。

数组

Java中，数组就是一个常量，用于将相同数据类型的数据存储在内存中。数组中的每一个数据元素都属于同一个数据类型。例如全班30个学员的成绩都是整型，就可以存储在一个整型数组里面。

下面来看数组的基本要素。

• 标识符。首先，和变量一样，在计算机中，数组也要有一个名称，称为标识符，用于区分不同的数组。
• 数据元素。当给出了数组名称，即数组标识符后，要向数组中存放数据，这些数据就称为数组元素。
• 数组下标。在数组中，为了正确的得到数组元素，需要对它们进行编号，这样计算机才能根据编号去存取，这个编号就称为数组下标。
• 元素类型。存储在数组中的数组元素应该是同一数据类型，如可以把学员的成绩存储在数组中，而每一个学员的成绩可以用整型变量存储，因此称它的元素类型是整型。

使用数组的步骤:

• 声明数组：在Java中，声明一堆数组的语法如下：

数据类型[] 数组名;

或者

数据类型 数组名[];

以上两种方式都可以声明一个数组，数组名可以是任意合法的变量名。声明数组就是告诉计算机该数组中数据的类型是什么。例如:

int[]  scores;//存储学员的成绩，类型为int
double height[];//存储学员的身高，类型为double
String[] names;//存储学员的姓名，类型为String

• 分配空间

  虽然声明了数组，但并不会为数组元素分配内存空间，此时还不能使用数组。因此要为数组分配内存空间，这样数组的每一个元素才能对应一个存储单元。

  简单地说，分配空间就是要告诉计算机在内存中分配一些连续的空间来存储数据。在Java中可以使用new关键字来给数组分配空间。

  数组名 = new数据类型[数组长度];

  两部合并，即在声明数组的同时就给它分配空间，语法如下。

  数据类型[] 数组名 = new 数据类型[数组长度]

• 赋值

分配空间后就可以向数组里放数据了。数组中的每一个元素都是通过下标来访问的，语法如下

数组名[下标值];

例如,向scores数组中存放数据。

scores[0] = 89;

scores[1] = 60;

scores[2] = 70;

会发现数组的下标是规律变化的，即从0开始顺序递增，所以考虑用循环变量表示数组下标，从而利用循环给数组赋值。

Scanner input = new Scanner(System.in);
for(int i = 0;i < 30; i++){
	score[i] = input.nextInt();		//从控制台接受键盘输入进行循环赋值
}

在编写程序时，数组和循环往往结合在一起使用，可以大大简化代码，提高程序效率。通常，使用for循环遍历数组或者给数组元素赋值。

语法

数据类型[] 数组名={值1，值2，值3，…值n};

• 对数据进行处理

package Ch08;
import java.util.Scanner;
public class Yuxi {
	public static void main(String[] args) {
		int[] scores  = new int[5];
		int sum = 0;
		Scanner input = new Scanner(System.in);
		System.out.println("请输入五位学员的成绩:");
		for (int i = 0; i < scores.length; i++) {
			scores[i]=input.nextInt();
			sum = sum+scores[i];
			
		}
		System.out.println("学员的平均分是:"+(double)sum/scores.length);
	}
}

在循环中，循环变量i从0开始递增直到数组的最大长度scores.length。因此，每次循环i加1，实现数组的每个元素和的累加。

数组常见错误

1. 数组下标从1开始
2. 数组访问越界

注意：数组下标从0开始，而不是从1开始。如果访问数组元素时指定的下标小于0，或者大于等于数组的长度，都将出现数组下标越界异常。

总结

进行处理

package Ch08;
import java.util.Scanner;
public class Yuxi {
	public static void main(String[] args) {
		int[] scores  = new int[5];
		int sum = 0;
		Scanner input = new Scanner(System.in);
		System.out.println("请输入五位学员的成绩:");
		for (int i = 0; i < scores.length; i++) {
			scores[i]=input.nextInt();
			sum = sum+scores[i];
			
		}
		System.out.println("学员的平均分是:"+(double)sum/scores.length);
	}
}

在循环中，循环变量i从0开始递增直到数组的最大长度scores.length。因此，每次循环i加1，实现数组的每个元素和的累加。

数组常见错误

1. 数组下标从1开始
2. 数组访问越界

注意：数组下标从0开始，而不是从1开始。如果访问数组元素时指定的下标小于0，或者大于等于数组的长度，都将出现数组下标越界异常。

总结

其实看上去都是很简单的但是如果同时使用起来的话还是有点难度的，学习编程的只要头脑清晰，看到题目先想想怎么做，在脑袋里面自己画流程图，然后在做就行。千万不要觉得难就不学习了，不要知难而退，多多运用，你就会记住这个这个结构怎么使用了。