java方法复习（基于狂神说）

目录

一 什么是方法 

二 方法的定义及调用

三 方法重载

四 命令行传参

五 可变参数

六 递归

---

一 什么是方法 

        以System.out.println()为例 ，System是一个类，out是一个对象，println（）是一个方法；     

        java方法是语句的集合，它们在一起执行一个功能；（1）方法是解决一类问题的步骤的有序组合。（2）方法包含在类或对象中。（3）方法在程序中被创建，在其他地方被引用。

        设计方法的原则:  最好保持方法的原子性，就是一个方法完成一个功能，有利于后期的扩展。

        方法的命名规则：驼峰规则

//main 方法
    public static void main(String[] args) {
        int sum = sum(1, 2);
        System.out.println(sum);
        mulTable();
    }
    //简单的求和方法,有public static 别的地方才可以调用。int 表示返回值类型
    public static int sum(int i, int j) {
        return i + j;
    }
    //输出乘法表方法
    public static void mulTable() { 
        for (int a = 1; a <= 9; a++) {
            for (int b = 1; b <= a; b++) {
                System.out.print(b + "*" + a + "=" + b * a + "\t");
            }
            System.out.println();
        }
    }

二 方法的定义及调用

        方法的定义：java方法类似于其他语言的函数，用来完成特定功能的代码片段。

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

                （1）修饰符：可选，告诉编译器如何调用该方法。定义了方法的访问类型；例如 public static finnal ；

                （2）返回值类型：方法可能有返回值，returnValueType 是方法返回值的数据类型。有些方法没有返回值，用void。

                （3）方法名：方法的实际名称。方法名和参数表共同构成方法签名。

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

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

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

                （5）方法体：方法体包含具体的语句。定义该方法的功能。

        结构：

                修饰符 返回值类型 方法名（参数类型 参数名）{

                        方法体；

                        return 返回值；

                }

注：return 除了返回值之外，还可以终止方法。

例题：比大小

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

方法调用：

        调用方法：对象名.方法名（实参列表）

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

        当方法返回为一个值时，方法调用通常当作一个值。例如

int larger = max(30,40);

        当方法返回值为void时，方法调用一定是一条语句。

课后扩展：值传递和引用传递；Java都是值传递。

三 方法重载

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

方法重载的规则：（1）方法名称必须相同；（2）参数列表必须不同，个数不同、或类型不同、或参数排列顺序不同等。（3）方法的返回类型可以相同，也可以不同。（4）仅仅返回类型不同不足以成为方法的重载。

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

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

    //比大小,double类型
    public static double max(double num1,double num2){
        double result = 0;
        if (num1==num2){
            System.out.println("num1=num2");
            return 0;
        }
        if(num1>num2){
            result = num1;
        }else{
            result = num2;
        }
        return result;
    }

四 命令行传参

        有时候需要运行一个程序时再传递给它参数，这要靠传递命令行参数给main() 函数实现。

命令行传参即在cmd界面运行时传递参数。 

package methods;

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

不常用；

五 可变参数

        从JDK1.5开始，java支持传递同类型的可变参数给一个方法。

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

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

        例题：找出数组中的最大值

public class Demo03 {
    public static void main(String[] args) {
        test(1, 2, 3);
        int ans = printMax(1,2,4,6,8,13,3,10);
        System.out.println(ans);
    }

    //可变参数
    public static void test(int... x) {
        System.out.println(x[0]);
        System.out.println(x[1]);
    }
    //例题 找出数组中最大值
    public static int printMax(int... x){
        if (x.length==0){
            System.out.println("无数字输入；");
            return 0;
        }
        int ans=x[0];
        for(int i = 0; i < x.length; i++)
        {
            if (ans < x[i]) {
                ans = x[i];
            }
        }
        return ans;
    }
}

六 递归

        递归：自己调用自己。

        利用递归可以用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转换为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量的程序就可以描述出接替过程所需要的多次重复计算，大大减少代码量。

        递归的能力在于用有限的语句来定义对象的无限集合。

        递归结构包括两个部分：

                递归出口：什么时候不调用自身方法。即结束的标志。

                递归体：什么时候调用自身方法。

例题：计算阶乘

public class Demo04 {
    public static void main(String[] args) {
        int ans = f(5);
        System.out.println(ans);
    }
    //阶乘
    public static int f(int n) {
        if (n == 1) {   //结束条件
            return n; 
        }
        return n * f(n - 1);  //调用自身
    }
}