方法

方法就是部分算法逻辑封装起来的代码块（也就是将一个功能封装起来），它可以被调用，也可以被其他方法调用。减少代码重复，便于维护。

方法的定义和调用

方法的定义有5个要素： 修饰词、返回值类型、方法名、参数列表和方法体。 如下：

备注：

• 方法的修饰词可以是 public、protected、private、static、final、abstract、synchronized、native、transient、volatile
  • 修饰词不是必须的，如果没有修饰词，默认是 public
  • 修饰词可以有多个
• 方法的参数列表可以是无参、一个参数、多个参数
  • 多个参数时，参数之间用逗号隔开
• 方法的返回值类型可以是 void、int、double、char、boolean、String、Object、数组类型、类型名称、接口名称
  • void 没有返回值，方法没有返回值，必需是 void
  • 有返回值则需要通过 return 语句返回值，注意：return 返回值类型要与方法的返回值类型一致
• 方法的调用
  • 不加 static 修饰符的方法，需要通过 new 创建实例对象来调用【后续】
  • 加了 static 修饰符的方法 可以使用 类.方法名 进行调用，不需要实例化
  • 同一个类中，方法忽略 类. ，直接写方法名，也可以通过实例对象调用

public static void main(String[] args) {
    /**
     * 调用 static 修饰的方法
     */
    // 1. 使用 类.方法名 调用
    Method.getSun(1, 2);
    // 2.如果在同一个类中可以忽略 类.
    int t = getSun(1, 2);
    System.out.println(t); //3
    /**
     * 调用非 static 修饰的方法
     */
    // 必需要实例化对象，才能调用方法，否则报错
    Method m = new Method();
    int t1 = m.getValue(1, 2);
    System.out.println(t1);
}

// 方法定义
public static int getSun(int a, int b) {
    // 方法体
    //返回值
    return a + b;
}

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

备注：

• public 修饰符是默认的，可以省略不写
• 关于方法传参
  • 如果有，则与定义的参数类型一致
• 关于 return
  • 如果方法没有返回值，那么 return 不能写，否则报错
  • 如果方法有返回值，那么 return 后面值类型与定义的返回值类型相同
  • return 后面的值，可以是表达式的值，也可以是变量值或者常量值

public static void main(String[] args) {
    getSumInt(1, 2);
    getSumDouble(1.0, 2.0);

    String name = "张三";
    getName(name);
    // 方法有返回值，那么接收返回值的变量类型必须和方法返回值类型一致
    int t = getValaue(1, 2);
    System.out.println(t);

    int[] scores = getScores();
    System.out.println(Arrays.toString(scores));
}

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

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

static void getName(String name) {
    System.out.println(name);
}

// 使用 return 语句返回值，注意：return 返回值类型要与方法的返回值类型一致
static int getValaue(int a, int b) {
    return a + b;
}

static int[] getScores() {
    int[] scores = {100, 200, 300};
    return scores;
//        return new int[]{100, 200, 300};
}

java 中为什么 main 方法要加 static 修饰？

public static void main(String[] args) {
    // ...
}

java 中的 main 方法理解为一个程序启动器，它是程序的入口，程序启动时，会自动先执行 main 方法，也就是是由JVM 调用的。 static 修饰的方法是静态方法是存储在 静态存储区内的，可以通过 类.方法名 直接进行调用，不需要进行实例化， 没有 static 修饰的方法是存储在 实例化对象 内的，需要进行 实例化 后才能调用，显然 main 作为程序的主入口不可能先实例化在调用， 所以 main 方法必须要 static 来修饰，是因为 main 方法是 Java 解释器调用的，那时候还没有任何对象产生。

备注：

• 实例化 就是 用 new 关键字创建一个对象的过程就是实例化。
• 不加 static 修饰符的方法，需要通过 new 创建实例对象来调用
• 加了 static 修饰符的方法 可以使用 类.方法名 进行调用，不需要实例化

public class Method {
    public static void main(String[] args) {
        /**
         * 调用 static 修饰的方法
         */
        // 直接调用方法
        int t = getSun(1, 2);
        // 类.方法名 调用
        Method.getSun(1, 2);
        System.out.println(t); //3
        /**
         * 调用非static 修饰的方法
         */
        // 必需要实例化对象，才能调用方法，否则报错
        Method m = new Method();
        int t1 = m.getValue(1, 2);
        System.out.println(t1);
    }

    public static int getSun(int a, int b) {
        // 方法体
        return a + b;
    }

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

递归方法

递归方法就是一个方法调用另外一个方法，而另外这个方法就是自己，说白了就是自己里面调自己，形成了一个递归结构，如下：

public static void main(String[] args) {
    m();
}
public static void m(){
    System.out.println("1");
    m();
    System.out.println("2");
}

会报栈内存溢出错误，Exception in thread "main" java.lang.StackOverflowError，JVM 退出程序

方法重载

什么是方法重载？方法重载（overload）是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。调用重载方法时， Java 编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数不同的方法。 调用方法时通过传递给它们的不同个数和类型的实参来决定具体使用哪个方法。

什么情况下使用方法重载？在同一个类当中，如果多个功能是相似的，可以考虑将它们的方法名定义的一致，使用方法重载机制，这样便于程序员的调用， 以及代码美观，但相反，如果两个方法所完成的功能完全不同，那么方法名也一定要不一样，这样才是合理的。

满足以下三个条件候构成方法重载：

• 在同一个类当中
• 方法名相同
• 参数列表不同：个数不同算不同，顺序不同算不同，类型不同也算不同

public static void main(String[] args) {
    // 普通写法，调用
    int s = getSunInt(1, 2);
    System.out.println(s);
    float s1 = getSunFloat(1.1f, 2.2f);
    System.out.println(s1);
    double s2 = getSunDouble(1.0, 2.0);
    System.out.println(s2);
    // 方法重载，调用
    int s3 = getSun(1,2);
    System.out.println(s3);
    float s4 = getSun(1.1f,2.2f);
    System.out.println(s4);
    double s5 = getSun(1.0,2.0);
}
// 普通写法 -------------------
public static int getSunInt(int a, int b) {
    return a + b;
}
public static float getSunFloat(float a, float b) {
    return a + b;
}
public static double getSunDouble(double a, double b) {
    return a + b;
}
// 方法重载 ---------------
public static int getSun(int a, int b) {
    return a + b;
}
public static float getSun(float a, float b) {
    return a + b;
}
public static double getSun(double a, double b) {
    return a + b;
}