Java-Day006

你总是这样轻言放弃的话，无论过多久都只会原地踏步

方法的概述、方法的定义、方法的调用、方法的重载和方法的递归

一、概述

方法是指人们在实践过程中为达到一定目的和效果所采取的办法、手段和解决方案。

所谓方法，就是解决一类问题的代码的有序组合，是一个功能模块。编程语言中的方法是组合在一起来执行操作语

句的集合。Java语言中的方法在其他语言中也可能被称为函数。

二、定义

一、声明格式

访问修饰符 返回值类型 方法名([参数]){
	方法体
}

1. 访问修饰符：方法允许访问的范围
2. 返回值类型：方法最终返回的结果数据类型，没有返回值写void
3. 方法名：自定义的方法的名字，必须使用合法的字符，见名知意
4. 参数：参数可以有多个，每个以,分开，没有不写

例如：

public void helloWorld(){
	System.out.print("Hello World");
}

Tips：方法不能嵌套

二、分类

根据方法是否带参数，是否有返回值可以将方法分为一下几种

• 无参无返
• 无参有返
• 有参有参
• 有参无返

三、void关键字

void关键字，表示该方法没有返回值。

四、形参与实参

• 形参：方法声明里的参数，用来接收调用者传来的数据
  • 形参只有在方法被调用的时候，虚拟机才会分配内存单元，在方法调用结束之后便会释放所分配的内存单元。
  • 形参只在方法内部有效
• 实参：调用的时候传递给方法的参数。实参在传递给别的方法之前是要被赋值的。

五、return关键字

1、定义

• 立马结束方法
• 返回数据给方法调用者

2、return语句

• return语句可以出现在任何有返回值，或者无返回值的方法中

  • 在没有返回值的方法中，遇到return则结束方法
  • 在有返回值的方法中，遇到 return则返回return后面的数据（返回的数据要和方法声明中写的数据类型一样）

• 一个方法中可以有多个return语句

• 一个方法中最终只能有一个return被执行

• 在一定会被执行的return语句后面写的语句，为不可达语句，编译不会通过

  public int a1(){
      return 0;
      System.out.println("不可达语句");
  }
  

  运行结果

3、签名

方法的签名，确保在一个类中的唯一性。方法的签名只看方法名和形参（类型，个数，顺序），与修饰符，返回值无关。

三、调用

一、格式

• 如果方法无返回值，则调用该方法必须是一个语句，不能使用变量接收
• 如果方法具有返回值类型，返回一个值，通过变量接收，或者直接输出或调用

1、无返回值

public class Demo08 {
    public static void main(String[] args) {
        a1();
    }

    public static void a1(){
        System.out.println("我是一个没有返回值的方法");
    }
}

Tips：static为静态修饰符，想要在main方法中直接调用别的方法，被调用的方法需要进行静态修饰

2、有返回值

public class Demo08 {
    public static void main(String[] args) {
        System.out.println(a1());
    }

    public static String a1(){
        return "Hello World";
    }
}

Tips：static为静态修饰符，想要在main方法中直接调用别的方法，被调用的方法需要进行静态修饰

二、类型兼容

在调用方法的时候，形参与实参，接收类型与返回类型和返回值类型应该保持一致

• 形参→实参
• 接收类型>=返回值类型>=return类型

三、值传递

方法调用时实际参数把它的值传递给了对应的形式参数，可以说是把实际参数的值拷贝个了形式参数，这个过程称之为值传递。

应为是拷贝的，所以内存中存在两个相等的基本类型，即形式参数和实际参数，后面的操作都是对形参的修改，不涉及到实参，所以不影响实际参数的值。

四、传参时的类型转换

实参传给形参的时候，如果满足自动类型转换的条件则会发生自动类型转换

public class Demo12 {
    public static void main(String[] args) {
        a1(1,1);
    }

    public static void a1( int a, double b){
        System.out.println(a+b);
    }
}

运行结果

四、重载

一、场景

一般来说重载都使用在功能相同的方法中

例如：计算两个数的和(分别计算int类型的和double类型的)

这时候就可以使用重载来实现

public class Demo09 {
    public static void main(String[] args) {
        addNumber(1,1);
        addNumber(1.0,1.0);
    }

    public static void addNumber(int n, int m){
        System.out.println("int->"+(n+m));
    }
    public static void addNumber(double n, double m){
        System.out.println("double->"+(n+m));
    }
}

二、要求

使用重载必须满足以下要求

• 必须在同一个类
• 方法名必须相同
• 参数列表不同
  • 参数类型不同
  • 参数顺序不同
  • 参数个数不同

Tips：方法的返回值与重载无关

1、参数类型不同

public class Demo09 {
    public static void main(String[] args) {
        addNumber(1,1);
        addNumber(1.0,1.0);
    }

    public static void addNumber(int n, int m){
        System.out.println("int->"+(n+m));
    }
    public static void addNumber(double n, double m){
        System.out.println("double->"+(n+m));
    }
}

运行结果

2、参数顺序不同

public class Demo10 {
    public static void main(String[] args) {
        printNameAndAge(18,"张三");
        printNameAndAge("李四",20);
    }

    public static void printNameAndAge(int age, String name){
        System.out.println(age + "\t" + name);
    }
    public static void printNameAndAge(String name, int age){
        System.out.println(name + "\t" + age);
    }
}

运行结果

3、参数个数不同

public class Demo11 {
    public static void main(String[] args) {
        a1(1,2);
        a1(1,2,3);
    }

    public static void a1(int a,int b){
        System.out.println(a+b);
    }
    public static void a1(int a,int b,int c){
        System.out.println(a+b+c);
    }

}

运行结果

三、注意事项

1、返回值不同，无法构成重载

public class Demo12 {
    public static void main(String[] args) {
        a1();
        a1();
    }

    public static int a1(){
        return 0;
    }
    public static String a1(){
        return "0";
    }
}

运行结果

2、注意不要使用方法的滥用

public class Demo12 {
    public static void main(String[] args) {
        a1(1,1);
    }

    public static void a1( int a, double b){
        System.out.println(a+b);
    }
    public static void a1(double a, int b){
        System.out.println(a+b);
    }
}

运行结果

五、递归

一、定义

说白了就是自己调用自己

二、结构

递归结构分为两部分：

• 递归头
  • 停止递归的条件，如果没有递归头将会陷入死循环
• 递归体
  • 什么时候需要调用自己

三、缺陷

• 递归会消耗大量的系统栈堆，内存消耗多，递归的调用速度要比循环慢很多，用时需谨慎。

Tips：任何可以通过递归完成的操作，都可以使用循环迭代完成。

四、递归阶乘用例

public class Demo13 {
    public static void main(String[] args) {
        System.out.println(jc(10));
    }

    public static int jc(int i){
        if (i==1){
            return 1;
        }
        return i*jc(i-1);
    }
}

运行结果
3628800