java之面向對象

1. 對象概念

什麼是面向對象

 1. 面向對象思想将客觀世界中的事物描述為對象，并通過抽象思維方法将需要解決的實際問題分解成人們易于了解的對象模型，然後通過這些對象模型來建構應用程式的功能

 2. 面向對象開發的一些概念: 類、對象、繼承、封裝、多态等

什麼是對象

 1. 一切客觀存在的事物都是對象,比如這輛汽車、這個人、這間房子、這張桌子、這株植物、這張支票、這件雨衣。 概括來說就是：萬物皆對象。

對象的組成

 1. 屬性（名字，性别，年齡）

 2. 行為（跑，跳，放技能，吃，罵人）

一個對象可以成為另一個對象的屬性

 1. 電動自行車和馬達，馬達是一個對象，電動自行車又是一個對象。

2. 什麼是類

2.1. 類是什麼？

類是對大量對象共性的抽象

類是客觀事物在人腦中的主觀反映

類是建立對象的模闆(在類裡建立對象)

2.2. 類由兩部分組成

屬性、對象

  例如學生類，凡是學生，都有學号、姓名、班級等，這些都是描述學生特征的，稱為學生類的屬性；凡是學生，都有回答問題、做實驗等行為

2.3. 類和對象的關系

類是一個族群，對象是族群中的個體

2.4. 程式執行個體

建立一個Person類

new相當于複制，每個new出來的對象都是獨立的建立的一個人類

在主函數中建立一個對象，并賦予屬性，然後調用方法

3. Java中類的定義及使用

定義一個類的文法

 類體由兩部分組成：成員變量、成員方法

成員變量的聲明

 成員方法的聲明:其實就是類似函數，隻不過叫法不同

類的使用

通過類建立一個對象

 1. 文法 類型 變量名 = new 類類型名();

 2. 如 Student stu = new Student(); Student是我們自己定義的類型

 3. new相當于複制，每個new出來的對象都是獨立的為對象的成員變量指派

 4. 文法：對象名.屬性名 = 屬性值

調用對象的成員方法

 1. 文法：對象名.方法ming(參數……)；

4. New建立類

該圖利用new建立的類，經過了向上轉型，本質是子類，但用的使用隻能當做父類用，不能通路子類中的屬性和方法

5. 對象與類

在一個類中可以調用其他類的對象

變量、方法傳回值、方法參數都可以是對象，萬物皆對象

6. 方法重載

重載(overloading)

 同一個類中定義了多個方法名相同而參數不同的方法

Person的類

主方法實作

7. 構造方法

Java語言通過類的構造方法建構對象，構造方法與普通方法的聲明類似，但是構造方法有一些特征：

 1. 構造器的名稱必須與類名相同。

 2. 構造器沒有傳回類型，包括關鍵字void也不能有。

 3. 任何類都含有構造器。如果沒有顯式地定義類的構造器，則系統會為該類提供一個預設的構造器。這個預設的構造器不含任何參數。一旦在類中顯式地定義了構造器，系統就不會再為這個類提供預設的構造器了。

 4. 不寫傳回值類型，傳回值是一個對象

 5. 構造方法隻有在被new的時候調用

Person類

main方法實作

構造方法的使用

 通過使用new運算符構造對象

構造方法除了用于執行個體化對象之外，可以通過構造方法為成員變量指派

8. 面向對象執行個體之飼養員喂食

8.1. 思路

可見我們需要建立飼養員類和動物類還有食物類

8.2. 實作

8.2.1. 飼養員

  看飼養員類中的方法傳入的參數，是一個動物類和一個食物類，可見這非常符合人類的思維方式，就這麼用就完了。

8.2.2. 動物類

8.2.3. 食物類

8.2.4. main方法

9. 類屬性和執行個體屬性

9.1. 什麼是類成員

使用static修飾的成員方法和成員變量稱為類成員

使用static修飾的成員變量叫做類變量

使用static修飾的成員方法叫做類方法

類成員是不依賴對象存在的，屬于類屬性，可以通過類直接對其進行通路。

所有的對象共享一個類成員。

9.2. 什麼是執行個體變量

未使用static修飾的成員方法和成員變量稱為執行個體成員

未使用static修飾的成員變量叫做執行個體變量

末使用static修飾的成員方法叫做執行個體方法

隻有每個對象才可以使用

9.3. 執行個體變量與類成員示意圖

  從這個圖中可以看出，每建立一個對象就複制一個類模闆，每個對象中的屬性互相獨立，但是使用static修飾的類成員，隻有一個，它不依賴對象，所有的對象偶可以通路他，即使沒有對象，也可以通過類進行通路。

9.4. 執行個體變量和類變量的差別

所有該類的對象共享同一個類變量，但是每個對象都會有自己獨特的執行個體變量

所有該類的對象都能改變類變量的值，隻要有一個對象改變類變量的值，所有對象通路類變量時，通路的值就是改變的值

執行個體變量在使用前必須建立一個對象，根據對象名.變量名使用，但是類變量可以不建立對象

9.5. static作用(靜态代碼塊)

靜态代碼塊

 1. 是一個以static為前導的代碼塊，一般用于為類的工作做一些初始化工作，如初始化一些靜态變量。

 2. 一個類中可以有許多靜态初始化塊，并且它們可以出現在類體的任何地方。運作時系統會保證靜态初始化塊會按照它們在源代碼中出現的順序被調用

執行順序

  靜态代碼塊随着類加載而加載，有多個靜态代碼塊的，按代碼塊前後順序加載，一個代碼塊，隻執行一次。

 1. 靜态代碼塊和main在一個類中，優先執行靜态代碼塊

 2. main方法寫在類的外邊，用new或調用都會導緻類被加載執行，并且隻執行1次，靜态代碼塊沒有被執行，Student類

靜态代碼塊被執行

9.6. static和final static

這兩個是不同的概念，final static是定義一個靜态的并且不能修改的變量。

10. 類方法和執行個體方法

10.1. 程式示範

10.2. 示意圖

10.3. 細節說明

  類方法:裡面可以使用靜态變量和類方法 但是不能使用執行個體屬性和執行個體方法，因為在方法被初始化的時候還并不存在執行個體，隻用建立對象後才有執行個體，具體看示意圖。

10.4. 類方法

使用static修飾（靜态方法），屬于整個類的，不是屬于某個執行個體的

  裡面可以使用靜态變量，也可以調用靜态方法，但是不能使用執行個體屬性(變量)或執行個體方法，因為還沒有執行個體(對象)存在

  一個類中的方法可以互相調用。但要注意：執行個體方法可以調用該類中的其他方法，例如，a()可以調用b()。類方法隻能調用其他類方法，不能調用執行個體方法。例如，name()隻能調用name1()而不能調用a()/b()。

  當類檔案加載到記憶體時，執行個體方法不會被配置設定記憶體空間，隻有在對象建立之後才會配置設定。而類方法在該類被加載到記憶體時就配置設定了相應的記憶體空間。

類方法隻能通路其他static方法。

類方法隻能通路其他static資料，類變量。

10.5. 執行個體方法

 1. 不用static修飾

 2. 執行個體方法既能對類變量操作也能對執行個體變量操作。

10.6. 調用

類名.方法名([參數])調用，可以不建立對象

執行個體方法使用對象名.方法名([參數])調用，必須建立對象調用類方法

10.7. 調用執行個體方法

11. this的使用

在類中如果局部變量和成員變量不重名，那直接寫成員變量名時，this. 被隐藏了,this表示目前的對象

用于一個類中局部變量和成員變量重名，this.變量名 = 成員變量

this是一種特殊的引用，指向目前對象

this的兩種使用方法

 1. 如果發生局部變量與成員變量命名沖突時，可以通過this.成員變量名的方式區分執行個體變量和局部變量

 2. 一個構造方法中需要調用同一個類的另一個構造方法，可以通過this()的方式調用，但this()必須要書寫在第一行

通過this.成員變量名調用隐藏的成員變量

this([參數清單])調用本一個類的另外一個構造方法

12. 封裝

封裝的概念

 封裝屬性/方法，使其隻能在類中使用，出了類就不可以通路

封裝的分類

 1. 對屬性的封裝：将屬性設定為private(私有)，限制其隻能在類的内部使用

 2. 對方法的封裝：對于方法的封裝，将外部可以通路方法設定為public,将外部不能通路的方法設定為private

快速生成set/get方法，右鍵/選擇如下

 1. 全選，也可以根據自己的要求進行選擇

 2. 生成效果

封裝屬性的使用方法

 name、age、sex都被封裝起來了，隻能用公開的方法，修改或擷取(類似函數，傳參數/或取傳回值)

封住之後的使用

13. 繼承

什麼是繼承

 1. 一個新類可以從現有的類派生，這樣的過程叫做繼承

 2. 那麼在繼承的過程中，新類被稱為子類，現有的類被稱為父類，子類将會繼承父類的屬性和行為。

繼承的文法

 [修飾符] class 子類類名 extends 父類類名{類體部分}

子類的擴充

 子類除了可以擁有父類非私有的屬性和方法外，也可以擴充自己的屬性和方法

繼承的使用細節

 1. Java中的繼承是單繼承，也就是一個類隻能有一個父類。

 2. 如果一個類沒有顯式的繼承某一個類，那麼它有一個預設的父類是java.lang.Object類

 3. Java繼承了父類非私有的成員變量和成員方法，但是請注意：子類是無法繼承父類的構造方法的

13.1. 通路修飾符

通路修飾符對成員變量和成員方法的通路限定

13.2. super關鍵字

super代表的是父類對象

super的使用方式

 1. super.屬性名 用于在子類中調用父類被隐藏的同名執行個體變量

 2. super([參數清單]) 用于在子類的構造方法中調用父類的構造方法

super.變量名的使用

super([參數清單])的使用

每一個子類的構造方法在沒有顯式調用super()，系統都會提供一個預設的super()

super() 書寫在第一行

可以在子類構造方法中顯式調用super(),完成對特定父類構造方法的調用

如果父類的構造方法中有帶參數的，那子類的構造方法至少有一個結構跟父類的相同

13.2.1. 注意事項

父類中的參數可以為父類類型

在通路時，可以進行如下操作

記住一句話，子類屬于父類，但父類不屬于子類，是以可以進行第11和13行操作

14. 重寫方法

重寫 override

  子類從父類繼承的某個執行個體方法無法滿足子類的功能需要時，需要在子類中對該執行個體方法進行重新實作，這樣的過程稱為重寫，也叫做覆寫。

方法重寫的要求

 1. 子類重寫方法的通路修飾範圍必須大于或者等于父類對應方法的通路修飾符範圍

 2. 除修飾符外，重寫方法的其他部分必須和父類保持一緻

15. 向上轉型與向下轉型

15.1. 向上轉型

15.1.1. 概述

有一個動物類（Animal），它有兩個子類Dog和Cat，有些時候我們想要一個對象，這個 對象可能是Dog也可能是Cat，這個時候我們可以這樣：

 1. 聲明一個動物a：Animal a ;

 2. 動物a是一隻貓：a=new Cat();

 3. 動物a是一條狗：a=new Dog();

 4. 這是用子類的執行個體指派給父類變量，這種情況稱為向上轉型。

向上轉型後，原來子類的屬性和方法不可以被使用，轉型後隻被當做父類使用

public class Test {  
  
	public static void main(String[] args) {  
		//Students1是Students 的子類  
		Students1 s = new Students1("1234","張山");  
		//向上轉型  
		Students s1 = (Students)s;  
		s.say();		//報錯，不可以通路子類屬性和方法  
		System.out.println(s1.code);	  
	}  
  
}  
public class Students1 extends Students{  
	String code1 = "12345";  
	String name;  
	public Students1(String code, String name) {  
		super(code, name);  
		System.out.println("OK");  
		// TODO Auto-generated constructor stub  
	}  
	public boolean say(Students s) {  
		//Students1 st = (Students1)s;  
		return code.equals(s.code);  
	}  
}  
  
public class Students{  
	String code;	//學生學号  
	private String name;	//學生姓名  
	public String getCode() {  
		return code;  
	}  
	public Students(String code , String name) {  
		this.code = code;  
		this.name = name;  
	}  
	public void setCode(String code) {  
		this.code = code;  
	}  
	public String getName() {  
		return name;  
	}  
	public void setName(String name) {  
		this.name = name;  
	}  
	  
	//equals預設判斷記憶體位址，有時不符合業務邏輯，需要重寫  
	public boolean equals(Object obj) {  
		Students s = (Students) obj;  
		return this.code.equals(s.code);  
	}  
}  
           

15.1.2. 向上轉型程式示意

15.1.3. 總結

  向上轉型，轉型後的對象完全當做父類使用，當子類和父類共有某個方法時，可以直接方法子類方法而父類的方法将會被屏蔽，但是當通路子類獨有的方法的時候，會報錯，不可以通路。

15.2. 向下轉型

15.2.1. 概述

把一個父類對象強制轉換為一個子對象

  就是一個狗通過向上轉型後，轉成動物類(父類)，此時這個動物是一個狗，當向下轉型後，狗就又變回了自己。

下圖為錯誤的寫法，應該寫成Dog c = (Dog)a;

  該圖解析:一個人說這條狗是一個動物(向上轉型)，另一個人說這個動物是一條狗(向下轉型)，如果說這個動物是個貓(大錯特錯)

  向下轉型後，不可以通路父類屬性和方法，隻被當做子類使用，向下轉型的前提是，經過向上轉型(圖1)，該圖中的第一條語句經過了向上轉型，本質是是Students1，但此時被當做Students，經過下面的向下轉型，還原到本質，當被用作子類使用時，可以通路父類的非私有屬性和方法(圖2)

圖1

圖2

15.2.2. 向下轉型程式示意

15.2.3. 總結

 1. 當被用作子類使用時，可以通路父類的非私有屬性和方法

 2. 子類通過向上轉型為父類時，用時是當父類用，但本質是子類，不可以通路子類中的屬性和方法，由于本質是子類，是以就可可通過向下轉型變為子類

 3. 當被用作子類時，可以通路父類的非私有屬性和方法

 4. 如果父類的本質還是父類(沒有經過向上轉型)，那隻能當做父類使用，不能向下轉型

 5. 向下轉型一定要類型比對，比如原先的動物是一條狗，你現在要向下轉型變成一隻貓，這是不符合邏輯的。

16. 多态

什麼是多态

 1. 多态顧名思義即為多種形态的意思

 2. Java中多态的含義：發送消息給某個對象，讓這個對象自行決定采用哪種行為響應這個消息

 3. 子類對象的引用指派給父類引用變量來實作動态的方法調用

Java中形成多态的前提

 1. 繼承

 2. 重寫

 3. 向上轉型

  當利用向上轉型時，利用動物對象a.eat()，如果相應子類中有該方法，則輸出該方法，沒有則輸出父類中的eat()方法

多态的作用

 1. 提高代碼的可重用性

 2. 降低子產品之間的耦合度：上面Cat、Dog、Animal類之間的關系不大

多态程式示例

17. 抽象類和抽象方法

  形狀類Shape需要提供用于計算面積和周長的方法，但是形狀本身沒有被确定，那麼計算周長和面積的方法就無法确定，此時我們就需要使用抽象類和抽象方法。

  由于Shape類計算周長和面積的方法無法确定，那麼就可以将這樣的方法聲明為抽象的，以便在具體的子類中進行實作。

抽象方法的聲明

 1. [修飾符] abstract 傳回值類型 方法名([參數清單]);

 2. 注意：因為抽象方法無法确定具體執行的功能，所有抽象方法沒有方法體，需要在小括号後加上分号

因為抽象類不是一個具體的類，是以無法執行個體化，但是抽象類可以用于聲明對象

抽象類可以被繼承，在子類中實作抽象類的所有抽象方法，以達到抽象類的具體化

具體化後的子類方法就可以用來建立對象了

第14行屬于向上轉型，不可以調用子類的屬性，可以調用抽象父類的子類方法(父類中的抽象方法)

18. 接口

  接口注重使用，給你一個接口你拿來用就行了，接口就是一種約定，一種标準化(比如插座的插口，國際标準插口)

Java與生活聯系非常緊密

  在軟體工程中，經常将一個大的項目分由不同的開發小組共同開發，各個小組的開發工作是并行的。在很多時候，對于不同小組的程式員來說，清楚地說明各自的軟體如何互相作用，并就此達成統一“約定”是很重要的。這種情況下，每一小組都可以在對其他小組怎麼編寫代碼一無所知的情況下，就能編寫自己的代碼，并且各自小組編寫的代碼能很好的協同工作。接口就是這樣的“約定”。

接口隻是一個設計，它不能直接使用，需要具體實作

接口中隻能有常量和抽象方法

18.1. 接口概述

1. 接口用來制定規範

2. 接口可以有很多種實作

     例如:USB接口，USB燈，USB風扇，USB滑鼠，USB鍵盤等等。

3. 接口可以用來聲明對象

     USB a= new USB風扇();

4. 接口是不具體的，不能用來直接建立對象
5. 接口是一種規範，是抽象的，就相當于一張設計圖，一份圖紙，不能直接建立對象，具體怎麼實作我不管。

在Java中接口不僅僅是程式開發過程中“約定”，更是更加抽象化的抽象類

18.2. 接口的定義

[修飾符] interface 接口名{[常量];[抽象方法]}

18.3. 接口的實作

定義類時通過implements關鍵字實作接口

[修飾符] class 類名 [extends 父類名] [implements 接口1,接口2,……]{類體部分}

18.4. 調用接口

18.5. 接口示意圖

18.6. USB接口練習

先設計USB接口規範

//定義USB規範    
public interface Usb {    
	public abstract void run();    
	public abstract void end();    
}  
           

然後各個廠商可以使用該USB接口規範，比如台燈廠商，使用USB接口規範

//台燈制作廠商    
public class Light implements Usb {    
    
	public void run() {    
		System.out.println("來風啦");    
	}    
    
	@Override    
	public void end() {    
		System.out.println("風停啦，歡迎使用本風扇");    
		    
	}    
    
}  
           

資料線生産商采用USB接口規範

//資料線生産商    
public class Wire implements Usb {    
    
	@Override    
	public void run() {    
		System.out.println("開始傳輸資料");    
	}    
	    
	@Override    
	public void end() {    
		System.out.println("資料傳輸停止");    
	}    
	    
}    
           

  在main方法中調用，先聲明一個USB裝置，因為以上這些實作了USB規範協定，是以都是USB裝置，可以建立一個USB裝置，然後讓這個裝置運作

public class Test {    
    
	public static void main(String[] args) {    
		Usb u;  //聲明一個USB裝置    
		u = new Wire(); //因為Wire實作了USB規範協定，是以Wire是USB裝置    
		    
		u.run();    
		u.end();    
	}    
}  
           

18.7. 多重繼承

一個類可以實作多個接口，一個類可以繼承多個接口，進而解決了Java單繼承的缺點。

public 和abstract預設添加上

 1. m1隻能實作接口MyInterface中的方法

 2. m2隻能實作接口MyInterface1中的方法

 3. m3能實作兩個接口中的方法

public interface MyInterface {  
    //設計一個标準，這個标準裡，有說話這個功能  
    public final static String name = "小李";  
    public abstract void say();   
}  
  
public interface MyInterface1 {  
      
    public abstract void eat();  
    //void eat();  
}  
  
public class Myclass implements MyInterface,MyInterface1{  
      
    public void say() {  
        System.out.println("實作接口MyInterface中方法");  
    }  
  
    @Override  
    public void eat() {  
		m2.eat();  
        //能說能吃  
        Myclass m3 = new Myclass();  
        m3.eat();  
        m3.say();  
    }  
  
}  
           

在Java中類之間的繼承關系是單繼承，也就是說一個類有且隻能有一個父類。

而Java中的接口實作了多繼承，也就是說一個接口可以有多個父接口

MyInterface接口繼承了MyInterface1接口，說明MyInterface接口包含了MyInterface1接口的所有内容

public interface MyInterface extends MyInterface1{  
    //設計一個标準，這個标準裡，有說話這個功能  
    //Java中的接口實作了多繼承，一個接口可以有多個父接口  
    public final static String name = "小李";  
    public abstract void say();   
}  
  
public interface MyInterface1 {  
      
    public abstract void eat();  
    //void eat();  
}  
  
public class Myclass implements MyInterface{  
      
    public void say() {  
        System.out.println("實作接口MyInterface中方法");  
    }  
  
    @Override  
    public void eat() {  
        System.out.println("不寫這個MyInterface1中的方法不行");  
    }  
      
}  
  
public class Test {  
    public static void main(String[] args) {  
        MyInterface m1 = new Myclass();  
        m1.say();  
        m1.eat();  
    }  
}  
           

接口的作用

 1. 提高程式的重用性

 2. 提高程式的可擴充性

 3. 降低程式的耦合度

沒有使用接口

使用接口

這段代碼的作用就是，我跟你要一個接口(第7行)，然後我使用這個接口(第11行，就是調用接口裡的方法)

  定義的接口隻是一個約定，告訴你這個接口有吃，說話的功能，而接口的子類，實作這個約定，在main方法裡，建立接口類的子類對象，在調用接口時，你必須把根據約定做好的東西(子類)給我，我才能使用這個接口的功能l.on()

實作了多繼承

19. 匿名内部類

匿名内部類

 一般用在隻想用一次，以後就不用了

内部類

 如果隻想在一小段範圍内使用幾次，使用内部類

public class Test {  
    public static void main(String[] args) {  
        /**  
         * 内部類，如果隻想在一小段範圍内使用幾次，使用内部類  
         * @author 最帥的我  
         *  
         */  
        class Xixi implements MyInterface{  
            public void eat() {  
                System.out.println("這是一個内部類");  
            }  
  
		    @Override  
            public void say() {  
                System.out.println("而且有名字");  
            }  
        }     
		/**  
         * 匿名内部類，用在隻想調用一次，以後就不用了  
         */  
        MyInterface m1 = new MyInterface() {  
            @Override  
            public void eat() {  
                System.out.println("這是一個匿名的内部類");  
            }  
            @Override  
            public void say() {  
                System.out.println("一次性");  
            }  
              
        };  
          
        //使用匿名内部類  
        m1.eat();  
        m1.say();  
        //使用有名字的内部類  
        MyInterface m2= new Xixi();  
        m2.eat();  
        m2.say();  
}	  
           

20. 包裝類

java.lang包下為8種基本資料類型提供對應的包裝類

8中基本資料類型以及對應的包裝類

包裝類作用

 包裝類提供了字元串、基本資料類型和包裝類互相轉化的方法

  數字基本資料類型的包裝類都繼承了Number類，它們的使用方式相似，下面以常用的基本資料類型int對應的包裝類Integer為例說明數字類型包裝類的使用

 1. 基本資料類型 int值轉化為Integer類型對象

int i = 20;  
Integer integer1 = new Integer(i);//方法一  
Integer integer2 = Integer.valueOf(i);//方法二  
           

 2. Integer對象轉化為基本資料類型int值

Integer integer = new Integer(20);  
int i1 = integer.intValue();  
           

 3. String類型的數字轉化為Integer對象

String s = “120”;  
Integer integer1 = new Integer(s);//方法一  
Integer integer2 = Integer.valueOf(s);//方法二  
           

 4. Integer類型轉化為String類型

Integer integer = new Integer(20);  
String s1 = integer.toString();  
           

 5. String類型的數字轉化為基本資料類型的int值

String s = “120”;  
int i1 = Integer.parseInt(s);//方法一  
Integer integer = new Integer(s);  
int i2 = Integer.intValue();//方法二  
           

 6. 基本資料類型int轉化為字元串

int i1 = 20;  
String str = String.valueOf(i1);//方法一  
str = Integer.toString(i2);//方法二  
           

boolean類型的包裝類Boolean：Boolean用于将一個基本資料類型boolean值包裝為對象

 1. 将boolean值轉換為Boolean對象

Boolean b1 = new Boolean(true);//方法一  
Boolean b2 = Boolean.valueOf(true);//方法二  
           

 2. 将Boolean對象轉換為boolean值

Boolean b =  new Boolean(true);  
boolean b1 = b.booleanValue();//方法一   
           

Integer的equals方法

 1. Integer的equals方法繼承自Object，并且進行了重寫

 2. Integer的equals方法隻有一種情況傳回true：兩個Integer類型的對象 i1 和 i2包含的值相等時；其他情況傳回false

 比如：

Integer i1 = new Integer(20);  
Integer i2 = new Integer(30);  
Integer i3 = new Integer(20);  
boolean  b = i1.equals(i2);//false  
b = i1.equals(i3);//true  
           

包裝類中的toString方法重寫過

  不是什麼類型資料都可以轉換為包裝類，比如布爾型資料類型轉換為整型包裝類是不可以的，必須同類型包裝。

 1. 特殊情況，整型資料轉為長整型資料,這是可以的，下面代碼中雖然括号中要求填長整型資料，但是java中預設将整型資料轉換為長整型資料，小可以轉大，大不可以轉小。

int m =335;  
Long l = Long.valueOf(m);  
           

再說包裝類

 1. 字元串轉doubel，第一種方法Double包裝類中有一個parseDouble方法可以将字元串轉為Double包裝類，該方法會傳回Double包裝類資料，同類型包裝之間預設自動轉換(其他類似)。

//字元串轉double  
String s1 = "12.3456";  
Double d1 = Double.parseDouble(s1);   
Double d2 = Double.valueOf(s1);  
Double d3 = new Double(s1);  
double d4 = d1;  
System.out.println(d4);  
  
//double轉字元串  
double d5 = 3.14159;  
String d6 = Double.valueOf(d5).toString();  
String d7 = Double.toString(d5);  
String d8 = new Double(d5).toString();  
String d9 = "" + d5;  
System.out.println(d6);