冒泡，选择排序法，函数的封装与调用

public static void main(String[] args) {
	
	int sum = add(1,2);//调用add函数，并用sum来接收函数的返回值
	System.out.println(sum);
	
	int sum1 = add(1,2,3);//调用add函数，并用sum来接收函数的返回值
	System.out.println(sum1);
	
	int [] arr1 = method(arr);//调用method函数，并用数组arr1来接收函数的返回值
	System.out.println(Arrays.toString(arr1));
	
	int [] list = maopao_for(arr);//调用maopao_for函数，并用数组list来接收函数的返回值
	System.out.println(Arrays.toString(list));
	
	int [] str = check(arr);//调用check函数，并用数组str来接收函数的返回值
	System.out.println(Arrays.toString(str));
	
	int [] str1 = maopao_while(arr);//调用maopao_while函数，并用数组str1来接收函数的返回值
	System.out.println(Arrays.toString(str1));
	
	int [] str2 = check_while(arr);//调用check_while函数，并用数组str2来接收函数的返回值
	System.out.println(Arrays.toString(str2));
	
	int [] str3 = maopao_do_while(arr);//调用maopao_do_while函数，并用数组str3来接收函数的返回值
	System.out.println(Arrays.toString(str3));
	
	int [] str4 = check_do_while(arr);//调用check_do_while函数，并用数组str4来接收函数的返回值
	System.out.println(Arrays.toString(str4));
}

/*
 * 函数（方法）：定义在类里面，具有独特功能的一段代码块
 * 优点：提高代码的复用性；简化代码；封装代码，隐藏细节
 * 格式：
 * 修饰符 返回值类型 函数名(参数的类型 形式参数){
 * 函数体;
 * return 返回值;（没有返回值得时候可以省略）
 * }
 * void:没有返回值
 * 函数有返回值的时候必须定义相同类型的变量接收
 * 函数的调用：
 * 		函数名(参数);
 * 基本数据类型当参数传递没有返回值的时候，对数据的改变没有作用
 * 引用数据类型当参数传递没有返回值的时候，对数据的改变有作用
 */


/*
 * 函数重载：
 * 1、在同一个类中
 * 2、方法名相同
 * 3、参数的类型或者参数的类型不同
 * 4、和返回值无关
 */
public static int add(int a,int b){
	int sum = a+b;
	return sum;
}
public static int add(int a,int b,int c){
	int sum = a+b+c;
	return sum;
}

/*
 * 形式参数和实际参数
 * 形式参数：
 * 		引用数据类型也可以作为形式参数传递
 * 实际参数：
 * 		
 */
static int [] arr = new int []{1,2,3,3,4,5,6,7};
public static int[] method(int [] arr){
	arr[0] = 8;
	return arr;
}

/*
 * 对排序的方法进行封装
 */
public static int [] maopao_for(int [] arr){//封装for冒泡排序法
	for(int i=0;i<arr.length-1;i++){
		for(int j=0;j<arr.length-1-i;j++){
			if(arr[j]<arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
	return arr;
}
public static int [] check(int [] arr){//封装for选择排序法
	for(int i=0;i<arr.length-1;i++){
		for(int j=i+1;j<arr.length;j++){
			if(arr[i]>arr[j]){
				int temp =arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
		}
	}
	return arr;
}
public static int [] maopao_while(int [] arr){//封装while冒泡排序法
	int i = 0;
	while(i<arr.length-1){
		int j = 0;
		while(j<arr.length-i-1){
			if(arr[j]<arr[j+1]){
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
			j++;
		}
		i++;
	}
	return arr;	
}

public static int [] check_while(int [] arr){//封装while选择排序法
	int i = 0;
	while(i<arr.length-1){
		int j = i+1;
		while(j<arr.length){
			if(arr[i]>arr[j]){
				int temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
			j++;
		}
		i++;
	}
	return arr;
}

public static int [] maopao_do_while(int [] arr){//封装do_while冒泡排序法
	int u = 0;
	do{
		int y = 0;
		do{
			if(arr[y]<arr[y+1]){//哪两个数进行比较
				int temp = arr[y];
				arr[y] = arr [y+1];
				arr[y+1] = temp;
			}
			y++;
		}while(y < arr.length-u-1);
		u++;
	}while(u < arr.length-1);
	return arr;
}

public static int [] check_do_while(int [] arr){//封装do_while选择排序法
	int r = 0;
	do{
		int e = r+1;
		do{
			if(arr[r]>arr[e]){
				int temp = arr[r];
				arr[r] = arr [e];
				arr[e] = temp;
			}
			e++;
		}while(e<arr.length);
		r++;
	}while(r<arr.length-1);
	return arr;
}

}