一、Java正則表示式

正則表示式定義了字串的模式

正則表示式可以用來搜尋、編輯或處理文字

正則表示式並不僅限於某一種語言，但是在某種語言中有細微的差別

二、Java方法

System.out.println()

• println()是一個方法
• System是系統類
• out是標準輸出物件

方法的定義

修飾符 返回值型別 方法名(引數型別 引數名){
    ...
    方法體
    ...
    return 返回值;
}

方法呼叫

Java支援兩種呼叫方法的方式，根據方法是否返回值來選擇

當程式呼叫一個方法時，程式的的控制權交給了被呼叫的方法。當被呼叫方法的返回語句執行或者到達方法體閉括號時候交還控制權給程式。

當方法返回一個值的時候，方法呼叫通常被當作一個值。類比C

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; 
   }
}
 

方法的過載

如果你呼叫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]);
      }
   }
}

$ javac CommandLine.java 
$ java CommandLine this is a command line 200 -100
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

構造方法

當一個物件被建立時候，構造方法用來初始化該物件。構造方法和它所在類的名字相同，但構造方法沒有返回值。

通常會使用構造方法給一個類的例項變數賦初值，或者執行其他必要的步驟來建立一個完整的物件。

不管你是否定義構造方法，所有的類都有構造方法，因為Java自動提供了一個預設構造方法，它把所有成員初始化為0.

// 一個簡單的建構函式
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);
   }
}

以下是個例子

// 一個簡單的建構函式
class MyClass {
  int x;
 
  // 以下是建構函式
  MyClass(int i ) {
    x = i;
  }
}


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

可變引數

方法的可變引數的宣告如下

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()方法

它在物件被垃圾收集器析構（回收）之前呼叫，用來清楚回收物件。

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");  
  }  
}

$ javac FinalizationDemo.java 
$ java FinalizationDemo
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed