Java基础学习（四）

Java基础学习（四）：方法

目录

• Java基础学习（四）：方法
  • 定义
  • 调用
  • 参数传递
  • 重载
  • 命令行传参
  • 可变长参数
  • 递归

本文为个人学习记录，内容学习自 狂神说Java 和 黑马程序员

---

定义

方法的组成部分：

• 修饰符：可选，定义了访问类型
• 返回值类型： 没有返回值时为 void ，否则为具体返回值
• 方法名：方法的实际名称，应遵守驼峰原则
• 参数类型 参数名：可选，为形参
• 方法体：定义该方法的功能

修饰符 返回值类型 方法名(参数类型 参数名){
    // 方法体
    return 返回值;		// 结束方法，没有返回值时可不写
}

---

调用

方法的调用根据类型的不同可以分成两种：（这个和“类变量”-“实例变量”的区别一致）

• 静态方法：对于用 static 修饰的方法，可以直接在类内使用 方法名(实参)
• 非静态方法：对于没有用 static 修饰的方法，需要先声明对象再调用 对象名.方法名(实参)

下面根据类和方法的位置分开进行讨论：

1. 类调用自身的方法时：

   • 静态方法：

     public class Test {
         public static void main(String[] args) {
             say();											// 直接调用即可，也可以写成 Test.say();
         }
         public static void say(){							// 静态方法使用static修饰
             System.out.println("Hello");
         }
     }
     

   • 非静态方法：

     public class Test {
         public static void main(String[] args) {
             Test test = new Test();							// 需要先创建一个对象，再进行调用
             test.say();
         }
         public void say(){									// 非静态方法
             System.out.println("Hello");
         }
     }
     

2. 类调用其他类的方法时：

   • 静态方法

     package com.vitoria.oop;								// 包名
     import com.vitoria.oop.Demo02;							// 导入其他类，如果是在同一个包下可省略，此处就可省略
     
     public class Demo01 {
         public static void main(String[] args) {
             Demo02.say();									// 对于其他类中的静态方法，可以直接调用，但不能直接写成 say();
         }
     }
     

   • 非静态方法

     package com.vitoria.oop;								// 包名
     import com.vitoria.oop.Demo02;							// 导入其他类，如果是在同一个包下可省略，此处就可省略
     
     public class Demo01 {
         public static void main(String[] args) {
             Demo02 demo02 = new Demo02();					// 对于其他类中的非静态方法，需要先创建对应对象再调用
             demo02.say();
         }
     }
     

3. 本质：

   • 静态方法随着类一同加载，非静态方法随着对象一同加载

   • 静态方法只能调用静态方法

     虽然 main 函数作为程序的入口，但本质上也是一个静态方法 public static void main，因此其内部只能调用静态方法，若想调用非静态方法需要先创建对象

   • 非静态方法可以调用静态和非静态方法

     public void a(){
         b();												// 非静态方法可以调用非静态方法
         c();												// 非静态方法也可以调用静态方法
     }
     public void b(){}
     public static void c(){}
     

---

参数传递

1. 值传递

   public class Demo03 {
       public static void main(String[] args) {
           int a = 1;
           System.out.println(a);								// 输出为 1
           change(a);											// 传递的是基本类型的变量，是一种值传递
           System.out.println(a);								// 输出为 1
       }
       public static void change(int a){
           a = 10;
       }
   }
   

2. 引用传递

   public class Demo04 {
       public static void main(String[] args) {
           Person person  = new Person();
           System.out.println(person.name);					// 输出为 null
           change(person);										// 传递的是引用类型的变量，是一种引用传递，在内存分析中我们知道，引用类型的变量存储的其实是堆中的地址
           System.out.println(person.name);					// 输出为 victoria
       }
       public static void change(Person person){
           person.name = "victoria";
       }
   }
   
   class Person{
       String name;
   }
   

---

重载

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

重载的规则：

• 方法名称必须相同
• 参数列表必须不同（个数不同、或类型不同、或参数排列顺序不同等）
• 返回值类型可以相同也可以不同

---

命令行传参

示例：

package com.vitoria.method;											// 包名

public class Demo02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {						// length参数用于获取数组长度
            System.out.println("args[" + i + "]: " + args[i]);		// 逐个打印传递给main的参数
        }
    }
}

假设当前终端路径位于项目文件夹处，Demo02.java 文件位于 src\com\vitoria\method\Demo02.java

1. 编译：

   javac src\com\vitoria\method\Demo02.java
   

2. 运行：

   cd src															// 要执行包下的文件，必须先移动到src目录下
   java com.vitoria.method.Demo02 aaa bbb ccc						// aaa bbb ccc 是传递给main方法的参数
   

3. 输出结果：

   args[0]: aaa
   args[1]: bbb
   args[2]: ccc
   

---

可变长参数

• 在 JDK5 之后，支持传递同类型的可变长参数给一个方法
• 在方法的声明中，在指定参数类型后加一个省略号（...），表明该参数为可变长参数
• 一个方法中只能指定一个可变长参数，且它必须是该方法的最后一个参数
• 可变长参数的本质是一个数组

public class Demo03 {
    public static void main(String[] args) {
        test(1, 2, 3);
    }
    public static void test(int... i){				// 使用static修饰方法，这样才能在类内直接使用（这点和类变量一致）
        for (int j = 0; j < i.length; j++){			// 此处i是可变长参数，长度任意
            System.out.println(i[j]);
        }
    }
}

---

递归

• 定义：方法调用本身，称之为递归

• 优点：可以用简单的程序解决复杂的问题

• 缺点：递归次数多了容易导致栈溢出（内存不足），需要大量计算的场合应避免使用递归

• 示例：使用递归实现阶乘

  public class Demo04 {
      public static void main(String[] args) {
          int result = test(5);
          System.out.println(result);
      }
      public static int test(int x){
          if (x == 1){
              return 1;
          }else{
              return x * test(x-1);
          }
      }
  }