(五)方法概括

方法

方法的定义与调用

方法:就是编写有特定功能的一段代码,并且可以被重复调用.

格式:

• 修饰符:public,stasic等. static修饰的方法可以使用类名.方法名调用
• 返回值类型:看需求是否需要给调用者返回结果,void表示无返回值
• 方法名遵循标识符规则与规范
• 形式参数():有需要参数的可以在括号中定义,括号不能省略
• 实际参数:调用某一具体方法是,实际传递的值.

[修饰符] 返回值值类型 方法名(参数类型 参数名1,参数类型 参数名2,...){
     方法体;
    [return 返回值;]
}

注意事项:
    1.定义方法需要定义在类中
    2.一个类可以定义多个方法,方法与方法间是平行的,没有先后顺序

调用:

例子

//需求：定义求两个整数之和的方法
public class Demo09 {
    public static void main(String[] args) {

       //调用方法名
        getSum(10 , 5);

    }
    // 返回值类型类型void,所以没有返回值,一般打印都是没有返回值的
    public static void getSum(int a,int b){
        int c =a+b;
        System.out.println(c);
    }
}

方法的设计

例题:

需求1：定义一个方法，打印指定多少行的指定字符串

public class Demo10 {
    public static void main(String[] args) {
        //需求1：定义一个方法，打印指定多少行的指定字符串
        printStr(3, "小罗");
    }

    public static void printStr(int row,String str){
        for (int i = 1; i <=row ; i++) {
            System.out.println(str);
        }
    }
}

可变参数

可变参数是一种语法糖,简单来说就是在方法传递数组中一种更简便的方式

一般用…表示

格式:

[修饰符] 返回值类型 方法名称(参数类型 参数1,,,参数类型...参数名)
{
方法体;
[return 返回值;]
}

注意:

• 可变参数底层其实就是一个一维数组
• 可变参数,需要作为方法中最后一个参数,避免歧义
• 方法中最多只能有一个可变参数

普通数组传递:

public class Demo04 {
    public static void main(String[] args) {
        //需求:定义一个方法,传入两个参数,一个double数组表示多个商品的价格,一
        // 个double类型的折扣,返回商品总价格
        double[] arr={1,2,3,4,5};
        double result = totalPrice(0.5, arr);
        System.out.println( result);
    }
      //参数列表为  double discount ,double[] price             
    public static double totalPrice(double discount ,double[] price){
        double total = 0.0;
        for(double e:price){
            total +=e;
        }
        return  total* discount;
    }


}

使用可变参数:

public class Demo04 {
    public static void main(String[] args) {

        // 直接可以定义数组元素
        double re = totalPrice1(0.8, 1.0,2.0,3.0,4.0);
        System.out.println(re);
    }

    //使用可变参数定义
    public static double totalPrice1(double discount ,double...price1){
        double total = 0.0;
        for(double e:price1){
            total +=e;
        }
        return  total* discount;
    }
}

方法的重载(overload)

• 方法重载判断:

1. 同一类中,方法名相同
2. 方法参数列表不同(参数类型,参数个数,参数顺序)有其一不同就是参数列表不同

• 也可以根据方法签名判断是否重载

  1.方法签名:方法的名字和其他参数类型构成方法签名

​ 2.在同一类中,方法名字相同但签名不同的多个方法构成方法重载

• 注意:方法重载和返回值,方法修饰符无关

例子:

public class Demo05 {
    public static void main(String[] args) {
    }

    //个数不同
    //签名:add(int,int)
    public static int add(int a ,int b){
        return a+b;
    }

    //签名:add(int,int,int)
    public static int add(int a ,int b,int c){
        return a+b+c;
    }

    //类型不同
    //签名:add(double,double)
    public static double add(double a ,double b){
        return a+b;
    }

    //顺序不同
    //签名:add(double,int)
    public static double add(double a ,int b){
        return a+b;
    }
}

方法的值传递机制

值传递分为基本数据类型与引用数据类型

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

        int m =10; //一开始main方法中 m的值为10
        change(m);
        System.out.println(m);

     int[] arr = {1,2,3};
        change(arr);
        System.out.println(arr[0]);  //100
    }
    
    public static void change(int a ){
    //基本数据类型变化
        a=100;  
    }
    
    public static void change(int[] array){
    //引用数据类型变化
        array[0] =100;
    }
}

基本数据类型值传递内存图:

引用数据类型值传递内存图:

递归

方法自身调用自身的现象称为递归

递归的两个要素:

1. 递归停止的条件
2. 递归体

递归好处:让程序简单明了,好理解

缺点:递归占内存,递归没有结束,内存一直占用

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

        for (int i =1;i<=20;i++){
            System.out.println("i="+i+fb(i));
        }
    }

    //需求:输出费布拉切前20项 1 1 2 3 5 8 13 21
    public static long fb(int n ){
        //1.停止条件
        if(1 ==n ||2==n){
            return 1;
        }
        return fb(n-1)+fb(n-2);
    }
}

递归的使用场景和问题特征：
当解决一个问题时，可以分为多层步骤
外层解决问题的步骤和内层解决问题的步骤一样
外层问题依赖内层问题的解决
内层问题解决了，外层问题自然解决