Java方法详解

Java方法详解

跟着狂神学Java的第三天_{今天也要好好加油}

再小的帆也能远航！

什么是方法

Java方法是语句的集合，它们在一起执行一个功能。

• 方法是解决一类问题的步骤的有序组合
• 方法包含于类或对象中
• 方法在程序中被创建，在其他地方被调用

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于后期的扩展。

方法的命名规则：首字母小写+驼峰命名

方法的定义和调用

Java的方法类似于其他语言的函数，一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：

方法包含一个方法头和一个方法体。

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

• 修饰符：可选，定义了该方法的访问类型（如public，static等）

• 返回值类型：方法可能会返回值，根据需要返回的数据类型决定返回值类型。例如需要返回整数可以用int，不需要返回值使用void

• 方法名：方法的实际名称。方法名和参数表共同构成方法签名。

• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包括任何参数。

  ​ 形式参数：在方法被调用时用于接收外界输入的数据

  ​ 实参：调用方法时实际传递给方法的数据

• 方法体：包含具体的语句，定义该方法的功能。

  eg：

  //这是需要返回值的方法
  //	修饰符		返回值类型 方法名 形式参数
  public static 	int  max(int a,int b){
      //方法体
      int maxNum;
      if(a>b) maxNum=a;
      else maxNum=b;
      return maxNum;//返回值
  }
  
  //这是不需要返回值的方法
  //	修饰符		返回值类型 方法名 形式参数(不需要就不写)
  public static 	void  sayHello(){
      //方法体
      System.out.println("Hello");
  }
  

方法的重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载规则：

• 方法名必须相同

• 参数列表必须不同（个数不同或类型不同、参数的排列顺序不同等）

• 方法的返回类型可以相同也可以不同

• 仅仅返回类型不同不足以成为方法的重载

实现理论：

​ 方法名称相同时，编译器会根据调用方法的参数个数，参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

eg：

public class Demo01 {
    public static void main(String[] args) {
        int sum1=add(1,2);	//调用第一个
        double sum2=add(1.0,2.0);	//调用第二个
        int sum3=add(1,2,3);	//调用第三个
        System.out.println("sum1="+sum1+" sum2="+sum2+" sum3="+sum3);//sum1=3 sum2=3.0 sum3=6
    }
    public static int add(int a,int b){//最原始的add，两个整数相加，返回值为int类型
        return a+b;
    }
    public static  double add(double a,double b){//重载add，变成两个double类型相加，返回值为double类型
        return a+b;
    }
    public static int add(int a,int b,int c){//重载add，变成三个int类型相加，返回值为int类型
        return a+b+c;
    }
}

可变参数

在上面两个数的add方法里面，实现了三个数的add方法重载，那如果四个，五个，六个....n个数呢？重载也会很麻烦。而可变参数可以传递无限多个参数。

怎么声明可变参数？在指定参数类型后面加一个省略号(...)

一个方法中只能声明一个可变参数，并且必须是方法的最后一个参数，任何普通的参数必须放在它前面声明。

eg：

public class Demo03 {
    public static void main(String[] args) {
        int a=add(1,2);
        int b=add(1,2,3,4,5);
        int c=add(1,2,3,4,5,6,7,8,9,10);
        System.out.println("a="+a);
        System.out.println("b="+b);
        System.out.println("c="+c);
    }
    
    public static int add(int ...a){//a是可变参数
        if(a.length==0){//a.length访问可变参数a的长度(有几个参数)
            System.out.println("没有传递任何参数");
            return 0;
        }
        int sum = 0;
        for (int i = 0; i <a.length ; i++) {
            sum += a[i];//把每个都加起来
        }
        return sum;
    }
}

输出结果为：

递归

方法自己调用自己。为什么会自己调用自己呢？一个方法可以用来解决某一类问题，当你在解决问题的时候，碰到了同类型的规模更小的问题的时候，就可以用解决大问题的方法来解决小问题了，即自己调用自己了。举个例子，你要写10张卷子，写完一张后面临的问题是写9张卷子，那写9张卷子就是相当于写10张卷子的同类型规模更小的问题了，你写10张怎么写的，写9张一样怎么写。

递归的两个基本条件：

• 递归边界：到什么时候不再调用自己；
• 递归调用自己的同时向边界靠拢。

打个可能不太恰当的比喻：教导主任交给学生会主席一个任务，学生会主席又分配给几个副主席去做，等副主席做完了他再整理一下就行了；副主席也是一样的想法，于是他们又把任务分配给各个部长去做；巧了，部长也是这么想的，于是又交给了副部长；副部长一样的，又交给了各小组长；小组长也不想干，就给了组员，组员怎么办？没人分配了，只能自己干咯。所以组员就相当于是递归的边界，从学生会主席到组员的任务依次分配传递过程就相当于是递归，自己调用自己。
eg：

public class Demo04 {
    public static void main(String[] args) {
        int ans=f(5);
        System.out.println(ans);
        int res=Fibonacci(10);
        System.out.println(res);
    }
    public static int f(int n){//求阶乘的递归方法
        //n!=n*(n-1)! n-1的阶乘是n的阶乘的同类型问题
        if(n==1) return 1;//边界
        return n*f(n-1);//调用自己向边界靠拢
    }
    public static int Fibonacci(int n){
        //F(n)=F(n-1)+F(n-2) 求第n-1和n-2个F值是求第n个F值的同类型问题
        if(n==1||n==2) return 1;//边界
        return Fibonacci(n-1)+Fibonacci(n-2);//调用自己向边界靠拢
    }
}

​ 运用递归的关键在于怎么把大问题转化为同类型规模更小的子问题。但是递归也有缺陷，多次调用函数，会堆栈，占用大量栈空间，影响速度，所以它并不是一个很好的算法，小规模可以递归，大规模尽量寻找其他算法代替。