方法

• Java方法是语句的集合，它们在一起执行一个功能。

  方法是解决一类问题的步骤的有序组合

  方法包含于类或对象中

  方法在程序中被创建，在其他地方被引用

• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

Java的方法类似于其它语言的函数，是一段用于完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

• 修饰符：修饰符，这是可以选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

• 返回值类型：方法可能会返回值，returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。

• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。

• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。

• 方法体：方法体包含具体的语句，定义该方法的功能。

  修饰符 返回值类型 方法名 (参数类型 参数名){
  …
  方法体
  …
  return 返回值；
  }

调用方法：对象名.方法名(实参列表)

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：int max = max(20,30);

如果方法返回值是 void ,方法调用一定是一条语句。System.out.println("Hello");

注意： 值传递（Java）和引用传递:

值传递： 使用两个不同的存储单元，执行中，形式参数值改变不会影响实际参数值。

引用传递： 实际为引用地址，实际参数和形式参数指向同一地址，执行中形式参数会影响实际参数。

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数。

• 方法重载的规则：

• 实现理论：

  方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

有时候你希望运行一个程序时候再传递给他消息。这要靠传递命令行参数给main()函数实现。

public static void main(String[] args){
    for(int i = 0; i < args.length; i++){
        System.out.println("args[" + i +"]:" + args[i]);
    }
}

注意：

先编译：在类的文件夹下直接javac 类名.java

在运行：一定要在src目录下才能运行java 包名.类名 参数(1 2 3)

JDK1.5开始，Java支持传递同类型的可变参数给一个方法。（本质就是数组）

在方法声明中，在指定参数类型后加一个省略号（…）。

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void main(String[] args) {
    printMax(34, 3, 3, 2, 56.5);
    printMax(new double[]{1, 2, 3});
}
public static void printMax(double... numbers){
    if (numbers.length ==0){
        System.out.println("No argument passed");
        return;
    }
    double result = numbers[0];
    //排序
    for (int i = 1; i < numbers.length; i++){
        if (numbers[i] > result){
            result = numbers[i];
        }
    }
    System.out.println("The max value is " + result);
}

• 递归就是：A 方法调用 A 方法！就是自己调用自己

• 利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解决过程所需要的多次重复计算，大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
• 递归体：什么时候需要调用自身方法。

递归适合小量计算，如果太大量计算容易内存崩溃，死机。【栈机制】（尽量不用递归）

例题：求N的阶乘

public static void main(String[] args){
    System.out.println(f(5));
}
// n的阶乘
public static int f(int n){
    if (n == 1){
        return 1;
    }else {
        return n * f(n-1);
    }
}

数组

• 数组是相同类型数据的有序集合。

• 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。

• 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

• 首先必须声明数组变量，才能在程序中使用数组。

  声明数组变量的语法：

  dataType[] arrayRefVar; // 首选的方法
  或
  dataType arrayRefVar[]; // 效果相同，但不是首选方法

• Java 语言使用 new 操作符来创建数组，语法：dataType[] arrayRefVar = new dataType[arraySize];

• 数组的元素是通过索引访问的，数组索引从0开始

• 获取数组长度：arrays.length

Java内存分析：

• 静态初始化

  //静态初始化：创建 + 赋值
  int[] a = {1, 2, 3};

• 动态初始化

  //动态初始化：包含默认初始化，未赋值前有默认值。
  int[] a = new int[2];
  a[0] = 1;
  a[1] = 2;

• 数组的默认初始化

  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方法被隐式初始化。

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。

• 其元素必须是相同类型，不允许出现混合类型。

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。

• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

• 下标的合法区间：[0,length-1]，如果越界就会报错；

  public static void main(String[] args){
  int[] a=new int[2]; //a长度为2，下标表示为a[0]，a[1]。
  System.out.println(a[2]);//a[2]以超出设定值：出现异常->ArraylndexOutOfBoundsException:数组下标越界异常！
  }

• ArraylndexOutOfBoundsException:数组下标越界异常！

小结：

• 普通的For循环

• For-Each 循环

• 数组作方法入参

• 数组作返回值

例题：

    public static void main(String[] args) {
        int[] arrays = {11,12,13,14,15};
        //打印全部的数组元素
        for (int i = 0; i < arrays.length; i++){
            System.out.println(arrays[i]);
        }
        System.out.println("====================");
        //打印数组元素之和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++){
            sum = sum + arrays[i];
        }
        System.out.println("sum=" + sum);
        System.out.println("=================");
        //查找数组内最大元素
        int max = arrays[0] ;
        for (int i = 1; i < arrays.length; i++){
            if (max < arrays[i]){
                max = arrays[i];
            }
        }
        System.out.println("max=" + max);
    }


public static void main(String[] args) {
    int[] arrays ={1, 2, 3, 4, 5};
    //JDK1.5 没有下标
    for (int array : arrays) {
        System.out.print(array + " ");
    }
    System.out.println();

    System.out.println("打印数组");
    printArray(arrays);

    System.out.println("反转数组：");
    int[] reverse= reverse(arrays);
    printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays){
    int[] reverse =new int[arrays.length];
    for (int i = 0, j = reverse.length-1; i <arrays.length; i++, j--){
        reverse[j] = arrays[i];
    }
    return reverse;
}
//打印数组元素
public static void printArray(int[] arrays){
    for (int i = 0; i <arrays.length; i++) {
        System.out.print(arrays[i] + " ");
    }
}

• 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。

• 二维数组 int a[][] =new int[2][5]; 这个二维数组 a 可以看成一个两行五列的数组。

例题：

public static void main(String[] args) {
    int[][] array = {{1, 2}, {2, 3}, {3, 4}, {4, 5}};
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array[i].length; j++) {
            System.out.print(array[i][j] + " ");
        }
    }
}

• 数组的工具类java.uti.Arrays

• 由于数组对象本身并没有什么方法可以供我们调用，但是 API 中提供了一个工具类 Arrays 供我们使用，从而可以对数据对象进行一些基本的操作。

• 查看 JDK 帮助文档

• Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）

具有以下常用功能：

1、给数组赋值：通过 fill 方法。

2、对数组排序：通过 sort 方法，按升序。

3、比较数据：通过 equals 方法比较数组中元素值是否相等。

4、查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

public static void main(String[] args) {
    int[] a = {3, 54, 8, 2, 9, 6, 57, 12, 87};
    //打印数组元素，Arrays.toString
    System.out.println(Arrays.toString(a));
    //数组排序操作
    Arrays.sort(a);
    System.out.println(Arrays.toString(a));
    //数组填充
    Arrays.fill(a, 7);
    System.out.println(Arrays.toString(a));
    //选择填充 [2, 6)
    Arrays.fill(a, 2, 6, 0);
    System.out.println(Arrays.toString(a));
}

• 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序！

• 冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知。

• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n^2)。

  public static void main(String[] args) {
  int[] a = {23, 5, 6, 76, 8, 1, 2, 9, 34, 76};
  int[] sort = sort(a);
  System.out.println(Arrays.toString(a));
  }
  public static int[] sort(int[] array){
  int temp = 0;
  boolean flag = false;
  for (int i = 0; i <array.length-1 ; i++) { // 最大外循环，判断要走多少次
  for (int j = 0; j <array.length-1-i ; j++) { // 排序循环，比较大小，交换位置
  if (array[j+1] < array[j]){
  temp = array[j];
  array[j] = array[j+1];
  array[j+1] = temp;
  flag = true;
  }
  if (flag == false){//优化，提前结束。
  break;
  }
  }
  }
  return array;
  }

• 需求：编写五子棋游戏中，有存盘退出或续上盘的功能。

• 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。

• 解决：稀疏数组

介绍：

当一个数组中大部分元素为0，或者为同一值得数组时，可以使用稀疏数组来保存该数组。

稀疏数组的处理方式是：

• 记录数组一共有几行几列，有多少个不同值。
• 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

如下图：左边是原始数组，右边是稀疏数组

    public static void main(String[] args) {
        int[][] array1 = new int[11][11];//0代表空，1代表黑子，2代表白子
        array1[1][2] = 1;//给黑子定位
        array1[2][3] = 2;//给白子定位
        //输出原始数据
        System.out.println("原始数据:");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
        System.out.println("======================");
        //转换为稀疏数组保存
        //1.求和有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j] != 0){
                    sum++;
                }
            }
        }
        System.out.println("稀疏数组：");
        //2.创建一个稀疏数组的数组
        int[][] array2 = new int [sum+1][3];//确定第一条稀疏数组的数据
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //3.将非零的值，存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }
        System.out.println("序 "+" 行 "+" 列 "+" 值 ");//打印数组
        int xu = 0;
        for (int[] ints : array2) {
            System.out.print(xu+" ");
            for (int anInt : ints) {
                if (anInt<10) {
                    System.out.print("  " + anInt + " ");
                } else {
                    System.out.print(" " + anInt + " ");
                }
            }
            xu++;
            System.out.println();
        }
        /*
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");
        }*/
        System.out.println("========================");
        //转换成原始数据
        System.out.println("还原原始数组：");
        int[][] array3 = new int[array2[0][0]][array2[0][1]];//确认原始数组整体大小
        for (int i = 1; i <array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];//将数组的数据赋值
        }

        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }