JavaSE--方法

一、方法

1、方法的定义

// 语法格式
[修饰符列表] 返回值类型 方法名(形式参数列表){
    方法体；
    // return;终止当前方法
}

 

注意：方法写完之后需要调用去使用，不调用没法用

  1）修饰符列表：

    不是必选的

  2）返回值类型：

    可以是任何数据类型（基本数据类型和引用数据类型）

    返回值：一般是指一个方法执行结束之后的结果，通常返回一个数据，返回值实际给的是调用者

      当一个方法执行结束不返回任何值时，需要写void关键字，表示无返回值，但是也可以写return

  3）注意：

    如果返回值类型不是void，那么在方法执行结束后必须使用  return 值;  ，来完成值的返回
            如果没有return中编译器会报错，只要return执行，当前方法必然结束

  4）方法名

    方法名要见名知意，规则首字母消息，后面每个单词首字母大写

  5）形式参数列表：

    每一个参数都是局部变量，方法结束后内存释放

    个数：0-n个，使用逗号隔开  (int x,int y,double z,String s)

  6）可变长度参数列表：

    a）语法

// 类型后面三个点，一定是三个点
类型...

    b）概述

      b1.可变长度参数要求的参数个数是：0到N个。

      b2.可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个

      b3.可变长度参数可以当做一个数组来看待

public class ArgsTest {
    public static void main(String[] args) {
        m();
        m(10);
        m(10, 20);

        m2(100);
        m2(200, "abc");
        m2(200, "abc", "def");

        m3("ab", "de", "kk", "ff");

        String[] strs = {"a","b","c"};
        // 也可以传1个数组
        m3(strs);

    }

    public static void m(int... args){
        System.out.println("m方法执行了！");
    }

    // 报错
    //public static void m2(int... args2, String... args1){}

    // 必须在最后，只能有1个。
    public static void m2(int a, String... args1){

    }

    public static void m3(String... args){
        //args有length属性，说明args是一个数组！
        // 可以将可变长度参数当做一个数组来看。
        for(int i = 0; i < args.length; i++){
            System.out.println(args[i]);
        }
    }

}

  7）方法体

    方法体中编写业务逻辑代码，遵循自上而下的顺序执行，

    需要数据，数据来源就是形参

 

2、方法的调用

  压栈：方法只有在调用的时候才会在栈中分配空间，并且调用时就压栈

  弹栈：方法执行结束之后，该方法所在的空间就会释放，此时会发生弹栈

  方法调用叫做压栈，方法结束叫做弹栈

/*
    方法必须调用才能使用
    1、调用：
        类名.方法名(实际参数列表);
    2、实参和形参的数据类型必须一一对应
*/
public class MethodTest02{
    public static void main(String[] args){
        // 调用方法
        // (10,2)叫做实际参数列表 实参
        // 接收方法的返回值：使用变量来接收，
        // 也可以不接收，但是不接收没有意义啊
        int result = MethodTest02.divide(10,2);
        System.out.println(result);
        // 自动类型转换  可以
        double jieguo = MethodTest02.divide(10,2);
        // 注意：：对于没有返回值的方法，变量不可以接收
    }
    public static int divide(int x,int y){
        T.print();// 调用方法不一定非要在main方法中，不要把main方法特殊化
        return x / y;
    }
}
class T{
    public static void print(){
        System.out.println("hello");
    }
}

/*
    调用方法时，什么时候类名可以省略
    a方法调用b方法，a和b方法在同一个类的时候，“类名.”可以省略
    不在同一个类中的时候，不可以省略
*/
public class MethodTest04{
    public static void main(String[] args){
        MethodTest04.print();
        // “类名.”可以省略不写，因为在同一个类中
        print();
        // 跨类调用的时候不可以省略
        MyClass.print1();
    }
    public static void print(){
        System.out.println("hello");
    }
}
// 类2
class MyClass{
    public static void print1(){
        System.out.println("hello");
    }
    public static void print2(){
        System.out.println("hello");
    }
}

3、实际参数列表

/*
    实际参数列表
*/
public class MethodTest03{
    public static void main(String[] args){
        // 使用小容量
        byte b1 = 10;
        byte b2 = 20;
        // 把小容量传进去是可以的
        int result = MethodTest03.divide(10,20);
    }
    public static int divide(int x,int y){
        return x / y;
    }
}

4、break;和return;语句的区别

/*
    break终止最近的循环
    return终止当前方法
*/

public class MethodTest05{
    public static void main(String[] args){
        for(int i = 0;i < 10;i++){
            if(i == 5){
                // break;// 终止for循环
                return;// 终止当前方法，不是一个级别  也就是hello不会输出
            }
            System.out.println(i);
        }
        System.out.println("hello");
    }
}

 

二、方法的重载overload

1、方法重载机制：

  功能相似的，可以让方法名相同，更加易于代码的编写

  注意：重载不能随便用，如果两个功能压根不相干，之间根本没有关系，此时使用重载机制，会导致编码更麻烦。无法进行功能的区分

2、java语言中，怎么进行方法区分：

  首先java编译器会通过方法名进行区分，方法名相同下，会通过方法的参数类型区分

  注意：方法重载和方法的返回值类型以及修饰符无关

public calss OverloadTest01{
    public static void main(String[] args){
        System.out.println(sum(10,20));
        System.out.println(sum(10L,20L));
        System.out.println(sum(10.0,20.0));
    }
    // 计算int类型数据求和
    public static int sum(int a,int b){
        return a + b;
    }
    // 计算long类型数据求和
    public static long sum(long a,long b){
        return a + b;
    }
    // 计算double类型数据求和
    public static double sum(double a,double b){
        return a + b;
    }
}

3、什么时候代码发生重载

  条件1：在同一个类中

  条件2：方法名相同

  条件3：参数列表不同：参数的个数、类型、顺序不同都算不同

 

三、方法的递归

1、方法递归

  方法自己调用自己，就是方法递归

  当递归时，程序没有结束条件，一定会发生栈内存溢出错误

  所以 ：递归必须要有结束条件

public class RecursionTest01{
    public static void main(String[] args){
        doSome();
    }
    public static void doSome(){
        System.out.println("doSome");
    }
}