第三章 选择结构 （一）

1、if选择结构

if就是一种判断的方法，在生活当中我们经常需要做判断，然后才能够决定是否做某件事情。比如：我很渴，我想吃西瓜，正好我看到一家水果店，里面有西瓜，，我是买还是不买。

if选择结构是根据条件判断之后再做处理的一种语法。

if(条件1){
    //代码块
}	//这是语法，很简单

这个图叫流程图，看到if的执行过程一目了然。后面我会一一介绍地。

程序执行时，先判断条件，当结果为true时程序先执行大括号里的代码块，在执行if结构大括号部分。当结果为false时，不执行大括号里面的代码块，而直接执行if结构后面的代码。

publie class Yang{
    public ststic void main(String []args){
        //语句1;		//先执行语句1和2
        //语句2;
        if(条件){		//然后在进行if判断条件是否成立
           //语句3;	//如果成立则输出语句3
        }
        //语句4;		//不成立就输出语句4
    }
}

接下来我介绍一下流程图，他能简单的帮你调整思路，一步一步的去进行。

2、流程图介绍

第一个长方形圆角，它带表的是程序的开始和结束。程序有开始就有结束

第二个菱形，它代表判断和分支。一个菱形就代表一个判断。

第三个平行四边形，输入和输出指令。System.out.println("");它就代表这个输出语句，还有输入语句

第四流箭头，流程线。就比做一条路吧，它箭头在哪里，你就走哪里

第五长方形，计算步骤/处理符号，在代码计算的时候。

第六圆加箭头，连接符

3、逻辑运算符

运算符	汉语名称	表达式	说明	举例
&&	与、并且	条件1&&条件2	两个条件同时为真，结构就为真，两个条件一个为假，结果为假	可以睡觉的条件：作业做完了&&有充足的时间。两个都为真就睡觉，一个不行，就睡不了。
||	或、或者	条件1||条件2	两个条件一个为真，结构就为真，两个同时为假，结构就为假	早上吃早餐：吃粉||吃包子。两个条件一个为真，就吃那个，若都没有，就不吃了。
！	非	！条件	条件为真时，结果为假。条件为假时，结果为真。	成为IT精英的条件：！划水。

4、三目运算符

数据类型 变量名 = 条件 ？成立true 不成立false

请看下面代码，就运用了&&和||。

非短路&：&&判断时，若前条件为false，则跳过条件二判断

非短路|：||判断时，若前条件为false，则跳过条件二判断

publie class Yang{
	public static void main(String []args){
        int score1 = 100;
        int score2= 72;
        if((score1 > 98&& score2 > 80) || (score1 == 100 && score2 > 70)){
            System.out.println("老师说：不错，奖励一个棒棒糖！");
        }
    }
}

这个他给了你两种方案，第一种score1 > 98&& score2 > 80，score大于98，但是score2 不大于所以不满足，为什么？因为&&两个条件同时为真，结构就为真，两个条件一个为假，结果为假。下一个score1 == 100 && score2 > 70，score等于100没错，score大于70也没错。两个条件都为真，结果就为真。这两个方案是由||连起来的所以用后面那个。这个代码灵活运用了两个运算符。

运算符，就是要看题目条件灵活运用！

在生活中有奖励就有惩罚else，看下面语法。

if(条件1){
    //代码块1
}else {
    //代码块2
}

这里出现了一个的单词else，else的作用是，来否定if里面的条件，就是if条件不满足就执行else里面的代码块。

5、多重if结构

if(条件1){
    //代码块1
}else if(条件2){
    //代码块2
}else{
    //代码块3
}

publie class Yang{
	public static void main(String []args){
        int score = 70;
        if(score >= 80){				//条件1
             System.out.println("良好");	//代码块1
        }else if(score >= 60){			//条件2
             System.out.println("中等");	//代码块2
        }else{
             System.out.println("差");	//代码块3
        }
    }
}

score等于70，if判断70大于80吗，不大于。就进入条件2进行判断，70大于60没错，那就执行输出代码块2。

条件越多，if的条件也就多，一步步来，理清楚就非常简单了！

6、嵌套if结构

if(条件1){
	if(条件2){
		//代码块1
	}else{
		//代码块2
	}
}else{
	//代码块3
}

import java.util.Scanner;
public class Aa {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入比赛成绩：");
		double score = input.nextDouble();
		System.out.println("请输入性别：");
		String ganden = input.next();
		if(score <= 10) {				//条件1
			if(ganden.equals("男")) {	//条件2
				System.out.println("进入男子组决赛！");		//代码块1
			}else if(ganden.contentEquals("女")){	//条件3
				System.out.println("进入女子组决赛！");		//代码块2
			}
		}else {
			System.out.println("淘汰！");		//代码块3
		}
	}
}

只有当满足外层的if选择结构的条件时，才会判断if内层的条件。

else总是与它前面最近那个缺少else的if配对。还有注意字符的缩进！！！

if学完还是比较简单啦。

第四章 选择结构 (二)

7、switch选择结构

if和switch来说switch选择结构可以更好的解决等值配对问题。

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

这里switch、case、default、break都是java关键字。来看看他们的作用2

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

import java.util.Scanner;
public class KH {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("输入星期：");
		int sum = in.nextInt();		//在控制台输入一个整数
		switch(sum) {				//把输入的值放在小括号里进行选择
		case 1:
		case 3:
		case 5:
			System.out.println("学习编程！");
			break;
		case 2:
		case 4:
		case 6:
			System.out.println("学习英语！");
			break;
		case 7:
			System.out.println("休息！");
              break;
            default:
                System.out.println("输入错误！");	//如果输入错误，就输出这个语句
		}
	}
}

仔细看一下上面的代码，这是一个星期的计划，在你不知道星期几要干嘛的时候，在控制台输入一个数字就会出现相应的语句。如果输错就会输出“输入错误！”。合理运用，切记别少单词或打错！！！

8、处理系统异常

在程序运行的时候，总有一些意想不到的人，本来是要输入数字，可我要是输入字符呢？？？

难搞吧！

这个就是上面代码的输出结果，我输入文字后他就报错了，它有个引号引着main，这说明main方法错误，最后面小括号里KH.java：10，他说的是你的第十行有错误，针对这个问题，书本上也讲出来了，看下面代码：我从里面加了一个if，if小括号里面有个单词hasNextInt()，这是用来判断用户从键盘上输入的字符是否合法。如果用户输入的是数字，就根据输入的具体数值跳转到相应的菜单。如果用户输入的不是数字，就运行else里面的语句“请输入正确的数字！”

if选择结构和switch可以结合起来一起用，灵活运用。

import java.util.Scanner;
public class KH {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.print("输入星期：");
		if (in.hasNextInt() == true) {
			int sum = in.nextInt();
			switch(sum) {
			case 1:
			case 3:
			case 5:
				System.out.println("学习编程！");
				break;
			case 2:
			case 4:
			case 6:
				System.out.println("学习英语！");
				break;
			case 7:
				System.out.println("休息！");
			}
		}else {
			System.out.println("请输入正确的数字！！");
		}
	}

}

第五章 循环结构 (一)

9、while循环结构

while(循环条件){		//循环条件就是一个表达式，他的值为boolean类型，正确时true，不正确是false
    //循环操作
}

int i = 1;				//声明并初始化循环变量
while (i <= 100){		//判断循环条件是否满足，满足则执行循环操作，不满足就退出循环，循环条件
    System.out.println("好好学习")	//执行完循环操作后，再次判断循环条件，决定继续执行循环或退出循环，循环体
        i = i + 1;		//累加求和
}			//举例

这个也不是很难，只要了解while的使用步骤：

1、声明并初始化循环变量

2、判断循环条件是否满足，满足则执行循环操作，不满足就退出循环

3、执行完循环操作后，再次判断循环条件，决定继续执行循环或退出循环

10、使用while循环结构解决问题的步骤

1、分析循环条件和循环操作

2、套用while语法写出代码

3、检查循环能否退出

public class DF {
	public static void main(String[] args) {
		int i = 0;
		while (i < 4) {
			System.out.println("循环一直运行不会退出！");
			//这里少了声明东西？？？
		}
	}
}

上面黄色字体哪里少了一个东西，你可以去试试运行着串代码，它会无限的输出 “循环一直运行不会退出！” ，为什么呢？分析代码会发现，i的值一直都没有改变，i一直都等于0，一直小于四，使用它会一直循环下去。这种情况称为 “死循环” 要加一个 i++ ，它每循环一次自身就会加一。做完后都要好好检查一下。

while当一开始循环条件不满足的时候，while循环一次也不会执行。

11、程序调试、

设置断点——启动调试——单步运行——观察变量；

12、do——while循环

do——while先是会运行输出一遍，在去判断条件是否在次循环。

do{
    //循环体
}while(循环条件);

int i = 0;		//声明并初始化循环变量
do{
   System.out.println("好好学习");		//执行一遍循环操作
    i++			//迭代
}while(i <= 100);		//满足就继续，不满足就退出

13使用do——while循环结构解决问题的步骤

1、分析循环条件和循环操作

2、套用do——while语法写出代码

3、检查循环能否退出

14、while与do——while的不同点

1、语法不同。do——while循环条件将while关键字和循环条件放在后面，而且前面多了关键字do，后面多了一个分号。

2、执行次序不同。while循环结构先判断，再执行；do——while循环结构先执行，再判断。

3、在一开始循环条件就不满足的情况下，while循环结构一次都不会执行，do——while循环结构则不管什么情况都会至少 执行一次。

第六章 循环结构 (二)

15、for循环

for循环主要的作用是反复执行一段代码，直到满足为止，分为四个部分：

1、初始部分：设置循环的初始状态，i = 0;

2、循环体：重复执行代码，输出“好好学习，天天向上。”

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

4、循环条件：判断是否继续循环条件，如使用“i<100” 判断循环次数是否已经达到100，在for循环结构中，这几个部分同 样必不可少，不然循环就会出现错误。for循环的一般格式如下：

for(表达式1;表达式2;表达式3){			//for关键字后面括号中的三个表达式必须用“;”隔开
    //循环体
}

表达式	形式	功能	举例
表达式1	赋值语句	循环结构的初始部分，为循环变量赋初值	int i = 0
表达式2	条件语句	循环结构的循环条件	i < 100
表达式3	赋值语句，通常使用++或–运算符	循环结构的跌打部分，通常用来修改循环变量的值	i++

for循环的结构顺序：

1、执行初始部分（int i = 0;）

2、进行循环条件判断（i < 100;）

3、根据循环条件判断结果。如果为true，则执行循环体；如果为false，则退出循环，步骤(4)和(5)均不执行

4、执行迭代部分，改变循环变量值(i++)

5、一次循环步骤(2)~(4),直到退出for循环结构。表达式1这个初始部分仅仅执行了一次。

import java.util.Scanner;
public class YX3 {
	public static void main(String[] args) {
		int i,j;
		Scanner input = new Scanner(System.in);
		System.out.println("请输入一个值");
		int val = input.nextInt();
		System.out.println("根据这个值可以输出一下加法表");
		for(i = 0, j = val; i <= val; i++, j--) {			//","它是用隔开多个表达式组成的表达式
			System.out.println(i+"+"+j+"="+(i+j));
		}
	}
}

16、跳转语句

java有三种类型的形式break；continue；retrun。我们这本书学的是break和continue。先看一下switch里面的break语句的作用：

import java.util.Scanner;
public class YX4 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("查看日程表，请输入日期(1-5)");
		int day = input. nextInt();
		switch(day) {
		case 1:
			System.out.println("出席IT科技展剪彩仪式");
			break;
		case 2:
			System.out.println("飞抵香港参加亚太区会议");
			break;
		case 3:
			System.out.println("会议结束油香港海洋公园");
			break;
		case 4:
			System.out.println("抵京召开公司月度股东大会");
			break;
		case 5:
			System.out.println("*时间");
			break;
		}
	}
}

在switch选择结构块中，break，语句用于终止switch语句中的某个分支，使程序跳到switch选择结构的下一条语句

for(int i = 0;i < 100; i++){
    //跑400m
    if(不能坚持){
        break;		//退出比赛
    }
}

我理解的break是它终止if循环，比如上面的代码，进入for循环跑的400m以后，在if判断输入不能坚持的话直接break，终止if循环 ，for循环就结束了。

在switch选择结构中，continue，语句不执行完所有的循环体，就跳出本次循环，开始进入下一次循环。

for(int i = 0;i<10;i++){
    //跑400m
    if(不口渴){
        
    }
    //接过水壶，喝水
}

17、循环结构总结

无论那一中循环结构，都有四个必不可少的部分：初始部分、循环条件、循环体、迭代部分。缺少了任何一个都可能造成严重的错误。

while循环结构：先进行条件判断，在执行循环体。如果条件不成立，退出循环。

do——while循环结构：先执行循环体，在进行条件判断，循环体至少执行一次。

for循环结构：限制性初始化部分，在进行判断，然后进行迭代部分的计算。如果条件不成立，跳出循环。

第七章 循环结构综合练习

第七章主要就是第五章和第六章的复习，在把他们灵活利用起来，

import java.util.Scanner;
public class SJ1 {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		System.out.println("青鸟迷你游戏平台 > 游戏晋级");
		int score =0;	//通关要求
		int count = 0;	//记录通关局数
		int n = 0;		//总局数
		String answer;
		do {
			System.out.println("您正在玩第" + n + "局，成绩为：");
			score = in.nextInt();
			if (score > 80) {
				count++;
			}
			++n;
			if(n > 5) {
				System.out.println("游戏结束!");
				break;
			}else {
				System.out.println("继续下一局吗？（yes/no）");
				answer = in.next();
				if(answer.equals("no")) {
					System.out.println("您已经中途退出游戏！");
					break;
				}else {
					System.out.println("进入下一局");
				}
			}
		}while(n <= 5); 
		double rate = count /5.0;
		if(n > 5) {
			if(rate > 0.8) {
				System.out.println("\n恭喜通过一级");
			}else if(rate > 0.6) {
				System.out.println("\n恭喜通过二级");
			}else {
				System.out.println("\n对不起，您未能晋级，继续加油！");
			}
			
		}else {
			System.out.println("\n对不起，您未能晋级，继续加油！");
		}
	}

}

以上包括了do——while、if、break，还有导包。

第八章 数组

18、什么事数组

数组就是一个变量，用于将相同的数据类型的数据存储在内存中，数组中的没一个数据元素都属于同一数据类型。比如：全班30个同学的成绩都是int类型，就可以存储在一个int类型的数组里面。

声明一个变量就是在内存空间分配一块合适的空间，数组就是在内存空间划出一串连续的空间。

19、数组由那些组成

标识符：标识符就是跟变量一样，数组也要有一个名称。变量名一样。

数组元素：放进去的整型，字符就成为为数组元素‘

数组下标：就是编好，数组里面都是有编号的，要去数字的话只能根据编号去取，编号从0开始；

元素类型：存储在数组中的数据类型都要是同一类型的，数组也是同一类型，比如存放的是整数，那么它的数组元素类型 是整型。

数组的大小、长度是数组可容纳元素的最大数量。定义一个数组同时也定义了它的大小。

20、使用数组的步骤

1、声明数组：

数据类型[]	数组名;
数据类型	数组名[];

2、分配空间：有两种方法

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

3、赋值：

数组名[下标值];

还有一种边声明边赋值：

数据类型[] 数组名  = new 数据类型[]{值1、2、3、4、5、};		//第二个中括号必须为空

接下来看一看5位同学的平均成绩：

import java.util.Scanner;
public class YX {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int [] scores = new int [5];		//创一个数组声明并分配空间
		int sum = 0;						//存储五个同学的成绩
		System.out.println("请输入五位同学的成绩：");			//提示
		for(int i = 0 ;i < scores.length;i++) {			
			scores [i] = in.nextInt();			//循环五次输入五位同学的成绩
			sum = sum + scores[i];				//进行五次的循环累加
		}
		System.out.println("学员的平均分是" + (double)sum/scores.length);	//最后输出
	}
}

数组一经创建，长度是不可以改变，如果越界访问数组下表超过0至数组长度-1的范围，程序会报错。一般用一下方式

数组名.length

在代码中我们写成：

i < score.length;

而不是写成：

i < 5;

public class FTP {
	public static void main(String[] args) {
		String[] xing = new String[5];
		xing[0] = "张三";
		xing[1] = "李四";
		xing[2] = "王二";
		xing[3] = "麻子";
		xing[4] = "小红";
		for (int i = 0; i < xing.length; i++) {
			System.out.print(xing[i] + " ");
		}
	}
}

public class FTP {
	public static void main(String[] args) {
		String[] xing = new String[] {"张三","李四","王二","小红"};
		for (int i = 0; i < xing.length; i++) {
			System.out.print(xing[i] + " ");
		}
	}
}

以上两种方法都可以输出。

数组排序：

import java.util.Arrays;

Arrays.sore(数组名);				//语法
for(int i = 0;i < score.length;i++)	{	//升序
    
}	

for(int = score.length; i >= 0 ;i--){	//降序
    
}

求数组最大值：定义一个变量，赋值为0，然后把下标为[0]的值赋给max，在哪max和里面的四位数作比较，与赋值，只要其他下标里面的值比max大，那就把那个值赋给max，如此循环，就可以得到最大值。

public class YX2 {
	public static void main(String[] args) {
		int [] scores = new int [5];
		int max = 0;
		max = scores[0];
		for(int i = 0; i < scores.length;i++) {
			if(scores[i] > max) {
				max = scores[i];
			}
		}
		System.out.println("考试成绩最高分为：" + max);
	}
}

​ 向数组插入元素：

import java.util.Scanner;
public class YX3 {
	public static void main(String[] args) {
		int[] list = new int [6];		//声明数组元素与分配空间
		list[0] = 99;					//0~1赋值
		list[1] = 85;
		list[2] = 82;
		list[3] = 63;
		list[4] = 60;
		
		int index = list.length;		//保存新插入文字的位置
		System.out.println("请输入新增成绩：");
		Scanner in = new Scanner (System.in);
		int num = in.nextInt();			//输入插入的数据
		for(int i = 0;i < list.length;i++) {	//找到新元素的插入位置
			if(num > list[i]) {
				index = i;
				break;
			}
		}
		for(int j = list.length - 1;j > index;j--) {		//降序
			list[j] = list[j - 1];
		}
		list[index] = num;			//赋值下标
		System.out.println("插入成绩的下标是" + index);
		System.out.println("插入后的成绩信息是：");
		for(int k = 0;k < list.length;k++) {
			System.out.println(list[k] + "\t");			//最后输出
		}
	}

}

第九章 循环结构进阶

21、二重循环结构

第五、六章我们学习了while、do——while、for的循环结构，第九章将跟深入的学习循环——二重循环，二重循环是用来解决更复杂的问题。

二重循环就是循环体内还包括一个完整的循环结构，以下：

while与while的嵌套
while(循环条件1){
    //循环操作1
    while(循环条件2){
        //循环操作2
    }
}

//do——while与—do—while的嵌套
do{
    //循环操作1
    do{
     //循环操作2
    }while(循环条件2);
}while(循环条件1);

//for与for的嵌套
for(循环条件1){
    //循环操作1
    for(循环条件2){
        循环操作2
    }
}

//while与for的嵌套
while(循环条件1){
    //循环操作1
    for(循环条件2){
        //循环操作2
    }
}

循环条件1和循环操作1是外层循环，循环条件2和循环操作2是内层循环。外循环执行一遍，内循环从初始值到结束值执行几遍，二重循环的时候，先看外层循环是否满足，再去分析内层循环。还有外层循环只输出一遍。下面有一个例子：

import java.util.Scanner;
public class YX {
	public static void main(String[] args) {
		int[] score = new int[4];		//成绩数组
		int classNum = 3;				//班级数
		double sum =0.0;				//保存成绩总和
		double[] average = new double[classNum];		//平均成绩数组
		Scanner input = new Scanner(System.in);
		for (int i = 0; i < average.length; i++) {		//内层循环控制每个班的参赛人数
			sum = 0.0;
			System.out.println("请输入第" + (i + 1) + "个班级的成绩:");
			for (int j = 0; j < average.length; j++) {
				System.out.print("请输入第" + ( j + 1 ) + "个学员的成绩:");
				score[j] = input.nextInt();
				sum = sum + score[j];			//成绩累加
			}
			average[i] = sum / score.length;		//计算平均分
			System.out.println("第" + (i + 1) + "个班级参赛写元的平均分是：" + average[i] + "\n");
		}
	}
}

输出的程序就这个样子：

22、二重循环中的continue和break

continue：跳出本次循环进入下一次循环。

for(循环条件1){
	for(循环条件2){
	循环操作1
	continue;
	循环操作2
	}
	循环操作3
}

break:终止本层循环，执行这个循环以外的语句。

for(循环条件1){
    for(循环条件2){
        循环操作1
        break；
        循环操作2
	}
    循环操作3
}

这章的量有点大，主要考验你的逻辑思维能力，脑子转不过来就只能一遍遍的敲慢慢的去理解了。

总结：这个总结是写给我自己看的，其实我理解的也并不多，都是一遍遍敲出来的，昨天考了一场考试，让我知道，只有理解才能真正的记忆！！！