java中的一些概念總結【學習心得】

[java中的包裝類】

什么叫做包裝類？

在java的設計中提倡一種思想："一切皆對象"，那么這樣一來就出現了一個問題？從

數據類型的劃分中我們知道java中的數據類型可以分為基本數據類型和引用數據類型，但

是基本數據類型怎么能稱作是對象呢？此時我們需要將基本數據類型進行包裝，將8種基

本數據類型變成一個類的形式，這就是包裝類的作用。

例如把int包裝成一個類Integer,這樣就可以以類的形式操作基本數據類型了。

其中：

Integer,Byte、Float、Double,Short,Long者B屬于Number類的子類，Numb

er類本身提供了一系列的返回6種基本數據類型的操作。

Character和Boolean是Object類的直接子類。

Number類:

一個抽象類，主要作用是將包裝類中的內容變成基本數據類型，主要方法如下：

bytebyteValueO——以byte形式返回指定的數值。

abstractdoubledoubleValue()-----以double形式返回指定的數值。

abstractfloatfloatValue()——以float形式返回指定的數值。

abstractintintValue()-----以int形式返回指定的數值。

abstractlonglongValueQ-----以long形式返回指定的數值。

shortshortValue()-----以short形式返回指定的數值。

裝箱——將基本數據類型變成包裝類

拆箱——將包裝類變為基本數據類型

例程1:

publicclassDemo01{

publicstaticvoidmain(String[]args){

intx=30;//基本數據類型

Integeri=new工nteger(x);//裝箱一將基本數據類型變成包裝類

inttemp=Value();—將包裝類變為基本數據類型

System.out.printIn(temp);

7

floaty=30.9f;//基本數據類型

Floatf=newFloat(y);//裝箱一將基本數據類型變成包裝類

floattem=f.floatvalue();—將包裝類變為基本數據類型

System.out.printin(tem);

12:

booleanb=true;//基本數據類型

Booleanbb=newBoolean(b);//裝箱一將基本數據類型變成包裝類

booleant=bb.valueOf(b);〃拆箱一將包裝類變為基本數據類型

System.out.printin(t);

}

18)

控制臺輸出：

30

30.9

true

在JDK1.5之前，對于程序本身來說,包裝類是不能進行"+"、……運算，因為那

是一個類。但是在JDK1.5之后對程序的包裝類功能進行了改變，增加了自動裝箱與拆箱機

制，而且也可以使用包裝類進行數字運算。

例程2:

publicclassDemo02{

publicstaticvoidmain(String[]args){

Integerii=10;//自動裝箱為工nteger

Floatff=3.3f;//自動裝箱為Float

Booleanboo=false;//自動裝箱為Boolean

ii++;//直接對裝箱后的類進行操作

ff一;

boo=!boo;

10

intxx=ii;〃自動拆箱為int

floatyy=ff;//自動拆箱為float

booleanbool=boo;//自動拆箱為boolean

14

System.out.printin(xx)

System.out.printin(yy)

17System.out.printin(bool);

)

19}

控制臺輸出：

11

2.3

true

在包裝類中還有一個最大的特點：就是可以將字符串變為指定的數據類型。

例程3:

publicclassDemo03{

publicstaticvoidmain(String[]args){

Stringstrl="99";〃由數字組成的字符串

Stringstr2="56.8”；

Stringstr3="true";

System.out.printIn(Integer.parselnt(strl))〃/轉化為相應的類型輸出

System.out.printin(Float.parseFloat(str2));

System.out.printin(Boolean.parseBoolean(str3));

}

11}

控制臺輸出：

99

56.8

true

方法的參數或者返回類型也可以設置成響應的包裝類。如下如所示：

voidtakeNumber(Integeri){}

intgiveNumber(){

returnx;

2014-12-08

JAVA

1101瀏覽12回答

最佳回答

2015-09-09

太厲害了，第一天，第一次的心態，基本覺得以后做事的水平了

?湯宗

回復0

J蕭瀟暮雨（提問者）

非常感謝!

【Object類】

在java中一切類都是以繼承的關系存在的。現在假設定義了一個Person

{}類，如果一個類在定義的時候如果沒有默認指明它的繼承關系，那么它默

認繼承Object類，所以Person類的實際代碼是：

classPersonextendsObject{

Object類是所有類的父類。

Object類的構造方法：publicObject()

Object類中的3個主要方法：

publicbooleanequals(Objectobj)----對象比較

publicinthashCode()-----取得hash碼

publicStringtoStringO----對象打印時調用

一個完整的類在定義的時候應該重寫Object類中的3個主要方法。

例程一：toString方法的使用

classDemo{//定義Demo類，實際上就是繼承了Object類

}；

publicclassObjectDemoOl{

publicstaticvoidmain(Stringargs[]){

Demod=newDemo();//實例化Demo對象

System.out.printin("不力HtoString()輸出：”+d);

System,out.println("力口上toString()輸出：'*+d.toString());

)

)；

控制臺輸出：

不力口toString。輸出：gpf.Demo@18fld7e

力口上toString。輸出:gpf.Demo@18fld7e

由此可見，加與不加toString的結果是一樣的，也就證明了對象在打印的

時候一定會調用toString()方法，是默認調用的。那么此時就可以利用此

特性完成類中信息的輸出。

例程二：重寫toString方法，輸出類中的信息

classPerson{

privateStringname;//定義name屬性

privateintage;//定義ag一屬性

publicPerson(Stringname,intage){

=name;

this.age=age;

)

8OOverride

publicStringtoString(){

return"姓名："++*'；年齡："+this.age;

)

)；

publicclassObjectDemo02{

publicstaticvoidmain(Stringargs[]){

nn

Personper=newPerson(Tomf13);//實例化Person

System.out.printin("對象信息：,,+per);

)

)；

控制臺輸出：對象信息：姓名：Tom;年齡：13

equals()方法:

equals()方法的主要功能是進行對象的比較操作，String本身是Obje

ct類的子類，所以已經重寫了該方法。equals()方法的主要功能是完成對

象的比較的。

例程三：equals()方法比較對象。

-classPerson{

privateStringname;//定義name屬性

privateintage;//定義age屬性

publicPerson(Stringname,intage){

=name;

this.age=age;

)

?Override

publicbooleanequals(Objectobj){

if(this==obj){//地址相等

returntrue;//肯定是同一個對象

}

if(!(objinstanceofPerson)){//不是Person對象

returnfalse;

15}

Personper=(Person)obj;//向下轉型

if(.equals()&&per.age==this.age){

returntrue;//依次比較內容

}else{

returnfalse;

}

}

230Override

publicStringtoStringO{

return"姓名："++"；年齡："+this.age;

)

27)

publicclassObjectDemo03{

publicstaticvoidmain(Stringargs[]){

Personperl=newPerson(nRubbyn,30);//實例化Person

Personper2=newPerson(nRubbyn,30);//實例化Person

System.out.printIn(perl.equals(per2)一個人!”:"不是同一個

人！”)

System.out.printin(perl.equals("hello")?”是同一個人！”:“不是同一

個人！”);

36

)

}

控制臺輸出：

是同一個人！

不是同一個人！

Object類是所有類的父類，則所有類的對象都可以使用Object接收，但

是Object不光可以接收對象，還可以接收任意的引用數據類型。

例程四：使用Object接收接口實例

interfaceA{

publicStringgetInfo();

3}

classBimplementsA{

50Override

publicStringgetlnfo(){//覆寫方法

return"Hell。World!!!n;

)

9}

publicclassObjectDemo04{

publicstaticvoidmain(Stringargs[]){

Aa=newB();//向上轉型，為接口實例化

Objectobj=a;//使用Object接收，向上轉型

Ax=(A)obj;//向下轉型

System.out.printin(x.getlnfo());

)

17}

控制臺輸出：

HelloWorld!!!

例程五：使用Object接收數組

publicclassObjectDemo05{

publicstaticvoidmain(Stringargs[]){

inttemp[]={1,3,5,7,9};//定義數組

Objectobj=temp;//使用Object接收數組

print(obj);

)

publicstaticvoidprint(Objecto){

if(oinstanceofint[]){//判斷是否是整型數組

intx[]=(int[])o;

for(inti=0;i<x.length;i++){

System.out.print(x[i]+n\tn);

)

)

}

15}

控制臺輸出：13579

總結：Object類是所有類的父類，只要是引用數據類型，都可以使用Obje

ct類進行接收

對象在進行向下轉型之前，一定會發生向上轉型（instanceof關鍵字）

2014-12-09

回復1

手

瀟暮雨

【static關鍵字】

非static關鍵字聲明的屬性和方法，每個對象都占有各自的內容。如果現

在希望一個屬性和被該類的所有對象共同擁有，則可以將其聲明為static類

型，聲明為static類型的屬性或者方法之后，此屬性或者方法也稱為靜態變

量和方法，可以由類名直接調用。

使用static聲明屬性：

static可以聲明全局屬性

classPerson{//定義Person類

Stringname;//定義name屬性，暫時不封裝

intage;//定義age屬性，暫時不封裝

Stringcountry="A城"；//定義城市屬性，有默認值

publicPerson(Stringname,intage){

=name;

this.age=age;

}

publicvoidinfo(){//得到信息

System.out.printin("姓名："++”，年齡：

"+this.age+”,城市："+country);

}

13)

publicclassStaticDemoOl{

publicstaticvoidmain(Stringargs[]){

Personpl=newPerson(“張三”，30);//實例化對象

Personp2=newPerson("李四”，31);//實例化對象

Personp3=newPerson("王五”，32);//實例化對象

19：

();

();

();

}

}

控制臺輸出：

姓名：張三，年齡：30,城市：A城

姓名：李四，年齡：31,城市：A城

姓名：王五，年齡：32,城市：A城

以上代碼確實實現了一些基本功能，但是此時的城市名稱不叫"A城"而

改成了"B城"，如果現在已經產生了5000個對象，那么就意味著此時就

需要修改5000個對象中的country屬性。所以此時最好使用static關鍵字

聲明屬性。代碼改為：

classPerson{//定義Person類

Stringname;//定義name屬性，暫時不封裝

intage;//定義age屬性，暫時不封裝

staticStringcountry="A城”;//定義城「廿屬性，有默認值，static

publicPerson(Stringname,intage){

=name;

this.age=age;

)

publicvoidinfo(){//得到信息

System.out.printIn(*'++”,年齡:

"+this.age+",城市：**+country);

)

13}

publicclassStaticDemo02{

publicstaticvoidmain(Stringargs[]){

Personpl=newPerson(“張三”，30);//實例化對象

Personp2=newPerson("李四”，31);//實例化對象

Personp3=newPerson("王五”，32);//實例化對象

System.out.printIn(n--------------修改之前----------------“);

();

();

();

Person.country="B城";//修改static屬性，使用類名

System.out.printin(H--------------修改之后----------------“);

();

();

();

)

)

控制臺輸出：

-------------修改之前------------

姓名：張三，年齡：30,城市：A城

姓名：李四，年齡：31,城市：A城

姓名：王五，年齡：32,城市：A城

-------------修改之后------------

姓名：張三，年齡：30,城市：B城

姓名：李四，年齡：31,城市：B城

姓名：王五，年齡：32,城市：B城

由以上例程可以看出：修改一個對象中的country屬性，則其他對象的c

ountry屬性也全部被改變，證明該屬性是該類的所有對象所共享的。

每一個對象都有自己各自的堆棧空間，堆內存中保存著各自的屬性，但是

所有的static屬性則是保存在了全局數據區中，所有的對象共同指向全局數

據區中的一個內容，所以當一個對象修改之后，所有對象的該屬性將全部被

改變。

PS:java中內存區域的劃分：

棧內存：保存對象的名稱（訪問的堆內存的地址）

堆內存：保存每個對象的具體屬性

全局數據區：保存static類型的數據

全局代碼區：保存所有方法的定義

一般使用static屬性的時候,最好使用類名稱直接調用，采用"類名.屬性"

的形式進行調用。

同理，可以使用static關鍵字聲明方法。——此方法可以使用static關鍵

字直接調用【注意：不能調用非static修飾的屬性和方法】。

classPerson{//定義Person類

privatestaticStringcountry="A城”;//定義靜態屬性

privateStringname=nHellon;

publicstaticvoidsFun(Stringc){

System.out.printin(nname="+name);//錯誤，不能調用非static

6屬性

fun();//錯誤，不能調用非static方法

}

publicvoidfun(){

System.out.printin(nWorldH);

}

}

以上代碼編譯時將出現錯誤：

錯誤：無法從靜態上下文中引用非靜態變量name

因為static屬性和方法可以在對象沒有進行實例化的時候直接調用。

static關鍵字的實際應用：

l.static關鍵字是所有對象所共享的，那么就可以使用static屬性來統計

一個類到底產生了多少個實例化對象。【每一個對象在實例化的時候就必須

調用構造方法，在構造方法中添加一個static屬性】

2.可以使用static關鍵字進行自動編名操作。

例程一：使用static屬性實現對象計數器

1classDemo{//定義Demo類

privatestaticintcount=0;//所有對象共享此屬性

publicDemo(){

count++;

//只要有對象產生就應該自增

System.out.printin("產生了"+count+“個對象！”);

)

9}

publicclassStaticDemo06{

publicstaticvoidmain(Stringargs[]){

newDemo();//增加新對象

newDemo();//增加新對象

newDemo();//增加新對象

)

)

控制臺輸出：

產生了1個對象！

產生了2個對象！

產生了3個對象！

例程二：使用static關鍵字進行自動編名操作：

1classDemo{

privateStringname;//保存名字

privatestaticintcount=0;//所有對象共享此屬性

publicDemo(){

count++;//

有對象產生就自增

="default-”+count+**.javan;//

自動進行編名操作

)

publicDemo(Stringname){

name;//可以通

過構造賦值

)

publicStringgetName(){//取得姓名

;

}

20)

publicclassStaticDemo07{

publicstaticvoidmain(Stringargs[]){

System.out.printIn(newDemo().getName());

System.out.printIn(newDemo(nhello.javan).getName

0)；

System.out.printIn(newDemo().getName());

System.out.printin(newDemo

(nwelcome.java1').getName());

System.out.printIn(newDemo().getName());

)

}

控制臺輸出：

default-l.java

hello.java

default-2.java

welcome.java

default-3.java

由以上程序可以得出凡是沒有給出默認的文件名的，就使用默認的名字，

并且依次遞增，指定名字的就不會使用默認的名字。

【理解main方法】

publicstaticvoidmain(Stringargs[])

static——靜態方法，可以由類名稱直接調用，執行java程序的時候是j

ava類名稱

void——主方法是程序的起點，不需要返回值

Stringargs[]一輸入的參數，參數傳遞形式：java類名稱參數1參

數2……

例如：一個程序在運行的時候要求參數的個數必須為3個，可以在操作之

前進行一個判斷，判斷參數的個數。如果在輸入的參數中間包含空格，應該

使用雙引號括起來當做一個參數來處理。

publicclassMain{

publicstaticvoidmain(Stringargs[]){

if(args.length!=3){//輸入的參數如果不足3個，則出錯

System.out.printin("輸入的參數不足三個，程序退出?”);

System.exit(1);//直接退出此程序

}

for(inti=0;i<args.length;i++){//循環輸出輸入的參數

System.out.println(“第"+(i+1)+”個參數："+args[i]);

)

)

11)

控制臺輸出：

javaMain12

輸入的參數不足三個，程序退出~

javaMainHello123"你好啊慕課網BAT##￥"

第1個參數：Hello

第2個參數：123

第3個參數：你好啊慕課網BAT##￥

其中最后一個參數"你好啊慕課網BAT##￥”本身包含空格應該使用雙引

號包含起來。

【代碼塊】

代碼塊是使用"{}"括起來的一段代碼，根據位置的不同，可以將代碼塊

劃分為4種。

普通代碼塊：直接定義在方法中的代碼塊

publicclassCodeDemoOl{

publicstaticvoidmain（Stringargs[]）{

{//普通代碼塊

intx=30;//就屬于一個局部變量

System,out.printin（"普通代碼塊-->x="+x）;

}

intx=100;//與局部變量名稱相同

System.out.printin（"彳弋碼塊之夕卜-->x="+x）;

}

10）

執行結果：

普通代碼塊x=30

代碼塊之外一>x=100

構造塊：直接在類中編寫的代碼塊

classDemo{

{//直接在類中編寫代碼塊，稱為構造塊

System.out.printIn(nl>構造塊。“);

}

publicDemo(){//定義構造方法

System.out.printin(H2>構造方法。**);

)

8}

publicclassCodeDemo02{

publicstaticvoidmain(Stringargs[]){

newDemo();//實例化對■象

newDemo();//實例化對象

newDemo();//實例化對象

}

15)

程序的輸出結果：

1、構造塊。

2、構造方法。

1、構造塊。

2、構造方法。

1、構造塊。

2、構造方法。

由程序運行結果可以知道：構造塊優先于構造方法執行，且執行多次，只

要一有實例化對象產生就執行構造塊中的內容。

靜態代碼塊：使用static關鍵字修飾的代碼塊

1classDemo{

{//直接在類中編寫代碼塊，稱為構造塊

System.out.printIn(H1構造塊。*,);

)

static{//使用static,稱為靜態代碼塊

System.out.printIn(n0>靜態代碼塊“);

}

publicDemo(){//定義構造方法

System.out.printIn(^^2^構造方法。“);

}

11}

publicclassCodeDemo03{

static{//在主方法所在的類中定義靜態塊

System.out.printIn("在主方法所在類中定義的代碼塊”);

)

publicstaticvoidmain(Stringargs[]){

newDemo();//實例化對象

newDemo();//實例化對象

newDemo();//實例化對象

)

21}

運行結果：

在主方法所在類中定義的代碼塊

1、構造塊。

2、構造方法。

1、構造塊。

2、構造方法。

1、構造塊。

2、構造方法。

可以發現主方法中定義的靜態代碼塊優先于主方法執行；普通類中的靜態

塊優先于構造方法執行，不管有多少個實例化對象產生，靜態代碼塊只執行

一次，靜態代碼塊的主要功能就是為靜態屬性初始化。

同步代碼塊：與多線程相關

^\瀟瀟暮雨

【對象數組】

所謂對象數組就是指包含了一組相關的對象，但是在對象數組的使用過程

中一定要清楚一點：數組一定要先開辟空間，但是因為其是引用數據類型，

所以數組里面的每一個值都是null,在使用的時候，對象數組中的每一個對

象都要進行實例化操作。

對象數組的聲明：

類對象數組名稱口=new［數組長度］;

classPerson{

privateStringname;

publicPerson(Stringname){

=name;

}

publicStringgetName(){

;

}

publicclassObjectArrayDemoOl{

publicstaticvoidmain(Stringargs[]){

//類名稱數組名稱口=new類名稱[長度]

Personper[]=newPerson[3];//月:辟了三個空間大

14

小的數組

System.out.printin(”==============數組聲明

//對象數組初始化之前，每一個元素都是默認值

for(intx=0;x<per.length;x++){//循環4俞出

System.out.print(per[x]+“、“);//

因為只是開辟好了空間，所以都是默認值

24)

//分別為數組中的每個元素初始化，每一個都是對象，都需

要單獨實例化

per[0]=newPerson(“張三”);//實例化第一個元素

per[1]=newPerson("李四”);//實例化第二個元素

per[2]=newPerson(“王五”);//實例化第三個元素

System.out.printin(”\n==============對象實例化

for(intx=0;x<per.length;x++){//循環輸出

System.out.print(per[x].getName()+“、”)

//此時，已經實例化完成了，所以會直接打印出姓名

)

}

控制臺輸出：

==============數組聲明=================

null、null、nulk

==============對象實例化=================

張三、李四、王五、

由以上程序可以看出對象數組中的內容沒有實例化之前都是默認值null,

對象數組中的每個對象都要單獨進行實例化。

數組在初始化的時候有動態初始化【先聲明，再賦值】和靜態初始化【聲

明的時候就賦值】，對象數組也不例外。

.classPerson{

privateStringname;

publicPerson(Stringname){

=name;

)

publicStringgetName(){

;

}

9}

publicclassObjectArrayDemo02{

publicstaticvoidmain(Stringargs[]){

//聲明一個對象數組，里面有三個對象，使用靜態初始化方

式完成

Personper[]={newPerson(“張三”)，newPerson("李

四”)，newPerson(;

System.out.printin("\n==============數組輸出

for(intx=0;x<per.length;x++){//循環輸出

System.out.print(per[x].getName()+“、”)

23

；//此時，已經實例化完成了，所以會直接打印出姓名

25)

)

27)

控制臺輸出：

數組輸出

張三、李四、王五、

【內部類】

在一個類的內部可以定義另一個類（類中的任意位置，包括在方法中定

義）。如果在一個類Outer的內部再定義一個類Inner,此時類Inner就稱

之為內部類，而類Outer則稱之為外部類。

內部類可以聲明為public或者private,當內部類聲明為public或者pr

ivate時，對其訪問的限制與成員變量和成員方法完全相同。

1classOuter{//定義外部類

privateStringinfo="hell。world**;//定義夕卜部類的私有

屬性

classInner{//定義內部類

publicvoidprint(){//

定義內部類的方法

System.out.printIn(info);//

1n

直接訪問外部類的私有屬性

}

)

publicvoidfun(){

//定義外部類的方法

newInner().print();//

18：

通過內部類的實例化對象調用方法

)

21}

publicclassInnerClassDemoOl{

publicstaticvoidmain(Stringargs[]){

newOuter().fun();

//調用外部類的fun()方法

)

81}

控制臺輸出：

helloworld

以上程序中，Inner類作為Outer類的內部類存在，并且在外部類的fun

()方法中直接實例化內部類的對象并調用print()方法。

內部類存在的特點：

缺點：正常的一個類操作時，在類中最好只定義屬性或者方法。如果在

一個類中再定義另一個類的話，肯定破壞了一個程序的結構。

優點：使用內部類的唯一優點是可以訪問外部類中的私有屬性

使用static關鍵字聲明內部類，則此內部類就稱之為外部類，可以通過“外

部類.內部類"的方式進行訪問。

classOuter{//定義外部類

privatestaticStringinfo="helloworld";//定義外

部類的私有屬性

staticclassInner{//使用static定義內部類為外部類

publicvoidprint(){//

定義內部類的方法

System.out.printIn(info);//

直接訪問外部類的私有屬性

)

)

publicvoidfun(){

15

//定義外部類的方法

newInner().print();//

18:

通過內部類的實例化對象調用方法

)

21}

publicclassInnerClassDemo03{

publicstaticvoidmain(Stringargs[]){

newOuter.Inner().print();

25：

//調用外部類的fun()方法

)

控制臺輸出:helloworld

在外部訪問內部類

一個類除了可以通過外部類進行訪問，也可以直接在其他類中進行調用，

調用格式：

外部類內部類內部類對象=外部類實例new內部類()；

1classOuter{//定義外部類

privateStringinfo="hell。world";//定義外部類的私有屬性

classInner{//定義內部類

publicvoidprint(){//定義內部類的方法

System.out.printin(info);//直接訪問外部類的私有屬性

}

)

publicvoidfun(){//定義外部類的方法

newInner().print();//通過內部類的實例化對象調用方法

}

11}

publicclassInnerClassDemo04{

publicstaticvoidmain(Stringargs[]){

Outerout=newOuter();//外部類實例化對象

Outer.Innerin=out.newInner();//實例化內部類對象

in.print();//調用內部類的方法

17)

)

控制臺輸出：

helloworld

在方法中定義內部類

classOuter{//定義外部類

privateStringinfo="helloworld'1;//定義外部類的私有

屬性

publicvoidfun(finalinttemp){//定義外

部類的方法，參數用final

classInner{

：。//在方法中定義的內部類

publicvoidprint（）｛

12-

//定義內部類的方法

System.out.println（”類中的屬性：+

15

info）;//直接訪問外部類的私有屬性

System.out.printin（"方法中的參數：

18

+temp）;

201）

}

newInner().print();//

23

通過內部類的實例化對象調用方法

}

26}

publicclassInnerClassDemo05{

publicstaticvoidmain(Stringargs[]){

newOuter().fun(30);//調用外部類的方法

)

}

控制臺輸出：

類中的屬性：helloworld

方法中的參數：30

內部類需要訪問方法中的參數需要使用final關鍵字

2014-12-10

回復0

￡

【繼承】

子類繼承父類實際上是擴充父類類的功能。子類不能直接訪問父類中的私

有屬性，如以下程序:

classPerson{