Java語言學習（五）：面向對象入門

    接下來的博客，我將着重說下面向對象的編程思想，這個是Java編程開發的重點內容，對之後的開發有着深遠的影響，必須重視起來。在使用Java語言開發時，時刻要以面向對象的思想考慮問題，面向對象的基礎就是類。

    首先，說下類的定義，下面是類的通常定義模式：

    （1）任務：定義類

    （2）準備工做：類中存在的元素有成員變量和方法

    （3）編程：

    定義類，提供成員變量和方法：

public class Book {
	private String bookName;//定義書名
	private String author;//定義做者
	private double price;//定義價格
	//構造方法初始化
	public Book(String bookName,String author,double price){
		this.bookName = bookName;
		this.author = author;
		this.price = price;
	}
	public String getBookName(){
		return bookName;
	}
	public String getAuthor(){
		return author;
	}
	public double getPrice(){
		return price;
	}
}

    測試類，建立對象：

public class TestBook {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//建立對象
		Book book = new Book("Java語言學習","Yoki",66.66);
		//經過對象調用類的方法
		System.out.println("書名："+book.getBookName());
		System.out.println("做者："+book.getAuthor());
		System.out.println("價格："+book.getPrice());
	}

}

    （4）運行：輸出實例化類對象的信息

    注意：在Java中，使用class關鍵字來定義類。一個類一般包括域和方法兩部分，域表示對象的狀態，方法表示對象的行爲。使用new關鍵字建立類的對象。通常來講，變量在使用前須要對其進行初始化，Java中虛擬機會自動爲其初始化，像基本數據類型，好比 byte、int、long、float、char等，而像引用類型的變量，如String類型，在使用前須要進行初始化，不然會拋出null異常。除了成員變量，還有局部變量，使用前也需初始化。

    上面是通常的類的定義，還有種方式：單例模式

    （1）任務：單例模式

    （2）準備工做：單例模式的特色在於僅能得到一個對象，需將構造方法私有化，並提供一個靜態方法返回類的對象

    （3）編程：

/*
 * 單例模式
 */
public class Emperor {
	//聲明一個類的引用
	private static Emperor emperor = null;
	//將構造方法私有
	private Emperor(){}
	//實例化引用
	public static Emperor getInstance(){
		if(emperor == null)
			emperor = new Emperor();
		return emperor;
	}
	public void getName(){
		System.out.println("單例模式！！！");
	}
}

    測試類：

public class TestEmperor {
	public static void main(String[] args){
		Emperor e1 = Emperor.getInstance();
		e1.getName();
		Emperor e2 = Emperor.getInstance();
		e2.getName();
	}	
}

    （4）運行：輸出信息

    接着，咱們再經過漢諾塔的案例來進一步熟悉下：

    （1）任務：漢諾塔

    （2）準備工做：漢諾塔的思想：將N個盤子從A移到C，須要先將第N個盤子上面的N-1個盤子移到B上，這樣才能將第N個盤子移到C上，同理，爲了將第N-1個盤子從B移到C上，須要將N-2個盤子移到A上，這樣才能將第N-1個盤子移到C上。經過遞歸實現漢諾塔的求解。

    （3）編程：

import java.util.Scanner;

public class HanoiTower {
	public static void moveDish(int level,char from,char inter,char to){
		if(level == 1)
			System.out.println("從"+from+"移動盤子1到"+to);
		else{
			moveDish(level-1,from,to,inter);
			System.out.println("從"+from+"移動盤子"+level+"到"+to);
			moveDish(level-1,inter,from,to);
		}
	}
	public static void main(String[] args){
		System.out.println("請輸入漢諾塔的階數：");
		Scanner scan = new Scanner(System.in);
		try{
			int nDisks = scan.nextInt();		
			moveDish(nDisks,'A','B','C');
		}catch(Exception e){
			System.out.println("輸入不合法！");
		}
	}
}

    （4）運行：在控制檯輸入階數，輸出移動的操做步驟

    在方法的構造中，重載是對方法名過多的一種處理，當對象在調用方法時，能夠根據方法參數的不一樣肯定執行那個方法。方法參數的不一樣包括參數類型不一樣、參數個數不一樣、參數順序不一樣，即這些不一樣能構造出相同名稱的方法。構造方法是一種特殊類型的方法，聲明時，遵照一些規定：

    構造方法的名稱與類名相同；

    構造方法無返回值；

    構造方法老是與new操做符一塊兒使用；

    此外，在構造方法中，可使用this來調用其餘構造方法，使用super調用超類構造方法。

    對於類中的成員變量，大多經過公有public或者私有private的方式修飾。加入static修飾成員變量，則該變量時所用對象共享的，任何一個對象的修改會影響其餘對象。以下

public class Book{
    //定義一個計數器
    private static int counter = 0;
    public Book(String bookName){
        System.out.println("書名："+bookName);
        counter++;
    }
    public static int getCounter(){
        return counter;
    }
}

    在測試類中，利用書名數組建立對象：

public static void main(String[] args){
    String[] bookNames = {"Java語言學習","PHP語言學習","C語言學習"};
    for(int i=0;i<bookNames.length;i++){
        new Book(bookNames[i]);
    }
    System.out.println("計數器爲："+Book.getCounter());
}

    運行程序打印出計數器爲3，說明建立3次對象，計數器變量共享，才能疊加而不是從新從初始值0開始。

    Java中的類都是Object類的直接或間接子類。如在Object類中定義了equals()方法，toString()方法等，咱們也能夠重寫（加上@Override註解）該方法，使其符合咱們的使用要求，以下：

public class Book{
    private String bookName;
    private String author;
    
   @Override
    public String toString(){
        return "書名："+bookName+",做者："+author;
   }
}

    Java將內存空間分爲兩塊，即堆和棧，在棧中保存基本類型和引用變量，在堆中保存對象。對於基本類型可使用 「=」 來進行克隆，此時兩個變量沒有關聯關係；對於引用變量使用 「=」 進行克隆，將修改引用，此時兩個引用變量將指向同一個對象，則一個變量對其進行修改會改變另外一個變量。克隆又分爲淺克隆和深克隆，這裏不作介紹了。

    最後還有個序列化的問題，進行序列化的類須要實現Serializable接口，該接口無任何方法，僅是個標識接口。具體的使用有機會再說了。