本文详细介绍了Java SE中的选择结构，包括基本if、if-else、多重if、嵌套if和switch语句的语法和执行流程。同时，提到了局部变量的概念和作用范围，以及循环结构的基本组成部分和while循环的执行过程。此外，还提及了函数、递归、数组、数组元素的访问和扩容方法，以及排序中的冒泡排序原理。
1、选择结构与分支结构
（1）基本if选择结构
语法：
if(布尔表达式){
代码块 //当表达式结果为true，则执行该代码块
}
执行流程：
对布尔表达式进行判断；
结果为true，则先执行代码块，在执行后续代码块；
结果为false，则跳过代码块，在执行后续代码块。
（2）if else选择结构
语法：
if(布尔表达式){
//代码块1
}else{
//代码块2
}
执行流程：
对布尔表达式进行判断。
结果为：true，则先执行代码块1，在退出整个代码块，执行后续代码；
结果为：false，则先执行代码块2，在退出整个代码块，执行后续代码；
（3）多重if选择结构
语法：
if(布尔表达式){
代码块1
}else if(布尔表达式){
代码块2
}else if(布尔表达式){
代码块3
}else{
代码块4
}
执行流程：
表达式1为：true，则执行代码块1，在退出整个结构；
表达式2为：true，则执行代码块2，在退出整个结构；
表达式3为：true，则执行代码块3，在退出整个结构；
以上均为false；则执行代码块4，在退出整个结构；
注意：相互排斥，当有一个条件为true时，其他均不再执行，使用与区间判断（区间条件，遵循从大到小或从小到大）。
（5）嵌套if选择结构
语法：
if(外层布尔表达式){
if(内层布尔表达式){
内层代码块1
}else{
内层代码块2
}
}else{
代码块2
}
执行流程:
当外层条件满足时，在判断内层条件。
注意：选择结构中，可以嵌套另一个选择结构，可任意组合（if、if else、多重if），嵌套结构可能存在因没有缩进而导致的书写串行，进而执行有问题。
（6）分支结构：
switch(变量|表达式){ //byte short int char String
case 1:
逻辑代码1;
break;
case 2:
逻辑代码2;
break;
default:
逻辑代码3;
break;
}
执行流程：
如果变量中的值等于1，则执行逻辑代码块1。
如果变量中的值等于2，则执行逻辑代码块2。
如果变量中的值等于n，则执行逻辑代码块n。
如果变量中的值没有匹配的case值时，执行default中的逻辑代码。
注意：switch的case被选中后，不会主动退出这个结构，需手工追加break，跳出整个switch。
2、 局部变量：
（1）概念：声明在函数内部的变量，必须先赋值，再使用。
（2）作用范围：从定义行开始，到所在的代码块结束。
（3）注意：多个变量，在重合的作用范围内，不允许重名。
3、循环结构
（1）通过某个条件，使一段代码周而复始的执行
（2）循环的组成部分：
（2.1）初始部分：循环用以判断的变量
（2.2）循环条件：决定是否继续循环的依据
（2.3）循环操作：单次执行的逻辑代码或任务（一次循环要做的事情）
（2.4）迭代部分：控制循环条件改变的增量
（3）while循环
（3.1）语法：
while(布尔表达式){
}
执行流程：
先对布尔表达式进行判断，结果为true，则执行逻辑代码块。
本次执行完毕后，再进行判断，结果仍旧为true，则再次执行逻辑代码。
直至宣布布尔表达式为false时，才会退出整个结构，执行后续代码。
（3.2）特点：首次即有入口条件，先判断、再执行；适用于循环次数明确的情况。
（4）do while循环：
（4.1）语法：
do{
}while(布尔表达式);
执行流程：
先执行一次逻辑操作之后，在执行布尔表达式的判断。
如果结果为true，则再次执行循环操作。
如果结果为false。才会退出整个循环结构，执行后续代码。
（4.2）特点：首次没有入口条件，先执行、再判断；适用于循环次数不明确的情况。
5、 for循环：
（5.1） 语法：
for( 1.初始部分 ; 2.循环条件 ; 4.迭代部分){
3.循环操作
}
执行流程：
首次执行初始化部分（仅一次）。
对布尔表达式进行判断，结果为：true，则执行逻辑代码。
本次执行完毕后，执行迭代部分，再次判断，结果依旧为true，则再次执行逻辑代码。
直至宣布布尔表达式为false时，才会退出整个结构，执行后续代码。
（5.2） 特点：首次即有入口条件，先判断、再执行；适用于循环次数明确的情况。
6、 流程控制语句：
（6.1)break：中止、跳出switch、以及所有的循环结构。
(6.2）continue：结束本次，进入下一次循环。
7、 嵌套循环：
（7.1）概念：在一个完整的循环当中，嵌套另一个完整的循环结构。
（7.2）经验：
(7.2.1)图形：外层控制行数、内层控制列数。
(7.2.2)其他：外层控制循环次数、内层控制单次循环操作。
8、函数
(8.1) 概念：实现特定功能的一段代码，可反复使用。
(8.2) 函数的定义：
public static void 函数名称(){
//函数的主体（功能代码）
}
(8.3) 定义的位置：定义在类的内部，与main函数并列。多数情况下，定义在main函数的下面
(8.4) 函数的调用：函数名();
(8.5) 函数的执行顺序：函数调用时，优先执行函数内部代码，结束后，返回到函数调用处，继续向下执行。
9、 形式参数、实际参数：
（9.1）定义语法：
public static void 函数名称 ( 形式参数 ) { //局部变量的声明
}
（9.2）调用语法：
函数名称( 实际参数 ); //为形式参数赋值
10、补充：
（10.1） == 比较的是地址，不是内容。所以当比较字符串时，==不够准确。
（10.2) 比较字符串时，应使用 s1.equals(s2) ，可准确的比较字符串内容。
(10.3) 当比较两个字符串不相同时，可使用 !s1.equals(s2)。 !（逻辑运算符：非）代表“不是”
11、返回值与返回值类型：
（11.1) 定义返回值类型：基本数据类型、引用数据类型、void
(11.2) return value; //函数可以返回一个结果，类型必须与函数定义的返回值类型一致。
(11.3) 一个函数只能有一个返回值，如果函数中包含分支，需要保证所有的分支都有正确的返回值。
（11.4） return的两种用法：
1). return value; //表示结束当前函数，并伴有返回值，返回到函数调用处。（有具体的返回值类型）
2). return; //表示结束当前函数，直接会返回到函数调用处。（返回值类型是void）
12、总结：
（12.1) 注意：一个类中可以定义多个函数，函数之间属于并列关系，不可嵌套。
（12.2） 经验：一个函数只做一件事。
（12.3） 好处：
减少代码冗余。
提高复用性。
提高可读性。
提高可维护性。
方便分工合作。
13、递归：
（13.1) 实际再发中，递归可以解决一些具有既定规律的问题。
(13.2) 当需要解决的问题可以拆分成若干个小问题，大问题、小问题的解决方法相同，有特定的规律，函数自己调用自己。
(13.3) 设置有效的出口条件，避免无穷递归。
14、数组
（14.1） 概念：一组连续的存储空间，存储多个相同数据类型的值。
（14.2) 数组的创建：
数据类型[] 数组名 = new 数据类型[长度]; // int [] a = new int[5];
15、数组的组成概述：
（15.1) 数组中的每个“格子”称为“数组的元素”。
(15.2) 对元素的访问分为：“赋值”、“取值”。
(15.3) 访问元素时，需要通过“下标”（从0开始，依次+1，自动生成）
(15.4) 访问的语法：数组名[下标]; //存：a[0] = 10; 取：a[0]
(15.5) 下标的范围：0 ~ 数组的长度-1 ，如果不在有效下标内，产生java.util.ArrayIndexOutOfBoundsException：错误下标
语法层面：硬性要求
一套：《Java语言规范》：规定了什么，就能用什么。没有规定的，绝不能用。
一套：《Java虚拟机规范》：规定了怎么用，就支持怎么用，没有规定的，随便用。（支持自我创造）
16、数组“的扩容”：
(16.1)创建数组时，必须显示指定长度，并在创建之后不可更改长度。
（16.2)扩容的思路：
（16.2.1）创建长度大于原数组的新数组；
（16.2.2）将原数组中的数据依次复制到新数组当中。
（16.3） 数组的复制：
（16.3.1) 循环将原数组中的所有元素数据逐一赋值给新数组。
(16.3.2)System.arraycopy(原数组 , 原数组起始位置 , 新数组 , 新数组起始位置 , 长度);
(16.3.3)数组类型的变量 = java.util.Arrays.copyOf(原数组 , 新长度); //根据长度创建新数组，并将原数组中的元素赋值到新数组中
17、地址的替换：
（17.1） 基本数据类型的变量存储的是值;基本数据类型,存储在栈中(基本类型的变量中，直接存储“值”）
（17.2） 引用数据类型的变量存储的是地址;引用数据类型,存储在堆中（应用类型的变量中，存储的时堆中的“地址”
（17.3) nums = newNums; //将新数组的地址，赋值给nums变量，进而在后续操作nums时，则操作长度更大的新数组。
18、数组类型的参数：
（18.1)基本数据类型的传递，是“值”的传递，一方改变，不会影响另一方
（18.2)引用数据类型的传递，是“地址”的传递，一方改变，会影响另一方
19、 可变长参数：
（19.1） 概念：可接收多个同类型实参，个数不限，使用方式与数组相同。
（19.2） 语法：数据类型... 形参名 //必须定义在形参列表的最后，且只能有一个，支持0~N个参数。
int... = int[] String... = String[] char... = char[] double... = double[]
method(xxx , xxx[] , xxx... ); //可变长参数，是对数组的一种便利写法的补充（80%的场景用数组，20%的场景用可变长参数）
20、排序：
（20.1)冒泡排序：
(20.1.1)相邻的两个值比较大小，互换位置。
(20.1.2)记忆：外层 length - 1 ；内层 length -1 - i
补充：嵌套循环约定俗称的变量命名，一重循环 i；二重循环j；三重循环k；
(20.2)选择排序：
(20.2.1）固定值与其他值比较大小，互换位置。
（20.2.2）记忆：外层 length - 1 ；同时外层i作为固定值，内层的j = i+1作为其他值的起始
21、二维数组：
（21.1) 概念：一维数组中的一维数组，数组中的元素，还是数组。
(21.2) 语法：
先声明、再分配空间：
数组类型[][] 数组名;
数组名 = new 数组类型[高纬度][低维度];
声明并分配空间：
数据类型[][] 数组名 = new 数组类型[高维度][低维度];
声明并赋值：
数据类型[][] 数组名 = new 数组类型[高维度][];//不规则数组，自行new低维度数组
声明并赋值：
数据类型 数组名 = {{1,2,3},{4,5},{6,7,8,9}};//显示初始化
(21.3) 注意：高维数组中的每一个元素，保存了低维数组的地址。访问array[0]等价于在访问0x0000A111（"二维数组的内存分配图"）
22、面向对象：
（22.1) 程序的概念：
程序是为了模拟现实世界、解决现实问题而使用计算机语言编写的指令集合。
(22.2) 现实世界组成：
程序员眼中，世界是由无数个对象组成的。
(22.3) 什么是对象：
一切客观存在的事物都是对象，万物皆对象。
初期：看得见、摸得着、并真实存在，都是对象。
(22.4) 对象有什么：
任何对象，一定有自己的特征和行为。
(22.5) 特征和行为：
特征：称为属性，一般为名词，代表对象都有什么。
行为：称为方法，一般为动词，代表对象能做什么。
(22.6)分析一个对象都有什么（属性）
颜色 - 黑色
品牌 - apple
价格 - 5000
型号 - 11pro
重量
尺寸
材质
(22.7)分析一个对象能做什么（方法）
打电话（拨号 -> 发射）
发短信
拍照
上网（app聊天、游戏、听音乐）
(22.8)程序中的对象：
程序如何模拟现实世界？
现实世界中，都是对象，程序中也应有对象。
程序当中必须具有和现实中相同的对象，用以模拟。
使用程序中的对象，代表现实中的对象，并执行操作，解决现实问题。
现实生活中的对象从哪里来？
手机 -> 工厂 -> 图纸（模板）
现实与程序：
现实中的对象，来自于模板，通过模板造出来的实体，即是现实的对象。
程序中的对象，来自于模板（“类”），通过类造出来的实体，即是程序中的对象。
(22.9)定义类、创建对象
（22.10）类与对象的关系：
类：定义了对象应具有的特征和行为，类是对象的模板。
对象：拥有多个特征和行为的实体，对象是类的实例。
PS：
属性、实例变量、成员变量，三者等价
实例方法、成员方法，二者等价
reference - 引用、句柄、指针
扫一扫
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
