一、程序流程控制概述
流程控制语句：可以控制程序的执行流程。主要分成三种类型：顺序结构、选择结构（也称分支结构）、循环结构。
1、顺序结构
①顺序结构的概念：是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。总的来说，就是写在前面的先执行，写在后面的后执行。
②顺序结构的特点：从上往下，依次执行。
③顺序结构图：
例如如下代码，代码进入main函数之后，开始从上往下依次执行三个输出语句。
class ShunXuJieGouDemo {
public static void main(String[] args) {
System.out.println("程序开始了");
System.out.println("我爱Java");
System.out.println("程序结束了");
}
}2、选择结构
①选择结构，也称分支结构。选择结构有着特定的语法规则，代码要执行具体的逻辑判断进行运算，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
②选择结构的类型：在Java中，有两种选择结构语句，if语句和switch语句。其中，if语句又有这三种形式。分别是：单分支结构，双分支结构，多分支结构。
③if语句的三大类型
- 单分支结构。这是最简单的一种选择结构，它只是简单的判断某个条件是否成立，如果成立就执行一段代码。语句形式为：
if(布尔类型表达式)｛
语句一；
……
｝
注：如果if控制的语句体中只有一条语句时，大括号可以省略掉。语句一；
……
｝
执行流程为：首先判断布尔类型表达式的结果是true还是false，如果为true则执行语句一等语句，为false就不执行。如下图所示：
- 双分支结构。双分支结构是一个标准的，完整的if语句实现形式，它首先判断某个条件是否成立，如果成立就执行一段代码，如果条件不成立则执行另一段代码，语句形式为：
if(布尔类型表达式){
语句体1
}else{
语句体2
}
执行流程为：判断布尔类型表达式中值为true还是false，如果为true则执行语句体1，为false则执行语句体2。如下图所示：
- 多分支结构：这是if语句嵌套形式的一种，它是多个if语句的嵌套，语句形式如下：
if(布尔类型表达式) {
语句体1;
}else if (关系表达式2) {
语句体2;
}
…
else{
语句体n+1;
}
执行流程是：
a、首先判断布尔类型表达式的结果是true还是false，为true是则执行语句体1；
b、如果是false就继续判断关系表达式2看其结果是true还是false；
c、如果是true就执行语句体2；
d、如果是false就继续判断关系表达式……看其结果是true还是false；
e、……；
f、如果没有任何关系表达式为true，就执行语句体n+1。
执行流程如下图所示：
if语句结构的代码示例：
import java.util.*;
/*
if语句的三种形式的演示：
if语句分为三种结构：单分支结构
双分支结构
多分支结构
*/
public class IfDemo{
public static void main(String[] args){
/*int i = 20;
//if语句的第一种形式：单分支结构
if(i >10){
System.out.println("这是if语句的单分支结构演示");
}*/
//if语句的第二种形式：双分支结构
/*int a = 10;
int b = 15;
if(a == b){
System.out.println("a和b的值相等");
}
else{
System.out.println("a和b的值不相等");
}*/
/*
if语句的第三种形式：多分支结构
这里用一个小例子来演示一下if语句的多分支结构。
需求：通过键盘录入一个成绩并判断出成绩的等级。
90-100分为优秀，80-90为良好，70-80为中等，60-70为及格，60分以下不及格。
*/
//创建键盘录入对象。
Scanner scan = new Scanner(System.in);
//录入数据
Sop("请输入考试成绩：");
int score = scan.nextInt();
//利用多分支结构对输入的成绩进行等级判断
if(score <0 || score > 100){
Sop("您输出的成绩有误");//输入的数据不合理，直接返回输入错误。
}
else if(score >= 90 && score < 100){
Sop("您的考试成绩等级为“优秀”");
}
else if(score >= 80 && score < 90){
Sop("您的考试成绩等级为“良好”");
}
else if(score >= 70 && score < 80){
Sop("您的考试成绩等级为“中等”");
}
else if(score >= 60 && score < 70){
Sop("您的考试成绩等级为“及格”");
}
else{
Sop("您的考试成绩等级为“不及格”，要加油啦！");
}
}
public static void Sop(Object obj){
System.out.println(obj);
}
}④选择语句的第二种形式：switch语句
相关概念阐述：switch语句专用于实现多分支结构程序，其特点是各分支清晰而直观。switch语句后面的括号中可以是任何表达式，取其整数部分与各常量表达式比较。其中常量表达式必须是能够自动转换为整型的，如字符型、短整型、枚举等。语句形式如下：
switch(表达式){
case 常量表达式1：语句1；braek；
case 常量表达式2：语句2；braek；
......
case 常量表达式n：语句n；braek；
default: 语句n+1
}
Switch语句的格式解释：switch语句中表达式的取值只能为byte、short、int、char四种类型；case后面跟的是要和表达式进行比较的值；break表示中断，结束的意思，可以结束switch语句；default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。执行流程图如下所示：
Switch语句的代码实例演示：
/*
面试题：
byte可以作为switch的表达式吗?可以
long可以作为switch的表达式吗?不可以
String可以作为switch的表达式吗?Jdk1.7以后可以
案例：
键盘录入一个数据，根据这个数据，我们输出对应的星期?
键盘录入1,对应输出星期一
键盘录入2,对应输出星期二
...
键盘录入7,对应输出星期日
分析：
1:键盘录入，用Scanner实现
2:判断我们既可以使用if语句，也可以使用我们要讲解的switch语句
注意：
A:遇到左大括号缩进一个tab的位置。
B:关联不是很大的语句间空行
*/
import java.util.Scanner;
class SwitchDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);
//控制键盘录入数据
System.out.println("请输入一个数据(1-7):");
int week = sc.nextInt(); //3
//switch判断语句
switch(week) {
case 1:
System.out.println("星期一");
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;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的数据有误");
break;
}
}
}3、循环结构
在Java中，有着三种循环语句：for，while，do……while。
①for循环语句详解
- for循环的语法格式为：
for(初始化语句；判断条件语句；控制条件语句){
......
循环体语句
......
}
- for循环语句流程图：
- 注意事项：
a、判断条件语句的结果是一个boolean类型。
b、循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
c、一般来说：有左大括号就没有分号，有分号就没有左大括号。
- for循环语句实例代码演示（统计水仙花数）：
/*
需求：统计”水仙花数”共有多少个
分析：
A:首先必须知道什么是水仙花数
所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
举例：153就是一个水仙花数。
153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
B:定义统计变量，初始化值是0
C:三位数告诉了我们范围，用for循环就可以搞定
D:获取每一个三位数的个，十，百的数据
E:按照要求进行判断
F:如果满足要求就计数。
*/
class ForDemo{
public static void main(String[] args) {
//定义统计变量，初始化值是0
int count = 0;
//三位数告诉了我们范围，用for循环就可以搞定
for(int x=100; x<1000; x++) {
//获取每一个三位数的个，十，百的数据
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//按照要求进行判断
if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) {
//如果满足要求就计数。
count++;
}
}
System.out.println("水仙花数共有"+count+"个");
}
}②while循环语句详解
while循环语法格式
- 基本格式
while(判断条件语句) {
循环体语句;
}
- 扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
- while循环语句流程图
- while循环和for循环的区别
a、while循环和for循环可以互换
b、两者在格式上和使用上有点小区别。for循环中控制条件语句中的变量在循环结束后就不能再被访问到了。而while循环中还能继续使用。
c、for循环适合于针对一个范围判断进行操作。while循环适合于判断次数不明确操作。
- while循环代码演示（依旧使用上例中的水仙花用while循环实现）：
/*
需求：统计水仙花数有多少个
*/
class WhileDemo3 {
public static void main(String[] args) {
//while循环版本
int count = 0;
int y = 100;
while(y<1000) {
int ge = y%10;
int shi = y/10%10;
int bai = y/10/10%10;
int x = ge*ge*ge+shi*shi*shi+bai*bai*bai;
if(x == y) {
System.out.println(x);
count++;
}
y++;
}
System.out.println("1000以内的水仙花数共有"+count+"个");
}
}③do...while循环语句详解
do…while循环语句基本格式
-
基本格式
do {
循环体语句;
}while((判断条件语句);
-
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
-
do…while循环语句流程图：
-
do…while代码演示：
public class DoWhileDemo{
public static void main(String[] args){
int x = 11;
do{
System.out.println("无论如何我都要执行一次");
}while(x < 10);
}
}三种循环语句其实可以完成一样的功能，也就是说可以等价互换，但是还是有些小区别的：
-
do…while循环至少会执行一次循环体
- for循环和while循环只有在条件成立时才会去执行循环体
注意事项：
写循环时，优先考虑for循环，再考虑while循环，最后考虑do…while循环。
⑤循环嵌套结构的使用(如：打印九九乘法表)
/*
需求：在控制台输出九九乘法表。
首先我们写出九九乘法表：
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
...
1*9=9 2*9=18 3*9=27 ...
注意：
'\x' x表示任意，这种做法叫转移字符。
'\t' tab键的位置
'\r' 回车
'\n' 换行
*/
class ForForTest{
public static void main(String[] args) {
//为了使用数据，我们从1开始
for(int x=1; x<=9; x++) {
for(int y=1; y<=x; y++) {
System.out.print(y+"*"+x+"="+y*x+"\t");
}
System.out.println();
}
}
}4、跳转控制语句
在前面的java概述中，我们就提到过goto在java中是保留字，目前不能使用。没有了goto语句虽然增强了安全性，但在我们想知道某个循环在执行到哪一步就结束的时候却带来了不方便。为了弥补这个缺陷，java提供了break，continue和return来实现控制语句的跳转和中断。
- break：中断
- continue：继续
- return：返回
①break概述
break的使用场景：
- 在选择结构switch语句中
- 在循环语句中
- 离开使用场景的存在是没有意义的
break的作用：
- 跳出单层循环
- 跳出多层循环
记住：
a、当break语句单独存在时，下面不要定义其它语句，因为执行不到，
b、break跳出所在的当前循环
c、如果出现了循环嵌套，break想要跳出指定的循环，可以通过标号来实现。
②continue概述
continue的使用场景：
- 在循环语句中
- 离开使用场景的存在是没有意义的
continue的作用：
- 单层循环时对比break
- 也可以带标签的使用。
③return：return关键字不是为了跳出循环，更常用的功能是结束一个方法，也就是退出一个方法。跳转到上层使用的方法。
二、一维数组
1、数组的概念
a、定义数组：是同一类型数据的集合，其实数组就是一个容器。数据既可以存储基本数据类型，也可以存储引用数据类型。b、数组的好处：可以自动给数组中的元素进行编号，方便操作这些元素。
- 元素类型 [] 数组名 = new 元素类型 [元素的个数或者数组长度]。eg：int [] arr = new int [5]；
- 元素类型 [] 数组名 = new 元素类型 [] ｛元素、元素、……｝。eg：int [] arr = new int [] {3,5,1,7}; int [] arr = {3,5,1,7};
2、数组的初始化
java中的数组必须进行初始化才能使用。所谓初始化，就是为数组中的元素分配内存空间，并为每个数组元素赋值。数组的初始化方式：
a、动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
b、静态初始化：初始化时指定每个元素的初始值，由系统决定数组长度。
3、java中的内存分配
java中的内存分为：寄存器，本地方法区和方法区a、栈内存：存储的都是局部变量，而且变量所属的作用域一旦结束，该内存自动释放。
b、堆内存：存储的都是数组和对象（其实数组就是对象），凡是new建立的都存储在这里。
堆内存的特点：
①每一个实体都有着地指值。
②堆内存中的每一个变量都有着默认初始化值，根据类型的不同而不同。
③垃圾回收机制。
4、java中的数组操作
对数组操作最基本的动作就是存和取，核心思想就是对角标的操作。数组常见操作演示：
/*
数组常见操作演示
*/
class ArrayTest {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55};
/*********************1、获取数组元素*********************************/
//通过数组角标一个一个获取
System.out.println(arr[0]);
//通过循环获取
for(int x=0; x<arr.length; x++) {
//x=0,1,2,3,4
System.out.println(arr[x]);
}
//改进方法,这样输出[11,22,33,44,55]
System.out.print("[");
for(int x = 0;x < arr.length;x++){
if(x == arr.length-1)
System.out.println(arr[x]+"]");//最后一个元素。
else{
System.out.print("arr:"+arr[x]+",");
}
}
/*********************2、获取数组最大值or最小值*********************************/
/*
思路：找一个元素作为参照，然后遍历数组，依次获取元素与参照进行比较，大（小）
则保留，小（大）则离开，最后参照物里保存的就是最大（小）值
*/
int max = arr[0];
for(int x = 0;x < arr.length;x++){
if(arr[x]>max)
max = arr[x];
}
int min = arr[1];
for(int x = 0;x < arr.length;x++){
if(arr[x]<min)
min = arr[x];
}
System.out.println("数组的最大值max为："+max);
System.out.println("数组的最小值min为："+min);
/*********************3、逆序输出数组元素*********************************/
/*
逆序输出就是把数组元素对调
思路：把0角标与arr.length-1角标元素对调
……
做到arr.length/2即完成对调。
*/
//交换前
System.out.print("交换前：");
printArray(arr);
for(int x = 0;x < arr.length;x++){
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
//交换后
System.out.print("交换后：");
printArray(arr);
}
//为了操作方便，将数组遍历封装成一个方法，以便示范中调用。
public static void printArray(int arr[]){
System.out.print("[");
for(int x = 0;x < arr.length;x++){
if(x == arr.length-1)
System.out.println(arr[x]+"]");//最后一个元素。
else{
System.out.print(arr[x]+",");
}
}
}
}三、二维数组
1、二维数组的概念
二维数组其实就是一个元素为一维数组的数组。
2、二维数组的格式
- 格式1：int [] [] arr = new int arr [3] [2]。创建一个二维数组，该数组中有3个一维数组，每一个一维数组中有两个元素。
- 格式2：int [] [] arr = new int [3] [] 。二维数据中有3个一维数组，每一个一维数组都是默认初始化值null。可以对这三个一维数组分别进行初始化。
- 格式3：int [] [] arr = {{1,2,3},{4,5},{6}}
3、二维数组的遍历
代码演示如下：
/*
需求：二维数组遍历
外循环控制的是二维数组的长度，其实就是一维数组的个数。
内循环控制的是一维数组的长度。
*/
class Array2Test {
public static void main(String[] args) {
//定义一个二维数组
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
/************************遍历方法1************************/
//我们可以发现arr[0] = {1,2,3};所以可以如下进行遍历
for(int x=0; x<arr[0].length; x++) {
System.out.println(arr[0][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[1].length; x++) {
System.out.println(arr[1][x]);
}
System.out.println("--------------");
for(int x=0; x<arr[2].length; x++) {
System.out.println(arr[2][x]);
}
System.out.println("--------------");
//用循环改进，外循环的长度就是二维数组的长度，内循环的长度是一维数组的长度。
for(int x=0; x<arr.length; x++) {
for(int y=0; y<arr[x].length; y++) {
System.out.print(arr[x][y]+" ");
}
System.out.println();
}
}
}4、二维数组练习：打印杨辉三角
代码演示如下：
/*
需求：打印杨辉三角形(行数可以键盘录入)
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
分析：看这种图像的规律
A:任何一行的第一列和最后一列都是1
B:从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
步骤：
A:首先定义一个二维数组。行数如果是n，我们把列数也先定义为n。
这个n的数据来自于键盘录入。
B:给这个二维数组任何一行的第一列和最后一列赋值为1
C:按照规律给其他元素赋值
从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
D:遍历这个二维数组。
*/
import java.util.Scanner;
class Array2Test2 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner scan = new Scanner(System.in);
//这个n的数据来自于键盘录入。
System.out.println("请输入一个数据：");
int n = scan.nextInt();
//定义二维数组
int[][] arr = new int[n][n];
//给这个二维数组任何一行的第一列和最后一列赋值为1
for(int x=0; x<arr.length; x++) {
arr[x][0] = 1; //任何一行第1列
arr[x][x] = 1; //任何一行的最后1列
}
//按照规律给其他元素赋值
//从第三行开始，每一个数据是它上一行的前一列和它上一行的本列之和。
for(int x=2; x<arr.length; x++) {
//这里如果y<=x是有个小问题的，就是最后一列的问题
//所以这里要减去1
//并且y也应该从1开始，因为第一列也是有值了
for(int y=1; y<=x-1; y++) {
//每一个数据是它上一行的前一列和它上一行的本列之和。
arr[x][y] = arr[x-1][y-1] + arr[x-1][y];
}
}
//这个时候，要注意了，内循环的变化必须和曾经讲过的九九乘法表类似
for(int x=0; x<arr.length; x++) {
for(int y=0; y<=x; y++) {
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}
}四、Java函数（方法）
1、函数的概述
定义：方法就是完成特定功能的代码块
![]()
3、函数（方法）的重载
a、函数重载的定义：在一个类中，允许存在一个以上的同名函数，只要它们的参数个数或参数类型不同即可。
b、函数重载的注意事项：
定义：方法就是完成特定功能的代码块
- 在很多语言中都有函数的定义
- 函数在java中被称为方法
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return返回值;
}
①方法的格式说明：- 修饰符：修饰符后面会详细解释。
- 返回值类型：用于限定返回值的数据类型。
- 方法名：一个名称，为了方便我们调用方法。
- 参数类型：限定调用方法时传入参数的数据类型。
- 参数名：是一个变量，接收调用方法时传入的参数。
- 方法体：完成功能的代码。
- return：结束方法以及返回方法指定类型的值。
- 返回值：程序被return带回的结果，返回给调用者。
- 这个功能的结构是什么，即明确返回值类型，明确方法结果的返回值类型。
- 这个功能实现过程中是否需要未知内容参与运算，即明确参数列表，明确有几个参数及参数的类型。
- 方法不调用不执行。
- 方法与方法是平级关系，不能循环调用。
- 方法定义的时候参数之间用逗号隔开。
- 方法调用的时候不用再传递数值类型。
- 如果方法的返回值类型不是void，则一定要有return返回一个值。
3、函数（方法）的重载
a、函数重载的定义：在一个类中，允许存在一个以上的同名函数，只要它们的参数个数或参数类型不同即可。
b、函数重载的注意事项：
- 同一个类
- 同名
- 参数个数不同或者参数类型不同
- 函数重载和返回值类型无关
- java是严谨性语言，如果函数出现调用的不明确性，会编译失败。