六.语句
1) 判断结构
if：语句用于做判断使用的。
常见于对某个范围进行判断，或者几个变量进行判断，还有就是boolean表达式的判断。
判断语句三种格式：
1. if (条件表达式){}执行语句;
执行流程：如果条件表达式为true，就执行语句，否则，什么都不执行。
2. if(条件表达式){
if语句执行体;
}else{
else语句执行体;
}
执行流程：如果条件表达式为true，就if语句执行体；否则，就执行else语句执行体；
3. if(条件表达式){
if语句执行体;
}
else if(条件表达式){
else if语句执行体;
}
...
else{
else语句执行体;
}
执行流程：
如果条件表达式1 为true，就执行if语句执行体;；
如果条件表达式2 为true，就执行else if语句执行体;；
如果条件表达式...为true，就执行else if语句执行体;；
否则，就执行else语句执行体；
注意事项
1:什么时候用哪一种if语句？第一种格式在判断条件为一种情况下使用。第二种格式在判断条件为两种情况下使用。第三种格式在判断条件为多种情况下使用。
2:if语句执行完会执行另外一个语句吗？
每一种if语句其实都是一个整体，如果有地方执行了。其他的就不执行了。
3:大括号需要每次都写上吗？
如果if或者else里面控制的语句体是一条语句，是可以省略大括号的，
但是，如果是控制多条语句，就必须写上大括号。
建议：永远写上大括号。
4:大括号和分号一般不同时出现。
if(true)
System.out.println("true");
else
System.out.println("false");;
举例：需求：获取两个数中的最大值。//因为获取俩个数中的最大值必须有一个结果.所以可以先考虑三元运算符。int x=1,y=2,z;z=(x>y)?x:y;
作用域：
所有变量的定义只在它所属的大括号内有效。
特殊：
可以和条件表达式在某些情况下进行替换。
一般是在赋值的情况下可以。
2)选择结构
switch 语句
用于做选择使用的。一般用于几个常量的判断。
switch 语句 会把几个常量值直接加载到内存，在判断的时候，效率要比 if 语句 高。
所以，针对几个常量的判断，一般选择 switch 语句。
选择语句格式：
switch(变量){
case 取值1：
执行语句;
break ;case 取值 2：
执行语句;
break ;...default:
执行语句;
break;
}
针对格式的解释
switch:表示这里使用的是switch语句，后面跟的是选项。
表达式：byte,short,int,char
JDK 1.5以后可以是枚举
JDK 1.7以后可以是字符串
case:表示这里就是选项的值，它后面的值将来和表达式的值进行匹配。
case:后面的值是不能够重复的。
break:switch语句执行到这里，就结束了。
default:当所有的case和表达式都不匹配的时候，就走default的内容。
它相当于if语句的else。一般不建议省略。
执行流程：
进入switch语句后，就会根据表达式的值去找对应的case值。
如果最终没有找到，那么，就执行default的内容。
注意事项：
a: default 整体可以省略吗?
可以，但是不建议。
b:default的位置可以放到前面吗?
可以，但是不建议。
c:break可以省略吗?
可以，但是不建议。default在最后，default的break是可以省略的，但是结果可能有问题。
d:switch语句什么时候结束呢?
就是遇到break或者执行到程序的末尾。
if 和 switch 的应用：if语句特点:
1,对具体的值进行判断。
2,对区间判断。
3,对运算结果是boolean类型的表达式进行判断。
switch语句特点:
3)循环结构1,对具体的值进行判断。
2,值的个数通常是固定的。
对于几个固定的值判断，建议使用switch语句，因为switch语句会将具体的答案都加载进内存。效率相对高一点。
3.switch只能对基本数据类型进行操作 byte,short,int,char
循环语句：while, do while , for
如果我们发现有很多重复的内容的时候，就该考虑使用循环改进代码。
让我们代码看起来简洁了。while循环语句格式：
while(条件表达式){
循环执行体;
}
do while 循环语句格式：
do {
循环执行体;
}while(条件表达式);
while 特点：条件如果不满足，不会走循环体
do while特点：条件无论是否满足，循环体至少执行一次。
for循环语句格式：
for (初始化表达式；循环条件表达式；循环后的操作表达式){
执行语句;(循环体)
}
循环注意 ： while 先判断后执行。 do while 先执行一次后判断。循环总结：一定要注意哪些语句需要参加循环，哪些不需要。总结：什么时候用循环语句？
当对某些语句执行很多次时，就使用循环结构。
总结：什么情况用for，什么情况用while呢？
for和while可以互换。如果用于定义循环增量。用for更合适。因为节约内存。
当然，当我们在写测试程序时，为了书写的简洁，也是可以用while，因为容易看。
不过建议使用for，习惯成自然。你懂的
。
嵌套循环:
简单的说就是循环里面还有循环。
外循环执行一次，内循环执行一遍。
for(初始化表达式;条件表达式;循环后的操作表达式){
for(初始化表达式;条件表达式;循环后的操作表达式){
}
}
while(条件表达式){
while ( 条件表达式 ){}
}总结：嵌套循环是外循环条件成立执行一次，内循环必须执行到条件不满足才结束。
1)累加思想：
原理：通过变量记录住每次变化的结果，通过循环的形式，进行累加动作。
2).计数器思想：
原理：通过一个变量记录住数据的状态变化，也许通过循环完成。
3)大圈套小圈思想：
原理：尖朝上改变条件。尖朝下改变初始值。
注意 ：
1， for 里面的连个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2， while 和 for 可以互换，区别在于 for 为了循环而定义的变量在 for 循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
3， 最简单无限循环格式： while ( true )， for (;;)无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。比如在循环体定义判断语句。
其它流程控制语句：
有些时候，我们需要对循环进行一些控制终止,这个时候，就出现了两个关键字：
break和continue
break（跳出），continue（继续）
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
注意：
1， 这两个语句离开应用范围，存在是没有意义的。
2， 这两个语句单独存在下面都不只可以有语句，因为执行不到。
3， continue语句是结束本次循环继续下次循环，结束之后会去判断表达式。3， continue语句是结束本
4， 标号的出现，可以让这两个语句作用于指定的范围。方便了可以跳出多重循环或者继续哪层循环。
练习题：
七.函数
1.函数的定义：
(1).函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
(2).函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2...) {
}执行语句;
return 返回值;
2.函数的特点：
(1).定义函数可以将功能代码进行封装，便于对该功能进行复写。
(2).函数只有被调用才会被执行。
(3).函数的出现提高了代码的复用性。
(4).对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的 return语句如果在最后一行可以省略不写。
(5).函数中只能调用函数，不可以在函数内部定义函数。
(6).定义函数时，函数的结果应该返回给调用者，交由调用者处理。
(7).可以自定义一个访问权限。
定义函数时需要注意：
1.功能中只定义所需内容，不是该功能所需的内容不要定义。
2.如果非要定义，也是单独定义一个功能来体现。以后开发时，尽量都将功能以不同的函数来体现。
3.不要将代码都定义在主函数中。
4.主函数的作用是：对已有的功能的进行调用，可以理解为用于功能的测试。
5.函数名就是一个自己定义的标示符。函数名的定义，要尽量体现出这个函数的功能。是为了增强该函数的阅读性，方便于调用者使用，所以函数名一定要有起的有意义。
6.静态方法只能调用静态方法。主函数是静态的。
7.返回值类型和参数类型没有直接关系。
定义函数时候需要有两个明确：
1）这个函数会得到什么结果，也就是返回值是什么。
2）有没有未知内数据参与运算。
3.函数的重载（Overload）：
(1).重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数和参数类型不同即可。
(2).重载的特点：与返回值类型无关，只看参数列表。
4.函数重载什么时候使用？(3).重载的好处：方便于阅读，优化了程序设计。
注:Java是严谨性语言，如果函数出现的调用不确定性，会编译失败。
重载：当定义的功能相同，但参与运算的未知内容不同，那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的
同来区分多个同名函数。
八.数组
1.数组的概述：
(1).概念：同一种类型数据的集合。其实数组就是一个容器。
(2).好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
(3).对数组的基本操作就是存和取。核心思想：基于角标。
(4)既可以存储基本数据类型又可以存储引用类型，只是长度固定。集合长度可变，但只能存储引用类型。
2.数组的定义：
3.数组的特点：
1）元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
2）元素类型[] 数组名 ={1,2,3,4,5,6,7};可以直接指定具体的数据
3）元素类型[] 数组名；
数组名 = new 元素类型[元素个数或数组长度];
1）数组定义时，必须明确数组的长度(就是数组中可以存储的元素的个数。)因为数组长度是固定的。
2）数组定义时，必须明确数组中的元素的数据类型。
例子：
char[] arr = new char[5];
arr[0] = '黑';arr[1] ='马';
4.数组的内存结构：
Java内存区域的划分：1）寄存器。2）本地方法区。3）方法区。 4）栈内存。5）堆内存。
为什么划分这么区域？因为每一个内存区域对数据的处理方式不同。目前要讲的就是栈和堆。
1）栈内存的特点：存储都是局部变量
(函数参数,函数内定义的变量,语句中定义的变量)变量一旦使用完(作用域结束)，就会在栈内存中自动释放。
2）堆内存特点：存储的是实体
1.堆内存中的实体都有首内存地址值.
2.堆内存中的变量都有默认初始化值.
3.对于没有任何引用变量指向的实体，会视为垃圾，会被垃圾回收机制所回收。
(数组和对象，只要是new的，都在堆内存中)
5.操作数组时常见问题：
A.数组角标越界异常(ArrayIndexOutOfBoundsException):操作数组时，访问到了数组中不存在的角标。
B.空指针异常(NullPointerException)：当引用没有任何指向值为null的情况，该引用还在用于操作实体。
6.对数组的常见操作：
1.获取数组中的元素 2.获取最值 3.排序（冒泡排序 最大的在最后、选择排序）
4.查找（折半查找 只针对有序）插入（针对有序）
1).获取数组中的元素，通常会用到遍历：
2).获取最值：
最大值：
- /* 思路：
- 1，需要进行比较。并定义变量记录住每次比较后较大的值。
- 2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
- 如果遍历到的元素大于变量中记录的元素，就用变量记录住较大的值。
- 3，遍历结果，该变量记录就是最大值。
- 定义一个功能来是实现。
- 明确一，结果。
- 是数组中的元素。int .
- 明确二，未知内容。
- 数组.
- */
最小值：
- /* 思路：
- 1，需要进行比较。并定义变量记录住每次比较后较小的值。
- 2，对数组中的元素进行遍历取出，和变量中记录的元素进行比较。
- 如果遍历到的元素小于变量中记录的元素，就用变量记录住较小的值。
- 3，遍历结果，该变量记录就是最小值。
- 定义一个功能来是实现。
- 明确一，结果。
- 是数组中的元素。int .
- 明确二，未知内容。
- 数组.
- */
3).排序：
- /*排序（选择排序，冒泡排序）*/
- public static void swap(int[] arr,int x,int y)
- {
- int temp = arr[x];
- arr[x]= arr[y];
- arr[y]= temp;
- }
- /*
- 冒泡排序。
- */
- public static void bubbleSort(int[] arr)
- {
- for(int x=0; x<arr.length-1; x++)
- {
- for(int y=0; y<arr.length-1-x; y++)
- {
- if(arr[y]>arr[y+1])
- {
- swap(arr,y,y+1);
- }
- }
- }
- }
- /*
- 选择排序。
- */
- public static void selectSort(int[] arr)
- {
- for(int x=0; x<arr.length-1; x++)
- {
- for(int y=x+1; y<arr.length; y++)
- {
- for(arr[x]>arr[y])
- {
- swap(arr,x,y);
- }
- }
- }
- }
数组的工具类Arrays：开发中主要用于操作数组用其工具类。
此类包含用来操作数组（比如排序和搜索）的各种方法。
其主要方法为：
1.排序：Arrays.sort( arr );2.二分查找：Arrays.binarySearch(arr, key);
如果它包含在数组中，则返回搜索键的索引；否则返回(-(插入点) - 1)。
3,复制指定的数组：Arrays.copyOf(arr, newLength);返回新数组，长度不足则填充响应值。
4.复制指定范围的数组：Arrays.copyOfRange(arr,from,end);含头不含尾5.toString: Arrays.toString(arr); 返回数组的字符串形式
利用数组进行进制转换
public static void toBin(int num){
//定义二进制的表。
char[] chs = {'0','1'};
//定义一个临时存储容器。
char[] arr = new char[32];
//定义一个操作数组的指针
int pos = arr.length;
while(num!=0){
int temp = num & 1;
arr[--pos] = chs[temp];
num = num >>> 1;
}
for(int x=pos; x<arr.length; x++){
System.out.print(arr[x]);
}
}
public static void trans(int num,int base,int offset){
if(num==0){
System.out.println(0);
return;
}
char[] chs = {
'0','1','2','3',
'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
//定义一个临时容器。
char[] arr = new char[32];
int pos = arr.length;
while(num!=0){
int temp = num & base;
arr[--pos] = chs[temp];
num = num >>> offset;
}
System.out.println("pos="+pos);
//存储数据的arr数组遍历。
for(int x=pos;x<arr.length; x++) {
System.out.print(arr[x]);
}
}
//二进制
public static int toBin(int num){
trans(num,1,1);
}
//八进制
public static int toBa(int num){
trans(num,7,3);
}
//十六进制
public static int toHex(int num){
trans(num,15,4);
}
注意: String toBina=Integer.toBinaryString (int i)
String toHex=Integer.toHexString(int i)
String toOctalString=Integer.toOctalString(int i)
九：二维数组
1.什么是二维数组：
其实元素就是一个一维数组。
2.二维数组格式：
(1).方式1:元素类型[][] 数组名 = new 元素类型[3][2];
例子:
int[][] arr = new int[3][2];
解释：
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1索引位赋值为78写法是：arr[0][1] = 98;
(2).方式2：元素类型[][] 数组名 =new 元素类型[3][];
例子:
int[][] arr = new int[3][];
二维数组中有3个一维数组元素
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];
(3).方式3：元素类型[][] 数组名 = {{一维数组元素}{一维数组元素}{一维数组元素}};
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
3.二维数组的遍历
思路：
(1).二维数组的每一个元素是一维数组。
获取到每一个一维数组。
(2).一维数组的遍历。
class Test {
public static void main(String[] args) {
//二维数组的遍历
int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
//arr.length 获取二维数组的长度，其实也就是一维数组的个数
for(int x=0; x<arr.length; x++) {
//arr[x].length 获取的是每一个一维数组的长度
for(int y=0; y<arr[x].length; y++){
//arr[x][y] 获取的是二维数组的元素
System.out.print(arr[x][y]+"\t");
}
System.out.println();
}
}}