Java 方法基础-优快云博客

Java 方法

1.什么是方法

Java 方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，即实现某个功能的语句块的集合。一个方法只能完成一个功能，这样有利于我们后期扩展。

2.方法的定义及调用

2.1 方法定义

Java 的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，一般情况下定义一个方法的格式如下：

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

修饰符：是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会返回值。
参数类型：参数像是一个占位符，当方法被调用时传递值给参数。

形式参数：在方法被调用时用于接收外界输入的数据。
实参：调用方法时实际传给方法的数据

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

public class Demo02 {
     
     public static void main(String[] args) {
         System.out.println( max(66,88));
     }
     
     //  比大小
     public static int max(int num1,int num2){
         int result ;
         if(num1 == num2){
             System.out.println("num1==num2");
             return 0;       // 终止方法
         }
         if(num1>num2){
             result=num1;
         }else{
             result=num2;
         }
         return result;
     }
 }

2.2 方法调用

调用方法：对象名.方法名(实参列表)
Java 支持两种调用方法的方式，根据方法是否返回值来选择。
- 当方法返回一个值的时候，方法调用通常被当作一个值。
```
 int larger = max(66,88);
```
- 若方法返回值是 void ，方法调用一定是一条语句
```
 System.out.println("吧啦吧啦吧啦");
```

2.3 值传递(Java)与引用传递

2.3.1 值传递

含义：在调用函数时，将实际参数的一个副本传递给函数的形式参数。
特点：
- 函数内部对形式参数的任何修改，都只影响这个副本，而不会影响原始的实际参数。
- 就像你给了同事一份文档的复印件，他在复印件上怎么涂改，都不会影响你手里的原件。

2.3.2 引用传递

含义：在调用函数时，将实际参数的引用（内存地址）本身传递给函数的形式参数。
特点：
- 函数内部对形式参数的操作，相当于直接对原始的实际参数进行操作。
- 就像你给了同事你家大门的钥匙，他可以用这把钥匙直接进入你家，移动家具、更换物品

//  情况1：传递基本数据类型（如 int, double, char 等）
 public class Test {
     public static void main(String[] args) {
         int a = 10;
         System.out.println("调用前 a = " + a); // 输出 10
         changeValue(a);
         System.out.println("调用后 a = " + a); // 输出 10，a 的值没有改变
     }
 
     public static void changeValue(int num) {
         num = 20; // 这里修改的是副本 num 的值，原始的 a 不受影响
     }
 }
 // 调用 changeValue(a) 时，传递的是变量a的值的副本（也就是 10）。在方法内部，将形参 num 改为 20，这只是修改了副本，原始变量 a 仍然是 10。

 // 案例2:传递引用数据类型（如对象、数组）
 class Person {
     String name;
     Person(String name) {
         this.name = name;
     }
 }
 public class Test {
     public static void main(String[] args) {
         Person myPerson = new Person("Alice");
         System.out.println("调用前 name = " + myPerson.name); // 输出 Alice
         changeName(myPerson);
         System.out.println("调用后 name = " + myPerson.name); // 输出 Bob！对象被修改了
     }
 
     public static void changeName(Person p) {
         p.name = "Bob"; // 这里通过引用的副本，修改了原始对象的属性
     }
 }
 /*
 1.myPerson 是一个引用变量，它存储的是对象在堆内存中的地址（比如 0x1234）。
 2.当调用 changeName(myPerson) 时，Java 进行值传递，传递的是 myPerson 这个引用变量里存储的地址值的副本（也就是 0x1234 这个值的副本）。
 3.现在，方法内的形参 p 和方法外的 myPerson 都指向了同一个对象（地址 0x1234）。
 4.所以，通过 p.name = "Bob" 去修改对象属性时，是真实地修改了堆内存中那个地址为 0x1234 的对象。
 5.方法调用结束后，myPerson 去访问这个对象，自然看到的是修改后的结果。
  */

3.方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数
方法重载的规则：
1. 方法名称必须相同
2. 参数列表必须不同(个数不同、或类型不同、或参数排列顺序不同等)。
3. 方法的返回类型可以相同也可不同。
4. 仅仅返回类型不同不足以成为方法的重载。
实现理论：
- 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配来选择对应的方法，若匹配失败则编译器报错。

4.命令行传参

当你希望运行一个程序时候再传递给它消息，此时要靠命令行参数给 mian() 函数实现。

 public class Demo03 {
     public static void main(String[] args) {
         // args.length 数组长度
         for(int i = 0;i<args.length;i++){
             System.out.println("args["+ i + "]:"+args[i]);
         }
     }
 }

5.可变参数

Java 支持传递同类型的可变参数给一个方法
在方法声明中，在指定参数类型后加一个省略号(...)
一个方法只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo04 {
     public static void main(String[] args) {
         printMax(66,88,22,44,55);            // 传递可变长参数(其本质也相当于数组)
 
         printMax(new double[]{6,2,8,4,10});  // 传递的是一个数组
     }
     public static void printMax(double... numbers){
         if(numbers.length==0){
             System.out.println("NO argument passed");
             return;
         }
         double result = numbers[0];
         // 排序！
         for(int i=1;i<numbers.length;i++){
             if(result<numbers[i]){
                 result = numbers[i];
             }
         }
         System.out.println("The max value is:"+ result);
     }
 }

6.递归

递归就是：自己调用自己！小数据时可用递归，数据量比较大时要避免使用递归。

递归结构包括两个部分：

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

// 递归思想  求阶乘
 public class Demo05 {
     public static void main(String[] args) {
         System.out.println(f(3));
     }
     // 1!=1
     // 2！=2*1
     // 3！=3*2*1
     public static int f(int n){
         if(n==1){
             return 1;
         }else{
             return n*f(n-1);
         }
     }
 }