第3節(jié) 面向?qū)ο蟾呒?/h1>

一、繼承

1.1 概述和使用

繼承是java面向?qū)ο缶幊碳夹g(shù)的一塊基石，因為它允許創(chuàng)建分等級層次的類。繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

格式如下所述：

class 父類 { }class 子類 extends 父類 { }

繼承的限制：Java中只有單繼承，多重繼承，沒有多繼承。

看下面的例子：

package com.kaikeba.objectoriented.senior;public class inherit2 {public static void main(String[] args) {Student2 s = new Student2();s.setName("張三");s.setAge(18);s.say();} }class Person2 {private String name;private int age;public String sex;public Person2() {}public Person2(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void say() {System.out.println("我是："+name+"，我今年"+age+"歲了");} }class Student2 extends Person2 { }

結(jié)果如下：

我是：張三，我今年18歲了

子類繼承父類后，可以使用父類的屬性和方法（public和protected修飾的）。

1.2 子類實例化內(nèi)存分析

Student s = new Student()內(nèi)部的創(chuàng)建過程：

1、先查看Student是否有父，若有，先在堆內(nèi)存中創(chuàng)建一個父對象的空間，再創(chuàng)建一個Student對象空間，同時super指向父類對象，可以找到父對象。

2、s.setName("張三");若發(fā)現(xiàn)Student類中沒有setName方法，就會使用Person的setName，并將name賦值到Person對象中，若有就用自己的，這個后面說。

補充： 父類中只有用public和protected修飾符修飾的屬性和方法才可以被子類使用，比如Student對象無法使用Person私有的屬性，但是可以通過set和get來操作屬性。

1.3 super關(guān)鍵字

this表示當(dāng)前對象：

????- this.屬性 區(qū)別成員變量和局部變量

????- this.() 調(diào)用本類的某個方法

????- this() 表示調(diào)用本類構(gòu)造方法，只能用在構(gòu)造方法的第一行語句。

????- this關(guān)鍵字只能出現(xiàn)在非static修飾的代碼中

super表示父類對象：

????- super.屬性 表示父類對象中的成員變量

????- super.方法()表示父類對象中定義的方法

????- super() 表示調(diào)用父類構(gòu)造方法

????????可以指定參數(shù)，比如super("Tom",23);

????????任何一個構(gòu)造方法的第一行默認(rèn)是super();

????????可以寫上，如果未寫，會隱式調(diào)用super();

????- super()只能在構(gòu)造方法的第一行使用。

????- this()和super()都只能在構(gòu)造的第一行出現(xiàn)，所以只能選擇其一。寫了this()就不會隱式調(diào)用super()。

super調(diào)用父類構(gòu)造方法，必須滿足父類中有對應(yīng)的構(gòu)造方法，見下述代碼：

package com.kaikeba.objectoriented.senior;public class inherit2 {public static void main(String[] args) {Student2 s = new Student2();s.say();} }class Person2 {private String name;private int age;public String sex;public Person2() {}public Person2(String name, int age) {this.name = name;this.age = age;}public void say() {System.out.println("我是："+name+"，我今年"+age+"歲了，性別："+sex);} }class Student2 extends Person2 {public Student2() {//super調(diào)用了父類的全參構(gòu)造方法super("無名稱", 1);super.sex = "男";} }

結(jié)果如下：

我是：無名稱，我今年1歲了，性別：男

1.4 重寫（Override）與重載（Overload）

子類中可能需要對父類的一些方法進(jìn)行修改，這就是重寫的概念：

重寫（override）規(guī)則：

• 1.參數(shù)列表必須完全與被重寫方法的相同；

• 2.返回類型必須完全與被重寫方法的返回類型相同；

• 3.訪問權(quán)限不能比父類中被重寫的方法的訪問權(quán)限更低。例如：如果父類的一個方法被聲明為public，那么在子類中重寫該方法就不能聲明為protected；

• 4.父類的成員方法只能被它的子類重寫。

• 5.聲明為static和private的方法不能被重寫，但是能夠被再次聲明。

package com.kaikeba.objectoriented.senior;public class override {public static void main(String[] args) {Student3 s = new Student3();s.say();} }class Person3 {//父類方法public void say() {System.out.println("鋤禾日當(dāng)午");} }class Student3 extends Person3 {//子類對父類方法的重寫public void say() {System.out.println("參數(shù)列表 與 返回值類型 必須相同");}// void say() { // System.out.println("權(quán)限修飾符級別不能更低"); // } }

面試中可能會考察重載（Overload）與重寫（Override）的區(qū)別：

1. 發(fā)生的位置：

????1. 重載：一個類中

????2. 重寫：子類對父類方法進(jìn)行重寫

2. 參數(shù)列表規(guī)則：

????1. 重載：必須不同（長度，類型，順序不同均可）

????2. 重寫：必須相同

3. 返回值類型：

????1. 重載：與返回值類型無關(guān)

????2. 重寫：返回值類型必須一致

4. 訪問權(quán)限：

????1. 重載：與訪問權(quán)限無關(guān)

????2. 重寫：子類的方法權(quán)限必須高于等于父類的方法權(quán)限

5. 異常處理：

????1. 重載：與異常無關(guān)

????2. 重寫：異常范圍可以更小，但是不能拋出新的異常

二、final關(guān)鍵字

final關(guān)鍵字用于修飾屬性、變量：

????變量成為常量，無法對其再次進(jìn)行賦值；

????final修飾的局部變量只能賦值一次（可以先聲明后賦值）；

????final修飾的成員屬性，必須在聲明時賦值。

public class finalkeyword {final int a = 10; //成員屬性public static void main(String[] args) {final int a = 10; //局部變量} }

????全局常量（public static final）

????????常量的命名規(guī)則：

????????????由一個或多個單詞組成，單詞與單詞之間必須使用下劃線隔開，單詞中所有字母大寫，例如：SQL_INSERT。

final用于修飾類：

????final修飾的類，不可以被繼承。

final用于修飾方法：

????final修飾的方法，不可以被子類重寫。

三、抽象類

3.1 概念

抽象類必須使用abstract class聲明；

格式：

abstract class 類名{ //抽象類 }

3.2 抽象方法

只聲明而未實現(xiàn)的方法稱為抽象方法（未實現(xiàn)指的是：沒有"{}"方法體 ），抽象方法必須使用abstract關(guān)鍵字聲明。

格式：

abstract class 類名 { //抽象類public abstract void 方法名(); //抽象方法，只聲明而未實現(xiàn) }

一個抽象類中可以沒有抽象方法，抽象方法必須寫在抽象類或者接口中。

3.3 幾個原則

抽象類本身是不能直接進(jìn)行實例化操作的，即：不能直接使用關(guān)鍵字new完成；

一個抽象類必須被子類所繼承，被繼承的子類（如果不是抽象類）則必須覆寫抽象類中的全部抽象方法。

3.4 常見問題

抽象類能否使用final聲明？

????不能，因為final修飾的類是不能被子類繼承的，而抽象類必須有子類才有意義，所以不能。

抽象類是否有構(gòu)造方法？

????能有構(gòu)造方法，而且子類對象實例化的時候的流程與普通類的繼承是一樣的，都是要先調(diào)用父類中的構(gòu)造方法（默認(rèn)是無參的），之后再調(diào)用子類自己的構(gòu)造方法。

????

3.5 抽象類與普通類的區(qū)別

抽象類必須用public或protected修飾（如果為private修飾，那么子類無法繼承，也就無法實現(xiàn)其抽象方法），默認(rèn)缺省為public。

抽象類不可以使用new關(guān)鍵字創(chuàng)建對象，但是在子類創(chuàng)建對象時，抽象父類也會被JVM實例化。

如果一個子類繼承抽象類，那么必須實現(xiàn)其所有的抽象方法。如果有未實現(xiàn)的抽象方法，那么子類也必須定義為abstract類。

四、接口

4.1 概念

如果一個類中全部方法都是抽象方法，全部屬性都是全局常量，那么此時就可以將這個類定義成一個接口。

定義格式：

interface 接口名稱{全局常量;抽象方法； }

接口的抽象程度更高，后續(xù)項目中使用的也比抽象類更多一些。

4.2 面向接口編程思想

這種思想是定義（規(guī)范，約束）與實現(xiàn)（名實分離原則）的分離。從整體的角度先構(gòu)思好接口，然后再去具體實現(xiàn)它。

優(yōu)點：

降低程序的耦合性；

易于程序的擴展；

有利于程序的維護(hù)。

4.3 全局常量和抽象方法的簡寫

因為接口本身都是由全局常量和抽象方法組成的，所以接口中的成員定義可以簡寫：

全局常量編寫時，可以省略public static final關(guān)鍵字，例如：

public static final String INFO = "內(nèi)容" ; 簡寫后： String INFO = "內(nèi)容" ;

抽象方法編寫時，可以省略public abstract關(guān)鍵字，例如：

public abstract void print() ; 簡寫后： void print() ;

4.4 接口的 實現(xiàn)implements 與 繼承extends

接口可以多實現(xiàn)： 格式：class 子類 implements 父接口1,父接口2...{} 以上的代碼稱為接口的實現(xiàn)。那么如果一個類即要實現(xiàn)接口，又要繼承抽象類的話，則按照以下的格式編寫即可：class 子類 extends 父類 implements 父接口1,父接口2...{} 接口因為都是抽象部分， 不存在具體的實現(xiàn)， 所以允許多繼承,例如：interface C extends A,B{}

實現(xiàn)后的接口是一個類，繼承后的接口還是一個接口。

注意： 如果一個接口想要使用，必須依靠子類。子類（如果不是抽象類的話）要實現(xiàn)接口中的所有抽象方法。

4.5 接口和抽象類的區(qū)別

抽象類要被子類繼承，接口要被類實現(xiàn)；

接口只能聲明抽象方法，抽象類中可以聲明抽象方法，也可以寫非抽象方法；

接口里定義的變量只能是公共的靜態(tài)的常量，抽象類中的變量是普通變量；

抽象類使用繼承來使用，無法多繼承；接口使用實現(xiàn)來使用，可以多實現(xiàn)；

抽象類中可以包含static方法，但是接口中不允許（靜態(tài)方法不能被子類重寫，因此接口不能聲明靜態(tài)方法） ；

接口不能有構(gòu)造方法，但是抽象類可以有。

五、多態(tài)

5.1 概念

多態(tài)就是對象的多種表現(xiàn)形式（多種體現(xiàn)形態(tài)）。

5.2 多態(tài)的體現(xiàn)

對象的多態(tài)性 ：在類中有子類和父類之分，子類就是父類的一種形態(tài)，對象多態(tài)性就從此而來。

方法的重載和重寫也是多態(tài)的一種，不過是方法的多態(tài)性 ：

???? 重載：一個類中方法的多態(tài)性體現(xiàn)

???? 重寫：子父類中方法的多態(tài)性體現(xiàn)

5.3 多態(tài)的使用：對象的類型轉(zhuǎn)換

類似于基本數(shù)據(jù)類型的轉(zhuǎn)換：

向上轉(zhuǎn)型 ：將子類實例變?yōu)楦割悓嵗?/p>

???? 格式：父類 父類對象名 = 子類實例 ;

向下轉(zhuǎn)型 ：將父類實例變?yōu)樽宇悓嵗?/p>

???? 格式：子類 子類對象 = (子類) 父類實例 ;

package com.kaikeba.objectoriented.senior;public class polymorphicDemo {/*** 父類引用指向子類對象* @param args*/public static void main(String[] args) { // Person5 p = null; // Student5 s = new Student5(); // p = s; //s是p的一種形態(tài) // p.say();Student5 a = new Student5();Nurse b = new Nurse();Person5 p1 = a;Person5 p2 = b;p1.say();p2.say();// Student5 a2 = (Student5) p1;Student5 a3 = (Student5) p2;a3.say();} }

Student實例可以向上轉(zhuǎn)型為父類Person實例，Person實例也可以向下轉(zhuǎn)型回Student實例，但是不能將Nurse實例轉(zhuǎn)為Student實例。

5.4 instanceof

作用：

????判斷某個對象是否是指定類的實例，則可以使用instanceof關(guān)鍵字。

格式：

????實例化對象 instanceof 類 //此操作返回boolean類型的數(shù)據(jù)

package com.kaikeba.objectoriented.senior;public class instanceofDemo {public static void main(String[] args) {Nurse6 n = new Nurse6();say(n);Student6 s = new Student6();say(s);}public static void say(Person6 p) {//如何判斷傳入的對象是此類型的哪種形態(tài)（哪個子類的對象）if(p instanceof Student6) {Student6 s = (Student6) p;s.say();}else {System.out.println("必須傳入學(xué)生形態(tài)，才可以執(zhí)行");}} }

結(jié)果如下：

必須傳入學(xué)生形態(tài)，才可以執(zhí)行 鋤禾日當(dāng)午

六、Object類

6.1 概念

Object類是所有類的父類（基類），如果一個類沒有明確的繼承某一個具體的類，則將默認(rèn)繼承Object類。 例如我們定義了一個類： public class Person { }其實它被使用時是這樣的： public class Person extends Object { }

觀察Object類的構(gòu)造器：只有一個無參構(gòu)造方法。

6.2 Object的多態(tài)

由于Object是所有類的父類，使用Object可以接收任意的引用數(shù)據(jù)類型，觀察下面的代碼： package com.kaikeba.objectoriented.senior;public class objectDemo {public static void main(String[] args) {String text = "123";say(text);int a = 10;say(a);}public static void say(Object o) {System.out.println(o);} }

6.3 toString方法

Object類下有一些方法：

目前只要掌握toString和equals即可，而且可以查看java API中文手冊，或者查看源碼來了解方法的具體作用。

先來看一下toString的源碼：

public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode()); }

返回對象的字符串表示形式，默認(rèn)的是包名類名@哈希碼 ，觀察如下代碼：

package com.kaikeba.objectoriented.senior;import java.util.Objects;public class Person7 {private String name;private int age;public Person7() {}public Person7(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;} } package com.kaikeba.objectoriented.senior;public class toStringDemo {public static void main(String[] args) {Person7 p = new Person7("張三",18);//System.out.println方法中默認(rèn)調(diào)用了toString方法System.out.println(p);} }

輸出的結(jié)果為：

com.kaikeba.objectoriented.senior.Person7@16e8e0a

這樣對對象的描述一般不是很直觀，所以一般建議繼承的子類都要重寫toString方法，在Person7類中加入重寫方法：

@Overridepublic String toString() {return "Person7{" +"name='" + name + '\'' +", age=" + age +'}';}

輸出結(jié)果就變?yōu)?#xff1a;

Person7{name='張三', age=18}

6.4 equals方法

指示某個其他對象是否“等于”此對象。

查看一下equals的源碼：

public boolean equals(Object obj) {return (this == obj); }

默認(rèn)的比較方式為 “==”，對于任何非空引用值x和y ，當(dāng)且僅當(dāng)x和y引用同一對象時，此方法返回true 。

但是這樣一般不太合理，一般而言，兩個對象的每個屬性都相同，那么我們就認(rèn)為其相同，而不是非要兩個引用都指向同一個對象才相同，所以一般建議重寫Object類中的equals方法。

equals方法重寫的五個特性：（面試可能會問）

• 自反性 ：對于任何非空的參考值x，x.equals(x)應(yīng)該返回true；

• 對稱性 ：對于任何非空的引用值x和y，x.equals(y)應(yīng)該返回true當(dāng)且僅當(dāng)y.equals(x)返回true；

• 傳遞性 ：對于任何非空引用值x，y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)應(yīng)該也返回true；

• 一致性 ：對于任何非空引用值x和y，多次調(diào)用x.equals(y)始終返回true或始終返回false，前提是未修改對象上的equals比較中使用的信息；

• 非空性 ：對于任何非空的參考值x，x.equals(null)應(yīng)該返回false。

我們將上述的main函數(shù)修改如下：

package com.kaikeba.objectoriented.senior;public class toStringDemo {public static void main(String[] args) {Person7 p1 = new Person7("張三",18);System.out.println(p1);Person7 p2 = new Person7("張三",18);System.out.println(p2);System.out.println(p1.equals(p2));} }

結(jié)果如下所示：

Person7{name='張三', age=18} Person7{name='張三', age=18} false

因為equals默認(rèn)的是使用了==來比較，p1和p2雖然屬性值一樣，但是畢竟是兩個對象，地址值不一樣，所以返回false；如果想通過屬性值來比較兩個對象是否相同，可以通過重寫equals方法來實現(xiàn)，在Person7類中重寫如下方法：

@Overridepublic boolean equals(Object o) {//如果兩個引用指向一樣，則肯定相同if (this == o) return true;//若o為空（能到這this肯定不為空）或this和o的類型不一致，肯定不同if (o == null || getClass() != o.getClass()) return false;Person7 person7 = (Person7) o;//類型一致，比較屬性值是否一致return age == person7.age && Objects.equals(name, person7.name);}

或：

public boolean equals(Object o) {if(this == o) {return true;}if(o == null) {return fasle;}if(o instanceof Person7) {Person7 p2 = (Person7) o;if(this.name.equals(p2.name) && this.age == p2.age) {return true;} }return false; }

在運行main函數(shù)，結(jié)果就變?yōu)閠rue了，這也是比較合理的：

Person7{name='張三', age=18} Person7{name='張三', age=18} true

七、內(nèi)部類

7.1 概念

在Java中，可以將**一個類定義在另一個類里面或者一個方法里面** ，這樣的類稱為內(nèi)部類。廣泛意義上的內(nèi)部類一般來說包括這四種：

????1. 成員內(nèi)部類

????2. 局部內(nèi)部類

????3. 匿名內(nèi)部類

????4. 靜態(tài)內(nèi)部類

7.2 成員內(nèi)部類

成員內(nèi)部類是最普通的內(nèi)部類，它的定義為位于另一個類的內(nèi)部，形如下面的形式： class Outer {private double x = 0;public Outer(double x) {this.x = x;}class Inner { //內(nèi)部類public void say() {System.out.println("x=" + x);}} }

如何使用成員內(nèi)部類：

Outer o = new Outer(); //先創(chuàng)建外部類對象 Outer.Inner i = o.new Inner(); //通過外部類對象來new內(nèi)部類對象

特點：

成員內(nèi)部類可以無條件訪問外部類的所有成員屬性和成員方法（包括private成員和靜態(tài)成員）。不過要注意的是，當(dāng)成員內(nèi)部類擁有和外部類同名的成員變量或者方法時，會發(fā)生隱藏現(xiàn)象，即默認(rèn)情況下訪問的是成員內(nèi)部類的成員。如果要訪問外部類的同名成員，需要以下面的形式進(jìn)行訪問： 外部類.this.成員變量 外部類.this.成員方法

看一個完整的例子：

package com.kaikeba.objectoriented.senior;public class Outer {private int x;public int getX() {return x;}public void setX(int x) {this.x = x;}class Inner {private int x = 200;public void say() {System.out.println("內(nèi)部類的變量x的值：" + x);System.out.println("外部類的變量x的值：" + Outer.this.x);}} } package com.kaikeba.objectoriented.senior;public class memberInnerClass {public static void main(String[] args) {Outer o = new Outer();o.setX(100);Outer.Inner i = o.new Inner();i.say();} }

結(jié)果如下：

內(nèi)部類的變量x的值：200 外部類的變量x的值：100

7.3 局部內(nèi)部類

局部內(nèi)部類是定義在一個方法或者一個作用域里面的類，它和成員內(nèi)部類的區(qū)別在于局部內(nèi)部類的訪問僅限于方法內(nèi)或該作用域內(nèi)。

看個例子直觀感受一下：

package com.kaikeba.objectoriented.senior;public class localInnerClass {public static void main(String[] args) {class Person{public void say() {System.out.println("鋤禾日當(dāng)午");}}Person p = new Person();p.say();} }

類的優(yōu)點是復(fù)用性高，但是局部內(nèi)部類出了方法或者作用域就不能用了，所以它不具備較高的復(fù)用性，使用的較少，但是創(chuàng)建一個只使用一次的對象可以考慮使用局部內(nèi)部類：

package com.kaikeba.objectoriented.senior;public class localInnerClass2 {public static void main(String[] args) {class ChildImp implements Child {@Overridepublic void say() {System.out.println("新編寫的局部內(nèi)部類的say方法內(nèi)部"+a);}}ChildImp c = new ChildImp();haha(c);}public static void haha(Child c) {} }

注意：局部內(nèi)部類就像是方法里面的一個局部變量一樣，是不能有public、protected、private以及static修飾符的。

7.4 匿名內(nèi)部類

匿名內(nèi)部類由于沒有名字，所以它的創(chuàng)建方式有點奇怪，創(chuàng)建格式如下： new 父類構(gòu)造器(參數(shù)列表) 實現(xiàn)接口() {//匿名內(nèi)部類的類體部分 }

在這里我們看到使用匿名內(nèi)部類我們必須要繼承一個父類或者實現(xiàn)一個接口，當(dāng)然也僅能繼承一個父類或者實現(xiàn)一個接口，同時它也是沒有class關(guān)鍵字，這是因為匿名內(nèi)部類是直接使用new來生成一個對象的引用，當(dāng)然這個引用時隱式的。

package com.kaikeba.objectoriented.senior;public class anonymousInnerClass {public static void main(String[] args) {Child c = new Child() {@Overridepublic void say() {System.out.println();}};haha(c);}public static void haha(Child c) {} }

注意：

使用匿名內(nèi)部類是，我們必須繼承一個類或者實現(xiàn)一個接口，但是兩者不可兼得，同時也只能繼承一個類或?qū)崿F(xiàn)一個接口；

匿名內(nèi)部類中是不能定義構(gòu)造函數(shù)的；

匿名內(nèi)部類中不能存在任何的靜態(tài)成員變量和靜態(tài)方法；

匿名內(nèi)部類為局部內(nèi)部類，所以局部內(nèi)部類的所有限制同樣對匿名內(nèi)部類生效；

匿名內(nèi)部類不能是抽象的，它必須要實現(xiàn)繼承的類或者實現(xiàn)接口的所有抽象方法；

只能訪問final型的局部變量 （面試題）：因為內(nèi)部類會被單獨編譯成一個字節(jié)碼文件，為了保證這個單獨的文件中用到的變量，與外面的變量的值絕對是一致的，系統(tǒng)從規(guī)則上限制了這個變量的值不可更改。

7.5 靜態(tài)內(nèi)部類

靜態(tài)內(nèi)部類也是定義在另一個類里面的類，只不過在類的前面多了一個關(guān)鍵字static。

靜態(tài)內(nèi)部類是不需要依賴于外部類對象的，這點和類的靜態(tài)成員屬性有點類似，并且它不能使用外部類的非static成員變量或者方法。

使用格式如下所示：

public class Test {public static void main(String[] args) {Outer.Inner inner = new Outer.Inner();} }class Outer {public Outer() {}static class Inner {public Inner() {}} }

八、包裝類

8.1 概述

在java中有一個設(shè)計的原則“一切皆對象”，那么這樣一來Java中的基本的數(shù)據(jù)類型，就完全不符合這種設(shè)計思想，因為Java中的八種基本數(shù)據(jù)類型并不是引用數(shù)據(jù)類型，所以Java中為了解決這樣的問題，引入了**八種基本數(shù)據(jù)類型的包裝類** 。

以上的八種包裝類，可以將基本數(shù)據(jù)類型按照類的形式進(jìn)行操作。也可以分為兩種大的類型：

• Number：Byte、Short、Integer、Long、Float、Double都是Number的子類表示是一個數(shù)字。

• Object：Character、Boolean都是Object的直接子類。

包裝類也是類，其在內(nèi)存中的表示和一般的類一樣：

8.2 裝箱和拆箱操作

以下以Integer和Float為例進(jìn)行操作：

• 裝箱：將一個基本數(shù)據(jù)類型變?yōu)榘b類；

• 拆箱：講一個包裝類變?yōu)橐粋€基本數(shù)據(jù)類型；

看如下代碼：

package com.kaikeba.objectoriented.senior;public class wrapperClass {public static void main(String[] args) {//手動裝箱JDK1.5之前Integer i = new Integer(200);//手動拆箱JDK1.5之前int a = i.intValue();//自動裝箱JDK1.5開始Integer j = 200;//自動拆箱JDK1.5開始int b = j;} } 在JDK1.5之前，如果想要裝箱，直接使用各個包裝類的構(gòu)造方法即可，例如：int temp = 10; //基本數(shù)據(jù)類型Integer x = new Integer(temp); //將基本數(shù)據(jù)類型變?yōu)榘b類 在JDK1.5，Java新增了自動裝箱和自動拆箱，可以直接通過包裝類進(jìn)行四則運算和自增自減操作，例如：Float f = 10.3f; //自動裝箱float x = f; //自動拆箱System.out.println(f * f); //直接利用包裝類完成System.out.println(x * x); //利用基本數(shù)據(jù)類型完成

因為所有的數(shù)值型的包裝類都是Number的子類，Number的類中定義了如下的操作方法，以下的全部方法都是進(jìn)行拆箱操作：

可以拆箱為不同的基本數(shù)據(jù)類型。

8.3 字符串轉(zhuǎn)換

使用包裝類還有一個很優(yōu)秀的地方在于：可以將一個字符串變?yōu)橹付ǖ幕緮?shù)據(jù)類型 ，此點一般在接收輸入數(shù)據(jù)上使用較多。

在Integer類中提供了以下的操作方法：

public static int parseInt(String s):將String變?yōu)閕nt型數(shù)據(jù)

在Float類中提供了以下的操作方法：

public static float parseFloat(String s):將String變?yōu)閒loat型數(shù)據(jù)

…

觀察如下代碼：

package com.kaikeba.objectoriented.senior;import java.util.Scanner;public class wrapperClass2 {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.println("請輸入內(nèi)容：");String text = input.nextLine();int x = Integer.parseInt(text);System.out.println(x+1);} }

結(jié)果如下：

請輸入內(nèi)容： 100 101

nextLine接收的是String類型的輸入，如果直接+1則當(dāng)成字符串來操作了，需要用parseInt轉(zhuǎn)為int類型，然后+1就是算術(shù)運算了。

九、可變參數(shù)

一個方法中定義完了參數(shù)，則在調(diào)用的時候必須傳入與其一一對應(yīng)的參數(shù)，但是在JDK1.5之后提供了新的功能，可以根據(jù)需要自動傳入任意個數(shù)的參數(shù) 。

語法：返回值類型 方法名稱(數(shù)據(jù)類型...參數(shù)名稱) {//參數(shù)在方法內(nèi)部，以數(shù)組的形式來接收}注意：可變參數(shù)只能出現(xiàn)在參數(shù)列表的最后。 package com.kaikeba.objectoriented.senior;public class variableParameters {public static void main(String[] args) {System.out.println(sum());System.out.println(sum(100));System.out.println(sum(100, 200));System.out.println(sum(100, 200, 300));System.out.println(sum(100, 200, 300, 500));}/*** int... nums，表示的是可變參數(shù)，調(diào)用時可以傳遞0-n個數(shù)字* 在方法的內(nèi)部，可變參數(shù)以數(shù)組作為載體體現(xiàn)*/public static int sum(int... nums) {int n = 0;for(int i=0; i < nums.length; i++) {n += nums[i];}return n;} }

結(jié)果如下所示：

0 100 300 600 1100

總結(jié)

以上是生活随笔為你收集整理的JavaSE——面向对象高级（继承、final关键字、抽象类与接口、多态、Object类、内部类、包装类、可变参数）的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。