一、复习

1.1 一维数组的声明和初始化

1、静态初始化：在声明数组时，在{}中直接把元素的值、个数都确定了。

元素的类型[]  数组名 = {值1，值2，值3};

元素的类型[]  数组名;
数组名 = new 元素的类型[]{值1，值2，值3};

2、动态初始化：声明数组时，只确定元素的个数，目前元素都是默认值。

元素的类型[]  数组名 = new 元素的类型[长度];

数组名[下标] = 值;

import java.util.Scanner;

public class ArrayReview {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40};

        Scanner input = new Scanner(System.in);

        //动态（运行时）确定数组的长度和元素的值
        System.out.print("请输入元素的个数：");
        int count = input.nextInt();

        int[] nums = new int[count];
        for(int i=0; i<nums.length; i++){
            nums[i] = (int)(Math.random()*100);
            System.out.print(nums[i]+" ");
        }

        input.close();
    }
}

3、普通 for 循环遍历数组：

快捷键：数组名.fori   或  itar

for(int i=0; i<数组名.length; i++){
    数组名[i]代表元素
}

1.2 数组的算法

（1）统计元素满足 xx 条件的个数

int count变量 = 0; //用于存储xx的个数
for(int i=0; i<数组名.length; i++){
    if(数组名[i] 满足xx条件){
    	count变量++;
    }
}

（2）累加和与平均值

int sum = 0;//存储总和
for(int i=0; i<数组名.length; i++){
    sum += 数组名[i];
}
double avg = (double)sum / 数组名.length;

（3）找最大值

int max = 数组名[0];
for(int i=0; i<数组名.length; i++){
    if(数组名[i]>max){
        max = 数组名[i];
    }
}

int min = 数组名[0];
for(int i=0; i<数组名.length; i++){
    if(数组名[i]< min){
        min = 数组名[i];
    }
}

（4）找最大值及其下标

元素不重复

int max = 数组名[0];
int maxIndex = 0;
for(int i=0; i<数组名.length; i++){
    if(数组名[i]>max){
        max = 数组名[i];
        maxIndex = i;
    }
}

元素重复

int max = 数组名[0];
String index = "0";
for(int i=0; i<数组名.length; i++){
    if(数组名[i]>max){
        max = 数组名[i];
        index = i + "";
    }else if(数组名[i] == max){
        index += "," + i;
    }
}

（5）反转

for(int left=0,right=数组名.length-1; left<right; left++,right--){
    元素类型 temp = 数组名[left];
    数组名[left] = 数组名[right];
    数组名[right] = temp;
}

（6）顺序查找

元素类型 target = 值;
int index = -1;//因为正常下标不会是-1
for(int i=0; i<数组名.length; i++){
    if(数组名[i] == target){
        index = i;
        break;
    }
}
if(index!=-1){
    找到了
}else{
    没找到
}

（7）冒泡排序

for(int i=1; i<数组名.length; i++){ //n个元素需要n-1轮
    for(int j=0; j<数组名.length-i; j++){
        //相邻元素  数组名[j] 与 数组名[j+1]
        if(数组名[j]  > 数组名[j+1]){
            元素的类型 temp = 数组名[j];
            数组名[j] = 数组名[j+1];
            数组名[j+1] = temp;
        }
    }
}

（8）选择排序

for(int i=1; i<数组名.length; i++){ //n个元素需要n-1轮
    for(int j=i; j<数组名.length; j++){
        if(数组名[j] < 数组名[i-1]){
            元素的类型 temp = 数组名[j];
            数组名[j] = 数组名[i-1];
            数组名[i-1] = temp;
        }
    }
}

二、数组

2.1 数组的算法（续）

2.1.1 二分查找（拓展，有基础的同学掌握）

二分查找有一个前提条件：数组必须是有序的。

二分查找比顺序查找好的地方：效率更高

public class BinarySearchTest {
    public static void main(String[] args) {
        int[] arr = {1, 5, 9, 23, 43, 58, 96}; //数组必须是有序的

      /*  int target = (int)(Math.random()*100);
        System.out.println("target = " + target);*/

        int target = 58;

        int left = 0;
        int right = arr.length - 1;

        int index = -1;
        while(left<=right){
            int mid = (left + right) / 2;
            if (target == arr[mid]) {
                //找到了
                index = mid;
                break;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {  //target < arr[mid]
                right = mid - 1;
            }
        }

        if(index != -1){
            System.out.println("找到了，下标是" + index);
        }else{
            System.out.println("没找到");
        }
    }
}

问：int mid = (left + right) / 2; 与 int mid = left + (right-left) / 2; 的区别？

public class MidIndexTest {
    public static void main(String[] args) {
        int[] arr = new int[Integer.MAX_VALUE/2 + 10];
        arr[arr.length-1] = 1;
        /*
        数组的长度比较大，数组的长度在 int最大值的一半以上。
        这里为了演示效果，把数组元素特殊化， arr数组前面的元素都是0，最后一个元素是1
         */

        int target = 1;//查找1

        int left = 0;
        int right = arr.length - 1;

        int index = -1;
        while(left<=right){
            //int mid = (left + right) / 2;//有风险，当数组长度比较大，目标值靠右时，可能出现left+right超过int范围越界了
            int mid = left + (right-left)/2;
            if (target == arr[mid]) {
                index = mid;
                break;
            } else if (target > arr[mid]) {
                left = mid + 1;
            } else {  //target < arr[mid]
                right = mid - 1;
            }
        }
        System.out.println("index = " + index);
    }
}

2.2 数组工具类

2.2.1 Arrays（掌握）

在 JRE 的核心类库中，已经给我们程序员定义了一个数组工具类：Arrays，它在 java.util 包。

• Arrays.toString(数组名)：将数组的元素拼接为一个字符串，拼接的格式是[元素 1,元素 2,元素 3]
• Arrays.sort(数组名)：将数组排序，实现升序排列
• Arrays.binarySearch(数组名, 目标值)：用二分查找在数组中查找目标值的位置。如果目标值存在，返回其下标，如果目标值不存在，返回-插入点-1，那么计算插入点就是 -(返回值+1)
• Arrays.copyOf(原数组名， 新数组的长度)：会从原数组中复制 n 个元素到新数组中，如果新数组的长度<原数组长度，那么 n 就是新数组长度；如果新数组长度>=原数组长度，那么 n 就是原数组长度。
• Arrays.copyOfRange(原数组名, from , to)：会从原数组中复制 n 个元素到新数组中，从原数组的[from]开始复制，如果 to 在原数组下标范围内，那么复制的是[from, to)的元素，to 超过原数组的下标，那么会复制[from , 原数组.length-1]范围的元素

案例 1：toString

import java.util.Arrays;

public class ArraysTest {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40};

        //想要在控制台打印数组的元素值
        //(1)遍历的方式
/*
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+" ");
        }
        System.out.println();
*/

        //(2)使用工具类
        //Arrays.toString(arr) 将arr数组的元素拼接为一个字符串，拼接的格式是[元素1,元素2,元素3]
        System.out.println(Arrays.toString(arr));
    }
}

案例 2：sort

import java.util.Arrays;

public class ArraysTest2 {
    public static void main(String[] args) {
        int[] arr = {50, 10, 30, 20};

        //排序之前：[50, 10, 30, 20]
        System.out.println("排序之前：" + Arrays.toString(arr));

        //给数组排序
        Arrays.sort(arr);//按照从小到大排序

        //排序之后：[10, 20, 30, 50]
        System.out.println("排序之后：" + Arrays.toString(arr));
    }
}

案例 3：binarySearch

import java.util.Arrays;

public class ArraysTest3 {
    public static void main(String[] args) {
        int[] arr = {1, 5, 9, 23, 43, 58, 96};

        int target = 58;
        //二分查找
        int index = Arrays.binarySearch(arr, target);
        System.out.println("查找58的index = " + index);//5

        target = 15;
        //二分查找
        index = Arrays.binarySearch(arr, target);
        System.out.println("查找target的index = " + index);//-6
        //-6的含义：（1）只要是负数下标，说明这个目标值不在数组中（2）-插入点-1 = index
        //插入点就是如果把target插入到现在的数字中，它应该在哪个位置
        System.out.println("target的插入点：" + -(index+1));
    }
}

案例 4：copyOf

import java.util.Arrays;

public class ArraysTest4 {
    public static void main(String[] args) {
        int[] arr = {1, 5, 9, 23, 43, 58, 96};

        //复制arr数组的元素，得到一个新数组
//        int[] nums = Arrays.copyOf(arr, 5);
//        int[] nums = Arrays.copyOf(arr, arr.length);
        int[] nums = Arrays.copyOf(arr, arr.length*2);

        System.out.println("arr数组：" + Arrays.toString(arr));
        //arr数组：[1, 5, 9, 23, 43, 58, 96]
        System.out.println("nums数组：" + Arrays.toString(nums));
        //nums数组：[1, 5, 9, 23, 43]
        //nums数组：[1, 5, 9, 23, 43, 58, 96]
        //nums数组：[1, 5, 9, 23, 43, 58, 96, 0, 0, 0, 0, 0, 0, 0]
    }
}

案例 5：copyOfRange

import java.util.Arrays;

public class ArraysTest5 {
    public static void main(String[] args) {
        int[] arr = {1, 5, 9, 23, 43, 58, 96};

        //复制arr数组的[from,to)范围的元素，得到一个新数组
        int[] nums = Arrays.copyOfRange(arr, 3,6);//复制[3,6)下标范围的元素
//        int[] nums = Arrays.copyOfRange(arr, 3,16);//复制[3,16)下标范围的元素
        //复制[3,6]的所有元素
       // int[] nums = Arrays.copyOfRange(arr, 13,16);//报错，起点必须在原数组下标范围内



        System.out.println("arr数组：" + Arrays.toString(arr));
        //arr数组：[1, 5, 9, 23, 43, 58, 96]
        System.out.println("nums数组：" + Arrays.toString(nums));
        //nums数组：[23, 43, 58]
        //nums数组：[23, 43, 58, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    }
}

2.2.2 System（掌握）

System 本身是系统类，不是专门为数组设计的，但是其中有一个方法可以为数组服务。arraycopy 方法。

System.arraycopy(原数组， 原数组被复制的元素中的最左边的下标, 目标数组， 目标数组存放新元素的最左边下标， 一共复制几个元素)

• 当原数组与目标数组是 2 个数组时，仅仅是元素的拷贝
• 当原数组与目标数组是 1 个数组时，呈现出来的是元素的移动

案例 1：两个数组

import java.util.Arrays;

public class SystemTest {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int[] nums = new int[10];

        //把arr数组的元素 复制到 nums数组中
//        System.arraycopy(arr, 0, nums, 0, arr.length);
//        System.arraycopy(arr, 0, nums, 3, arr.length);
        System.arraycopy(arr, 1, nums, 3, 4);

        System.out.println("arr的元素：" + Arrays.toString(arr));
        System.out.println("nums的元素：" + Arrays.toString(nums));
        //nums的元素：[10, 20, 30, 40, 50]
        //nums的元素：[0, 0, 0, 10, 20, 30, 40, 50, 0, 0]
        //nums的元素：[0, 0, 0, 20, 30, 40, 50, 0, 0, 0]
    }
}

案例 2：一个数组移动元素

import java.util.Arrays;

public class SystemTest2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};

//        System.arraycopy(arr, 0, arr, 1, 4);
        System.arraycopy(arr, 1, arr, 0, 4);

        System.out.println("arr的元素：" + Arrays.toString(arr));
        //arr的元素：[10, 10, 20, 30, 40]  相当于右移
        //arr的元素：[20, 30, 40, 50, 50]  相当于左移

    }
}

2.2.3 数组元素的插入和删除

1、插入新元素

import java.util.Arrays;

public class ArraysSystemTest {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};

        //需求：在arr中[1]位置插入新元素100.
        //创建一个更大的数组
        arr = Arrays.copyOf(arr, arr.length + 1);
        System.out.println("arr元素：" + Arrays.toString(arr));

        //右移[1]及其往后的元素
        System.arraycopy(arr, 1, arr, 2, 4);
        System.out.println("arr元素：" + Arrays.toString(arr));

        //把100放到[1]的位置
        arr[1] = 100;
        System.out.println("arr元素：" + Arrays.toString(arr));
    }
}

2、删除元素

import java.util.Arrays;

public class ArraysSystemTest2 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};

        //需求：删除arr中[1]位置的元素
        System.arraycopy(arr,2, arr, 1,3);
        System.out.println("arr的元素：" + Arrays.toString(arr));

        //复制一个新数组
        arr = Arrays.copyOf(arr, arr.length-1);
        System.out.println("arr的元素：" + Arrays.toString(arr));
    }
}

2.2.4 第三方工具包：HuTool（拓展了解）

官网：https://www.hutool.cn/

1、引入 jar

2、ArrayUtil 工具类

import cn.hutool.core.util.ArrayUtil;

import java.util.Arrays;

public class HuToolTest {
    public static void main(String[] args) {
        int[] arr = {2, 8, 6, 9, 7, 2, 3, 1};

        //在数组中找最大值
        int max = ArrayUtil.max(arr);
        System.out.println("max = " + max);//max = 9

        int target = 7;
        //因为数组是无序的，所以不能用二分查找，只能用顺序查找
        int index = ArrayUtil.indexOf(arr, target);
        System.out.println("7的index = " + index);//7的index = 4

        target = 10;
        index = ArrayUtil.indexOf(arr, target);
        System.out.println("10的index = " + index);//10的index = -1

        //反转数组
        ArrayUtil.reverse(arr);
        System.out.println("arr的元素：" + Arrays.toString(arr));
        //arr的元素：[1, 3, 2, 7, 9, 6, 8, 2]

    }
}

2.3 二维数组（了解）

一维数组，标记是[]，用来存储和管理一组数据的。

二维数组，标记是[][]，用来存储和管理多组数据的。

2.3.1 声明和静态初始化

语法格式：

元素的类型[][]  数组名 = {{第一组的元素列表}, {第二组的元素列表}, {第三组的元素列表}};

元素的类型[][]  数组名 ;
数组名 = new 元素的类型[][]{{第一组的元素列表}, {第二组的元素列表}, {第三组的元素列表}};

2.3.2 二维数组的遍历

for(int i=0; i<数组名.length; i++){
    for(int j=0; j<数组名[i].length; j++){
        数组名[i][j]代表元素
    }
}

public class TwoArrayTest1 {
    public static void main(String[] args) {
        //可以存储多组数据，每一组数据又是一个一维数组
        int[][] score = {{89,96,85,76}, {82,93,100}, {8,9,7,5,6,9}};
        /*int[][] score;
        score = new int[][]{{89,96,85,76}, {82,93,100}, {8,9,7,5,6,9}};*/


        // score.length代表一共有几组
        for (int i = 0; i < score.length; i++) {
//            System.out.println(score[i]);//看到的是地址值
            /*
            score[i]是一个一维数组
            score[0] 代表  {89,96,85,76}
            score[1] 代表  {82,93,100}
            score[2] 代表  {8,9,7,5,6,9}

            score[i].length是某一组的元素个数
            score[0].length 是 4
            score[1].length 是 3
            score[2].length 是 6
             */
            for (int j = 0; j < score[i].length; j++) {
                System.out.print(score[i][j]+" ");
            }
            System.out.println();
        }


    }
}

2.3.3 声明和动态初始化：矩阵型

语法格式：

元素的类型[][] 数组名 = new 元素的类型[一共有几组][每一组的元素个数];

public class TwoArrayTest2 {
    public static void main(String[] args) {
        //当每一组的人数是相同的，可以用下面这种方式
        int[][] score = new int[3][5];//代表一共有3组，每一组都有5个人

        score[0][0] = 100;
        score[0][1] = 96;
        score[2][1] = 85;

        for (int i = 0; i < score.length; i++) {
            for (int j = 0; j < score[i].length; j++) {
                System.out.print(score[i][j]+" ");
            }
            System.out.println();
        }
    }
}

2.3.4 声明和动态初始化：非规则

语法格式：

第一步：先确定有几组
    元素类型[][] 数组名 = new 元素的类型[共有几组][];

第二步：分别确定每一组有几个元素
    数组名[下标] = new 元素的类型[这个组的长度];

第三部：给元素赋值
    数组名[行的下标][列的下标] = 值;

public class TwoArrayTest3 {
    public static void main(String[] args) {
        //每一组的人数不同
        //第1组：6人
        //第2组：4人
        //第3组：5人
        int[][] score = new int[3][];

        //左边是数组名[下标]代表第几组
        //右边是 数据类型[长度]代表这个组一共有几个元素
        score[0] = new int[6];
        score[1] = new int[4];
        score[2] = new int[5];

        score[0][0] = 100;
        score[0][1] = 96;
        score[2][1] = 85;

        for (int i = 0; i < score.length; i++) {
//            System.out.println(score[i]);
            for (int j = 0; j < score[i].length; j++) {
                System.out.print(score[i][j]+" ");
            }
            System.out.println();
        }

    }
}

2.3.5 案例

案例 1

1 1 1 1 1
2 2 2 2 2
3 3 3 3 3

public class TwoArrayExercise1 {
    public static void main(String[] args) {
        /*
        1 1 1 1 1
        2 2 2 2 2
        3 3 3 3 3
         */
        int[][] arr = {{1, 1, 1, 1, 1}, {2, 2, 2, 2, 2}, {3, 3, 3, 3, 3}};

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

public class TwoArrayExercise2 {
    public static void main(String[] args) {
        /*
        1 1 1 1 1
        2 2 2 2 2
        3 3 3 3 3
         */
        int[][] arr = new int[3][5];

        int value = 1;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = value;
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
            value++;
        }
    }
}

案例 2

1
1 2
1 2 3
1 2 3 4

public class TwoArrayExercise3 {
    public static void main(String[] args) {
        /*
        1
        1 2
        1 2 3
        1 2 3 4
         */
        int[][] arr = {{1}, {1,2}, {1,2,3},{1,2,3,4}};

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

public class TwoArrayExercise4 {
    public static void main(String[] args) {
        /*
        1
        1 2
        1 2 3
        1 2 3 4
         */
        int[][] arr = new int[4][];


        int count = 1;
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[count++];

            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = j+1;

                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

练习题 3：杨辉三角

public class TwoArrayExercise6_2 {
    public static void main(String[] args) {
        int[][] yangHui = new int[10][];

        for (int i = 0; i < yangHui.length; i++) {
            /*
            当i=0， yangHui[0]的长度是1
            当i=1， yangHui[0]的长度是2
                   yangHui[i]的长度是i+1
             */
            yangHui[i] = new int[i+1];

            yangHui[i][0] = 1;//每一行的第1个元素
            // yangHui[i][yangHui[i].length-1] = 1;
            yangHui[i][i] = 1;//每一行的最后1个元素

            //中间的元素，j=1排除第1列，j<yangHui[i].length-1排除最后1列
            for(int j=1; j<yangHui[i].length-1; j++){
                yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];

            }

         }

        //打印
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j]+"\t");
            }
            System.out.println();
        }

    }
}

public class TwoArrayExercise6 {
    public static void main(String[] args) {
        int[][] yangHui = new int[10][];

        for (int i = 0; i < yangHui.length; i++) {
            /*
            当i=0， yangHui[0]的长度是1
            当i=1， yangHui[0]的长度是2
                   yangHui[i]的长度是i+1
             */
            yangHui[i] = new int[i+1];

            yangHui[i][0] = 1;//每一行的第1个元素
            System.out.print(yangHui[i][0]+"\t");

            //中间的元素，j=1排除第1列，j<yangHui[i].length-1排除最后1列
            for(int j=1; j<yangHui[i].length-1; j++){
                yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
                System.out.print(yangHui[i][j]+"\t");
            }

            // yangHui[i][yangHui[i].length-1] = 1;
            yangHui[i][i] = 1;//每一行的最后1个元素
            if(i>0) {
                System.out.print(yangHui[i][i] + "\t");
            }

            System.out.println();
        }


    }
}

思考题：回形数字矩阵

public class TwoArrayExercise5 {
    public static void main(String[] args) {
        int[][] arr = new int[10][10];

        int start = 1;
        int end = arr.length * arr[0].length;
        int leftColumn = 0;
        int rightColumn = arr[0].length-1;
        int upLine = 0;
        int downLine = arr.length-1;
        while (start<=end ) {
            //从左往右（上面）
            for(int j=leftColumn; j<=rightColumn && start<=end; j++){
                arr[upLine][j] = start++;
            }

            //从上往下
            for(int j=upLine+1; j<=downLine && start<=end; j++){
                arr[j][rightColumn] = start++;
            }

            //从右往左（下面）
            for(int j=rightColumn-1; j>=leftColumn && start<=end; j--){
                arr[downLine][j] = start++;
            }

            //从下往上
            for(int j=downLine-1; j>upLine && start<=end;j--){
                arr[j][leftColumn]=start++;
            }

            leftColumn++;
            rightColumn--;
            upLine++;
            downLine--;
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
    }
}

2.3.6 二维数组的内存分析

2.4 数组操作中常见的 2 个异常

1、ArrayIndexOutOfBoundsException

数组下标越界异常，数组名[下标]

2、NullPointerException

空指针异常

一维数组：
    引用数据类型[] 数组名 = new 引用数据类型[5];
	数组名[下标].方法

二维数组：
    元素类型[][] 数组名 = new 元素类型[5][];
	数组名[下标][下标] 或 数组名[下标].length 都会发生空指针异常

public class NullPointerExceptionTest {
    public static void main(String[] args) {
        String[] strings = new String[5];
//        strings[0] = "hello";
        System.out.println(strings[0].charAt(0));//h

        int[][] arr = new int[5][];
//        System.out.println(arr[0][0]);
//        System.out.println(arr[0].length);
    }
}

三、方法

这几天我们已经在用一些方法：

Arrays.toString(数组)      	toString()是调用一个方法
System.out.println(内容)     println(内容)是调用一个方法
Math.random()  				random()是调用一个方法

Scanner input = new Scanner(System.in);   Scanner(System.in)是一个特殊的构造方法，构造函数，构造器（后面单独讲）
System.out.print("请输入一个字符串：");    print(内容)是调用一个方法
String str = input.next();  			next()是调用一个方法

3.1 什么是方法

方法是代表一段独立的``可复用的``功能代码。

3.2 如何声明和调用方法（非常重要）

声明的格式：

public class 类名{
    【修饰符】 返回值类型 方法名1(【形参列表】){
        方法体语句;
    }

    【修饰符】 返回值类型 方法名2(【形参列表】){
        方法体语句;
    }

    【修饰符】 返回值类型 方法名3(【形参列表】){
        方法体语句;
    }
}

注意：

• 方法声明的位置，在类中，在方法外，方法与方法之间是独立的、并列的。
• 【修饰符】：今天统统把修饰符写成 public static， public（公共的）、static（静态的）
• 返回值类型：这个方法的功能完成之后，是否有结果需要返回，如果有结果，结果的类型是什么，如果没有结果返回，统一声明为 void。
  • 当方法的返回值类型不是 void，就说明它有结果返回，那么方法体中必须有 return 结果值;
• 方法名：就是一个标识符，遵循小驼峰命名法，要见名知意，能代表方法的功能。
• (形参列表)：这个方法完成功能时，是不是需要外面传入额外的数据，如果需要，需要几个，分别是什么类型，需要通过参数来定义。在真正调用方法之前，这个参数具体指是不清楚，它就是一个形式符号。

方法的形式：（从参数和返回值角度）

• 无参无返回值：()空，void
• 无参有返回值：()空，非 void
• 有参无返回值：(参数)，void
• 有参有返回值：(参数)，非 void

方法调用的格式：

• 如果跨类调用 ： 类名.方法，
• 如果本类调用：直接方法名即可
• 如果被调用的方法有(形参列表)，那么调用时必须传入对应个数、类型、顺序的实参。如果被调用方法没有参数，()是空的，那么调用时也是空()
• 如果被调用方法的返回值类型是 void，说明没有结果返回，就不能也不需要接收返回值。如果不是 void，说明有结果返回，用对应类型的变量接收返回值就可以。

3.3 如何查看一个类的源码

查看某个类的源码的快捷键：Ctrl + N（打开搜索框），打开某个类的源码之后，按 Ctrl + F12 查看成员列表

3.3 案例演示

案例 1

public class MethodDefineTest{
    //需求：这个方法可以求任意2个整数的和
    public static int add(int a,int b){
       return a + b;
    }

    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        int sum = add(x,y);
        System.out.println("sum = " + sum);
    }
}

案例 2

public class MethodDefineTest2 {
    //需求：这个方法可以实现在控制台打印 m行n列某字符组成的矩形
     public static void printRectangle(int m ,int n, char c){
         for(int i=1; i<=m; i++){
             for(int j=1; j<=n; j++){
                 System.out.print(c);
             }
             System.out.println();
         }
     }

    public static void main(String[] args) {
        printRectangle(5,10, '*');
        printRectangle(10,10, '$');
    }
}

案例 3

public class MethodDefineTest3 {
    //需求：这个方法可以产生[0,100)的整数
    public static int getANumber(){
        return (int)(Math.random()*100);
    }

    public static void main(String[] args) {
        int a = getANumber();
        int b = getANumber();
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

案例 4

import java.util.Arrays;

public class MethodInvokeTest {
    public static void main(String[] args) {
        //跨类调用时，public static修饰的方法，可以通过 类名.方法的方式调用
        int[] arr = {10,20,30,40};
        String s = Arrays.toString(arr);//用一个变量接收Arrays.toString()方法返回的结果
        System.out.println(s);

        System.out.println(Arrays.toString(arr));//直接打印 Arrays.toString()方法返回的结果

//        String str = Arrays.sort(arr);//错误，因为Arrays.sort()方法没有结果返回，返回值类型是void，就不能接受返回值
//        System.out.println(Arrays.sort(arr));//错误，因为Arrays.sort()方法没有结果返回
    }
}

3.4 练习题

练习题 1

import java.util.Scanner;

/*
（1）定义一个max方法，可以求任意两个整数中的最大值，
在主方法中从键盘输入2个整数，然后调用max方法测试
 */
public class MethodExercise1 {
    public static int max(int a,int b){
        /*if(a>b){
            return a;
        }else{
            return b;
        }*/
        return a>b ? a : b;
    }

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.print("请输入第1个整数：");
        int a = input.nextInt();

        System.out.print("请输入第2个整数：");
        int b = input.nextInt();

//        max(a,b).var 把这个方法调用的结果用一个变量接收
//        max(a,b); 按快捷键 Ctrl + Alt + V
        int result = max(a, b);
        System.out.println("result = " + result);

        System.out.print("请输入第3个整数：");
        int c = input.nextInt();

        int biggest = max(result,c);
        System.out.println("biggest = " + biggest);

        //把a,b的最大值拿到之后，与c继续比最大值
        input.close();
    }
}

练习题 2

/*
（2）定义一个getANumberBetween方法，可以得到一个[a, b)范围的随机整数
在主方法中调用getANumberBetween方法测试
 */
public class MethodExercise2 {
    public static int getANumberBetween(int a, int b){
        /*
        Math.random()得到 [0,1)的小数
        Math.random() * (b-a)  得到  [0, b-a)的小数
        Math.random() * (b-a) + a 得到 [a, b)的小数
        (int)(Math.random() * (b-a) + a) 得到 [a, b)的整数
         */
        return  (int)(Math.random() * (b-a) + a);
    }

    public static void main(String[] args) {
        int a = getANumberBetween(0, 100);
        System.out.println("a = " + a);

        int b = getANumberBetween(10, 20);
        System.out.println("b = " + b);
    }
}

练习题 3

/*
2、跨类调用练习题
（1）在MyArrays类中，定义一个 getSum方法，可以求任意一个int[]数组元素的总和
（2）在TestMyArrays类的main方法中，定义一个int[]数组，
然后调用MyArrays类的getSum方法求它们的总和
 */
public class MyArrays {
    public static int getSum(int[] arr) {
        int sum = 0;//存储总和
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }

}

public class TestMyArrays {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        int sum = MyArrays.getSum(nums);
        System.out.println("sum = " + sum);

        double[] price = {5.6, 9.9, 10.0};
      //  MyArrays.getSum(price);//报错， price数组是double[]类型，getSum要的是int[]类型
    }
}