Java编程基础（3）

• 一、方法（函数）
• • 1.定义
  • 2.重载
  • 3.递归
• 二、数组
• • 1.定义：
  • 2.常见操作
  • • 2.1.数组的遍历：
    • 2.2.数组的最值（最大值/最小值）：
    • 2.3.数组的排序：
  • 3.多维数组的定义及其使用
  • • 3.1.定义：
    • 3.2.使用

一、方法（函数）

1.定义

学习代码

package trian;

public class MethodDemo {
	public static void main(String[] args) {
		
		//调用自定义的方法
		draw(4,5);
		
	}
	/*
	 * 问题:要画矩形，需要不断使用该for嵌套代码。造成代码复用性很差.
	 * 
	 * 解决:定义一个功能用于画矩形，每次只要使用该功能即可。这样提高复用性。
	 * 
	 * 如何定义一个功能呢?
		1，它应该是一个封闭的区间。就是大括号。
		2，它需要有名称。
		3，需要有参与运算的数据。
		4，需要定义该功能的结果类型。
		
	 * 修饰符	返回值类型	函数名(参数类型	形式参数1,参数类型形式参数2,. .. )
		{
				执行语句;
				return返回值;//return关键字是用于结束该功能。并将后面的具体结构返回给调用者。
							//必须有return语句。
		}
	 * 注意:函数的返回值类型如果是void时，return语句可以省略不写。return;
			void表示的是没有返回值的情况。
	 */
	public static void draw(int row, int col) {
		
		for (int i = 0; i < row; i++) {
			for (int x = 0; x < col; x++) {
				System.out.print("*");
			}
			System.out.println();
		}
		//return;
	}

}

2.重载

学习代码

package trian;

public class MethodDemo2 {
	public static void main(String[] args) {
		//主方法内函数调用
		add(1, 2);
		add(2, 3, 3);
		printCFB();
		printCFB(6);
	}
	
	/*
	 函数名的定义就是为了描述该功能。
	 
	 一个类中出现同名的函数，只要他们的参数个数或者参数类型不同，就称之为函数的重载。overload。
	 和返回值无关。
	 */
	//两个整数的求和
	public static int add(int a , int b) {
		return a+b;
	}
	//三个整数的求和
	private static int add(int a ,int b, int c) {
		return a+b+c;
	}
	//两个小数的和
	public static double add(double a,double b) {
		return a+b;
	}
	//九九乘法表
	private static void printCFB() {
//		for (int i = 1; i <= 9; i++) {
//			for (int x = 1; x <=i ; x++) {
//				System.out.print(i+"*"+x+"="+i*x+"\t");
//			}
//			System.out.println();
//		}
		//优化代码
		printCFB(9);
	}
	public static void printCFB(int length) {
		for (int i = 1; i <= length; i++) {
			for (int x = 1; x <= i; x++) {
				System.out.print(i+"*"+x+"="+i*x+"\t");
			}
			System.out.println();
		}
	}
}

3.递归

此为求和递归的代码的画图解析

学习代码

package trian;
/*
		 *方法的递归：在方法的内部调用方法本身的过程。
		 *注意：
		  		方法的递归一定要有出口，否则就是死递归。
		 *死递归 举例：
		 		public static void show (){
		 		...
		 		show();	
		 	}
		 *案例：
		 		求1-n的和。
		 		通过循环既可以解决。
		 *如何通过递归解决的？
		 		1-n的和。
		 		如果n是1，结果是1
		 		如果n是2以上，结果是1一直加到n。
		 	规律:就是说1到n的和其实是1到(n-1)的和加上n组成的。
		 */
public class MethodDemo3 {
	public static void main(String[] args) {
		int sum = getsum(4);
		System.out.println("sum = "+sum);
	}
	/*
	 * 返回值类型:int
	 * 参数列表: int n.
		假设我写了一个方法getsum(n)，我说它表示求的是1到n的和。
		那么，1到n-1的和怎么表示呢?
			getsum(n-1)。
	 */
	public static int getsum(int n) {
		if (n==1) {
			return 1;//递归的出口，结束条件
		}
		int temp = getsum(n-1);//1到n-1的和
		return temp + n ;//规律
	}
}

二、数组

1.定义：

2.常见操作

2.1.数组的遍历：

package trian;

import javax.security.auth.x500.X500Principal;

/*
 把数据存储起来就是为了使用，而要使用数组中的数据，就必须通过索引。
 获取数组中的所有元素--遍历。
 */
public class ArrayDemo2 {
	public static void main(String[] args) {
		
		//定义一个数组
		int[] arr =  {1,2,3,4,5};
		
		/*
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);
		System.out.println(arr[4]);
		*/
		
		/*
		 * 发现一个问题，除了索引，其他的都重复的。
		 * 所以就需要通过循环来解决。
		 * 循环要做的事情，就是把索引全部给出来。
		 */
		
		/*for (int i = 0; i < 5; i++) {
			System.out.println(arr[i]);
		}
		System.out.println("*******************************************");
		*/
		
		
		//继续看一个数组
		int [] arr2 = {11,24,345,76,76,8768,54,67,789,234,4576,5632};
		/*假如数据太多，你就没有办法的去数了
		 * 那么这个时候，怎么来做数组的遍历呢？
		 * 假如能够提供给我数组的长度，就可以进行遍历了。
		 * Java提供了一个属性：length
		 * 格式： 数组名,length
		 */
		
		/*
		System.out.println(arr.length);
		System.out.println(arr2.length);
		System.out.println("-----------------------------------------------");
		
		for (int x = 0; x < arr2.length; x++) {
			System.out.println(arr2[x]);
		}
		*/
		PrintArray(arr2);
		System.out.println("*********************");
		PrintArray(arr);
	}
	/*
	 * 需求：数组遍历
	 * 思路：
	 		 返回值类型：void
	 		 参数列表：int[] arr
	 */
	public static void PrintArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}

}

2.2.数组的最值（最大值/最小值）：

package trian;

public class ArrayDemo3 {
	public static void main(String[] args) {
		int [] arr = {12,23,54,90,33};
		int max = GetMax(arr);
		int max2 = GetMax2(arr);
		System.out.println("max = "+max);
		System.out.println("max2 = "+max2);
	}
	/*需求：获取多个整数重得最大值。
	 *思路：
	 		1，数据多为了便于操作，先存储起来。需要容器，用数组。
	 		2,多个数据需要进行比较。每次都有较大的数，需要记录下来和下一个数比较。
			3,将数组中的元素都比一遍。最后，就有了最大值。
	 *步骤:
			1,需要数组。
			2，定义一个变量记录住较大的数。
			3，对数组进行遍历。让元素和较大的值进行比较。
			   如果元素大于较大的数，用变量记录该元素。
			4,遍历完成后，变量中记录就是最大值。
	 * 
	 */
	//定义功能：
	/*
	明确1：结果 int
	明确2：参数 int []
	 */
	
	//通过元素
	public static int GetMax(int [] arr) {
		//定义变量。初始化为数组中的任意一个元素。
		int max = arr [0];
		//遍历数组
		for (int i = 1; i < arr.length; i++) {
			//遍历的元素只要比max大，就用max记录下来。遍历到了最后max中记录的就是最大值了。
			if (arr[i]>max) {
				max = arr[i];
			}
		}
		return max;
	}
	
	//通过角标
	public static int GetMax2(int [] arr) {
		int max = 0;//初始化为数组中的任意一个角标。
		for (int i = 1; i < arr.length; i++) {
			if (arr[i]>arr[max]) {
				max = i;
			}
		}
		return arr[max];
	}
}

2.3.数组的排序：

package trian;

//使用现成的更香
import java.util.Arrays;

public class ArrayDemo4 {
	public static void main(String[] args) {
		int [] arr = {12,9,23,77,6,34};
		
		PrintArray(arr);
		SelectSort(arr);
		BubbleSort(arr);
		Arrays.sort(arr);
		PrintArray(arr);
	}
	
	/*
	 * 打印数组的方法。
	 */
	public static void PrintArray(int [] arr) {
		for (int i = 0; i < arr.length; i++) {
			if (i!=arr.length-1) {
				System.out.print(arr[i]+",");
				}
				else {
					System.out.println(arr[i]);
				}
			
		}
	}
	
	/*
	 * 冒泡排序。
	 */
	public static void BubbleSort (int [] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int x = 0; x < arr.length-1-i; x++) {
				if (arr[x]>arr[x+1]) {
					int temp = arr[x];
					arr[x] = arr [x+1];
					arr[x+1] = temp;
				}
			}
		}
	}
	
	/*
	 * 选择排序
	 */
	public static void SelectSort (int [] arr) {
		for (int i = 0; i < arr.length-1; i++) {
			for (int x = i+1; x < arr.length; x++) {
				if (arr[i]>arr[x]) {
					int temp = arr[i];
					arr[i] = arr [x];
					arr[x] = temp;
				}
			}
		}
	}
}

3.多维数组的定义及其使用

3.1.定义：

可以通过打印二维数组中的元素，明确二维数组的元素初始化特点。

3.2.使用

二维数组的体验方式

package trian;

public class ArrayDemo5 {
	public static void main(String[] args) {
		/*//二维数组
		int [][] arr = new int [3][2]; 
		
		System.out.println(arr);//[[I@15db9742 //二维数组实体
		System.out.println(arr[0]);//[I@6d06d69c //一维数组的实体
		System.out.println(arr[0][0]);
		*/
		
		int [][] array = new int [3][];//明确二维数组的长度，没有明确具体的一维数组
		System.out.println(array);//[[I@15db9742  二维数组实体
		System.out.println(array[0]);//null 空值
		//System.out.println(array[0][0]);//Exception in thread "main" java.lang.NullPointerException at trian.ArrayDemo5.main(ArrayDemo5.java:16)
	}

}

package trian;

public class Array2Demo5 {
	public static void main(String[] args) {
		/*
		 * 二维数组的另一种定义方式
		 */
		int [][] arr = {{12,13,45,78},{45,78,69},{11,22,33,44}};
		
		//需求：求和。
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			for (int x = 0; x < arr[i].length; x++) {
				sum +=arr[i][x];
			}
		}
		System.out.println("sum = "+sum);
	}

}