Java语言基础(下)
五、程序流程控制结构
就像日常生活中写文章时，可以采用顺叙、插叙、倒叙的方式描述一件事；在java语言中，程序代码的执行顺序也可以采用不同的“描述”方式，这种“描述”方式就是程序流程控制结构。
程序流程控制结构可以细分为以下三种方式：
(1)、判断结构：if语句
if语句有三种格式：
1)、if(条件表达式){执行语句;}
2)、if(条件表达式){执行语句;} else{执行语句;}
3)、if(条件表达式){执行语句;}else if(条件表达式){执行语句;}else{执行语句;}
注意：if语句可以进行多层的嵌套使用，并且条件表达式必须是Boolean类型的，要么是true，要么是false。
(2)、选择结构：switch语句
switch(表达式)
{
case取值1:
执行语句；
break；
case取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
注意：在switch语句中的选择的类型只能是这四种类型：byte、short、char、int。
(3)、循环结构:while语句,do while 语句，for语句
while语句格式：while(条件表达式){执行语句;}
do while语句格式：do{执行语句;}while(条件表达式);
for语句格式：for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句;
}
练习：打印一个九九乘法表：
package itheima.day03;
/*打印一个九九乘法表*/
public class Multiplication {
public static void main(String[] args) {
//运用大圈套小圈的原理
for(int row = 1;row <=9;row++){// 大圈控制行
for(int col = 1;col<=row;col++){//小圈控制列
System.out.print(col+"*"+row+"="+row*col+'\t');
}
System.out.println();
}
}
}注意：do while特点是条件无论是否满足，循环体至少被执行一次。,while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
(4)、其他流程控制语句:break语句，continue语句
break语句：跳出本层结构，用于选择结构和循环结构中。
continue语句：结束本次循环继续下次循环，用于循环结构中。
六、函数
函数的定义：函数就是封装了特定功能的一段独立的小程序，在java中，函数也称为方法。
函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，)
{
执行语句;
return 返回值;
}
定义函数就是为了将特定的功能进行封装，降低代码的耦合性，提高代码的重用性。函数只有被调用的时候才会被执行，并把执行后的返回值返回给调用者。当没有返回值时，返回类型使用关键字void表示，return语句可以省略不写。函数是支持调用其他函数的，但是不支持函数的嵌套定义，也就是函数中定义函数。
注意：一般定义函数时，要明确函数最后的返回结果，也就是要返回的数据；还要明确参与函数运算的数据，也就是形式参数的列表要明确；函数名应该尽量写成与该函数功能相同，提高阅读性。
函数的重载(overload)：在一个类中，当两个或者两个以上的函数名称相同，并且形式参数的列表不相同时，就称这些函数重载，重载与返回值类型无关。
例如： int add(int x,int y){returnx+y;}
intadd(int x,int y,int z){return x+y+z;}
doubleadd(double x,double y){return x+y;}
七、数组
数组：数组是一种容器，但数组这种容器中只能存储相同的数据类型元素。
格式：1、元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
例如：int[] arr = new int[10];
2、元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
例如：int[] arr = new int[]{1,5,8,7};
int[] arr = {1,5,8,7};
内存结构：每一个程序的运行都需要分配内存。在java中，为了提高运算的效率，因此对内存进行了划分。可以分为：栈内存、堆内存、方法区、本地方法区、寄存器。下面只介绍栈区和堆区，其他的内存结构会在以后的使用中再介绍。
栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放，相对来说较小。
堆内存：用于存储数组和对象，一般用new关键字建立的实体都存储在堆内存中；每一个实体都有内存地址值；每一个实体的变量都有默认初始化值；当实体不再被引用指向时，由垃圾回收器回收。如图3.1所示：
图3.1
下面就写几个练习熟悉一下函数和数组的操作：
获取最值：
package itheima.day04;
/*获取一个数组中的最大值*/
public class ArrayDemo1 {
public static void main(String[] args) {
int[] arr = {5,9,6,3,1,4,2,10};//1：定义一个数组
int max = getMax(arr);//2：调用函数，获取最大值
System.out.println("数组中最大值是："+max);//3：打印最大值，10
}
public static int getMax(int[] arr){//把一个独立的功能封装成为一个函数，使代码结构更加清晰
int max = arr[0];
for(int i=0;i<arr.length;i++){
if(max<arr[i]){
max = arr[i];
}
}
return max;
}
}排序：
package itheima.day04;
/*给一个数组进行排序*/
public class ArrayDemo2 {
public static void main(String[] args) {
int[] arr ={100,25,63,59,54,61,76};
printArray(arr);//打印数组
//selectSort(arr);//给数组进行选择排序
bubbleSort(arr);//给数组进行冒泡排序
printArray(arr);//再打印数组
}
public static void selectSort(int[] arr){//把选择排序的功能封装成为一个函数，提高代码复用性
for(int x = 0;x<arr.length-1;x++){//控制比较次数
for(int y = x+1;y<arr.length;y++){//控制每一次都多少个数进行比较
if(arr[x]>arr[y]){
swap(arr,x,y);//调用函数，交换两个值
}
}
}
}
public static void bubbleSort(int[] arr){//冒泡排序的函数
for(int x=0;x<arr.length-1;x++){//控制比较的次数
for(int y=0;y<arr.length-x-1;y++){//每一次要比较数的多少
if(arr[y]>arr[y+1]){
swap(arr,y,y+1);//交换两个数
}
}
}
}
private static void swap(int[] arr,int x,int y){//将重复调用的代码独立封装成为函数，使代码更加紧凑
int temp =arr[x];
arr[x] =arr[y];
arr[y] =temp;
}
public static void printArray(int[] arr){//打印函数
System.out.print("[");
for(int x =0;x<arr.length;x++){
if(x!=arr.length-1)
System.out.print(arr[x]+", ");
else
System.out.println(arr[x]+"]");
}
}
}折半查找(二分查找)：
package itheima.day04;
/*演示二分查找*/
public class BinarySearch {
public static void main(String[] args) {
/*二分查找的前提：要查找的数组必须是有序的，否则无法进行*/
int[] arr = {1,3,5,6,8,9,11};
int index = halfSearch(arr,1);//调用函数
System.out.println("index = "+index);
}
public static int halfSearch(int[] arr,int key){//二分查找的函数
int min = 0,max = arr.length-1,mid;
while(min<=max){
mid = (max+min)>>1;
if(key>arr[mid])
min = mid+1;//当要查找的数大于中间数时，在数组右边查找
else if(key<arr[mid])
max = mid-1;//当要查找的数小于中间数时，在数组左边查找
else
return mid;//找到直接返回角标
}
return -1;//没找到时返回-1
}
}十进制转换成其他进制：
package itheima.day04;
/*实现进制之间的转换*/
public class JinZhiConvertion {
public static void main(String[] args) {
int number = 60;
toBinary(number);//转换成二进制
toOctal(number);//转换成八进制
toHex(number);//转换成十六进制
}
public static void translation(int num,int base,int offset){
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;
if(num ==0){//检查数组是否为零
System.out.println(0);
return ;
}
while(num!=0){//转换
int temp = num&base;
arr[--pos] = chs[temp];
num = num>>>offset;
}
for(int x=pos;x<arr.length;x++){
System.out.print(arr[x]);
}
System.out.println();
}
public static void toBinary(int num){//转成二进制
translation(num,1,1);
}
public static void toHex(int num){//转成十六进制
translation(num,15,4);
}
public static void toOctal(int num){//转成八进制
translation(num,7,3);
}
}二维数组：数组中存储的元素还是一个数组，数组中的数组，就称为二维数组。
格式1：int[][] arr = new int[3][2];二维数组arr中有3个一维数组，每个一维数组有两个int类型的元素。
格式2：int[][] arr = new int[3][];二维数组arr中有3个一维数组，这3个一维数组都没有进行初始化。
格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};二维数组arr中有3个一维数组，这3个一维数组都已经初始化，并且已经固定。
注意：二维数组中存储的是每一个一维数组的地址值，并非具体的数组数值！
package itheima.day04;
public class ArrayInArray {
/*演示二维数组中的注意问题*/
public static void main(String[] args) {
int[][] arr = new int[3][];
System.out.println(arr.length);//3，打印二维数组的长度
System.out.println(arr[1]);//null，因为arr[1]还是一个一维数组，还没有初始化，所以为null
arr[0] = new int[]{2,3,6};//给二维数组中的一维数组初始化，就像初始化普通的一维数组一样
arr[1] = new int[]{5,9,6};
arr[2] = new int[]{7,8,4};
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();
}
}
}