Java程序结构课件

返回

Java程式結構 Java語言是一種純面向對象的程式設計語言，它的核心概念是類和對象，它的程式是基於類和對象建造的，程式中類的結構決定了程式的結構。這一章較深入系統地介紹Java程式的結構，介紹組成Java程式的類之間的關係。Java程式結構類層次結構對象的使用與對象間通信多態性介面與包訪問控制與修飾符類層次結構繼承的概念繼承的描述類的繼承規則變數的隱藏繼承的概念在日常生活中，我們常用“是一種（is-a）”關係來組織與表達知識，從而將知識組織成一種有層次、可分類的結構。面向對象程式設計方法將is-a關係引入到程式設計領域，用於描述類與類之間的關係，稱之為繼承。多態性同一運算或方法（如“+”）對不同類型的對象（如整型數，或字串）有不同的語義解釋。這種在程式中同一方法對不同類型的對象有不同解釋的現象稱為多態性多態性與繼承是密不可分的。通常，兩類對象都有共同的父類，在父類中定義的方法在這兩個子類中分別有不同的實現超類與子類我們在聲明類A時，指明類A繼承了類B（類B是一個已定義了的類），則類A通常就擁有了類B的成員變數和方法。此時，類B稱為類A的直接超類（superclass），超類也稱為父類或基類；類A稱為類B的直接子類（subclass），子類也稱為派生類繼承的描述Java語言中，聲明類首部的格式如下：

[類的修飾符]class

類名

[extends

超類名][implement

介面名表]其中“extends

超類名”部分就是用來描述繼承的，這裏超類名指明所聲明類的直接超類

繼承描述的演示

classCar //聲明Car類

{

int

car_number; voidset_number(int

car_num) {

car_number=car_num; } voidshow_number() {

System.out.println("我的車號是："+car_number); } } classTrashCarextendsCar//聲明TrashCar類，它繼承Car類

{

int

capacipy; voidset_capacity(int

trash_car_capacipy) {

capacipy=trash_car_capacipy; } voidshow_capacity() {

System.out.println("我的容量是："+capacipy+""); } }類的繼承規則直接子類繼承那些被聲明為public或protected的直接超類成員（包括成員變數和成員方法，下同）直接子類繼承那些未被存取許可權修飾符修飾的直接超類成員，只要該子類與該超類在同一個包中如果直接子類聲明了一個與直接超類中的成員同名的成員，則該子類不繼承該超類中的該同名成員直接子類不繼承被修飾為private的直接超類的成員

變數的隱藏直接子類聲明了一個與其直接超類的成員變數同名的成員變數，則稱該超類的該成員變數在該直接子類中被隱藏，關鍵字this和super分別用來指明直接子類和其直接超類中同名的成員變數當超類的成員變數、子類的成員變數和類中方法使用的局部變數三者同名，或其中的兩者同名時，可以使用關鍵字this和super來指定所要使用的變數this和super區別同名變數的演示classA{

intx； //類A中聲明了成員變數x ┇}classBextendsA //類B繼承類A，也繼承了類A的成員變數x{

intx; //類B中又聲明了成員變數x ┇ voidm() {

intx; //方法m聲明了自己的局部變數x ┇

super.x=2; //super.x是其所在類的父類即類A的x

this.x=1; //this.x

是其所在類即類B的x x=100; //x是方法本身的局部變數x ┇ }}對象的使用與對象間通信對象的創建對象的使用對象間的通信（消息）與實例方法的調用對象的創建Java中，類是某一類對象的共同特徵（屬性、行為）的描述，即類中含有某一類對象具有哪些屬性、哪些行為的資訊。而由類創建的多個對象都具有類所定義的那些屬性和行為。但是，由同一個類所創建的不同對象的同一個屬性的值可能不同對象的生命週期對象和現實生活中的事物一樣，有它的產生、發展和消亡的過程，在Java中分別稱之為對象的創建、使用和釋放，這一過程稱為對象的生命週期

定義一個學生類classStudent //Student是學生類名{ //定義成員變數

privateint

sNumber; //學號

privateStringsName; //姓名

privateStringsClass; //班號。以下是

定義成員方法

voidsetSNumber(int

xNumber) //成員方法setSNumber { sNumber=xNumber; }

int

getSNumber() //成員方法getSNumber { returnsNumber; } voidsetSName(String

xName)//成員方法setSName { sName=xName; } StringgetSName() //成員方法getSName { returnsName; } voidsetSClass(String

xClass) //成員方法setSClass { sClass=xClass; } StringgetSClass(); //成員方法getSClass { returnsClass; }}創建對象過程對象的聲明對象的實例化對象的初始化對象的聲明對象聲明的語法形式為:

類名對象名；該語句從指定的類創建對象。對象的實例化和初始化

必須給一個對象分配相應的存儲空間，才能使用它。在聲明一個對象時，並沒有為該對象分配存儲空間。對象的實例化完成對象的空間分配，對象實例化是通過new操作完成。構造方法的調用則確定了對象的初始狀態，這一過程就是初始化對象創建過程的演示classCourse //Course是課程類名{ //定義成員變數

privateint

cNumber;//課程編號

privateStringcName;//課程名

privateint

cUnit;//學分數

//定義成員方法

voidsetCNumber(int

xNumber) //成員方法setCNumber {

cNumber=xNumber; }

int

getCNumber()//成員方法getCNumber { returncNumber; } voidsetCName(String

xName)//成員方法setCName {

cName=xName; } StringgetCName()//成員方法getCName { returncName; } voidsetCUnit(int

xUnit)//成員方法setCUnit {

cUnit=xUnit; }

int

getCUnit() //成員方法getCUnit { returncUnit; } publicclassInitialDemo1 { publicstaticvoidmain(String[]args) { Coursecs1=newCourse();//聲明一個Course對象cs1 System.out.println(cs1.getCNumber());//輸出初始值cNumber System.out.println(cs1.getCName());//輸出初始值cName System.out.println(cs1.getCUnit());//輸出初始值cUnit }}演示對象的初始化classCourse //Course是類名{ //定義成員變數

int

cNumber=1; //課程編號

StringcName=”Wang”;//課程名

int

cUnit=2;//學分數} publicclassInitialDemo2{ publicstaticvoidmain(String[]args) { Coursecs1=newCourse();//聲明一個Course對象cs1 System.out.println(cs1.cNumber);//輸出初始值cNumber System.out.println(cs1.cName);//輸出初始值cName System.out.println(cs1.cUnit);//輸出初始值cUnit }}演示使用構造方法進行初始化classCourse //Course是類名{ //定義成員變數

int

cNumber=1; StringcName;

int

cUnit=2; //構造方法

Course(StringName,intUnit) {

cName=Name;

cUnit=Unit; }} publicclassInitialDemo3{ publicstaticvoidmain(String[ ]args) { Coursecs1=newCourse(“Zhang”,6);//使用類中聲明的構造方法

//聲明一個Course對象cs1 System.out.println(cs1.cNumber); System.out.println(cs1.cName); System.out.println(cs1.cUnit); }}演示由子類創建對象的過程classA{

intx=1;

inty=1;

A(intx1,inty1) { x=x1; y=y1; }}classBextendsA{

intx=2; floatz;

B(int

xx,int

yy) { super(0,0);//子類的構造方法中先調用超類的構造方法，否則Java調用默認的構造方法A()

this.x=xx;this.y=yy; }}publicclassEtndsDemo

{publicstaticvoidmain(String[]args){ Bb1=newB(1,2); System.out.println(b1.x); System.out.println(b1.y); System.out.println(b1.z);}}對象的使用引用對象的成員變數調用對象的成員方法對象作數組元素對象作類的成員變數引用對象的成員變數

引用對象成員變數的語法形式為：

對象名.成員變數名；

例：Rectangle類的聲明classRectangle{

intwidth；

intheight；

Rectangle()//Rectangle類的構造方法

{ width=20；height=30；

}}靜態變數和實例變數類

myclassintVar1;staticintVar2;對象myobject1Var1Var2對象myobject2Var1Var2myobject1.Var2myobject2.Var2myobject1.Var1myobject2.Var1靜態變數實例變數

調用對象的成員方法如前所述，調用對象成員方法的語法形式為：

對象名.成員方法名（[實際參數表]）；其中：⑴對象名指定所使用的對象；⑵成員方法名指定所要調用的成員方法；⑶實際參數表由0個或多個運算式構成，運算式之間用逗號“，”分隔調用對象方法參數傳遞過程演示classMethodDemo1{ //實現兩個形式參數x、y的相加，其和以方法返回值的形式傳回floatadd(floatx,floaty)

{ floatz; z=x+y; returnz; }}publicclassCallMethodDemo1{ publicstaticvoidmain(String[]args) { floatresult; methodDemo1addCall=newmethodDemo1(); result=addCall.add(3,5);//調用對象addCall的add方法，計算3+5

System.out.println(result);//result的值為3+5 }}說明實例

本例中類MethodDemo1給出一個實現兩float型數相加的方法。方法的參數x、y是參與加法的運算元，相加的結果存於局部變數z中，return語句指明z的值即是方法的返回值。類CallMethodDemo1的add對象調用了類MethodDemo1的方法add，實參為整型3和5演示方法的一種用法classFact{floatfact(intn)//定義計算n！的方法

{

inti; floatx=1;

for(i=1;i<n;i++) x=x*i; returnx;}}publicclassMethodCallDemo2{ publicstaticvoidmain(Stringargs[]) { Factx=newFact(); System.out.println(x.fact(10));//計算10！

System.out.println(x.fact(15));//計算15！

}}演示靜態方法的用法classFact{staticfloatfact(intn)//將方法fact聲名為靜態方法

{

inti; floatx=1;

for(i=1;i<n;i++) x=x*i; returnx;}}publicclassMethodCallDemo5{ publicstaticvoidmain(Stringargs[]) { System.out.println(Fact.fact(10));//直接用類名.方法名調用靜態方法

System.out.println(Fact.fact(15)); }}演示數組作為方法的參數Java中數組是作為對象來處理的classmethodDemo5{ floatfindMax(float

arr[])//形式參數arr[]是數組

{

inti; floattemp; temp=arr[0];

for(i=1;i<arr.length;i++) if(arr[i]>temp)temp=arr[i]; returntemp; }}publicclassMethodCallDemo6{ publicstaticvoidmain(Stringargs[]) { floatmax; floatx[]={1,2,3,4,5}; methodDemo5y=newmethodDemo5(); max=y.findMax(x);//實參x是數組，數組調用的返回值為5.0

System.out.println(max);}}對象作數組元素

對象也可以作數組元素，當對象作數組元素時，其數組稱為對象的數組。創建對象的數組時，首先對數組初始化，然後對數組的每個元素初始化對象作數組元素用法的演示classnode{ privateintdata; privatenodenext; voidsetData(intx) { data=x; }

int

getData() { returndata; } nodegetNext() { returnnext; } voidsetNext(nodex) { next=x; }}publicclassObjAsArrayElementDemo{ publicstaticvoidmain(Stringargs[]) { //創建3個結點

nodex[]=newnode[3]; //創建元素為node型對象的數組並初始化數組

inti;

for(i=0;i<x.length;i++)//初始化數組元素——對象

x[i]=newnode(); //給結點的data賦值，並組成鏈表

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

x[i].setData(i);

if(i<x.length-1)x[i].setNext(x[i+1]); } //利用start依次輸出鏈表各結點的值

nodestart=newnode(); start=x[0]; //指向鏈表的第1個結點

System.out.println(start.getData()); //輸出x[0].data

while(start.getNext()!=null) { start=start.getNext(); //指向下一結點

System.out.println(start.getData()); //輸出x[i].data } }}對象作類的成員變數classdate{ Stringyy;//年

Stringmm;//月

Stringdd;//日

date(String

xyy,Stringxmm,Stringxdd) //date構造方法

{

yy=xyy;mm=xmm;dd=xdd; }}classStudent{ privateint

idNumber,height; //學號、身高

privatecharsex; //性別

datebirthday; //出生日期birthday是對象

//Student構造方法

Student(intid,inth,chars,Stringxyy,Stringxmm,Stringxdd){

idNumber=id; height=h; sex=s; //調用date構造方法

birthday=newdate(xyy,xmm,xdd); }

int

getHeight(){returnheight;}

int

getSex(){returnsex;} voidshow(){//輸出學號，身高，性別，出生年份

System.out.println();

System.out.print("/t"+idNumber);

System.out.print("/t"+height);

System.out.print("/t"+sex);

System.out.println("/t"+birthday.yy); }}publicclassUseStudent{ publicstaticvoidmain(String[]args)throws

java.io.IOException{

intsum=0; doubleave; Student[]a=newStudent[3];//創建對象的數組,數組元素初始化

a[0]=newStudent(100001,169,'女',"1976","06","12"); a[1]=newStudent(100002,155,'女',"1976","02","03"); a[2]=newStudent(100003,175,'男',"1976","05","25");//求平均身高

for(inti=0;i<a.length;i++){ sum=sum+a[i].getHeight(); }

ave=sum/3.0; //輸出超過平均身高的女生學號與身高

System.out.println("超過平均身高的女生學號與身高為"); for(inti=0;i<a.length;i++) if((a[i].getHeight()>=ave)&(a[i].getSex()=='女')) a[i].show(); }}對象間的通信（消息）與實例方法的調用消息是一個對象發送給另一對象的資訊，用來驅動接受這一消息的對象的某個行為。消息由三部分組成：接受消息的對象、對象中描述某一行為的方法以及這一方法所需要的參數。這些問題包括對象作方法的參數、作方法的返回值、作數組元素以及作類的成員變數。對象作方法的參數

當方法的參數時類類型時，方法的實參就是一個對象，這就是對象作方法的參數的情形。與基本數據類型的變數作方法參數的情形不同，在基本數據類型的變數作方法參數的情形下，進行方法調用時的語義動作，是將實參的值傳遞給相應的形參。對象作方法參數的演示classobjPara //定義對象作為參數的類{ floattemp; //用成員變數temp傳遞參數值}classmethodDemo4{ voidadd(floatx,floaty,objParaz)//對象z作為方法add的參數

{ z.temp=x+y; //方法體對對象z進行操作，可以改變z的值

} voidcallAdd2(floatm,floatn) {

objParak=newobjPara(); add(m,n,k);//向方法add發消息，將參數m,n的值分別傳遞給x,y,並將k的

//存儲地址值傳送給z，然後執行方法add的方法體，計算x+y，

//計算結果通過k傳回callAdd方法

System.out.print(m+"+"+n+"="+k.temp);//k.temp的值即為m+n }}publicclassMethodCallDemo7{publicstaticvoidmain(Stringargs[]) {

objParax=newobjPara(); methodDemo4y=newmethodDemo4();

System.out.println(x.temp);//x.temp值為0.0 y.add(1,2,x); //調用對象y的add方法，計算結果存於對象x的temp變數中

System.out.println(x.temp); //x.temp值為3.0 y.callAdd2(1,2);//輸出1+2的結果

}}對象作方法的返回值classnode{ privateintdata; privatenodenext;//成員變數next是node類型，而node是正在聲明的類類型

voidsetData(intx) { data=x; }

int

getData() { returndata; } nodegetNext()//此方法的返回值類型是類類型

{ returnnext; } voidsetNext(nodex) { next=x; }}publicclassObjAsRetValDemo{ publicstaticvoidmain(Stringargs[]) { //創建3個結點

nodex1=newnode(); nodex2=newnode(); nodex3=newnode(); //給結點的data賦值

x1.setData(1); x2.setData(2); x3.setData(3); //把3個結點組成鏈表

x1.setNext(x2);x2.setNext(x3); //利用start依次輸出鏈表各結點的值

nodestart=newnode(); start=x1;//指向結點x1

System.out.println(start.getData()); //輸出x1.data start=start.getNext();//指向下一結點x2

System.out.println(start.getData()); //輸出x2.data start=start.getNext();//指向下一結點x3

System.out.println(start.getData()); //輸出x3.data }}多態性方法的重構與重載方法的動態調用抽象類多態性多態性，就是程式中同一操作在不同的環境中有不同語義解釋的現象。和繼承機制一樣，多態性是面向對象方法的一大特色，它提供了使同一程式有很強的適應不同環境的能力的描述機制。方法的重構與重載在直接子類中定義的某個方法與其直接超類的某個方法有相同的名稱和參數，則稱該子類重構（Overriding）了該超類的該方法，重構也稱為覆蓋在同一個類中定義了多個同名的方法，它們或有不同的形參個數或有不同的形參類型，則稱該方法被重載（Overloading）方法重構的演示classFather{voidspeak()//超類定義的speak方法

{

System.out.println("IamFather！"); }}classSonextendsFather{ voidspeak()//子類重構的speak方法

{

System.out.println("IamSon！"); }}方法重構的演示classFather{ voidspeak()//超類定義的speak方法

{

System.out.println("IamFather！"); }}classDemoThisSuperextendsFather{ voidspeak()//子類重構的speak方法

{

System.out.println("IamSon！"); } voiddemThisSuper() {

super.speak();//調用超類Father的speak方法

this.speak();//調用子類DemoThisSuper重構的speak方法}}classMethodCallDemo4{ publicstaticvoidmain(Stringargs[]) { Fatherx=newFather();

DemoThisSupery=newDemoThisSuper();

x.speak(); //執行方法體System.out.println("IamFather！"); y.speak(); //執行方法體System.out.println("IamSon！"); y.demThisSuper(); //super.speak()執行方法體System.out.println("IamFather！"); //this.speak()執行方法體System.out.println("IamSon！"); }}演示方法的重載classDemoverload{ int

add(int

x,inty) { returnx+y; } doubleadd(double

x,doubley) { returnx+y; }}classMethodCallDemo3{ publicstaticvoidmain(Stringargs[]) { Demoverloadx=newDemoverload();

int

im=1,in=2; doublefm=1.0,fn=2.0;

System.out.println(x.add(im,in));//調用時，匹配整型加方法int

add(int

x,inty)

System.out.println(x.add(fm,fn)); //調用時，匹配單精確度型加方法

//doubleadd(double

x,doubley) }}方法重構的規定子類重構父類方法時，子類方法的返回類型應當與被重構方法的相同子類不能重構父類的final和private方法子類不能用實例方法去重構父類的static方法。子類的static方法可重構父類的static方法，但不能重構父類的實例方法子類方法重構父類方法時，子類方法的訪問許可權修飾詞不能嚴於父類方法的訪問許可權修飾詞子類若要引用父類中的被重構方法，應使用“super．方法名”的方式方法的動態調用classLocation{//位置類int

x,y;//位置的座標

Location(int

locX,int

locY){x=locX;y=locY;} voidshow(){System.out.print("("+x+","+y+")");}}classPointextendsLocation{ //點類

booleanvisible; //可見性

Point(int

pointX,int

pointY,boolean

trueOrFalse){

super(pointX,pointY); //調用超類的構造方法

visible=trueOrFalse;} voidmoveTo(int

newX,int

newY){//方法----移動到新位置

x=newX;y=newY; }}classCircleextendsPoint{ //圓類

intr; //r存放半徑

Circle(int

centX,int

centY,int

radius,boolean

tureOrFalse){

super(centX,centY,tureOrFalse); r=radius;}

voidexpand(intdelta){r=r+delta;}//方法----擴展

voidcontract(intdelta){r=r–delta;}//方法----收縮

voidshow(){

System.out.print("\t圓心位於");

super.show();

System.out.print("\t半徑為"+r); if(visible)System.out.println("\t此圓發亮"); elseSystem.out.println("\t此圓不發亮");}}classTestPointCircle{publicstaticvoidmain(String[]args){Pointp=newPoint(200,200,false);

System.out.print("\t點p的位置是");

p.show();//調用超類Location的show方法

System.out.println();Circlec=newCircle(100,100,20,true);

c.show();//調用Circle類的show方法

c.moveTo(300,400);c.expand(40);

c.show();}}說明

子類對象的引用可以賦給超類對象的引用；方法形參為某類對象時，可用其子類對象作實參。當子類對象引用賦給父類對象引用後，父類對象引用引用的是子類實例，用這個父類引用來引用子類實例成員（變數與方法）時只能引用與父類成員同名的那些成員。若成員變數出現隱藏，引用的是父類變數，若成員方法出現重構，引用的是子類的方法。方法動態調用的演示

classTwoDimension{ voidshow(){}}classPointextendsTwoDimension{ privateintx,y;

Point(int

px,int

py){x=px;y=py;} voidshow(){//重構了超類的show方法，輸出點的位置

System.out.println("點的位置是("+x+","+y+")"); }}classLineextendsTwoDimension{ privateintx1,y1,x2,y2;

Line(int

px,int

py,int

qx,int

qy){ x1=px;y1=py;x2=qx;y2=qy; } voidshow(){//重構了超類的方法，輸出線段兩端位置，方法體語句略

}}classCircleextendsTwoDimension{ privateint

cX,cY,radius;

Circle(intx,inty,intr){

cX=x;cY=y;radius=r; } voidshow(){//重構了超類的方法，輸出圓心座標及半徑，方法體語句略

}}classUseTwoDimension{ staticvoidshowParameter(TwoDimensionplc){

plc.show(); } publicstaticvoidmain(String[]args){ Pointp=newPoint(10,10); Linel=newLine(0,20,100,20); Circlec=newCircle(100,100,50); //p,l,c均是TwoDimension類的子類類型，充當showParameter方法的實參

//將子類對象引用賦給超類對象引用

showParameter(p); //執行p.show()

showParameter(l); //執行l.show()

showParameter(c); //執行c.show() }}抽象類

使用修飾符abstract對類加以修飾，這個類就是抽象類（abstractclass），抽象類不能被實例化。通常，抽象類中含有抽象方法，抽象方法是指只給出方法聲明但沒有方法體的方法。子類在繼承抽象類時，必須重構其父類的抽象方法，給出具體的定義。演示抽象類及其用法abstractclassFigure //聲明抽象類Figure{ doublex,y; voidset_size(doublesize1,doublesize2) { x=size1; y=size2; } //聲明抽象方法get_area，它沒有方法體

abstractdoubleget_area();} classTriangleextendsFigure //Triangle繼承抽象類Figure { doubleget_area() //重構其超類的抽象方法get_area() { return(x*y/2); //三角形面積=底*高/2 } }classRectangleextendsFigure //Rectangle繼承抽象類Figure{ doubleget_area() //重構其超類的抽象方法get_area() {

return(x*y); //矩形面積=長*寬

}}介面與包介面包介面介面（interface）是一個協定，它定義了一組行為的介面，但沒有定義行為的具體實現過程。任何一個類都可以實現一個介面。所謂一個類實現一個介面，是指這個類給出這個介面的所有行為的具體實現過程。從語法上看，介面由介面首部和介面體組成。介面首部給出介面名，如果存在介面的繼承關係，也要在介面首部中給出。介面體主要是一組方法首部的說明，介面體中也可以聲明一些常量。介面聲明、實現和使用的演示//聲明介面FigureinterfaceFigure//介面首部，interface是關鍵字，Figure是介面名//介面體{ voidset_size(doublesize1,doublesize2);//方法首部給出行為的介面

doubleget_area();}//介面聲明結束classTriangleimplementsFigure//Triangle實現介面Figure，implements是關鍵字{ doublex,y; //實現介面的方法，給出所實現介面的所有方法首部的方法體

publicvoidset_size(doublesize1,doublesize2) { x=size1; y=size2; } publicdoubleget_area() { return(x*y/2);//三角形面積=底*高/2 }}classRectangleimplementsFigure //Rectangle實現介面Figure{ doublex,y; publicvoidset_size(doublesize1,doublesize2) { x=size1; y=size2; } publicdoubleget_area() { return(x*y); //矩形面積=長*寬

}}classoutput //output類使用介面Figure{ staticvoidput(Figureq) //此方法的參數是介面類型

{ System.out.println(q.get_area()); }}publicclassTestInterface{ publicstaticvoidmain(String[]args){ Figureft=newTriangle();//創建介面對象，其方法的具體實現過程

//由Triangle類給出

Figurefr=newRectangle();//創建介面對象，其方法的具體實現過程

//由Rectangle類給出

Rectangler=newRectangle();r.set_size(2,2); ft.set_size(2,2);fr.set_size(2,2);

output.put(ft);//實參是介面對象，輸出三角形面積：2

output.put(fr);//實參是介面對象，輸出矩形面積：4

output.put(r);//實參是實現介面的類的對象，輸出矩形面積：4 }}介面與抽象類的主要區別介面不能實現任何方法（即不能給出方法的具體實現過程），而抽象類卻可以一個類可以實現多個介面，但只能有一個直接超類介面不是任何類的繼承層次的組成部分，無關的幾個類可以實現同一個介面包包的概念包的創建包中成員的使用包的概念包（package）是一組相關類和介面的集合，它提供了訪問許可權和命名的管理機制。Java中的包主要有三個作用：

1）使得功能相關的類易於查找和使用----同一包中的類和介面通常是功能相關的；

2）避免了命名的衝突----不同包中的不同類可以同名；

3）提供一種訪問許可權的控制機制包的創建創建一個包，只需在定義了類和介面的原始檔案的第一行使用package語句package語句的作用域是包含該語句的整個原始檔案包中成員的使用三種方法使用包中的成員。如果要使用包A中的成員x，我們可以：⑴用長名A.x引用成員x；⑵importA.x語句裝入包的成員x；⑶importA語句裝入整個包A。訪問控制與修飾符類成員的訪問許可權類的修飾符類成員的訪問許可權private、protected和public是類成員（包括成員變數和成員方法）的