Jave从零开始（day06）

方法

1. 方法的概念

方法的概念：一系列代码指令的集合，用于实现特定的功能，可以被反复调用。

2. 方法的定义

public static void 方法名称( ){
​ //方法主体
}

3. 方法的调用

在需要调用方法的位置，直接书写方法名() 即可

方法书写完毕以后，必须调用才会执行，我们可以通过debug模式观察方法调用执行的过程

/**
 *  方法的概念：一系列代码指令的集合，用于实现特定的功能，可以被反复调用。
 *  方法的调用：在需要调用方法的位置，直接书写方法名() 即可
 *  方法书写完毕以后，必须调用才会执行，我们可以通过debug模式观察方法调用执行的过程
 *  使用方法改进Test1
 *
 *
 */
public class Test2 {
    public static void main(String[] args) {
        System.out.println("床前明月光");

        printSign();

        System.out.println("疑是地上霜");

        printSign();

        System.out.println("举头望明月");

        printSign();

        System.out.println("低头思故乡");

        printSign();
    }

    public static void printSign(){
        for (int i = 0; i < 10; i++) {
            System.out.print("-");
        }
        System.out.println();
    }

}

4. 参数

多数情况下，方法与调用者之间需要数据的交互；调用者必须提供必要的数据，才能使方法完成相应的功能。

形参：是指在方法定义的时候书写的参数

形参规定了参数的个数、类型、顺序，要求调用者在调用方法时必须传入与形参相同

个数、类型以及顺序的实参

实参：实际参数 调用方法时传入的参数

4.1 单个参数

/**
 *  使用参数完善Test2 实现可以让用户灵活的指定横线的个数
 */
public class Test1 {
    public static void main(String[] args) {
        System.out.println("床前明月光");

        printSign(10); // 10即为实参 实际参数 调用方法时传入的参数

        System.out.println("疑是地上霜");

        int a = 5;

        printSign(a); // a即为实参实际参数 调用方法时传入的参数


        System.out.println("举头望明月");

        int b = 5;
        int c = 3;

        printSign(b + c); // b + c 最终的值为实参


        System.out.println("低头思故乡");

        int num = 7;

        printSign(num); // num为实参

    }

    /**
     *  形参：是指在方法定义的时候书写的参数
     *  形参规定了参数的个数、类型、顺序，要求调用者在调用方法时必须传入与形参相同
     *  个数、类型以及顺序的实参
     * @param num
     */
    public static void printSign(int num){
        for (int i = 0; i < num; i++) {
            System.out.print("-");
        }
        System.out.println();
    }


}

4.2 多个参数

我们可以使用多个参数完善com.atguigu.test3.Test1 实现可以让用户灵活的指定符号的类型 和 符号的个数

/**
 *  使用多个参数完善com.atguigu.test3.Test1 实现可以让用户灵活的指定符号的类型 和 符号的个数
 */
public class Test1 {
    public static void main(String[] args) {
        System.out.println("床前明月光");
        printSign(5,"&" ); // 5 和 “&” 属于实参

        System.out.println("疑是地上霜");
        int num = 6;
        String sign = "#";
        printSign(num,sign);

        System.out.println("举头望明月");

        printSign(8,"%");

        System.out.println("低头思故乡");

        printSign(9, "*");

    }

    public static void printSign(int num,String sign){
        for (int i = 0; i < num; i++) {
            System.out.print(sign);
        }
        System.out.println();
    }

}

5. 返回值和返回值类型

如果方法执行完毕以后，需要返回具体的数据，需要同return关键字来返回

1.方法定义的时候返回值类型 写为具体返回数据的类型(任何类型都可以写)

2.方法最终使用return关键字返回的数据 必须和方法声明时书写的类型保持一致

return关键字表示中断方法并且返回内容

/**
 *  返回值和返回值类型
 *
 *  编写方法实现两个数求和计算 在main方法中对最终的结果判断是偶数还是奇数
 *  return表示中断方法并且返回内容 所以return关键字之后不能写代码了
 *
 *  对于有返回值的方法(也就是返回值类型不为void)，有以下3种调用方式
 */
public class Test2 {
    public static int add(int a,int b){
        int result = a + b;
        return result;
    }

    public static void main(String[] args) {
        // 对于有返回值的方法(也就是返回值类型不为void)，有以下3种调用方式
        int sum = add(10,21); // 第一种 调用并且赋值

        System.out.println(add(5, 6)); //第二种 直接打印方法 相当于打印方法的返回值

        add(1, 3); // 第三种 直接调用

        // 我们要判断奇数还是偶数 最终的结果从哪来呢？

        if(sum % 2 == 0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }


}

6. return关键字的其他用法

1.return关键字在分支结构中使用，必须保证每一条分支都有正确的返回值返回

/**
 *  return关键字在分支结构中使用，必须保证每一条分支都有正确的返回值返回
 *  根据用户传入的数值判断奇数还是偶数
 */
public class Test1 {
    public static String isEven(int num){
        if(num % 2 == 0){
            return "偶数";
        }
        return "奇数";
    }

    public static boolean isEven1(int num){
        if(num % 2 == 0){
            return true;
        }
        return false;
    }



    public static void main(String[] args) {
        String result = isEven(12);
        System.out.println(result);


        System.out.println(isEven1(10) == true ? "偶数" : "奇数");
        System.out.println(isEven1(10) ? "偶数" : "奇数");

    }


}

在返回值类型为void的方法中 依然可以使用return 此时return关键字之后不能加任何内容

/**
 *  在返回值类型为void的方法中 依然可以使用return  此时return关键字之后不能加任何内容
 *  此时return只表示中断方法
 */
public class Test2 {

    public static void m1(){
        for (int i = 1;i <= 10;i++){
            if(i == 5){
                return; // break 注意此处break和return的区别  return表示中断方法 break中断循环
            }
            System.out.println(i);
        }
        System.out.println("m1方法执行完毕");
    }

    public static void main(String[] args) {
        m1();
    }


}

7. 方法重载

同一个类中，方法名相同，参数列表不同(参数的个数、类型、顺序)，即可称之为方法重载 overload

/**
 *  方法重载：同一个类中，方法名相同，参数列表不同(参数的个数、类型、顺序)，即可称之为方法重载  overload
 *  方法重载的优点：屏蔽使用差异，提高阅读性，扩展性
 *  编写一些方法实现多个数的加法计算
 */
public class Test1 {
    public static int add(int a ,int b){
        return a + b;
    }

    public static int add(String str,int a){
        return 0;
    }

    public static int add(int a,String str){
        return 1;
    }

//    public static int add(int c,int d){
//        return c + d;
//    }

    public static int add(int a,int b,int c){
        return a + b + c;
    }

    public static int add(int a,int b,int c,int d){
        return a + b + c + d;
    }

    public static int add(int a,int b,int c,int d,int e){
        return a + b + c + d + e;
    }

    public static void main(String[] args) {
        add(10, 20);
    }

}

8. 多级调用

方法与方法之间可以互相调用，直接书写方法名即可

/**
 *  多级调用
 */
public class Test1 {
    public static void main(String[] args) {
        m1();
    }

    public static void m1(){
        System.out.println("m1 method start");
        m2();
        System.out.println("m1 method end");
    }

    public static void m2() {
        System.out.println("m2 method start");

        System.out.println("m2 method end");
    }
}

9. 递归

递归：可以简单的理解为自己调自己

递归属于将一个复杂的问题拆分简单的各个小问题

递归的两个必要条件：

• 1.当前问题可以拆分为小的问题
• 2.必须有递归的出口(回归的条件)

/**
 *  递归：可以简单的理解为自己调自己
 *  递归属于将一个复杂的问题拆分简单的各个小问题
 *  递归的两个必要条件：
 *      1.当前问题可以拆分为小的问题
 *      2.必须有递归的出口(回归的条件)
 *
 *      赵四 ====》 广坤 ====》 大拿 ====》 刘能====》小宝
 */
public class Test2 {
    public static void m1(){
        m1();
    }

    public static void main(String[] args) {
//        m1();

        System.out.println(getNum5(5));

        System.out.println(getNum(6)); ;
    }


    public static int getNum(int num){
        if(num == 1){
            return 1;
        }
        return num + getNum(num -1);
    }

    // 求1~5 之间的和

    public static int getNum5(int num){
        return num + getNum4(num -1);
    }

    public static int getNum4(int num){
        return num + getNum3(num -1);
    }

    public static int getNum3(int num){
        return num + getNum2(num -1);
    }

    public static int getNum2(int num){
        return num + getNum1(num -1);
    }

    public static int getNum1(int num){
        return 1;
    }


}