java方法

方法

一、方法的重载

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

方法重载的规则：

• 方法名称必须相同。
• 参数列表必须不同（个数不同、或者类型不同、参数排列顺序不同等）。
• 方法的返回类型可以相同也可以不同。
• 仅仅返回类型不同不足以成为方法的重载。

方法的重载可以让相同名称的函数，实现同一种类型的功能。

package method;

public class Demo2 {
    public static void main(String[] args) {
        int max1 = max(10,20);
        double max2 = max(10.0,20.0);
        //自动选择函数去执行
        System.out.println(max1);
        System.out.println(max2);
    }
    public static int max(int a ,int b)
    {
        int result =-1 ;
        if(a>b)
        {
            result = a;
        }
        else if (a<b)
        {
            result = b;
        }
        else
        {
            System.out.println("a=b");
            return 0;//程序中止，返回0.没有这句，返回result=-1.
        }
        return result;
    }


    //这个函数名称和上面一样
    //不同的是返回值类型、形参类型
    public static double max(double a ,double b)
    {
        double result =-1.0 ;
        if(a>b)
        {
            result = a;
        }
        else if (a<b)
        {
            result = b;
        }
        else
        {
            System.out.println("a=b");
            return 0;//程序中止，返回0.没有这句，返回result=-1.
        }
        return result;
    }
}

二、可变参数

由于有时候方法重载需要很多写很多函数，java支持传递同类型的可变参数给一个方法。

• 在方法声明中，在指定参数类型后加一个省略号（…），使用类似于数组。

• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

• package method;
  
  public class Demo3 {
      public static void main(String[] args) {
          System.out.println(  printMax(1.0,30.0,5.3,50.6)  );
          System.out.println(  printMax(new double[]{1,2,3})  );
      }
      public static double printMax(double...numbers)//numbers类似于一个数组
      {
          double result = 0.0;
          if (numbers.length == 0)
              System.out.println("no arguement passed ");
          result = numbers[0];
          for (int i = 0; i < numbers.length; i++)
          {
              if (numbers[i]>result)
                  result = numbers[i];
          }
          return result;
      }
  }
  
  

三、递归

A方法调用B方法，我们很容易理解！

递归就是：A方法调用A方法！自己调用自己。

递归结构包含两个部分：

• 递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
• 递归体：什么时候需要调用自身方法。

package method;

public class Demo4 {
    public static void main(String[] args) {
        System.out.println(f(5));
    }
    public static int f(int num)
    {
        if (num == 1)
            return 1;
        else return num*f(num-1);
    }
}

递归不要轻易使用，对内存要求较高，简单问题可以使用递归，复杂问题不建议使用。

四、一个例子

package method;

import java.util.Scanner;

public class Demo5 {
    public static void main(String[] args) {
        //设计一个计算器
        Scanner scanner = new Scanner(System.in);

        double num1  = scanner.nextDouble();
        String a = scanner.next();
        double num2  = scanner.nextDouble();

//        System.out.println("num1: "+ num1);
//        System.out.println("num2: "+ num2);
        System.out.println(caculator(a,num1,num2));

    }
    public static double caculator(String s, double... numbers)
    {
        double result = 0;
        switch (s)
        {
            case "+":
                result = numbers[0]+numbers[1];
                break;
            case "-" :
                result =  numbers[0]-numbers[1];
                break;
            case "*":
                result = numbers[0]*numbers[1];
                break;
            case "/":
                result = numbers[0]/numbers[1];
                break;
            default:
                System.out.println("符号输入错误！");
        }
        return  result;

    }
}