Java方法详解

1.何为方法：

Java是语句的集合，他们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合。
方法包含于类中或对象中。
方法在程序中被创建，在其他地方被引用。

例：System.out.println(); 系统类.对象.方法;

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

2.方法的定义及调用：

方法包含一个方法头和一个方法体。
- 修饰符：修饰符这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型：方法可能会返回值。returnValue Type是方法返回值的数据类型。有些方法执行所需要的操作，但没有返回值。在这种情况下，returnValue Type是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量，参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
  - 形式参数：在方法被调用时用于接收外界输入的数据。
  - 实参：调用方法时实际传给方法的数据。
```
package com.kuang.method;

public class Demo01 {
    public static void main(String[] args) {
        //实际参数：实际调用传递给他的参数
        int sum = add(4,5);
        System.out.println(sum);

    }

    //形式参数：用来定义作用
    public static int add(int a, int b) {
        return a + b;
    }
}
```
- 方法体：方法体包含具体的语句，定义该方法的功能。
- return：如果我们方法存在返回值的情况下，一定要把返回值通过renturn关键词返回出去，如果是void则不用。return是用来终止方法的！

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

java支持两种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，一般定义一个变量去接收他。如：int max = max(40,10);
如果方法的返回值是void，方法调用一定是一条语句。如：System.out.println(hello，kuang);
值传递和引用传递：

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。
引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身.

java内的基础类型数据传递都是值传递. java中实例对象的传递是引用传递。

3.方法重载

重载就是在一个类中，有相同的函数名，但形参不同的函数
重载规则：
- 方法名必须相同
- 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）
- 方法的返回值类型可以相同也可以不相同。
- 仅仅返回类型不同不足以成为方法的重载。
- 实现理论：方法名相同时，编译器会根据调用方法的参数个数，参数类型逐个去匹配，已选择对应的方法，如果匹配失败，编译器报错。

package com.kuang.method;

public class Demo02 {
    public static void main(String[] args) {
        double max = max(40.0,10.2);
        System.out.println(max);
    }

    //比大小
    public static int max(int num1, int num2) {
        int result = 0;
        if (num1 == num2) {
            System.out.println("num1=num2");
            return 0;        //终止方法
        } else if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }

    public static double max(double num1, double num2) {
        double result = 0;
        if (num1 == num2) {
            System.out.println("num1=num2");
            return 0;        //终止方法
        } else if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result;
    }
}

4.命令行传参

5.可变参数（不定向参数）

在方法的声明中，在指定参数类型后面加上一个省略号（...）
一个方法只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在他之前声明。
必须是相同的类型。

package com.kuang.method;

public class Demo04 {
    public static void main(String[] args) {
        Demo04 demo04 = new Demo04();
        demo04.test(123,456,789,101,112,131,415);
    }
    public void test(int... i){
        for (int i1 = 0; i1 < i.length; i1++) {
            System.out.print(i[i1] + "\t");
        }

    }
}

package com.kuang.method;

public class Demo05 {
    public static void main(String[] args) {
        //调用可变参数的方法
        printMax(12, 15, 10, 78, 46, 32);
        printMax(new double[]{1, 2, 3});

    }

    public static void printMax(double... number) {
        if (number.length == 0) {
            System.out.println("no");
            return;
        }
        double result = number[0];
        //排序
        for (int i = 1; i < number.length; i++) {
            if (number[i] > result) {
                result = number[i];
            }
        }
        System.out.println("max:" + result);
    }
}

6.递归(能不用就不用)

递归就是：就是A方法调用B方法，就是自己调用自己。
递归结构包括两个部分：
- 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环
- 递归体：什么时候需要调用自身方法。

package com.kuang.method;

public class Demo06 {
    public static void main(String[] args) {

        //阶乘
        System.out.println(f(5));
    }
    public static int f(int a){
        if (a==1){
            return 1;
        }else{
            return a*f(a-1);
        }
    }
}

作业：写一个计算器，要求实现加减乘除功能，并能通过循环接收新数据，通过用户交互实现。

package com.kuang.method;

import java.util.Scanner;

public class Demo07 {
    public static void main(String[] args) {

        while (true) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入第一个数字：");
            int num1 = scanner.nextInt();

            System.out.println("请输入第二个数字");
            int num2 = scanner.nextInt();

            System.out.println("请输入运算符（+、-、*、/）：");
            String operator = scanner.next();
            switch (operator) {
                case "+":
                    System.out.println("运算结果为：" + add(num1, num2));
                    break;
                case "-":
                    System.out.println("运算结果为：" + sub(num1, num2));
                    break;
                case "*":
                    System.out.println("运算结果为：" + mult(num1, num2));
                    break;
                case "/":
                    if (num2 == 0) {          //被除数不能为0
                        System.out.println("无意义！");
                    } else {
                        System.out.println("运算结果为：" + div(num1, num2));
                    }
                    break;
                default:
                    System.out.println("不符合要求的运算符！");
            }
        }
    }

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

    public static int sub(int a, int b) {
        return a - b;
    }

    public static int mult(int a, int b) {
        return a * b;
    }

    public static int div(int a, int b) {
        return a / b;
    }

}

基本满足要求。

数组

1.数组概述

相同类型数据的有效集合
数组中的若干个数据，按照一定的先后次序排列组合而成
通过下标来访问，从0开始。

2.数组声明创建

package com.kuang.arrary;

public class ArraryDemo01 {
    public static void main(String[] args) {
        //数组的两种创建方法
        //int[] num;      //java首选方法
        int nums[];     //c和c++选用的
        int[] num = new int[10];
        //数组赋值
        num[0]=1;
        num[1]=1;
        num[2]=1;
        num[3]=1;
        num[4]=1;
        num[5]=1;
        num[6]=1;
        num[7]=1;
        num[8]=1;
        num[9]=1;

        int sum = 0;
        for (int i = 0; i < num.length; i++) {
            sum = sum + num[i];
        }
        System.out.println("总和为：" + sum);
    }
}

Java内存分析：堆（存放new的对象和数组）、栈（基本变量类型包括具体数值）、方法区（可以被所有的线程共享，包含了所有的class和static变量）

三种初始化：静态、动态、默认初始化。

package com.kuang.arrary;

public class ArraryDemo02 {
    public static void main(String[] args) {
        //静态初始化
        int[] a = {1,2,3,4,5,6,7,8,9};

        //引用
        Man[] mans = {new Man(),new Man()};

        //动态初始化：包含默认初始化
        int[] b = new int[10];
        b[0] = 10;
        b[1] = 20;

        System.out.println(b[0]);
        System.out.println(b[1]);
        System.out.println(b[2]);
        System.out.println(b[3]);
    }
}

数组一旦被创建，它的大小是不可改变的。如果出现java.lang.ArrayIndexOutOfBoundsException: 10就是数组下标越界
其元素是相同类型
元素类型可以是任何数据类型，包括基本数据类型和引用数据类型
数组本身就是引用类型，数组也可以看成对象，数组中的每个元素相当于改对象的成员变量。

数组本身就是对象，java中的对象是在堆中
下标的合法区间：[0,length-1]

3.数组使用

package com.kuang.arrary;

import java.util.Arrays;

public class ArraryDemo04 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};

        //增强型for循环   （类型 元素： 数组）
        //jdk1.5，没有下标
        for (int array : arrays) {
            System.out.println(array);
        }

        printArrary(arrays);
        int[] reverse = reverse(arrays);
        printArrary(reverse);
    }

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

}

4.多维数组

是数组的数组，比如二维数组

package com.kuang.array;

public class ArrayDemo05 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};
        System.out.println(array[0][0]);
        System.out.println(array[0][1]);

        printArrary(array[0]);

        for (int i=0; i<array.length; i++){
            for (int j=0; j<array[i].length; j++){
                System.out.print(array[i][j] +" ");
            }
        }
    }
    //打印数组元素
    public static void printArrary(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + " ");
        }
        System.out.println();
    }
}

5.Arrarys类

数组的工具类java.util.Arrays
查看JDK帮助文档
Arrays类中的方法都是static修饰的静态方法，在使用时可以直接使用类名进行调用，而不用使用对象来调用。
常用功能：
- 给数组赋值：fill方法
- 数组排序：sort方法，升序
- 比较数组：equals方法
- 查找数组元素：binarySearch方法，对排序好的数组进行二分法查找。

package com.kuang.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a = {123, 45646, 4564,78, 45, 67 ,55};

        //打印数组元素Arrars.toString
        System.out.println(Arrays.toString(a));

        Arrays.sort(a); //排序，升序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,4,6,2);  //赋值
        System.out.println(Arrays.toString(a));
    }
}

6.稀疏数组

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

package com.kuang.array;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //创建一个二维数组11*11  棋盘     1：黑  2：白
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;

        //输出原始数组
        System.out.println("输出原始数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

        //转换为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数" + sum);

        //创建一个稀疏数组的数组
        //                         行     列     有效值
        int[][] array2 = new int[sum + 1][3];         //有效值？行  3列
        array2[0][0] = 11;     // 11行
        array2[0][1] = 11;     // 11列
        array2[0][2] = sum;    // 有效值


        //遍历二维数组，将非零得数存放在稀疏数组中
        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("稀疏数组");

        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("=========================");
        //还原稀疏数组
        //1.读取稀疏数组 11*11
        int[][] array3 = new int[array2[0][0]][array2[0][1]];

        //2.给其中的元素还原值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        //3.打印
        //输出还原数组
        System.out.println("输出还原数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

    }
}