方法与数组

1、什么是方法（Method）？

方法是一组为了实现特定功能的代码块的集合。方法在语法上的功能主要有以下两个：
①：结构化代码
将代码按照功能进行组织，使代码的结构比较清晰，容易阅读和修改，也就是程序的可维护性强。
②：减少代码重复
一个固定的功能，可能会在程序中多次使用，在使用时只需要调用写好的方法，而不用重复书写对应的功能代码。

方法在书写时需要注意以下两点：
①：逻辑严谨
方法实现的一个完整的功能，所以在书写时要考虑到各种可能的情况，并对每种情况做出恰当的处理。
②：通用性强（可重复利用）
方法实现的是一种功能，在实际实现时，可以根据需要，使方法具备一定的通用性，除非必要，否则不要写专用的方法。在Java 语言中，恰当的使用方法，将使程序更加优雅，便于阅读和使用。

我的总结：

方法：一段可重复使用的代码段；

程序中完成独立功能的一段代码的集合。

2、Java中方法的格式：

[修饰符] 返回值类型 方法名([参数类型 形式参数1，参数类型 形式参数2，……])

{

执行语句; [return 返回值;]//需要的话

}

参数列表（参数的类型 ，参数的个数，参数的顺序）

我的总结：只要上述有一个不一样，那么这个参数列表就不一样！对于方法而言，即使同名也不是同一个方法，也就是下面讲的方法签名。

3、方法里的属性

访问控制符：访问控制符限定方法的可见范围，或者说是方法被调用的范围。方法的访问控制符有四种，按可见范围从大到小依次是：public、protected，无访问控制符,private。其中无访问控制符不书写关键字即可。具体的范围在后续有详细介绍。

形式参数：在方法被调用时用于接收外界输入的数据。

实参：调用方法时实际传给方法的数据。

返回值：方法在执行完毕后返还给调用它的环境的数据。

返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回类型 void。

方法签名：方法名和方法的参数列表(能区别方法)；//最关键的

java语言中调用方法：对象名.方法名（实参列表）。

实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。

return 语句终止方法的运行并指定要返回的数据。

4、方法特点

它可以实现独立的功能;

必须定义在类里面;

它只有被调用才会执行;

它可以被重复使用;

方法结束后方法里的对象失去引用;

如何定义一个功能,并通过方法体现出来：

①　明确该功能运算后的结果.明确返回值类型;

②　明确在实现该功能过程中是否有未知内容参与运算，确定参数列表;

Eg：

package reviewDemo;
/**
 * player 的值分别是1,2,3或者其他值时，该方法返回“大明”，“二明”，“小明”，“我没有这个孩子”。
 */
public class Demo2 {
	public static void main(String[] args) {
		int player = 5;
		System.out.println("返回的结果是："+show(player));
	}
	
	public static String show(int p){
		switch (p) {
		case 1:
			return "大明";	
		case 2:
			return "二明";	
		case 3:
			return "小明";
		default:
			return "我没有这个孩子！";
		}
	}
}

5、什么是方法的重载（Overload）？

概念：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型或参数顺序不同即可。

存在的原因：

屏蔽了一个对象的同一类方法由于参数不同所造成的差异。

特点：

与返回值类型无关，只看参数列表。

以下是方法重载的示例：
public void a(int a){}
public int a(){}
public void a(int a,String s){}

Eg：

class Chongzai 
{
	public static void main(String[] args) 
	{
		int ret = name(3,4,5);
		System.out.println(ret);
	}
	public static int name(int a, int b)
	{
		int c = a+b;
		return c;
	}
	public static int name(int a, int b, int m)//这就叫做方法的重载，只要参数列表不一样。好处：用户使用时限制很小；
	{
		int c = a+b+m;
		return c;
	}
}

我的总结：方法重载，方法名相同，但是参数列表不一致！（和方法覆写不一样，方法覆写的方法名和参数列表都必须一样），注意方法重载和方法覆写的不同！

6、可变参数

从java5开始出现了可变参数，这是对java方法及数组的拓展！

方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。

定义格式： 返回值类型  方法名(参数类型 ... 形式参数){ }

可变参数的特点：

只能出现在参数列表的最后；

... 位于变量类型和变量名之间，前后有无空格都可以;

调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。

Eg：

package reviewDemo627;
import java.util.Arrays;
public class Demo6 {
	public static void main(String[] args) {
		int []age = {1,2,3,69,36,636,459};
		show(age);
	}
	
	public static void show(int...a){//此时这里写的就是可变参数，和数组的作用一样！
		//把数组给打印出来！
		System.out.println(Arrays.toString(a));
	}
}	

7、数组简介：

数组(Array)是Java 语言中内置的一种基本数据存储结构，通俗的理解，就是一组数的集合，目的是用来一次存储多个数据。数组是程序中实现很多算法的基础，可以在一定程度上简化代码的书写。

备注：

1. 数组的好处：数组里的每个元素都有编号，编号从0开始，并且依次递增，方便操作这些元素；

2. 使用Java数组：必须先声明数组，再给该数组分配内存；

3. 数组对应在内存中一段连续空间。

4. 数组元素必须是相同数据类型，也可以是引用数据类型，但是同一个数组中的元素必须是同一类数据类型。

8、一维数组的声明与初始化：

一维数组：可以理解为一列多行、类型相同的数据，其中每个数据被称为数组元素；

一维数组的声明方式：

  type varName[]; 或 type[] varName;(推荐)

Eg：int age[]; int []age;

数组的长度一旦确定,就不能改变,也就数组是定长的;

我的总结：java语言声明数组的时候不能指定其长度（元素的个数）。

Eg：int a[5]; //非法

初始化：

Java中的数组必先初始化才可以使用，所谓初始化就是为数组的数组元素分配内存，并为每个数组元素赋值；

数组初始化的两种方式：

静态初始化：初始化时由我们自己指定每个数组元素的初始值，由系统决定需要的数组长度；

格式：数组名 = new 数组类型[]{元素1,元素2,元素3...元素n};

简化语法：数组名 = {元素1,元素2,元素3...元素n};

动态初始化：初始化时由我们指定数组的长度，由系统为数组元素分配初始值；

格式：数组名 = new 数组类型[数组长度];

我的总结：

不能静态和动态初始化同时使用：

也就是说不能同时指定数组的长度和元素；

Eg:

package reviewDemo;
/**
 * 声明数组及初始化
 */
public class Demo3 {
	public static void main(String[] args) {
		int []age = new int[10];
		//动态初始化
		for (int i = 0; i < age.length; i++) {
			age[i] = i;
			System.out.print(age[i]+"     ");
		}
	}
}
输出为：0     1     2     3     4     5     6     7     8     9  

   

9、数组的使用：

Java语言的数组索引是从0开始的，也就是说数组里的第一个元素的索引是0,第二个元素的索引是1，依次可以类推。

常见操作：

给数组元素赋值

数组名[索引] = 数组类型的值 ;

访问数组元素

数组类型 变量 = 数组名[索引];

得到数组的长度

int len  = 数组名.length; //length是数组的属性

遍历数组（备注：length 属性和循环语句）

数组元素的索引范围（0，长度—1） 

Eg：判断数组是否重复

package reviewDemo;
/**
 * 判断数组是否重复
 */
public class Demo3 {
	public static void main(String[] args) {
		int []age = {1,2,3,4,5,6,5};
		for (int i = 0; i < age.length-1; i++) {//双层循环，定住一个，再考虑下一个！
			for (int j = i+1; j < age.length; j++) {
				if(age[i] == age[j]){
					System.out.println("有重复的！"+i+"  "+j);
					break;
				}
			}
		}
	}
}

求最大值：

package reviewDemo;
public class Demo4 {
	public static void main(String[] args) {
		int age[] = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };
		int max = age[0];
		for (int i = 0; i < age.length; i++) {
			if (max < age[i]) {
				max = age[i];
			}
		}
		System.out.println(max);
	}
}

经典用法：冒泡法排序

package reviewDemo627;
import java.util.Arrays;
//冒泡排序
public class Demo6 {
	public static void main(String[] args) {
		int []age = {1,2,36,363,56,95,12,32,1232,3263};
		
		for (int i = 0; i < age.length; i++) {
			for (int j = i+1; j < age.length-1; j++) {
				if(age[i] > age[j]){
					int temp = age[i];
					age[i] = age[j];
					age[j] = temp;
				}
			}
		}
		System.out.println(Arrays.toString(age));
	}
}	
//输出为：[1, 2, 12, 32, 36, 56, 95, 363, 1232, 3263]

10、分配内存空间

分配内存空间

数组名=new 数据类型[数组长度]；

new关键字用来实现为数组或对象分配内存。

数组具有固定的长度。获取数组的长度： 数组名.length

定义数组+分配内存空间

数据类型[]数组名=new 数据类型[数组长度];

定义数组时不指定长度，分配空间时指定数组长度；如：String cities[] = new String[6];

数组元素：

数组名[下标值];

数组下标从0开始  scores[0]=75；

数组的内存分配  栈内存和堆内存

如定义一个数组 int[]scores将在栈内存中为scores 分配内存空间，其值是一个不确定的值。

当执行语句scores=new int[5]时，将在堆内存分配连续5个空间，每个空间4个字节，用于存放整型数据，其初始值为0，然后将该段空间首地址，也就是第一个元素的地址，比如0*3000，赋给scores变量。该地址相当于一个指针，指向堆内存中分配的空间。此时堆内存中分配的5个空间可以分别使用scores[0],一直到scores[4]来表示。当执行四个赋值语句时，分别用指定值填充到对应元素位置。如果此时将null值赋给scores时，scores变量将不再指向任何位置，此时堆内存中分配的空间就变成了垃圾，由垃圾回收器在某一时间进行回收。

在方法中定义的变量，包括基本数据类型变量和引用数据类型变量，都将在栈内存中分配空间，当超过变量作用范围后，自动回收

我的总结：初始化=定义数组+分配空间+赋值

11、二维数组：

二维数组：(其实是一个一维数组，它的每一个元素又是一个一维数组),

可以看做是一张表格。

初始化：

动态初始化

int[ ][ ]  arr = new int[3][2];

定义了一个二维数组，其中有3个一维数组，每一个一维数组中有2个元素

静态初始化

int[ ][ ]  arr = new int[][]{{1,2},{3,4},{5,6}};

int[ ][ ]  arr = {{1,2},{3,4},{5,6}};

Eg：

public class Demo3 {
	public static void main(String[] args) {
		int age[][] = new int[][]{{1,2},{3,4},{5,6,7}};
System.out.println(age[0].length);//2
		System.out.println(age[2].length);//3
}
}

12、操作数组的工具类-Arrays

static int binarySearch(type[] a, type key) 使用二分搜索法来搜索key元素在数组中的索引；若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。 

static int binarySearch(type[] a, int fromIndex, int toIndex, type key) 使用二分搜索法来搜索key元素在数组中从fromIndex到toIndex的索引；若a数组不包括key，返回负数。（该方法必须已按升序排列后调用）。

static boolean[] copyOf(type[] original, int newLength) 复制指定的数组见下面备注

static byte[] copyOfRange(type[] original, int from, int to) 将数组的指定范围复制到一个新数组。 

static boolean equals(type[] a, type[] a2) 如果两个数组长度相等和元素一一相等，则返回 true 

static void fill(type[] a, type val) 将a数组所有元素都赋为val。

static void fill(type[] a, int fromIndex, int toIndex, type val) 将a数组从formIndex 到tiondex索引之间的元素都赋为val。  

static void sort(type[] a) //sort(int[] arr)对指定的数组按数字升序进行排序。 

static void sort(type[] a, int fromIndex, int toIndex) 对指定数组的从formIndex 到tiondex索引之间的元素按数字升序进行排序。 

static String toString(type[] a) 返回指定数组内容的字符串表示形式。多个数组元素之间用英文逗号或空格隔开。

我的总结：使用数组工具类可以节省时间，提高效率，注意常查阅api；

Eg：

package reviewDemo;
import java.util.Arrays;
//使用Arrays类
public class Demo4 {
	public static void main(String[] args) {
		int[] age = new int[] { 12, 26, 3, 60, 55, 6, 48, 4, 98 };
		System.out.println(Arrays.toString(age));//直接打印出数组的方法
		
		int []age2 = {1,2,3,4,5,6,98,65,23};
		int i = Arrays.binarySearch(age2, 98);
		System.out.println(i);
	}
}

13、Java5新特性对数组的支持：

增强for循环 → for-each

for (参数类型 参数名 : 数组名) {

代码块

}

Eg：

package reviewDemo;
public class Demo6 {
	public static void main(String[] args) {
		int []age = {1,2,3,69,36,636,459};
		for (int i : age) {
			System.out.println(i);
		}
	}
}

这样就用for-each把数组遍历输出！

我的总结：for-each用于数组和Iterable对象！在以后的集合学习中还会经常用到for-each循环。