1、 方法的定义

为什么要有方法？
方法（又叫函数） 就是一段特定功能的代码块。 方法提高程序的复用性和可读性。
比如， 有了方法， 我们可以把要重复使用的一段代码提炼出来， 然后在每个需要执行这段代码的地方去调用即可。
在一个打飞机的游戏中， 飞机需要发射子弹， 那么我们可以把发射子弹的这段代码写成方法， 这样就可以避免每次重写相同的代码。

方法的格式

语法：

访问权限修饰符 [其他的修饰符 如static] 返回值类型 方法名(参数类型1 形参1,参数类型2 形参2,…){ //形参列表
//方法体
return 返回值;
}

方法的格式说明:

修饰符： 目前就用 public static。 后面我们再详细的讲解其他的修饰符。

返回值类型： 就是功能结果的数据类型。

方法名： 见名知意， 首字母小写， 遵守驼峰命名法。 方便我们的调用。

2、 方法的形参与实参

参数：

  1. 实际参数： 就是实际参与运算的。
  2. 形式参数； 就是方法定义上的， 用于接收实际参数的。
  3. 参数类型： 就是参数的数据类型
  4. 参数名： 就是变量名
  5. 方法体语句： 就是完成功能的代码。

注意：

  1. 若当前方法中不要使用形参， 那么形参列表中可以为空
  2. 实参和形参的类型要相互兼容， 且： 实参的取值范围要小于或者等于形参类型的取值范围。

在调用方法中， 如果我们定义的方法有参数， 就必须在调用方法的同时传入这个值， 即给当前方法中的参数赋值，而这个传入的值我们称为实际参数， 也就是实参

实参： 传入的参数值

形参： 接收实参传过来的值。

注意： 实参名与形参名可以相同， 也可以不同。

小结： 形参就是一个变量， 实参就是一个值， 传参就是把一个值给一个形参赋值

  1. /**
  2.     方法（函数）
  3.     方法的返回值 :1、判断任意给定年份是否是闰年
  4. */
  5. import java.util.Scanner;
  6. public class Test3{
  7.     public static void main(String[] args){
  9.         //调用方法
  10.         boolean bool = isRunNian(2017);
  11.         if(bool){
  12.             System.out.println("闰年");
  13.         }else{
  14.             System.out.println("平年");
  15.         }
  17.         //
  18.         print();
  19.     }
  21.     public static boolean isRunNian(int year){
  23.         if((year%4==0 && year%100!=0) || year%400==0){
  24.             return true;
  25.         }else{
  26.             return false;
  27.         }
  28.     }
  30.     public static void print(){
  31.         for(int i=0;i<10;i++){
  32.             if(i==5){
  33.                 return;//表示方法结束
  34.                 // break;//跳出循环，在此二者作用相同，但事实有些区别
  35.             }
  36.             System.out.println(i);
  37.         }
  38.     }
  39. }

3、方法的返回值

return： 结束方法的。

返回值： 就是功能的结果， 由return带给调用者。

注意：

  1. 若当前方法没有返回值类型， 即返回值类型是void， 那么当前方法中可以不写return
  2. return即表示结束一个方法， 也可以将返回值返回给调用当前方法的调用者
  3. return返回值时一次只能返回一个值， 不可以返回多个值
  4. 一个方法中可以有多个return， 但被执行的只能有一个， 所以需要判断

4、方法重载

方法重载： overloading method

在类中可以创建多个方法， 它们具有相同的名字， 但具有不同的参数和不同的定义；

返回值不能作为重载的条件。

如：
public void method(int a){…}
public void method(char c){…}

  1. /**
  2.     方法（函数）
  3.     方法的重载:在同一个类中，方法名相同，参数列表不同，返回值不能作为重载的条件。
  4. */
  5. import java.util.Scanner;
  6. public class Test5{
  7.     public static void main(String[] args){
  9.         int result = add(10,20);
  10.         System.out.println(result);
  12.     }
  14.     public static int add(int a,int b){
  15.         return a+b;
  16.     }
  17.     public static float add(float a,float b){
  18.         return a+b;
  19.     }
  20.     public static float add(int a,float b){
  21.         return a+b;
  22.     }
  23. }

5、数组的定义

数组： 一组能够存储相同数据类型值的变量的集合。

当我们有一组相同类型的数据需要存储， 如果此时使用单个变量来存储， 我们将要定义若干个变量名， 这样将会非常繁琐， 并不利于维护

6、数组的赋值方式

  1. 使用默认的初始值来初始化数组中的每一个元素

    1. 语法： 数组元素类型 [] 数组名 = new 数组元素类型[数组中元素的个数（数组的长度）]; 
      1. int [] scores = new int[3];

  2. 先声明， 然后再赋予默认的初始值。

    1. 语法： 数组元素类型 [] 数组名;
    2. 数组名= new 数组元素类型[数组中元素的个数（数组的长度） ]; 
      1. int [] scores;
      2. scores = new int[3];

  3. 先声明， 然后再使用指定的值进行初始化。

    1. 语法： 数组元素类型 [] 数组名 = new 数组元素类型[]{元素1， 元素2,….}; 
      1. int [] scores = new int[]{56,78,98};

  4. 将第三种写法可以简化为（使用数组常量值给数组进行赋值）

    1. 语法： 数组元素类型 [] 数组名 = {元素1， 元素2,….}; 
      1. int [] scores = {56,78,98}

7、 数组的遍历

求数组的长度：

  1. x.length

数组取值：通过中括号中的位置 [0]

通过下标来访问数组中的元素。

下标： 从0开始， 到数组长度-1

  1. int[] scores = {89,90};
  2. int lastElement = scores[scores.length-1];    //访问最后一个元素值

遍历： 依次取出数组中的每一个元素。

遍历方式一： 普通的for循环

语法：

  1. for(int i = 0; i< 数组的长度;i++){
  2.     //i:循环变量， 同样： 也是数组的下标（取值范围[0,数组长度)）
  3.     数组中元素的类型 变量 = 数组名[i];
  4. }

1.5以后Java新增foreach循环和可变参数。

遍历方式二： 使用增强for循环【foreach循环】

语法：

  1. for(数组中元素的类型 变量:数组名){
  2.     数组中元素的类型 临时变量 = 变量;
  3. }
  1. /**
  2.     数组示例：1、猜数游戏：从键盘中任意输入一个数据，判断数列中是否包含此数。
  4. */
  5. import java.util.Scanner;
  6. import java.util.Random; //生成伪随机数
  7. public class Test8{
  8.     public static void main(String[] args){
  10.         int[] nums = new int[5];
  11.         int len = nums.length;
  12.         Random r = new Random();//创建一个可以生成随机数的工具
  13.         for(int i=0;i<len;i++){
  14.             nums[i] = r.nextInt(50);
  15.         }
  18.         Scanner input = new Scanner(System.in);
  19.         System.out.println("请输入你要猜的数：(50以内)");
  20.         int userNum = input.nextInt();
  22.         boolean flag = false;
  23.         for(int x:nums){
  24.             if(userNum==x){
  25.                 flag = true;
  26.                 break;
  27.             }
  28.         }
  30.         if(flag){
  31.             System.out.println("恭喜你，猜对了");
  32.         }else{
  33.             System.out.println("没猜对，加油！");
  34.         }
  36.     }
  37. }

8、可变参数

结合方法的定义， 可以用可变参数来代替数组作为参数。

  1. public static void print(int ... 变量名){
  2.     //可变参数在使用时作为数组使用。
  3. }

9、数组要注意的问题

使用数组要注意的问题：

空指针异常（NullPointerException）

数组越界异常（ArrayIndexOutOfBoundsException ）

数组内存结构分析： 数组是引用类型， 会存放在堆内存中

3、方法与数组 - 图1

10、二维数组

  1. /**
  2.     二维数组示例:JAVA中没有真正的多维数组，多维数组的表示方式是数组中的元素还是数组。
  3.     一起来参加屌丝程序员大赛吧，有3个班级各3名学员参赛，
  4.     记录每个学员的成绩，并计算每个班的平均分。
  6. */
  7. import java.util.Scanner;
  8. public class Test10{
  9.     public static void main(String[] args){
  11.         int[][] scores = {{78,98,88},{87,96,85},{67,78,89}};
  12.         int classLen = scores.length;
  13.         for(int i=0;i<classLen;i++){
  14.             int sum = 0;
  15.             int count = scores[i].length;
  16.             for(int j=0;j<count;j++){
  17.                 sum+=scores[i][j];
  18.             }
  19.             int avg = sum/count;
  20.             System.out.println("第"+(i+1)+"班的平均成绩是："+avg);
  21.         }
  22.     }
  23. }
  25. /*
  26. 78  98  88 
  27. 87  96  85
  28. 67  78  89
  29. 第1班的平均成绩是：88
  30. 第2班的平均成绩是：89
  31. 第3班的平均成绩是：78
  32. */

11、Arrays类

Arrays工具类： 用来操作数组（比如排序和搜索） 的各种方法

常用方法：

使用二分法查找

  1. Arrays.binarySearch(int[] array, int value);

数组内容转成字符串的形式输出

  1. Arrays.toString(int[] array);

数组排序

  1. Arrays.sort(int[] array);

复制指定的数组

  1. Arrays.copyOf(int[] array, int length);
  3. Arrays.copyOf(int[] array, int from, int to);
  5. System.arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

判断两个数组是否相等

  1. Arrays.equels();

使用指定元素填充数组

  1. Arrays.fill();
  1. /**
  2.     Arrays工具类的使用
  4. */
  5. import java.util.Scanner;
  6. import java.util.Arrays;
  8. public class Test16{
  9.     public static void main(String[] args){
  11.         int[] num = {45,65,76,87,98,901};
  13.         //二分查找
  14.         int index = Arrays.binarySearch(num,98);
  15.         System.out.println("找到的下标是："+index);
  17.         //输出数组
  18.         for(int n: num){
  19.             System.out.println(n);
  20.         }
  21.         //在测试输出数据时，可以使用，更加方便
  22.         System.out.println(Arrays.toString(num));
  24.         //排序
  25.         int[] num2 = {10,32,11,44,543,22,12};
  26.         Arrays.sort(num2);//快速排序
  27.         System.out.println(Arrays.toString(num2));
  29.         //数组的复制
  30.         int[] num3 = Arrays.copyOf(num2,10);
  31.         System.out.println(Arrays.toString(num3));
  33.         //
  34.         int[] newNum = new int[num2.length];
  35.         System.arraycopy(num2,0,newNum,0,num2.length);
  36.         System.out.println(Arrays.toString(newNum));
  38.         //小结，数组的复制：
  39.         /*
  40.             效率由高到低排序是：System.arraycopy -> Arrays.copyOf -> for
  41.         */
  43.         //判断两个数组的值是否相等
  44.         System.out.println(Arrays.equals(num2,newNum));
  46.         //填充数组
  47.         Arrays.fill(newNum,0);
  48.         System.out.println(Arrays.toString(newNum));
  49.     }    
  50. }

12、数组的增加与删除

应用数组的创建与拷贝

  1. import java.util.Arrays;
  2. import java.util.OptionalInt;
  4. /**
  5.  * 1、向数组中增加一个值（默认队尾）
  6.  * 2、向数组中增加一个值（指定位置）
  7.  * 3、删除数组中一个值（指定值）
  8.  * 4、删除数组中一个值（指定位置）
  9.  */
  10. public class Test18 {
  11.     public static void main(String[] args) {
  12.         int[] arr={1,2,3,4,5};
  13.         //1、向数组中增加一个值（默认队尾）
  14.         arr=addToArrays(arr,6);
  15.         System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6]
  17.         //2、向数组中增加一个值（指定位置）
  18.         arr=addToArrays(arr,2,8);
  19.         System.out.println(Arrays.toString(arr));//[1, 2, 8, 3, 4, 5, 6]
  21.         //3、删除数组中一个值（指定值）
  22.         arr=removeInArrays(arr,8);
  23.         System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6]
  25.         //4、删除数组中一个值（指定位置）
  26.         arr=removeByIndexInArrays(arr,0);
  27.         System.out.println(Arrays.toString(arr));//[2, 3, 4, 5, 6]
  28.     }
  30.     //1、向数组中增加一个值（默认队尾）
  31.     public static int[] addToArrays(int[] array,int val){
  32.         int len=array.length;
  33.         int[] res=new int[len+1];
  34.         System.arraycopy(array,0,res,0,len);
  35.         res[len]=val;
  36.         return res;
  37.     }
  39.     //2、向数组中增加一个值（指定位置）
  40.     public static int[] addToArrays(int[] array,int index,int val){
  41.         int len=array.length;
  42.         int[] res=new int[len+1];
  43.         System.arraycopy(array,0,res,0,index);
  44.         res[index]=val;
  45.         System.arraycopy(array,index,res,index+1,len-index);
  46.         return res;
  47.     }
  49.     //3、删除数组中一个值（指定值）
  50.     public static int[] removeInArrays(int[] array,int val){
  51.         int len=array.length;
  52.         int index=-1;
  53.         for(int i=0;i<len;i++){
  54.             if(val==array[i]){
  55.                 index=i;
  56.                 break;
  57.             }
  58.         }
  59.         //如果找不到这个数
  60.         if(index==-1){
  61.             return array;
  62.         }
  63.         int[] res=new int[len-1];
  64.         System.arraycopy(array,0,res,0,index);
  65.         System.arraycopy(array,index+1,res,index,len-index-1);
  66.         return res;
  67.     }
  69.     //4、删除数组中一个值（指定位置）
  70.     public static int[] removeByIndexInArrays(int[] array,int index){
  71.         int len=array.length;
  72.         if(index>=len || index<0){
  73.             return array;
  74.         }
  75.         int[] res=new int[len-1];
  76.         System.arraycopy(array,0,res,0,index);
  77.         System.arraycopy(array,index+1,res,index,len-index-1);
  78.         return res;
  79.     }
  80. }