第三章面向对象程序设计

第三章Java与面向对象技术1、面向对象的概念2、Java中的类、方法和变量3、Java名字空间及访问规则4、Java中的抽象类、接口和程序包5、对象的构造方法6.初始化块

所谓面向对象的方法学，就是使我们分析、设计和实现一个系统的方法尽可能地接近我们认识一个系统的方法。包括：1、面向对象的概念

面向对象的分析（OOA,Object-OrientedAnalysis）面向对象的设计（OOD,Object-OrientedDesign）面向对象的程序设计(OOPL,Object-OrientedProgram)面向对象技术主要围绕以下几个概念:

对象、抽象数据类型、类、类型层次（子类）、继承性、多态性。

对象有两个层次的概念:变量方法1、面向对象的概念

——对象

现实生活中对象指的是客观世界的实体；

程序中对象就是一组变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。现实生活中的对象可以将现实生活中的对象经过抽象，映射为程序中的对象。ClassCar{intcolor_number;intdoor_number;

intspeed;

voidbrake(){…}voidspeedUp(){…}voidslowDown(){…}}

抽象数据类型1、面向对象的概念

——对象

对象在程序中是通过一种抽象数据类型来描述的，这种抽象数据类型称为类（Class）。程序中的对象是类的一个实例，是一个软件单元，它由一组结构化的数据和在其上的一组操作构成。1、面向对象的概念

——类相似的对象可以归并到同一个类中去，就像传统语言中的变量与类型关系一样。

类是描述对象的“基本原型”，它定义一类对象所能拥有的数据和能完成的操作。在面向对象的程序设计中，类是程序的基本单元。……Carcar1;Carcar2;…

…CarcarN;1、面向对象的概念

——类消息软件对象通过相互间传递消息来相互作用和通信，一个消息由三部分组成:1.接受消息的对象

2.接收对象要采取的方法

3.方法需要的参数对象B对象A消息1、面向对象的概念

——类变量：指对象的所知道的状态。方法：指对象的功能单元。一个例子classHello{

}privateStrings；publicvoidshowString(){System.out.println(s);}publicvoidchangeString(Stringstr){s=str;}变量方法showString()方法changeString()1、面向对象的概念——类调用对象的方法相当于给对象发送消息，收到消息的对象通过改变自身的状态或者向其它对象发送消息来响应消息。在程序中所操作的对象是类的一个实例。创建一个对象：Helloobj=newHello();调用方法：obj.changeString(“dance”);

为什么要使用类？1、面向对象的概念

——类采用简单数据类型表示现实世界中概念的存在很大的局限性。例如：采用int型数据表示一个日期概念，需要使用3个变量：

intday,month,year;

使用类可以把现实问题中的对象映射为程序中的一个整体——类。如果要表示2个人的生日，就要使用6个变量并且在使用中必须时刻注意三者的联系和约束关系intday1,month1,year1;intday2,month2,year2;类中不但有变量，还有与之相关的操作所定义的方法。将变量和方法封装在一个类中，可以对成员变量进行隐藏，外部对类成员的访问都通过方法进行，能够保护类成员不被非法修改。classBirthDate{publicintday,month,year;publicinttomorrow(){}}BirthDatemybirth,yourbirth;1、面向对象的概念

——类BirthDatelily;lily.day=31;lily.month=5;lily.year=1992;已知当前日期对象，求第2天的日期对象：lily.day=lily.day+1;如果lily.day已经为31，操作结果是非法状态。使用类的另一个方便之处，就是操作上的方便为什么要使用类？可以定义一个成员方法tomorrow()，求第2天的日期对象。外部要获得当前日期的后一天时，只要调用： lily.tomorrow();封装把对象的所有组成部分组合在一起私有数据

方法

方法数据对象A对象B公有数据封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。1、面向对象的概念

——封装子类是作为另一个类的扩充或修正而定义的一个类。bicycle(superclass)MountainbikesRacingbikesTandembikessubclass1、面向对象的概念

——子类继承是子类利用父类中定义的方法和变量，就像它们属于子类本身一样。classCar{intcolor_number;intdoor_number;intspeed;publicvoidpush_break(){…}publicvoidadd_oil(){…}}

classTrash_CarextendsCar{doubleamount;publicvoidfill_trash(){…}}1、面向对象的概念

——继承extendsCar的作用就是copy了父类定义的变量和方法方法的重写重写使得在子类中可以重新定义父类中已有的方法，从而体现出子类自己的行为。classCar{intcolor_number;intdoor_number;intspeed;publicvoidpush_break(){speed=0;}publicvoidadd_oil(){…}}

classTrash_CarextendsCar{doublecapacity;publicvoidfill_trash(){…}

publicvoidpush_break(){speed=speed–10;}}1、面向对象的概念

——方法的重写重载指得是在同一个类中至少有多个方法名字、类型相同，但是参数不同。类voidshow(intint_num)voidshow(doubledouble_num)voidshow(intint_num,floatfloat_num)1231.23123,1.231、面向对象的概念

——方法的重载（多态性）类、方法、变量定义的语法规范对象的创建和使用继承、重写、重载、多态等概念内嵌类(innerclass)2、Java中的类、方法和变量2、面向对象的实现

Java中的类、方法和变量

类的严格定义及修饰字类的修饰字：[public][abstract|final]

缺省方式为friendly[类的修饰字]class类名称[extends父类名称][implements接口名称列表]{

变量定义及初始化；方法定义及方法体；}类体，其中定义了该类中所有的变量和该类所支持的方法，称为成员变量和成员方法。[变量修饰字]

变量数据类型变量名1,变量名2[=变量初值]…;

变量的定义及修饰字[public|protected|private][static][final][transient][volatile]成员变量的类型可以是Java中任意的数据类型，包括简单类型，类，接口，数组。2、Java中的类、方法和变量

——变量定义的语法规范成员变量的作用范围是定义它的类。[方法修饰字]

返回类型方法名称(参数1,参数2,…)[throwsexceptionList]{…(statements;)//方法体：方法的内容}方法的定义及修饰字[public|protected|private][static][final|abstract][native][synchronized]

返回类型可以是任意的Java数据类型，当一个方法不需要返回值时，返回类型为void。2、Java中的类、方法和变量

——方法定义的语法规范

参数的类型可以是简单数据类型，也可以是引用数据类型（数组、类或接口），参数传递方式是值传递。

方法体是对方法的实现。它包括局部变量的声明以及所有合法的Java指令。局部变量的作用域只在该方法内部。一个简单的类classCar{intcar_number;voidset_number(intcar_num){car_number=car_num;}voidshow_number(){System.out.println(“MycarNo.is:”+car_number);}}classCarDemo{publicstaticvoidmain(Stringargs[]){CarDemocar=newCar();DemoCar.set_number(3838);DemoCar.show_number();}}MycarNo.is:38382、Java中的类、方法和变量

——一个简单的类（1）对象的生成通过new操作符生成一个对象；例如：

CarBenz,; Benz=newCar();CarBWM=newCar();2、Java中的类、方法和变量

——对象（2）对象的构造过程为对象开辟空间，并对对象的成员变量进行缺省的初始化；对成员变量进行指定的初始化；调用构造方法。（3）对象的使用利用对象，通过运算符

·可以实现对变量的访问和方法的调用。例如：

BirthDatelily=newBirthDate(); intday; day=lily.day; //引用lily的成员变量day lily.tomorrow(); //调用lily的方法tomorrow()2、Java中的类、方法和变量

——对象

类的继承classCar{intcar_number;voidset_number(intcar_num){car_number=car_num;}voidshow_number(){System.out.println(“MycarNo.is:”+car_number);}}2、Java中的类、方法和变量

——继承classTrashCarextendsCar{intcapacity;voidset_capacity(inttrash_car_capacity){capacity=trash_car_capacity;}voidshow_capacity(){System.out.println(“Mycapacityis:”+capacity);}}2、Java中的类、方法和变量

——继承Car是父类，TrashCar是子类。TrashCar中继承了Car中的两个方法，同时又增加了两个新方法。classCarDemo{publicstaticvoidmain(Stringargs[]){TrashCardemoTrashCar=newTrashCar();

demoTrashCar.set_number(4949);demoTrashCar.show_number();demoTrashCar.set_capacity(20);demoTrashCar.show_capacity();}}继承的方法新增加的方法2、Java中的类、方法和变量

——继承

继承性是面向对象程序设计语言的另一基本特征，通过继承可以实现代码的复用。2、Java中的类、方法和变量

——继承如果缺省extends子句，则该类为java.lang.Object的子类。通过在类的声明中加入extends子句来创建一个类的子类：classSubClassextendsSuperClass{……}Java中不支持多重继承。继承而得到的类为子类，被继承的类为父类，父类包括所有直接或间接被继承的类。何时选择继承?一个很好的经验：“B是一个A吗?”如果是则让B做A的子类.例：研究生是学生吗？那么研究生就是学生的子类2、Java中的类、方法和变量

——继承常犯的错误A有一个B吗?例如让汽车轮子成为汽车的子类是错误的例：研究生是people吗？那么研究生就是people的子类继承后得到的类应该是同一类

类方法的重写方法重写即指在子类中重新定义父类中已有的方法。classCar{intcolor_number;intdoor_number;intspeed;publicvoidpush_break(){speed=0;}publicvoidadd_oil(){…}}

classTrash_CarextendsCar{doublecapacity;publicvoidfill_trash(){…}

publicvoidpush_break(){speed=speed–10;}}2、Java中的类、方法和变量

——重写

重写方法的调用对于重写的方法，Java运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用。publicclassDemoCar{publicstaticvoidmain(Stringargs[]){ CaraCar=newTrash_Car(); aCar.push_break();}}在这里，类Trash_Car中的push_break()方法将被调用。2、Java中的类、方法和变量

——重写方法重写时应遵循的原则（1）重写后的方法不能比被重写的方法有更严格的访问权限。（2）重写后的方法不能比被重写的方法产生更多的例外。2、Java中的类、方法和变量

——重写例：washtheshirt

washthecar

washthedog

我们通过判断被wash的物体知道该用哪种方法来wash早期语言，比如C语言，不同的函数不能通用，导致

shirtWash(shirt)

carWash(car)

dogWash(dog)2、Java中的类、方法和变量

——重载

类方法的重载方法重载即指多个方法可以享有相同的名字。但是这些方法的参数必须不同，或者是参数个数不同，或者是参数类型不同。2、Java中的类、方法和变量

——重载

例如，要打印不同类型的数据，int,float,String,不需要定义不同名的方法：

printInt(int);printFloat(float);printString(String)。

利用方法重载，只需要定义一个方法名：println()，接收不同的参数：

println(int);println(float);println(String);例：classWash{voidwash(Cloth

shirt){……}

voidwash(Auto

car){……}voidwash(Animal

dog,intn){……}

}2、Java中的类、方法和变量

——重载动态绑定：例：调用wash方法，所有名字为wash的方法都会被找出来。

wash(Clothshirt)wash(Autocar)wash(Animaldog,intn)2、编译器根据调用时的实参值，选择所调用的方法，例：wash(benz)2、Java中的类、方法和变量

——动态绑定

多态性类方法的重载是一种多态性。除此之外，多态性还可以是指在程序中需要使用父类对象的地方，都可以用子类对象来代替。 2、Java中的类、方法和变量

——多态性例如：publicclassEmployeeextendsObject{……}publicclassManagerextendsEmployee{……}则：Employeee=newManager();//合通过instanceof可以判断所引用的对象实例的实际类型。可以用方法来实现对成员变量的隐藏：

设置变量方法：setVariable()

获取变量方法：getVariable()classSample{ protectedintx; ……

voidsetX(intvar) { x=var; } intgetX() { returnx; } ……}2、Java中的类、方法和变量

——成员变量的隐藏在Java语言中，提供了操作符instanceof用来判断对象是否属于某个类的实例。publicvoidmethod(Employeee){if(einstanceofManager){…//dosomethingasaManager}elseif(einstanceofContractor){ …//dosomethingasaContractor}else{ …//dosomethingelse}}2、Java中的类、方法和变量

——对象状态的确定EmployeeManagerContractor2、Java中的类、方法和变量

——内嵌类（innerclass）在一个类的内部声明的类，称为内嵌类。publicclassS{

inta=10;

...//codeforS'smethodspublicvoidp(){returnnewT();}classT{intc=a+10;publicbooleanh(){return(c>=0);}}}

内嵌类只能在包含它的类中使用，同时它可以看作是该包含类的一段特殊代码，可以直接使用该包含类的变量和方法。内嵌类编译后也会形成一个单独的class，但它附属于其包含类。3、Java名字空间及访问规则--Java的修饰符每个类都拥有自己的名字空间，即指类及其方法和变量可以使用的范围即作用域，通过修饰符完成这种限定。对类而言：abstract类：不能直接产生属于这个类的对象；public类：不但可以被同一程序包(package)中的其它类使用，别的程序包中的类也可以使用；friendly类(缺省，包访问类)：只能被本程序包中的其它类使用，不能被别的程序包中的类使用。final类：不能被其他任何类所继承(安全的考虑)；当一个类可以被访问时，对类内的成员变量和成员方法而言，其作用域可以通过不同的修饰词施以限定。

3、Java名字空间及访问规则private：public:

protected：

friendly(default，前边没有修饰字的情况)：a.private我是自私的，别碰我!!!私有变量或私有方法只能在定义它的类中使用classSundae{

privateSundae(){}staticSundaemakeASundae(){returnnewSundae();}}

publicclassIceCream{publicstaticvoidmain(String[]args){Sundaex=newSundae();//errorSundaex=Sundae.makeASundae();}}a.privateclassSundae{privateSundae(){}staticSundaemakeASundae(){returnnewSundae();}publicstaticvoidmain(String[]args){

Sundaex=newSundae();//okSundaex=Sundae.makeASundae();}}a.private

b.public公有变量或公有方法在任何其它类中都可以访问我有，你有，全都有!!!packagec05.dessert;

publicclassCookie{

publicCookie(){System.out.println("Cookieconstructor");}

void

bite(){System.out.println("bite");}}同一个包、不同的包中的类importc05.dessert.*;

publicclassDinner{publicDinner(){System.out.println("Dinnerconstructor");}publicstaticvoidmain(String[]args){Cookiex=newCookie();x.bite();//Can'taccess}}b.public不用修饰符修饰的变量和方法称为友好变量和友好方法,可以在同一包中的不同类之间访问c.friendlypackagec05.dessert;

publicclassCookie{

publicCookie(){System.out.println("Cookieconstructor");}

voidbite(){System.out.println("bite");}}有事您call我，谁让咱们是朋友呢!!!packagec05.dessert;publicclassDinner{publicDinner(){System.out.println("Dinnerconstructor");}publicstaticvoidmain(String[]args){Cookiex=newCookie();x.bite();//Canaccess}}tected当子类和父类不在同一个包时，子类可以访问父类中的protected成员packagec05.dessert;

publicclassCookie{

publicCookie(){System.out.println("Cookieconstructor");}

voidbite(){System.out.println("bite");}}

我真想独立，摸摸兜里没有多少钱!!!如果两个类是继承关系，protected就相当于public,否则相当于friendlyimportc05.dessert.*;

publicclassChocolateChipextendsCookie{publicChocolateChip(){System.out.println("ChocolateChipconstructor");}publicstaticvoidmain(String[]args){ChocolateChipx=newChocolateChip();

x.bite();//Can'taccessbite}}tectedpackagec05.dessert;

publicclassCookie{publicCookie(){System.out.println("Cookieconstructor");}

Protectedvoidbite(){System.out.println("bite");}}

tectedimportc05.dessert.*;

publicclassChocolateChipextendsCookie{publicChocolateChip(){System.out.println("ChocolateChipconstructor");}publicstaticvoidmain(String[]args){ChocolateChipx=newChocolateChip();

x.bite();//Canaccessbite}}

tected例：classTom{publicStringname;privatefloatwage;intage;…………}

classJerry{

voidg()

{Tomcat=newTom();

=“jitty”;//合法//

cat.wage=4300.00f;//不合法//cat.age=34;//若Tom和Jerry的在同一包中是合法的//方法和变量是一样的3、Java名字空间及访问规则

同一个类中同一个包中不同包中的子类不同包中的非子类（任意类）

private ★ default ★ ★ protected ★ ★ ★ public ★ ★ ★ ★ 当子类中的变量名与父类的相同，父类的变量被遮盖。classA { intdata_a=3; } 3、Java名字空间及访问规则classBextendsA{intdata_a=5; }classCextendsB{voidprint_out(){System.out.println(“data_a=”+data_a);}}classdemo{publicstaticvoidmain(Stringargs[]){Cc=newC();c.print_out();}}data_a=53、Java名字空间及访问规则

——final：到此为止final在类之前表示该类是最终类，不能再被继承。final在方法之前表示该方法是最终方法，该方法不能被任何派生的子类重写。final在变量之前表示变量的值在初始化之后就不能再改变；相当于定义了一个常量。static在变量或方法之前，称为类方法（静态方法）或类变量（静态变量）。若无static修饰，则是实例方法和实例变量。对象共享静态变量的存贮空间classEx{chardata;staticints_data;}classDemo{Exa,b,c,d;}3、Java名字空间及访问规则

——static：类变量和类方法a=newEx();b=newEx();c=newEx();d=newEx();adataas_databdatacdataddata,d,c,b类变量的生存期不依赖于对象，相当于C语言中全局变量的作用。通过类名访问它们。publicclassStaticVar{ publicstaticintnumber＝5;}publicclassOtherClass{ publicvoidmethod() { intx=StaticVar.number; }}3、Java名字空间及访问规则

——static：类变量和类方法类方法则相当于C语言中的全局函数，其他的类也可以直接通过类名来访问类方法。（Java程序的入口方法main()就是一个类方法）publicclassGeneralFunction{ publicstaticintaddUp(intx,inty) { returnx+y; }}publicclassUseGeneral{ publicvoidmethod() { inta=9; intb=10; intc=GeneralFunction.addUp(a,b); }}3、Java名字空间及访问规则

——static：类变量和类方法注意：1.同一个类的实例方法可以访问该类的类变量和类方法；3、Java名字空间及访问规则

——static：类变量和类方法

讨论：鉴于类变量和类方法的这种存贮特性和访问特性，什么样的方法和变量设计成静态更合适呢？2.而类方法只能访问该类的类变量和类方法，不能直接访问实例的变量和方法。

不正确的引用classStaticError{Stringmystring=“hello”;publicstaticvoidmain(Stringargs[]){System.out.println(mystring);}}3、Java名字空间及访问规则

——static：类变量和类方法编译时错误信息：nonstaticvariablemystringcannotbereferencedfromastaticcontext“System.out.println(mystring);”。为什么不正确：静态方法访问了非静态变量。解决的办法1.将变量改成类变量classNoStaticError{

staticStringmystring=“hello”;publicstaticvoidmain(Stringargs[]){System.out.println(mystring);}}3、Java名字空间及访问规则

——static：类变量和类方法解决的办法2.先创建一个类的实例classNoStaticError{Stringmystring=“hello”;publicstaticvoidmain(Stringargs[]){

NoStaticErrornoError;noError=newNoStaticError();System.out.println(noError.mystring);}}3、Java名字空间及访问规则

——static：类变量和类方法4、Java中的抽象类、接口和程序包

——抽象类与抽象方法抽象类：用abstract关键字来修饰一个类时，该类叫做抽象类；抽象类必须被继承。抽象类不能被直接实例化。它只能作为其它类的超类，这一点与最终类（final类）正好相反。抽象方法：用abstract来修饰一个方法时，该方法叫做抽象方法。抽象方法必须被重写抽象方法只有声明，不能有实现。定义了抽象方法的类必须是抽象类。abstractreturnType

abstractMethod([paramlist]);两个类Circle和Rectangle，完成相关参数的计算classRectangle{publicfloatwidth,height;Rectangle(floatw,floath){width=w;//这里不需"this"height=h;}publicfloatarea(){returnwidth*height;}}classCircle{publicfloatr;Circle(floatr){this.r=r;//this指"这个对象的"}publicfloatarea(){return3.14*r*r;}}4、Java中的抽象类、接口和程序包

——抽象类与抽象方法假设有若干个Circle，以及若干个Rectangle，希望计算它们的总面积，直截了当的做法是将它们分别放到两个数组中，用两个循环，用加法，这种做法是不漂亮的。4、Java中的抽象类、接口和程序包

——抽象类与抽象方法如果还有其它形状：Triangle，Ellipses等，上述方法更显得“累赘”。我们希望有一种统一的表示，例如用一个数组shape[]，接受所有的形状，然后用：for(i=0;i<shape.length;i++){area_total+=shape[i].area();}abstractclassShape{abstractfloatarea();}classRectangleextendsShape{publicfloatwidth,height;Rectangle(floatw,floath){width=w;//这里不需"this"height=h;}publicfloatarea(){returnwidth*height;}}classCircleextendsShape{publicfloatr;Circle(floatr){this.r=r;//this指"这个对象的"}publicfloatarea(){return3.14*r*r;}}4、Java中的抽象类、接口和程序包

——抽象类与抽象方法

接口（interface）就是方法定义和常量值的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现。4、Java中的抽象类、接口和程序包

——接口接口的定义：[public]interfaceinterfaceName[extendsSuperInterfaceList]{ …… //常量定义和方法定义}interfaceCollection{ intMAX_NUM=100; voidadd(Objectobj); voiddelete(Objectobj); Objectfind(Objectobj); intcurrentCount();}4、Java中的抽象类、接口和程序包

——接口例：接口的定义1.用implements子句来表示一个类使用某个接口。4、Java中的抽象类、接口和程序包

——接口的使用3.在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法。

2.利用接口可实现多重继承，即一个类可以使用多个接口，在implements子句中用逗号分隔。

4.接口的作用和抽象类相似，只定义原型，不直接定义方法的内容。5.接口中的方法和变量必须是public的。interfaceCollection{ intMAX_NUM=100; voidadd(Objectobj); voiddelete(Objectobj); Objectfind(Objectobj); intcurrentCount();}classFIFOQueueimplementsCollection{ voidadd(Objectobj) {

…… }

voiddelete(Objectobj) { …… }

Objectfind(Objectobj) { …… }

intcurrentCount() { …… }}4、Java中的抽象类、接口和程序包

——接口主要用法：在后面介绍的事件驱动编程中，对发生事件的响应就是通过使用接口来实现的4、Java中的抽象类、接口和程序包

——接口例：publicclassInterfaceTestimplementsActionListener{Buttonbutton=newButton();

…….button.addActionListener(this)

……publicvoidactionPerformed(ActionEvente)｛………..}}4、Java中的抽象类、接口和程序包

——接口

由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同，因此同名的类有可能发生冲突。4、Java中的抽象类、接口和程序包

——程序包（类包）为了解决这一问题，Java采用包机制来管理类名空间。

Java的程序包和C语言中的库函数有些相似。一、

打包4、Java中的抽象类、接口和程序包

——程序包（类包）1.Java中用package语句来将一个Java源文件中的类打成一个包。它的格式为：packagepkg1[.pkg2[.pkg3…]];3.package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包，也叫默认包)。4、Java中的抽象类、接口和程序包

——程序包（类包）Square.javapackagemyclass.graphics;classSquare{…;}classCircle{…;}classTriangle{…;}思考：Square.class、Circle.class和Triangle.class会存放在硬盘上的什么位置？

4.Java编译器把包对应于文件系统的目录管理，package语句中，用.来指明目录的层次。packagemyclass.graphics;

这条语句指定这个包中的文件存储在目录path/myclass/graphics下。4、Java中的抽象类、接口和程序包

——程序包（类包）包层次的根目录path是由环境变量CLASSPATH来确定的。classpath=.;d:\jdk1.7\lib;当前文件夹

编译和生成包在前面Square.java中已定义了

myclass.graphics，编译时可以采用如下方式：javac[-ddestpath]Square.java4、Java中的抽象类、接口和程序包

——程序包（类包）则编译器会自动在destpath目录下建立子目录myclass/graphics

，并将生成的.class文件都放到destpath/myclass/graphics下。。destpath应该是环境变量CLASSPATH中的一个。

为了能使用Java中已提供的类，我们需要用import语句来引入所需要的类。importpackage1[.package2…].(classname|*);例如：importmyclass.graphics.*；importjava.io.*；由环境变量CLASSPATH确定4、Java中的抽象类、接口和程序包

——程序包（类包）myclasspathSquaregraphics二、类的导入5、对象的构造方法

构造方法具有和类名相同的名称，而且没有返回值。系统在产生对象时会自动执行。

构造方法应包含的内容：1.

定义一些初值或内存配置工作；

构造方法(Constructor)是一种特殊的方法。Java中的每个类都有构造方法，用来初始化该类的一个新的对象。

2.一个类可以有多个构造方法(重载)，根据参数的不同决定执行哪一个；3.如果程序中没有定义构造方法，则创建实例时使用的是缺省构造方法，它是一个无内容的空方法。5、对象的构造方法publicclassEmployee{privateStringname;privateintsalary;publicEmployee(Stringn,ints){ name=n;//为成员变量置初值 salary=s;}publicEmployee(Stringn){

this(n,0);//对重载的构造方法的调用

}publicEmployee(){

this(“Unknown”);}}thisclassThisClass{publicstaticvoidmain(){Bankbank=newBank();bank.someMethod(this);}}classCircle{intr;Circle(intr){

this.r=r;}publicarea(){returnr*r*3.14;}}5、对象的构造方法this指向自己的引用，它的一个主要作用是要将自己这个对象当作参数，传送给别的对象中的方法。supersuper指这个对象的父类。super可以用来引用父类中的(被重写的)方法、(被隐藏的)变量及构造方法。publicclassappleextendsfruits{publicapple(intprice){super(price);//调用父类r构造方法

super.var=value;//调用父类的变量super.method(paraList);//调用父类中定义的普通方法}}以上程序表示使用父类的构造方法生成实例，super必须是子类构造方法的第一条语句。5、对象的构造方法构造方法的执行classGame{Game(inti){System.out.println("Gameconstructor"+i);}Game(){System.out.println("noparameterGameconstructor");}}classBoardGameextendsGame{BoardGame(inti){System.out.println("BoardGameconstructor"+i);}BoardGame(){System.out.println("noparameterBoardGameconstructor");}