Java方法

方法

什么是方法

Java方法是语句的集合，在一起实现一个功能

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

方法的设计原则：保持方法的原子性，一个方法只完成一个功能，利于后期拓展。

方法命名规则：小写开头+驼峰

方法的定义

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

• 修饰符

• 返回值类型：方法可能会有返回值

• 方法名

• 参数类型：

  • 形参

  • 实参

• 方法体：具体实现语句

• 返回值：return

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

方法调用

调用方法：对象名.方法名(实参列表)

Java支持两种调用方法的方式，根据方法是否返回值来选择：

• 当方法返回一个值时，方法调用常被当做一个值

  int larger = max(30,40)
  

• 如果返回值时void，方法调用是一条语句

  System.out.println();
  

Java都是值传递

• 静态方法：修饰符里加上 static

​ 可以直接 类名.方法名 使用

public class Student{
    public static void say(){};
}

pubilc class Smith{
    public static void main(){
        Student.say();
    }
}

• 非静态方法：修饰符中没有static

  需要实例化这个类再使用

public class Student{
    public  void say(){};
}

pubilc class Smith{
    public static void main(){
        Student smith = new Student();
        smith.say();
    }
}

静态方法是和类一起加载的，非静态方法在对象实例化时加载。

方法的重载

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

方法重载的规则：

• 方法名称必须相同

• 参数列表必须不同(个数不同、类型不同、参数排列顺序不同等)

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

• 只有返回类型不同不能成为方法的重载

public static int max(int a, int b) {
       if (a == b){
           System.out.println("相等");
           return 0;
       }else if (a > b){
           return a;
       }else {
           return b;
       }
   }


public static double max(double a, double b) {
       if (a == b){
           System.out.println("相等");
           return 0;
       }else if (a > b){
           return a;
       }else {
           return b;
       }
   }

实现原理：

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

可变参数

若不确定方法的参数数量 可在最后一个参数的类型后+...

public void test(int... i){
    for (int j = 0; j < i.length; j++) {
        System.out.println(i[j]);
    }
}

HelloWorld helloWorld = new HelloWorld();
        helloWorld.test(1,2,3,4); //调用方法1
        helloWorld.test(new int[]{11,22,33,44});//调用方法2

递归

A方法调用A方法，自己调用自己

• 把一个大型复杂的问题层层转换为一个与原问题相似的规模较小的问题来求解

递归结构包含两个部分：

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

• 递归体：什么时候调用自身方法

  //阶乘
  public static int jieChen(int a){
          if ( a == 1 ){
              return 1;
          }else {
              return a*jieChen(a-1);
          }
      }
  
  jieChen(4);
  

能不用递归就别用递归

作业：计算器

import java.util.Scanner;

/**
 * @version: java version 1.8
 * @Author: Mr Orange
 * @description:
 * @date: 2024-07-02 0:14
 */
public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num1 = 0;
        int num2 = 0;
        int flag = 0;
        String operator = "";
        System.out.print("请输入: ");
        while (true){
            if (scanner.hasNextInt()){
                if (flag == 0){
                    flag++;
                    num1 = scanner.nextInt();
                }else {
                    flag++;
                    num2 = scanner.nextInt();
                }
            }else {
                operator = scanner.next();
            }
            if (flag == 2){
                rusult(operator, num1, num2);
                flag = 0;
                System.out.print("请输入: ");
            }
        }

    }
    public static void rusult(String operator,int num1,int num2){
        int number = 0;
        switch (operator){
            case "+":
                number=add(num1,num2);
                System.out.println("结果为："+number);
                break;
            case "-":
                number=sub(num1,num2);
                System.out.println("结果为："+number);
                break;
            case "*":
                number=mul(num1,num2);
                System.out.println("结果为："+number);
                break;
            case "/":
                number=div(num1,num2);
                System.out.println("结果为："+number);
                break;
            default:
                break;
        }
    }
    public static int add(int a, int b) {
        return a + b;
    };
    public static int sub(int a, int b) {
        return a - b;
    };
    public static int mul(int a, int b) {
        return a * b;
    };
    public static int div(int a, int b) {
        return a / b;
    };

}