方法

方法

什么是方法（函数）

方法是类或对象行为特征的抽象，也称为函数。

Java里的方法不能独立存在，所有的方法必须定义在类里。且方法不可以嵌套。

修饰符 返回值类型 方法名（参数类型1 形参1，参数类型2 形参 2，….）｛

程序代码;

return 返回值;

｝

其中：

形式参数：在方法被调用时用于接收外部传入的数据的变量。

参数类型：就是该形式参数的数据类型。

返回值：方法在执行完毕后返还给调用它的程序的数据。

返回值类型：方法要返回的结果的数据类型。

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

方法的参数传递分析

方法，必须有其所在类或对象调用才有意义。若方法含有参数：

形参：方法声明时的参数

实参：方法调用时实际传给形参的参数值

如何理解方法返回值类型为void的情况 ?

 

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

 

方法(method) : 是某种功能的抽象, 描述类或对象的行为动作. 也称为函数(function)
    
    注意 : 方法必须隶属于类, 方法不可以嵌套!!! 必须是并列关系
    
    声明方法 :
    修饰符 返回值类型 方法名(数据类型1 形参1, 数据类型2 形参2, 数据类型3 形参3,....) {
        方法体;
        return 具体的返回值;
    }
    
    修饰符 : public static, final, abstract....
    返回值类型 : 方法的功能的最终的成果数据的类型. 
    方法名 : 标识符, 用于定位
    形式参数 : 数据类型, 变量名, 表示方法的功能的完成所需要的数据, 没有数据不行, 但是数据是多少又不影响功能.
    return 返回值 : 把最后真正的成果数据返回 给 使用者
    
    方法 = 方法签名(不执行, 方法的使用说明书API) + 方法体(真正执行的代码);
    
    方法必须被调用了才真的执行.
    
    方法调用 : // 参数列表必须要以方法签名为准
        方法名(实际参数1, 实际参数2, ....);
    
    返回值 :  必须在调用的同时接收, 如果在调用时没有接收, 那么 返回 值马上消失, 永远无法找回.
        变量 = 方法调用本身;
        
    如果方法的返回值类型为void, 说明没有返回 值, 方法最后的return可以省略.
    
    无返回值方法的调用不可以用变量接收 返回 值, 也不可打印方法调用本身. 纯粹调用即可
    
    注  意：
        没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
​
        定义方法时，方法的结果应该返回给调用者，交由调用者处理。
​
        方法中只能调用方法，不可以在方法内部定义方法。
​
        方法的返回值只有一次机会接收, 就是在调用时
​
        如果在方法中又调用了方法本身, 称为递归调用
    
    // 执行流程 : 
        // 1) 传递参数, 把实参传递给对应的形参, a = 10, b = 20;本质就是 形参 = 实参. 是赋值操作
        // 2) 现场保护, 调用者方法准备进入暂停,挂起状态
        // 3) 被调用方法接收到实参后, 就真的开始执行, 执行里面的所有语句 
        // 4) 最后再把返回值40返回给调用者, 就是把返回值放入临时空间中, 被调用方法彻底结束
        // 5) 回到方法的调用位置处, 现场恢复, 恢复以后, 继续执行调用者方法, 并在调用者接收返回值.
    
    形参只要能兼容性地接收实参即可.
    
    方法调用有风险, 当调用方法时, 调用者会把执行权及控制权交给被调用方法.
*/
public class MethodTest {
    
    // 求2个整数的和
    public static int add(int a, int b) {
        System.out.println("add(int a, int b)...");
        int c = a + b;
        return c;
    }
    
    // 无参无返回 
    public static void test() {
        System.out.println("test()1....");
        System.out.println("test()2....");
        System.out.println("test()3....");
        System.out.println("test()4....");
        return; // 仅仅表示方法结束了.
    }
    
    public static void main(String[] args) {
        System.out.println("main begin");
        
        //我是调用者
        int x = add(10, 30);
        //System.out.println(c); 方法的局部变量不可以随意跨方法访问
        System.out.println(x);
        
        System.out.println(add(100, 80)); // 方法调用本身也可以直接被打印, 打印的就是它的返回值.
        
        //int n = test(); // 即使方法不需要传参, 也不能省略一对().
        test(); // 不可以接收返回 值是void的方法调用. 纯粹调用即可.
        //System.out.println(test()); // 如果返回 值是void, 绝对不可以打印它.
        
        test();
        
        System.out.println("main end");
    }
}

方法调用流程

public class MethodTest2 {
    
    public static void test(int a) {
        System.out.println("test(int a), a : " + a); // 1
        //while (true);
    }
    
    public static int add(int a, int b) {
        test(a); // 方法调用, 连环调用
        System.out.println("add(int a, int b)..."); // 2 
        short c = (short)(a + b);
        return c;
    }
    
    public static void main(String[] args) {
        System.out.println("main begin"); // 3 
        
        // 执行流程 : 
        // 1) 传递参数, 把实参传递给对应的形参, a = 10, b = 20;本质就是 形参 = 实参. 是赋值操作
        // 2) 现场保护, 调用者方法准备进入暂停,挂起状态
        // 3) 被调用方法接收到实参后, 就真的开始执行, 执行里面的所有语句 
        // 4) 最后再把返回值40返回给调用者, 就是把返回值放入临时空间中, 被调用方法彻底结束
        // 5) 回到方法的调用位置处, 现场恢复, 恢复以后, 继续执行调用者方法, 并在调用者接收返回值.
        byte x = 10; // short???
        short y = 30;
        int n = add(x, y); // 返回值类型必须 要以方法签名中的类型 为准
        
        System.out.println(n);
        
        System.out.println("main end"); // 4 
    }
}

方法的重载

/*
    方法的重载(Overload) 就是过载的意思, 因为太多了, 在同一个类中, 有多个同名方法, 但是参数不同, 就形成重载
    方法重载和返回值类型无关, 只要求参数不同, 参数不同体现为参数个数不同, 数据类型不同, 顺序不同.
    
    在调用时需要通过实参来进一步定位方法.
    实参和形参在匹配时, 优先精准匹配, 没有精准匹配, 再兼容性匹配.
*/
public class OverLoadTest {
    
    /*
    public static int add(int a, int b) {
        System.out.println("add(int a, int b)...");
        int c = a + b;
        return c;
    }
    */
    
    public static double add(double a, double b) {
        System.out.println("add(double a, double b)...");
        double c = a + b;
        return c;
    }
    
    public static double add(int a, double b) {
        System.out.println("add(int a, double b)...");
        double c = a + b;
        return c;
    }
    
    /* 此方法并没有和上面的方法重载, 而是冲突了, 因为方法参数的类型最重要. 
    public static double add(int b, double a) {
        System.out.println("add(int b, double a)");
        double c = b + a;
        return c;
    }
    */
    
    public static double add(double a, int b) { // 此方法和上面的方法表现为参数的类型的顺序不同, 可以重载
        System.out.println("add(double a, int a)");
        double c = a + b;
        return c;
    }
    
    public static int add(int a, int b, int c) {
        System.out.println("add(int a, int b, int c)...");
        int d = a + b + c;
        return d;
    }
    
    public static void main(String[] args) {
        //System.out.println(add(9, 20)); // 此方法可以和上面的2个方法的匹配度都一样, 所以编译会报错!!!
        System.out.println(add(9.0, 20)); // ? 
        System.out.println(add(9, 30, 80));
        System.out.println(add(5.2, 8.9));
        
        System.out.println(add(8, 9.9)); // int, double 
        
    }
}

递归

public class Test {
    
    // 求n的阶乘 n!
    // n * (n-1)!, 问题可以分解成一个小问题和相同类型的子问题.
    // 递归的思维方式 是告诉计算机做什么
    // 递归方法100%必须要有参数, 因为要通过参数的变化, 让它变成有限的递归.
    public static int test(int n) {
        //return test(n); // 方法调用自身称为递归调用, 这种写法的递归会导致栈溢出. 无限递归(死归)
        if (n == 1) { // 递归中必须要有中止条件, 否则会死归
            return 1;
        }
        return n * test(n - 1); // 递归时必须要让参数变化, 趋于中止条件.
    }
    
    public static void main(String[] args) {
        System.out.println(test(5));
        // for循环的思维是告诉计算机怎么做
        int result = 1;
        for (int i = 1; i <= 5; i++) {
            result *= i;
        }
        System.out.println(result);
    }
    
}

 

 

2. 声明定义一个方法的语法格式是什么? 解释每部分的作用.

   修饰符 返回值类型 方法名(数据类型1 形参1, 数据类型2 形参2, ......) {

   方法体;

   return 返回值;

   }

   返回值类型 : 表明方法的功能结束后的成果数据类型.

   方法名 : 标识符

   形式参数 : 方法的功能的完成需要一些外部数据的支持.

   方法体 : 语句, 真正要执行的代码

   return 返回值 : 把最终的真实的结果值返回给调用者

 

3. 如何调用一个带有形参的方法? 形参的作用是什么? 什么时候需要在方法中声明参数?

   方法名(实参1, 实参2, 实参3);

   形参的作用是传递数据, 调用者给被调用 方法传递数据

   方法的功能完成需要数据时, 而数据的值是多少又不影响功能性.

 

4. 方法的返回值是什么? 如何使用这个返回值?

   方法的最终成果数据.

   变量 = 方法调用;

   因为方法调用本身就是返回值了, 所以也可以直接使用方法调用.

   System.out.println(方法调用)

 

 

5. 什么是方法重载, 为什么要方法重载?

   在同一个类中, 方法名相同, 参数不同就形成重载, 参数不同体现为参数的类型不同, 个数不同, 顺序不同.

6.