Function方法-java

Java 方法

System.out.println();

• println()是一個方法
• System是系統類
• out是標准輸出對象

• 什么是方法
• 方法定義
• 方法調用
• void 關鍵字
• 通過值傳遞參數
• 方法重載
• 變量作用域
• 命令行參數的使用
• 構造方法
• 可變參數
• finalize()方法

什么是方法

Java執行語句的合集，一起執行一個功能

• 解決一類問題的步驟的有序組合
• 包含於類或者對象中
• 在程序中被創建，在其他地方被引用

優點
1. 使程序簡短而清晰
2. 有利於程序維護
3. 可以提高程序開發效率
4. 提高代碼復用性
方法命名規則
1. 第一個單詞小寫開頭，從第二個單詞起，每個單詞的首字母大寫
2. 下划線可能出現在Junit測試方法中用於分割名稱的邏輯組件

方法定義

語法格式：

//修飾符 返回值類型 方法名 （參數類型 參數名）{
    執行的方法體

    //如果有返回值
    return 返回值；
}

• 修飾符：可選的，告訴編譯器如何調用該方法，定義該方法訪問類型
• 返回值類型：可能會有返回值，retrunValueType是方法方悔之的數據類型。有些方法執行所有的操作，但沒有返回值，這種情況下關鍵字為void。
• 方法名：方法的實際名稱
• 參數類型： 參數像是一個占位符
• 方法體：包含具體的語句定義該方法的功能

例如：public static int age(int day){....}
參數可以有很多個
static float interest(float principal,int year){....}

注意：在一些其他語言中方法制過程和函數。，一個返回非void類型的方法稱為函數，一個返回void類型返回值的方法叫過程。

示例

/** 返回兩個整型變量數據的較大值 */
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;

   return result; 
}

方法調用

 

---

Java 支持兩種調用方法的方式，根據方法是否返回值來選擇。
當程序調用一個方法時，程序的控制權交給了被調用的方法。當被調用方法的返回語句執行或者到達方法體閉括號時候交還控制權給程序。
當方法返回一個值的時候，方法調用通常被當做一個值。例如：
int larger = max(30,40);
如果方法返回值是void，方法調用一定是一條語句
System.out.print("helloworld!");
示例

public class TestMax {
   /** 主方法 */
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);
      System.out.println( i + " 和 " + j + " 比較，最大值是：" + k);
   }

   /** 返回兩個整數變量較大的值 */
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result; 
   }
}

 

這個程序包含 main 方法和 max 方法。main 方法是被 JVM 調用的，除此之外，main 方法和其它方法沒什么區別。
main 方法的頭部是不變的，如例子所示，帶修飾符 public 和 static,返回 void 類型值，方法名字是 main,此外帶個一個 String[] 類型參數。String[] 表明參數是字符串數組。

 

void 關鍵字

示例
public class TestVoidMethod {
  public static void main(String[] args) {
    printGrade(78.5);
  }

  public static void printGrade(double score) {
    if (score >= 90.0) {
       System.out.println('A');
    }
    else if (score >= 80.0) {
       System.out.println('B');
    }
    else if (score >= 70.0) {
       System.out.println('C');
    }
    else if (score >= 60.0) {
       System.out.println('D');
    }
    else {
       System.out.println('F');
    }
  }
}

 

通過值傳遞參數

 

---

調用一個方法時候需要提供參數，你必須按照參數列表指定的順序提供。

示例

public static void nPrintln(String message, int n) {
  for (int i = 0; i < n; i++) {
    System.out.println(message);
  }
}

 

示例:交換兩個變量的值

public class TestPassByValue {
    /** 交換兩個變量的方法 */
  public static void swap(int n1, int n2) {
    System.out.println("\t進入 swap 方法");
    System.out.println("\t\t交換前 n1 的值為：" + n1
                         + "，n2 的值：" + n2);
    // 交換 n1 與 n2的值
    int temp = n1;
    n1 = n2;
    n2 = temp;

    System.out.println("\t\t交換后 n1 的值為 " + n1
                         + "，n2 的值：" + n2);
  }
  public static void main(String[] args) {
    int num1 = 1;
    int num2 = 2;

    System.out.println("交換前 num1 的值為：" +
                        num1 + " ，num2 的值為：" + num2);

    // 調用swap方法
    swap(num1, num2);
    System.out.println("交換后 num1 的值為：" +
                       num1 + " ，num2 的值為：" + num2);
  }

}
 

 

方法重載

上面使用的max方法僅僅適用於int型數據。但如果你想得到兩個浮點類型數據的最大值呢？
解決方法是創建另一個有相同名字但參數不同的方法，如下面代碼所示：

 

public static double max(double num1, double num2) {
  if (num1 > num2)
    return num1;
  else
    return num2;
}

如果你調用max方法時傳遞的是int型參數，則 int型參數的max方法就會被調用；
如果傳遞的是double型參數，則double類型的max方法體會被調用，這叫做方法重載；
就是說一個類的兩個方法擁有相同的名字，但是有不同的參數列表。
Java編譯器根據方法簽名判斷哪個方法應該被調用。
方法重載可以讓程序更清晰易讀。執行密切相關任務的方法應該使用相同的名字。
重載的方法必須擁有不同的參數列表。你不能僅僅依據修飾符或者返回類型的不同來重載方法。

 

變量作用域

變量的范圍是程序中該變量可以被引用的部分。
方法內定義的變量被稱為局部變量。
局部變量的作用范圍從聲明開始，直到包含它的塊結束。
局部變量必須聲明才可以使用。
方法的參數范圍涵蓋整個方法。參數實際上是一個局部變量。
for循環的初始化部分聲明的變量，其作用范圍在整個循環。

你可以在一個方法里，不同的非嵌套塊中多次聲明一個具有相同的名稱局部變量，但你不能在嵌套塊內兩次聲明局部變量。

命令行參數的使用

有時候你希望運行一個程序時候再傳遞給它消息。這要靠傳遞命令行參數給main()函數實現。
命令行參數是在執行程序時候緊跟在程序名字后面的信息。
示例

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

構造方法

 

---

當一個對象被創建時候，構造方法用來初始化該對象。構造方法和它所在類的名字相同，但構造方法沒有返回值。
通常會使用構造方法給一個類的實例變量賦初值，或者執行其它必要的步驟來創建一個完整的對象。
不管你是否自定義構造方法，所有的類都有構造方法，因為Java自動提供了一個默認構造方法，默認構造方法的訪問修改符和類的訪問修改符相同(類為 public，構造函數也為 public；類改為 private，構造函數也改為 private)。
一旦你定義了自己的構造方法，默認構造方法就會失效。

示例

// 一個簡單的構造函數
class MyClass {
  int x;

  // 以下是構造函數
  MyClass() {
    x = 10;
  }
}

調用構造方法初始化對象

public class ConsDemo {
   public static void main(String args[]) {
      MyClass t1 = new MyClass();
      MyClass t2 = new MyClass();
      System.out.println(t1.x + " " + t2.x);
   }
}

可變參數

 

---

JDK 1.5 開始，Java支持傳遞同類型的可變參數給一個方法。
方法的可變參數的聲明如下所示：
typeName... parameterName

示例

public class VarargsDemo {
    public static void main(String args[]) {
        // 調用可變參數的方法
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    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 (numbers[i] >  result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is " + result);
    }
}

 

finalize()方法

Java 允許定義這樣的方法，它在對象被垃圾收集器析構(回收)之前調用，這個方法叫做 finalize( )，它用來清除回收對象。
例如，你可以使用 finalize() 來確保一個對象打開的文件被關閉了。
在 finalize() 方法里，你必須指定在對象銷毀時候要執行的操作。
finalize() 一般格式是：

 

protected void finalize()
{
   // 在這里終結代碼
}

關鍵字 protected 是一個限定符，它確保 finalize() 方法不會被該類以外的代碼調用。
當然，Java 的內存回收可以由 JVM 來自動完成。如果你手動使用，則可以使用上面的方法。

 

示例

public class FinalizationDemo {  
  public static void main(String[] args) {  
    Cake c1 = new Cake(1);  
    Cake c2 = new Cake(2);  
    Cake c3 = new Cake(3);  

    c2 = c3 = null;  
    System.gc(); //調用Java垃圾收集器
  }  
}  

class Cake extends Object {  
  private int id;  
  public Cake(int id) {  
    this.id = id;  
    System.out.println("Cake Object " + id + "is created");  
  }  

  protected void finalize() throws java.lang.Throwable {  
    super.finalize();  
    System.out.println("Cake Object " + id + "is disposed");  
  }  
}