Java基础笔记（四）方法和数组

Java基础语法

Java语法之方法

类似于C语言中的函数，在java中，用于完成某些特定功能的代码块被称为方法。
格式如下：

	修饰符 返回值类型 方法名（参数类型1 参数名1,参数类型2 参数名2...）{
		方法体语句;
		return 返回值;
	}
	/*
	修饰符：后面在修饰符这一块详细介绍，目前先用public static做方法修饰
	返回值类型：就是方法要返回的结果的类型，如果是void类型，就不需要return语句；
	方法名：就是方法的名字，方便调用该方法，建议见名知意最好，且第二个单词首字母要大写
	参数类型：就是要传递的参数的数据类型，可以是基本类型，也可以是引用类型
	参数名：就是要传递的参数，可以是变量，也可以是对象
	参数分类：
			实参：实际参与运算的数据
			形参：方法上定义的，用于接收实际参数的变量
	方法体语句：就是完成功能的代码块
	return：结束方法
	返回值：就是功能的结果，由return带给调用者。
	*/

1.方法调用：
1.有明确返回值的方法
  a:单独调用，没有意义
  b:输出调用，不是很好，因为可能需要对结果进行进一步的操作。
  c:赋值调用，推荐方案
2.void类型修饰的方法
  a:单独调用
2.方法的注意事项：
  A:方法不调用不执行
  B:方法之间是平级关系，不能嵌套定义
  C:方法定义的时候，参数是用“,”隔开的
  D:方法在调用的时候，不用在传递数据类型
  E:如果方法有明确的返回值类型，就必须有return语句返回。
3.方法重载：
  在同一个类中，方法名相同，参数列表不同。与返回值无关。

  参数列表不同：
    参数的个数不同。
    参数的对应的数据类型不同。
  注意：方法重载也叫做（overload），还有一个类似的叫做方法重写（override），在后面会有介绍，两个不要弄混。

来几个方法练习代码：

public class MyTest {
	// 求和方法+方法重载演示多个数值求和
	public static void main(String[] args) {
		// 调用求和方法并传递2个要求和的值，然后结果赋给sum1并输出
		int sum1 = sum(10, 20);
		System.out.println(sum1);
		// 调用求和方法并传递3个要求和的值，然后结果赋给sum2并输出
		int sum2 = sum(10, 20, 30);
		System.out.println(sum2);
		// 调用求和方法并传递3个要求和的值，然后结果赋给sum3并输出
		int sum3 = sum(10, 20, 30, 40);
		System.out.println(sum3);
	}

	public static int sum(int a, int b) {
		return a + b;
	}

	public static int sum(int a, int b, int c) {
		return a + b + c;
	}

	public static int sum(int a, int b, int c, int d) {
		return a + b + c + d;
	}
}

/*
 *	需求：打印九九乘法表
 *	分析：
 *		a：写一个方法实现这个功能，方法名叫printTable
 *		b：返回值类型应该是void，参数无
 *		c：两层for循环实现，外层控制行数，里层控制列数
 *		d：根据乘法口诀表我们可以看出，每一个结果应该是行与列的乘积		
 */
public class MyTest {
	public static void main(String[] args) {
		// 调用方法
		printTable();
	}

	public static void printTable() {
		for (int x = 1; x < 10; x++) {
			for (int y = 1; y <= x; y++) {
				System.out.print(y + "*" + x + "=" + (x * y) + "\t");
			}
			System.out.println();
		}
	}
}

/*
	输出效果：
	1*1=1	
	1*2=2	2*2=4	
	1*3=3	2*3=6	3*3=9	
	1*4=4	2*4=8	3*4=12	4*4=16	
	1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
	1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
	1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
	1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
	1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81
*/

Java语法之数组

java中的数组，是存储同一种数据类型的多个元素的容器。数组是相同类型的变量按顺序组成的一种复合数据类型，称这些相同类型的变量为数组的元素或单元。数组通过数组名加索引来使用数组的元素。
数组属于引用型变量，创建数组需要经过声明数组和为数组分配变量两个步骤。

声明格式:
A:数据类型[] 数组名;
B:数据类型 数组名[];
例如： float boy[];
    float[] boy;

分配变量：

声明数组后，还必须为它分配内存空间，为一维数组分配内存空间的格式如下：

数组名字 = new 数组元素的类型[数组元素的个数];

例如： float boy[];

boy= new float[4];

声明数组和创建数组可以一起完成，例如：
float boy[]=new float[4];
数组的初始化

	动态初始化
		只给长度，系统给出默认值
			
		举例：int[] arr = new int[3];
	静态初始化
		给出值，系统决定长度
		举例：int[] arr = new int[]{1,2,3};
		简化版：int[] arr = {1,2,3};

Java的内存分配：

		A:栈 存储局部变量
		B:堆 存储所有new出来的
		C:方法区(面向对象部分内容)
		D:本地方法区(系统相关)
		E:寄存器(CPU使用)
注意：
		a:局部变量 在方法定义中或者方法声明上定义的变量。
		b:栈内存和堆内存的区别
			栈：数据使用完毕，就消失。
			堆：每一个new出来的东西都有地址
				   每一个变量都有默认值
					byte,short,int,long 0
					float,double 0.0
					char '\u0000'
					boolean false
				    引用类型 null
				    数据使用完毕后，在垃圾回收器空闲的时候回收。

使用数组

一维数组通过索引符访问自己的元素，如boy[0]，boy[1]等。需要注意的是索引从0开始 。

二维数组也通过索引符访问自己的元素，如a[0][1]，a[1][2]等。需要注意的是索引从0开始。

比如声明创建了一个二维数组a：

int a[][] = new int[2][3]；

那么第一个索引的变化范围为从0到1，第二个索引变化范围为从0到2。
下面来一些数组的常见操作和

常见数组使用代码

数组遍历
public class MyTest {
	public static void main(String[] args) {
		// 创建一个数组
		int[] a = { 1, 23, 45, 6536, 347, 67, 13, 41234, 2135, 41 };
		// 调用数组遍历方法
		arrayTraversal(a);
	}

	public static void arrayTraversal(int[] arr) {
		// for循环遍历数组所有元素
		for (int x = 0; x < arr.length; x++) {
			System.out.println(arr[x]);
		}
	}
}

数组最值
public static int getMax(int[] arr) {
		int max = arr[0];

		for (int x = 1; x < arr.length; x++) {
			if (arr[x] > max) {
				max = arr[x];
			}
		}

		return max;
	}
最小值：
public static int getMin(int[] arr) {
		int min = arr[0];

		for (int x = 1; x < arr.length; x++) {
			if (arr[x] < min) {
				min = arr[x];
			}
		}

		return min;
	}

逆序
	方式1：
		public static void reverse(int[] arr) {
			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;
			}
		}
		方式2：
		public static void reverse(int[] arr) {
			for(int start=0,end=arr.length-1; start<=end; start++,end--) {
				int temp = arr[start];
				arr[start] = arr[end];
				arr[end] = temp;
			}
		}

查表
		public static String getString(String[] strArray,int index) {
			return strArray[index];
		}
基本查找
	方式1：
		public static int getIndex(int[] arr,int value) {
			for(int x=0; x<arr.length; x++) {
				if(arr[x] == value) {
					return x;
				}
			}
			return -1;
		}	
	方式2：
		public static int getIndex(int[] arr,int value) {
			int index = -1;
			for(int x=0; x<arr.length; x++) {
				if(arr[x] == value) {
					index = x;
					break;
				}
			}	
			return index;
		}