Java基础——程序流程控制、函数与数组

一. 程序流程控制

1.顺序结构（就是Java代码从上往下的结构）

2.判断结构

2.1 if结构一

if(条件表达式){
	执行语句;
}

2.2 if结构二

if(条件表达式){
	执行语句;
}else{
	执行语句;
}

2.3 if结构三

if(条件表达式){
	执行语句;
}else if(条件表达式){
	执行语句;
}//这里可以添加多个else if语句
else{
	执行语句;
}

3.选择结构

switch(条件表达式){				
	case 取值1;	//1.switch语句支持的类型：byte、short、int、char、字符串、枚举
		执行语句;				
		break;
	case 取值2	//2.switch语句中的case和default是没有先后顺序的
		执行语句;
		break;
	//这里可以添加多个case语句
	default:	//3.当switch语句中满足取值却没有碰到break或者【}】会一直向下执行，直至遇到这两个结束标志
		执行语句;
		break;
}

4.循环结构

4.1 while循环

while(条件表达式){
	循环体;
}//定义变量只能定义在循环外

4.2 do、while循环

do{
	循环体;
}while(条件表达式);//先执行一次循环体，再判断条件 

4.3 for循环

for(初始化表达式;循环条件表达式;循环后的操作表达式){//不写条件表达式默认为true
	循环体;
}//for中定义的变量只存在于循环中，之后会释放。

4.4 知识点：

（1）计数器思想：通过一个变量记录住数据的状态变化

（2）for循环中可以并列多个循环语句

（3）continue语句：应用于循环结构，结束本次循环继续下一次循环，单独存在时下边不能有任何语句

（4）break语句：应用于循环结构或者选择结构，跳出本次循环或者选择，单独存在时下边不能有任何语句

（5）里外for循环都能添加标号，标号能够结合break与continue语句使用

二. 函数

1.结构公式

修饰符 返回值类型 函数名(参数类型 形式参数,参数类型 形式参数,...){
	//执行语句;
	//return 返回值;
}

2.注意

（1）建立函数有参数的话，书写函数时第一行应书写判断传入参数合法性的语句

（2）定义函数想好主要功能，由而确定返回值与参数列表，不要把一些列功能全部定义在一个函数中

（3）判定函数是否重载只看参数列表，和返回值类型无关

3.函数功能

3.1 十进制——>二进制、八进制、十六进制

	/*
	需求：十进制——>二进制、八进制、十六进制
	思路：1.设置字符仓库，包含表示二进制、八进制、十六进制的所有字符
		 2.二进制形式&1，八进制形式&7，十六进制形式&15得到角标号查表即可
		 3.二进制形式右移1位，八进制形式右移3位，十六进制形式右移4位获得新数字后继续重复3
		 4.直到指定数字为0时结束
	*/
	public static void cast(int num,int x,int offset){
		if(num==0){
			System.out.println(0);
			return;
		}
		StringBuffer sb = new StringBuffer();
		char[] farm = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
		int count = 0;

		while(num!=0){
			count = num & x;
			sb.append(farm[count]);
			num >>>=offset;
		}
		System.out.println(sb.reverse());
	}

	public static void toBin(int num){
		cast(num,1,1);
	}

	public static void toHex(int num){
		cast(num,15,4);
	}
	public static void toBa(int num){
		cast(num,7,3);
	}
	//查表法：定义相应字符数组作为仓库，查询得到想要字符即可

三. 数组——一种数据类型的集合

1.结构公式

元素类型[] 数组名 = new 数据类型[元素的个数或数组的长度];	//动态初始化
元素类型[] 数组名 = new 数据类型[]{元素,元素,...};		//静态初始化，后边的new 数据类型[]可以省略不写

2.Java内存结构

（1） 栈内存：数据使用完毕后会自动释放（局部变量存储在里面）

（2） 堆内存三大特性（对象存储在里面）

a.内存地址值：存放的都是对象，对象有地址值，栈区的变量引用的就是这个地址值

b.默认初始化值：对象内属性都有默认的初始化值

c.垃圾回收机制：垃圾不定时回收

3.初识异常

（1）数组越界异常：ArrayIndexOutOfBoundsException——访问到数组中不存在的角标

（2）空指针异常：NullPointerException——调用的引用所指向的值为null

4.数组的常见操作

4.1 获取数组的最值

	/*
	需求：获取指定数组的最大值或者最小值
	思路：1.建立变量max或者min，把数组零脚位的数组赋值给这两个变量
		 2.遍历数组，并在遍历过程中判断数组中每个数值与max或者min的大小关系
		    大则把大的数值赋值给max，小则把小的数值赋值给min
	*/
		int[] x = {13,41,521,4,3,234,51,351};
		int max = x[0];
		int min = x[0];
		for(int a=1;a<x.length;a++){
			if(max<x[a])
				max = x[a];
			if(min>x[a])
				min = x[a];
		}
		System.out.println("最大值为："+max+"\t最小值为："+min);

4.2 选择排序

	/*
	需求：对指定数组进行选择排序
	思路：1.首先1角标位置的元素与后边的元素相比较，比1位置小的元素与1角标元素位置互换，这样便利一遍数组
		 2.然后2角标位的元素与其后边的元素相比较，同上，以此类推排序完成
	*/
		int[] x = {13,41,521,4,3,234,51,351};
		for(int a=0;a<x.length;a++)
			for(int b=a;b<x.length-1;b++)
				if(x[a]>x[b+1]){
					x[a] = x[b+1]^x[a];
					x[b+1] =x[b+1]^x[a];
					x[a] = x[b+1]^x[a];
				}
		System.out.println(Arrays.toString(x));

4.3 冒泡排序

	/*
	需求：对指定数组进行冒泡排序
	思路：1.比较相邻两个元素的值，如1比2,2比3,3比4这样，比到最后一个角标位
		 2.比较的结果如果是前者大于后者，那么两者互换位置
		 3.这样的顺序额便利一遍数组，第二次从1角标位按着这种算法遍历到最后一个角标-1的位置停止。
		 4.以此类推遍历完整个数组
	*/
		x = new int[]{13,41,521,4,3,234,51,351};
		for(int a=0;a<x.length;a++)
			for(int b=0;b<x.length-a-1;b++)
				if(x[b]>x[b+1]){
					x[b] = x[b+1]^x[b];
					x[b+1] =x[b+1]^x[b];
					x[b] = x[b+1]^x[b];
				}
		System.out.println(Arrays.toString(x));

4.4 折半查找

	/*
	需求：对指定有序数组进行折半查41
	思路：1.首先设定三个值，给别为start=0,end=arr.length,mid=(start+end)/2
		 2.然后判断mid值是否与41相等，如果mid>41,那么end=mid-1;如果mid<41，那么start=mid+1.
		 3.再重新赋值start,end,mid即可，循环步骤知道找出结果
		 4.如果最后min>max那么返回-1
	*/
		int start=0;
		int end = x.length-1;
		int mid = (start+end)/2;
		while(x[mid]!=41){
			if(41>mid)
				start=mid+1;
			else
				end =mid-1;
			if(start>end){
				mid=-1;
				break;
			}
			mid = (start+end)/2;
		}
		System.out.println("查找值再数组中的索引位置为："+mid);

5.二维数组

元素类型[][] 数组名 = new 数据类型[里数组的个数][每个里数组的长度];	//格式1
元素类型[][] 数组名 = new 数据类型[里数组的个数][];	  //格式2,需注意！里数组初始化值为null
元素类型[][] 数组名 = {{元素..},{元素..},{元素..}};	 //格式3