JavaSE：基础入门（二）

1、流程控制语句

1.1、if/elseif/else

表达式里的最终返回值是boolean值

格式1
if(比较表达式) {
	语句体;
}

格式2
if(比较表达式) {
	语句体1;
}else {
	语句体2;
}
	
格式3
if(比较表达式1) {
	语句体1;
}else if(比较表达式2){
	语句体2;
}
...
else {
	语句体n+1;
}

1.2、switch

格式：
switch(表达式) {
	case 值1:
		语句体1;
		break;
	case 值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

注意
case后面只能是常量，不能是变量

1.3、控制跳转

 控制跳转语句：
break:中断，跳出,本身作为最后一次循环,之后不再做循环操作了,继续执行循环体外面的函数的
continue:继续（跳过当前，继续往下执行）
return:返回(它的作用不是结束循环的，而是结束方法的)

2、循环语句for/while/do…while

执行流程：
A:执行初始化语句
B:执行判断条件语句,看其返回值是true还是false
	如果是true，就继续执行
	如果是false，就结束循环
C:执行循环体语句;
D:执行控制条件语句
E:回到B继续。


for循环格式：
	for(初始化语句;判断条件语句;控制条件语句) {
		循环体语句;
	}
	
while循环的基本格式：
	初始化语句;
    while(判断条件语句) {
		 循环体语句;
		 控制条件语句;
	}
//特点：先判断，再执行

do...while循环的基本格式：
	初始化语句;
	do {
		循环体语句;
		控制条件语句;
	}while(判断条件语句);
	
	//特点：先执行，再判断	

补充：死循环

作用：等待  
	JDK源码 for (;;){
	     //自己的操作
	       }
		try (   
		Thread.sleep ) 
有一个循环，不停地去检测自己是队列的第一个,后面很多新的语言，死循环都有单独的写法，就是为了同for循环区别开

3、方法

方法：完成特定功能的代码块。
 
方法格式：
	修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
		方法体语句;
		return 返回值; 
	}
	
方法之间是平级关系，不能嵌套定义	
参数：
		实际参数：就是实际参与运算的。
		形式参数；就是方法定义上的，用于接收实际参数的。

可变参数：
		如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。
		格式：
			修饰符 返回值类型 方法名(数据类型... 变量) {}
		可变参数必须在最后

return：如果方法有明确的返回值类型，就必须有return语句返回。
方法重载：在同一个类中，方法名相同，参数个数||类型||顺序不同，与方法的修饰符和返回值无关，可以改变返回值的类型

	public static void main(String[] args) {
		int result=sum(10,20);
		int result1=sum(10,20,30);//方法重载
		int max=getMax(10,20);
		
		System.out.println(result);
		System.out.println(result1);		
		System.out.println(max);
	}
	
	//求和
	public static int sum(int a,int b){
		return a+b;
	}
	//override方法重载
	public static int sum(int a,int b,int c){
		return a+b+c;
	}
	//获取最大值
	public static int getMax(int a,int b){
		return a>b?a:b;
	}


调用:对象名.方法名
A.无参无返回值
B.无参有返回值.... 
	有返回值必须有return;返回值可以有多个吗?只能有1个 Golang return的值必须和返回值对应
C.有参数无返回值
	调用有参数的函数时,传入的参数类型必须一致 实参不需要类型	
D.有参数有返回值

4、数组

4.1、数组特点

数组:存储同一种数据类型的多个元素的容器。

定义格式：数据类型[] 数组名;

对数组进行初始化:
就是为数组开辟内存空间，并为每个数组元素赋予值

有几种方式分配空间
	a:动态初始化 只指定长度，由系统给出初始化值
		int[] arr = new int[3];	
	b:静态初始化 给出初始化值，由系统决定长度
		int[] arr={1,2,4,5}
	
数组名[索引]:索引其实就是每个元素的编号，从0开始，最大索引是数组的长度-1。
数组赋值必须是通过index (index从0开始)
没有赋值的,他的初始值是????数组类型的初始值
不能超过数组的长度（要不然会报越界的错）

4.2、遍历数组

//调用to_string方法的话两边是有中括号的
int[] arr={1,2,3,45,0,434,22};
for(int x=0; x<arr.length; x++) {
						System.out.println(arr[x]);
					}

第二种：
println是带换行符的，print不带
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, 3, 45, 0, 434, 22]

第三种：增强for遍历数组（代码量少）
for(元素类型 元素变量:遍历对象){
}

System.out.print("[");
for(int x:arr){  //注意，这里取出的是数组里面的元素值，而不是索引值
    if(x==arr[arr.length-1]){
        System.out.println(x+"]");
    }else{
        System.out.print(x+",");
    }
}
输出结果：[1,2,3,45,0,434,22]

4.3、逆序

for(int x=0; x<arr.length/2; x++) {  //前后元素做交换
    int temp = arr[x];
    arr[x] = arr[arr.length-1-x];
    arr[arr.length-1-x] = temp;
}
System.out.print("[");
for(int x:arr){
    if(x==arr[arr.length-1]){
        System.out.println(x+"]");
    }else{
        System.out.print(x+",");
    }
}

4.4、冒泡排序

	public static void bubbleSort(int[] arr){
		for(int x=0;x<arr.length-1;x++){
			for(int y=0;y<arr.length-1;y++){
				if(arr[y]>arr[y+1]){
					int temp=arr[y];
					arr[y]=arr[y+1];
					arr[y+1]=temp;
				}
			}
		}
	}

4.5、选择排序

	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[y] <arr[x]){
					int temp = arr[x];
					arr[x] = arr[y];
					 arr[y] = temp;
				}
			}
		}
	}

4.6、二分查找

	public static int getIndex(int[] arr,int value){
		//定义最大索引，最小索引
		int max = arr.length -1;
		int min = 0;
		
		//计算出中间索引
		int mid = (max +min)/2;
		
		//拿中间索引的值和要查找的值进行比较
		while(arr[mid] != value){
			if(arr[mid]>value){
				max = mid - 1;
			}else if(arr[mid]<value){
				min = mid + 1;
			}
			
			//加入判断
			if(min > max){
				return -1;
			}
			
			mid = (max +min)/2;
		}
		
		return mid;
	}

4.7、二维数组

二维数组：就是元素为一维数组的一个数组。
格式：
		数据类型[][] 数组名 = new 数据类型[m][n];
			m:表示这个二维数组有多少个一维数组。
			n:表示每一个一维数组的元素有多少个。
			
int[][] arr=new int[2][3];
int[][] arr1={{1,3,4},{2,5,6}};
System.out.println(arr[0]); 
System.out.println(arr[1]);
System.out.println(arr[0][0]);
System.out.println(arr[0][1]);