文章目录

• 1. 何谓方法
• 2. 方法的定义及调用
• • 方法的定义
  • 方法调用
• 3. 方法重载
• 4. 可变参数（实质与数组类似）
• 5. 递归（重点！！！！）
• 6. 练习题
• 总结

1. 何谓方法

• 众所周知，System.out.println() 是一个用于输出的语句，那么它为什么可以输出呢？他的本质又是什么呢？

  • System 是一个系统自带的类，out ** 是这个类的对象**，println() 是这个类的方法
  • 本质是调用 System 类中的标准输出对象 out 的 println() 方法

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

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

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

• 回顾：方法的命名规则？

  • 首字母小写和驼峰原则

2. 方法的定义及调用

方法的定义

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

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

• 方法包含一个方法头和一个方法体。如下列出一个方法的所有部分
  • 修饰符：修饰符是可选的，告诉编译器如何调用该方法，定义了该方法的访问类型
  • 返回值类型：方法可能会有返回值，返回值类型是指返回值的数据类型，有些方法没有返回值，这种情况下，返回值的类型是 void
• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名
• 参数类型：参数像是一个占位符，当方法被调用时，传递值给参数。这个值被称为实参或者变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包括任何参数
  • 形式参数：在方法被调用的时候用于就收外界输入的数据
  • 实参：调用方法时的实际传给方法的数据。
• 方法体：方法体包括具体的语句，定义该方法的功能。
• 代码演示：

package com.gaox.method;

/**
 * @author GAOXU
 */
public class Demo1 {
    //main方法
    public static void main(String[] args) {
        //调用方法，可以先创建类的对象，然后用对象来调用此方法
        //创建Demo1的对象
        Demo1 demo = new Demo1();
        int x = 3;
        int y = 5;

        //将demo.addMethod()方法的返回值存入sum中
        int sum = demo.addMethod(x, y);
        //输出两者之和
        System.out.println("两者之和为：" + sum);
    }

    /**
     * 求出两者之和并返回，public 为修饰符，int 为返回值类型，addMethod 为方法名
     * @param x 
     * @param y
     * @return
     */
    public int addMethod(int x, int y){
        //返回用 return 关键字，return 不仅可以作为返回的关键字，也可以作为结束方法的一个标识符！
        return (x + y);
    }
}

方法调用

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

demo.addMethod(x, y);		//来自于上一个代码演示

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

  • 当方法返回一个值的时候，方法调用通常被当作一个值

  //将demo.addMethod()方法的返回值存入sum中
  int sum = demo.addMethod(x, y);		//来自于上一个代码演示
  

  • 如果方法返回值时void，方法调用一定是一条语句。

  ---

• 拓展了解：值传递（Java）和引用传递？（必须掌握！！！）

  • 值传递（pass by value）是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中对参数进行修改，将不会影响到实际参数
  • 引用传递（pass by reference）是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数进行修改，将影响到实际参数

  	值传递	引用传递
  根本区别	会创建副本（copy）	不创建副本
  结果	函数中无法改变原始对象	函数中可以改变原始对象

  • 详细知识请点击这里查看

3. 方法重载

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

• 方法的重载规则：

  • 方法名必须相同
  • 参数列表必须不同（个数不同，或类型不同，参数排列顺序不同等）
  • 方法的返回类型可以相同，也可以不同
  • 仅仅返回类型不同不足以称位方法的重载

• 实现理论

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

package com.gaox.method;

/**
 * @author GAOXU
 */
public class Demo1 {
    //main方法
    public static void main(String[] args) {
        //调用方法，可以先创建类的对象，然后用对象来调用此方法
        //创建Demo1的对象
        Demo1 demo = new Demo1();
        int x = 3;
        int y = 5;
        double dx = 10.00;
        double dy = 20.00;
        
        //将demo.addMethod()方法的返回值存入sum中
        int sum = demo.addMethod(x, y);
        double dsum = demo.addMethod(dx, dy);
        //输出两者之和
        System.out.println("两者之和为：" + sum);
        System.out.println("两者之和为：" + dsum);
    }

    /**
     * 求出两者之和并返回
     * @param x
     * @param y
     * @return
     */
    public int addMethod(int x, int y){
        return (x + y);
    }
    
    /**
     * 
     * @param x
     * @param y
     * @return
     */
    public double addMethod(double x, double y){
        return (x + y);
    }
}

4. 可变参数（实质与数组类似）

• JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法
• 在方法声明中，在指定参数类型后加一个省略号(…)
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何普通的参数必须在它之前声名
• 代码演示

package com.gaox.method;

/**
 * @author GAOXU
 */
public class Demo3 {
    public static void main(String[] args) {
        //创建类的对象
        Demo3 demo3 = new Demo3();
        //调用test方法，因为是可变参数，所以传多少个参数都无所谓
        demo3.test(1, 2, 3, 4, 5);

    }

    /**
     * 可变参数
     * @param i
     */
    public void test(int ... i){
        //打印输出可变参数 i 的每一位
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }
}

5. 递归（重点！！！！）

• A方法调用B方法，我们很容易理解，而递归方法是：A方法调用A方法，自己调用自己！

• 利用递归可以用简单的程序来解决一些复杂的问题，他通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解

• 递归策略只需要少量的程序就可以描述出接替过程所需要的多次重复计算，大大减少了程序的代码量

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

• 递归结构包括两部分：

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

package com.gaox.method;

/**
 * @author GAOXU
 */
public class Demo4 {
    public static void main(String[] args) {
        //创建对象
        Demo4 demo4 = new Demo4();
        //调用对象的方法
        //demo4.test();
        int sum = demo4.factorial(5);
        System.out.println(sum);

    }


    /**
     * 创建一个失败的递归案例：没有递归头，会陷入死循环中，请不要写出这样的代码！！
     */
    public void test(){
        test();
    }

    /**
     * 输入一个数，计算其对应的阶乘（n！），并返回结果
     * @param number
     * @return
     */
    public int factorial(int number){
        //当number等于1时，此时1！等于 1，当number ！= 1 时，此函数会返回 number * factorial(number - 1)，达成的效果为 n * （n -1）
        if (number == 1){
            return 1;
        }else {
            return (number * factorial(number - 1));
        }
    }
}

• 递归试用范围：
  • 对于深度较浅的函数，递归使用便捷，而当递归深度增加后，由于Java是栈机制（后面会总结），会导致函数入栈和出栈的时间大大增加，这就使得递归方法使用巨慢无比！
  • 当基数较小的时候，使用递归十分方便；反之，尽量不要使用
  • 主要学习递归的思想！！！！！！！

6. 练习题

• 写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互实现

• 思路推荐：

  • 写4个方法：加减乘除
  • 使用循环 + switch 进行用户交互
  • 传递需要操作的两个数
  • 输出结果
  • 补充：尽量不要使用系统自带的数学类工具，练习题的目的是为了锻炼敲代码的能力！！！

• 参考代码（一定要自己先动手写！！！）

package com.gaox.method;

import java.math.BigDecimal;
import java.util.Scanner;

/**
 * @author GAOXU
 */
public class CalculatorDemo {
    public static void main(String[] args) {
        System.out.println("欢迎来到计算机程序！请选择你需要的操作：");
        System.out.println("A. 进入计算模式   B. 退出此程序");
        System.out.println("请在下方输入对应选项!");

        //定义类的对象，方便调用函数
        CalculatorDemo calculatorDemo = new CalculatorDemo();

        Scanner scanner = new Scanner(System.in);
        //获取第一步的操作
        String str = scanner.next();
        if ("A".equals(str)){
            //定义循环结束的条件
            int terminator = 0;
            while (terminator == 0){
                //输入操作数
                System.out.println("请输入两个操作数（用空格隔开）");
                double number1 = scanner.nextDouble();
                double number2 = scanner.nextDouble();
                double sum;

                System.out.println("请选择计算操作：（输入对应选项，退出程序请出入0）");
                System.out.println("1. 加法   2. 减法   3. 乘法   4. 除法");
                int option = scanner.nextInt();
                //对计算模式进行选择
                switch (option){
                    case 0:
                        terminator = -1;
                        break;
                    case 1:
                        sum = calculatorDemo.addition(number1, number2);
                        System.out.println("结果为：" + sum);
                        break;
                    case 2:
                        sum = calculatorDemo.subtraction(number1, number2);
                        System.out.println("结果为：" + sum);
                        break;
                    case 3:
                        sum = calculatorDemo.multiplication(number1, number2);
                        System.out.println("结果为：" + sum);
                        break;
                    case 4:
                        System.out.println("请输入你要保留的位数：");
                        int scale = scanner.nextInt();
                        sum = calculatorDemo.division(number1, number2, scale);
                        System.out.println("结果为：" + sum);
                        break;
                    default:
                        System.out.println("错误输入！请重新输入！");
                }
            }
        }

    }
    
    /*
    解释一下，运算时不能直接使用Double进行操作是因为操作后得出的结果保留的位数会出错，不是精确表示
    所以使用了如下提供的方法，会极大的提高结果的精确率
     */

    /**
     * 提供精确的加法运算
     * @param number1
     * @param number2
     * @return
     */
    public double addition(double number1, double number2){
        BigDecimal bigDecimal1 = new BigDecimal(Double.toString(number1));
        BigDecimal bigDecimal2 = new BigDecimal(Double.toString(number2));
        return (bigDecimal1.add(bigDecimal2).doubleValue());
    }

    /**
     * 提供精确的减法运算
     * @param number1
     * @param number2
     * @return
     */
    public double subtraction(double number1, double number2){
        BigDecimal bigDecimal1 = new BigDecimal(Double.toString(number1));
        BigDecimal bigDecimal2 = new BigDecimal(Double.toString(number2));
        return (bigDecimal1.subtract(bigDecimal2).doubleValue());
    }

    /**
     * 提供精确的乘法运算
     * @param number1
     * @param number2
     * @return
     */
    public double multiplication(double number1, double number2){
        BigDecimal bigDecimal1 = new BigDecimal(Double.toString(number1));
        BigDecimal bigDecimal2 = new BigDecimal(Double.toString(number2));
        return (bigDecimal1.multiply(bigDecimal2).doubleValue());
    }

    /**
     * 提供相对精确的除法运算
     * @param number1
     * @param number2
     * @param scale 保留的位数
     * @return
     */
    public double division(double number1, double number2, int scale){
        BigDecimal bigDecimal1 = new BigDecimal(Double.toString(number1));
        BigDecimal bigDecimal2 = new BigDecimal(Double.toString(number2));
        return (bigDecimal1.divide(bigDecimal2, scale, BigDecimal.ROUND_HALF_UP).doubleValue());
    }
}

• README
  • 本示例代码仅仅展示题目中需要的功能，对于与用户交互中的BUG请忽略（虽然是不好的习惯，但是博主真的赶时间