第三讲 Java面向对象编程

第三章JAVA面向对象编程***温故***Java程序数据类型运算符和表达式语句本讲要点面向对象编程的基础类的定义对象的创建与使用创建对象使用对象访问权限Static关键字一、面向对象编程的基础类和对象类是定义对象的模板，用来描述一类事物的共有属性和功能。对象是一个具体的事物。例：汽车类—某辆汽车学生类—某个学生窗口类—某个具体的窗口汽车(类)品牌型号颜色----------加速与减速设计转向设计刹车设计……这辆汽车(对象)品牌：保时捷型号：980颜色：灰色-------------------加速减速控制转向控制刹车控制

类是Java语言中的一种复合数据类型，是组成Java程序的基本要素。Java的类具有两种基本成分：数据和行为（状态和方法）。类的这两种成分被封装在类体中，与外界隔开。1、类的结构例：publicclassHelloWorld//类{

Stringstr=“Helloworld”;//状态，或叫成员变量publicstaticvoidmain(String[]args)//方法，或叫成员方法 { System.out.println(“Helloworld!!”); }}类的封装2、类的定义类首：类的修饰符有：public、abstract、final……extends父类名：表示所定义的类由“父类”继承而来。implements接口列表：该类对指定接口进行实现。{[类成员变量声明] [类方法声明]}类体：构造方法成员方法[修饰符]class类名[extends父类名][implements接口列表]publicclassPerson{

floatheight,weight; Stringname,peoNumber,nationality

publicPerson(Stingnationality){this.nationality=nationality;}

voidsetName(Stringname){ =name;}

voidspeak(Strings){ System.out.println(s);}}（1）成员变量与局部变量成员变量：是类的数据成分，在类体中直接定义，定义格式为：[修饰符]变量类型成员变量名列表；修饰符：public、private、protected、final、static等，用来标识变量的使用范围和性质。局部变量：在方法体内定义的变量和方法的参数是局部变量。局部变量名可以和成员变量名重名，此时局部变量会隐藏成员变量，如果想在该方法内部使用成员变量，使用关键字this。(2)构造方法的说明说明形式如下：

[构造方法修饰符]方法名（[形式参数列表]）

{方法体}⑴构造方法的名字与类的名字相同⑵构造方法没有返回类型(千万不要将返回值类型声明为void。也不能在方法内部使用return返回一个值。)

⑶构造方法是在创建对象时，系统自动为所创建的对象初始化化的方法。实际上Java语言为每一个类提供了一个默认的构造方法，也就是说，每个类都有构造方法。如果不定义一个构造方法，Java语言将调用它提供的默认的构造方法对一个新的对象进行初始化（3）成员方法成员方法是类的行为成分，声明格式如下：[修饰符]返回值类型方法名（[形参列表]）{ [方法体] [return表达式；]}classTriangle{ floatsideA,sideB,sideC,lengthSum; voidsetSide(floatsideA,floatsideB,floatsideC){ this.sideA=sideA; this.sideB=sideB; this.sideC=sideC; }}1、修饰符：public、private、protected、static、final……2、如果方法没有返回值，则使用void关键字。如果有返回值类型，则方法体中必须有return语句，并且表达式类型与方法类型一致。3、形式参数列表的形式如下： 类型名

形参名1，类型名形参名2，……类的定义--例1classPerson{

Stringname,sex; intage; voidsing() { System.out.println("Icansing!"); } voiddance() { System.out.println("Icandance!"); } voidout()//成员变量的操作只能放在方法中 { System.out.println("name:"+name); System.out.println("age:"+age); } }定义描述“人”的类：成员变量：姓名、性别、年龄；成员方法：唱歌，跳舞，输出classPerson{

Stringname,sex;intage;

publicPerson(){ age=18; name="无名";} publicPerson(Stringname){ =name;}voidsing(){ System.out.println("Icansing!");} voiddance(){ System.out.println("Icandance!");} voidout(){ System.out.println("name:"+name); System.out.println("age:"+age);} }定义描述“人”的类：成员变量：姓名、性别、年龄；成员方法：唱歌，跳舞，输出构造方法：对成员变量赋初值类的定义--例2：梯形类classLadder{

floata,b,h;

Ladder(floata,floatb){this.a=a;this.b=b;}voidsetH(floath){ this.h=h;} floatcalculatArea(){ return(a+b)*h/2;}}定义描述梯形类：成员变量：上底、下底、高成员方法：设置高，计算面积构造方法：对上下底赋初值2、创建和使用对象如何调用类中定义的成员变量和成员方法，在Java中类只有实例化为对象后才能被使用(注：main方法为特殊方法，由系统调用)，对象的使用“分三步走”：(1)声明对象：类名对象名；如：Personp(2)分配内存（对象的实例化）

对象名=new类构造方法名（[实参表]）；如：p=newPerson();(3)使用对象（对象的成员变量及方法的访问）

对象名.方法名、对象名.成员变量名如：p.agep.out()(1)声明和(2)初始化可以合并：类名对象名=new类的构造方法名（[实参表]）；如：Personp=newPerson();使用对象—例3方法一：在同一个类中使用对象classPerson{ . . . publicstaticvoidmain(String[]args) { Personp; p=newPerson(); ="zhangsan"; p.age=20; p.sing(); p.out(); } }栈内存堆内存p0x30000x30000age...newperson()产生的对象使用对象—例4方法二：在不同类中使用对象classPerson{ . . .}classPersonTest{ publicstaticvoidmain(String[]args) { Personp; p=newPerson(); ="zhangsan"; p.age=20; p.sing(); p.out(); }}使用对象—例5梯形classLadder{ . . .publicstaticvoidmain(String[]args){ floatarea; Ladderladder=newLadder(); ladder.a=10.0f; ladder.b=20.0f; ladder.setH(5f); area=ladder.calculatArea(); System.out.println("area="+area);}}Java程序classLadder{ floata,b,h; voidsetH(floath) { this.h=h; } floatcalculatArea() { return(a+b)*h/2; }}PublicclassLadderTest{publicstaticvoidmain(String[]args){ floatarea; Ladderladder=newLadder(); ladder.a=10.0f; ladder.b=20.0f; ladder.setH(5f); area=ladder.calculatArea(); System.out.println("area="+area);}}}对象变量的赋值classPersonTest{ publicstaticvoidmain(String[]args) { Personp1,p2,p3; p1=newPerson(); p2=newPerson("孙悟空"); p3=newPerson("猪八戒"); p1=p2; =“唐僧”;p1.age=50; p1.out();p2.out();p3.out(); } }结果如何?对象变量的赋值，是对象中保存的地址发生的变化如果一个对象没有任何变量引用它，则它成为垃圾内存。3、访问权限用一个类创建一个对象后，通过对象可以访问这个类的成员变量和成员方法，但这种访问是有一定限制的。这种限制取决于在声明变量和成员方法时使用的修饰符：public、private、protected、友好（未使用修饰符）。（1）private变量和方法访问权限最小，只能在同一个类中被访问。同一个类的方法中直接访问。同一个类的对象也可以引用本类的私有成员。不能在另一个类中引用（2）友好变量和方法不使用修饰符：public、private、protected，即缺省这些修饰符的情况。比private权限级别高一级友好成员只能被同类或同包中的不同类引用。classPerson{ privateintage; privateStringname;Stringsex;

privatevoidout(){ System.out.println(name+“年龄：”+age+“岁");}

voidsetAge(intage){this.age=age;}publicstaticvoidmain(String[]args){Persontom=newPerson();="汤姆“; tom.age=20;//或tom.setAge(20); tom.out(); }}例6：classPersonTest{ publicstaticvoidmain(String[]args){ Personmarry=newPerson(); =“玛丽”//非法使用变量namemarry.age=20;//非法引用变量age marry.out();//非法调用方法out()

marry.sex=“女”//合法使用变量sexmarry.setAge=20;//合法调用方法setAge

}}（3）protected变量和方法比友好成员高一级，比public低一级。不能在不同包的类中被引用。如果不同包中的类是本类的子类，则子类的对象可以引用本类的受保护成员。（4）public变量和方法访问权限最大，可以在不同类、不同包的类中访问。packageex1;publicclassArea{ privatefloatgetArea(floatr) { System.out.print("方法一：");

return3.14f*r*r; } doublegetArea(floatx,inty) { System.out.print("方法二：");

returnx*y; } protectedfloatgetArea(intx,floaty) { System.out.print("方法三：");

returnx*y; } publicdoublegetArea(floatx,floaty,floatz) { System.out.print("方法四：");

return(x+x+y*y+z*z)*2.0; }}例7（2）public变量和方法packageex2;importex1.Area;classAreaTest{ publicstaticvoidmain(String[]args){Areaa=newArea();System.out.println(a.getArea(2.0f));//不合法

System.out.println(a.getArea(2.7f,12));//不合法System.out.println(a.getArea(12,2.7f));//

合法System.out.println(a.getArea(2.0f,10,20));//合法}}（2）public变量和方法packageex2;importex1.Area;classAreaTestextendsArea{ publicstaticvoidmain(String[]args){AreaTesta=newAreaTest();System.out.println(a.getArea(2.0f));//合法

System.out.println(a.getArea(12,2.7f));//合法System.out.println(a.getArea(2.7f,12));//不合法System.out.println(a.getArea(2.0f,10,20));//不合法}}变量和方法的访问控制（总结）publicprotected友好private同类同包不同类不同包子类通用不同情形下对象访问说明符4、static关键字静态变量/静态方法：对于成员变量/成员方法的声明，可以在类型的前面加修饰符“static”，称之为静态变量/静态方法。静态变量/静态方法属于类而不属于类的某个实例，可直接由类名来调用（类名·变量名/类名·方法名），因此也叫类变量/类方法；实例变量/实例方法：非静态的成员变量/方法必须实例化后通过对象名来调用（对象名·变量名/对象名·方法），因此称为实例变量/实例方法。说明：类变量和类方法也可以通过实例调用。类变量，它属于类所有，且在所有的实例中都共享同一个内存空间；实例变量，对于每一个实例，这个变量都拥有独自的内存空间。类方法，在类加载时分配方法入口地址，因此可被类直接调用。实例方法，只有创建类的对象，才会分配方法入口地址，并只能通过对象调用方法。（1）类变量/类方法、实例变量/实例方法classStaticDemo{staticintx;inty;publicstaticintgetX(){ returnx;}publicstaticvoidsetX(intnewX){ x=newX;}publicintgetY(){ returny;}publicvoidsetY(intnewY){ y=newY;}}0xStaticDemo入口地址getx()入口地址setx()publicclassShowDemo{publicstaticvoidmain(String[]args){System.out.println("静态变量x="+StaticDemo.getX());

StaticDemoa=newStaticDemo();

StaticDemob=newStaticDemo();

a.setX(10);b.setX(30);

a.setY(20);b.setY(40);

System.out.println("静态变量a.x="+a.getX());System.out.println("静态变量b.x="+b.getX());System.out.println("静态变量x="+StaticDemo.getX());System.out.println("实例变量a.y="+a.getY());System.out.println("实例变量b.y="+b.getY());

}}例8：内存模型分析实例变量0a.y0xStaticDemo0b.y10x30x20a.y40b.y总结（静态成员在使用时应该注意）：①静态方法中只能直接调用同类中其他静态成员，而不能调用非静态成员。反之，则可以。②静态成员的引用直接通过类名引用，也可以通过该类的对象来引用。③静态方法中不能使用super和this变量。例9：classA{staticinti=10;Strings="helloworld!";publicstaticvoidmain(String[]args){ System.out.println("i="+i);// System.out.println("s="+s);}}（2）static应用注意事项**总结**类的定义成员变量说明成员方法说明对象的创建和使用创建对象通过对象引用成员变量和成员方法构造方法构造方法与一般成员方法的区别构造方法不是void型访问权限

private,友好，protected,publicStatic关键字二、面向对象编程进阶类的继承多态抽象类和抽象方法接口包1、类的继承动物猫狗哺乳动物鸟燕子麻雀类的定义可以是分层次的，低层的类具有高层类的属性和方法，称高层类为父类，低层类为子类。子类使用父类中定义的方法和变量时，就像它们属于子类本身一样。可以简化编程的过程，有利于代码的复用。子类除了拥有父类的方法和变量之外，也可以定义自己方法和变量。哺乳动物：胎生，能用母乳喂养幼仔。猫：胎生，能用母乳喂养幼仔。会捉老鼠。1、类的继承(续）继承：由已有类创建新类的机制。新类继承已有类的成员，并可根据需要增加自己新的成员。已有类称为父类，新类称为已有类的子类。Java不支持多继承，一个子类只能有一个父类，但一个父类可以派生出若干个子类。classPerson{Stringname;intage;Person(Stringname){ =name;}publicvoidsetAge(intage){ this.age=age;}voidout(){ System.out.println("姓名:"+name+"年龄:"+age+"岁");}}子类（例）publicclassStudentextendsPerson{intjava,flash;Student(Stringname,intjava,intflash){ super(name); this.java=java; this.flash=flash; setAge(5000);}voidout(){ super.out(); System.out.println("java:"+java+"\tflash:"+flash);

}voidlearn(){ System.out.println(name+"islearning");}publicstaticvoidmain(String[]args){ Students=newStudent("孙悟空",80,80); s.out(); s.learn();}}1、类的继承性（续）子类和父类在同一包中子类可继承其父类中非私有成员（不是private的成员）子类和父类不在同一包中子类只能继承受保护的和共有成员（public、protected）(1)成员变量的隐藏和方法的重写成员变量的隐藏：如果在子类中定义了与父类中同名的变量，父类的这个变量将被隐藏。方法的重写：如果子类中定义了与父类同名、同类型、相同参数的方法，则称子类覆盖了父类的方法。这是子类的一种“变异”，子类可以根据需要把从父类继承来的方法进行改造。比如：在student类中重新声明方法out()voidout(){super.out(); System.out.println("java:"+java+"\tflash:"+flash);}(2)super关键字特殊变量super，提供了对父类的访问。1、可以使用super访问父类被子类隐藏的变量或覆盖的方法。如：在student类中改写out方法时，可以使用super.out();来调用父类中对name和age的输出。调用父类的变量。2、可能通过Super([参数表])来调用父类的构造方法。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。(3)this关键字this关键字只能用在实例方法或构造方法中，提供了对当前对象的访问。voidsetAge(intage){ this.age=age;}publicstaticvoidmain(String[]args){ Personp1,p2,p3; p1=newPerson(); p2=newPerson("孙悟空");

p3=newPerson("猪八戒",300,2.8f,380); p1.setAge(18);p2.setAge(19);p3.setAge(20); p1.out();p2.out();p3.out();} （4）final类和final成员final类：不能派生子类。final变量，其值不能在程序运行过程中改变，是常量。final方法，不能被子类方法重写。如：publicfinalclassFather{}publicclassSonextendsFather?如：publicclassFather{finalintx=10;publicfinalvoidshow(){}}publicclassSonextendsFather{publicvoidshow(){}}（5）对象的上转型对象父类的变量能否引用子类的对象？能。子类的变量能否引用父类的对象？不能。父类的变量称为子类对象的上转型对象。Personp;p=newStudent();Students;s=newStudent();p=s;新增变量新增方法从父类继承或重写的变量从父类继承或重写的方法

s的上转型对象S对象psPersonp=newStudent("唐僧",100,100);p.out();//p.learn();Studentsp=(Student)p;sp.learn();

（5）上转型对象操作说明上转型对象不能操作子类新增成员上转型对象可以操作从父类继承的成员，或在子类中重写的父类成员。上转型对象在被改写的成员时，调用子类成员，而非父类成员。上转型对象通过强制类型转换成为子类对象。2、多态性在程序中同一符号或名字在不同情况下具有不同解释的现象称为多态性。表现在两方面：方法的重载。方法的覆盖。（1）方法的重载在一个类中可以定义同名的方法，但是参数的类型和个数不能完全相同，同名的方法可以有不同的方法体从而完成不同的任务，当调用方法时，系统会自动调用与实际参数类型和个数相匹配的的那一个方法，这就是方法的重载。在面向对象编程中，这种同一个名字可以有不同解释的现象称为多态。（1）方法的重载（续）在一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。同名的方法可以有不同的方法体从而完成不同的任务，当调用方法时，系统会根据调用方法的实际参数类型和个数自动调用相应的方法，这就是方法的重载。classHeshang{ voiddashui(Strings) { System.out.println(s+"挑水喝"); }

voiddashui(Strings1,Strings2) { System.out.println(s1+"和"+s2+"抬水喝"); }

voiddashui(Strings1,Strings2,Strings3) { System.out.println(s1+""+s2+""+s3+"没水喝"); }

publicstaticvoidmain(String[]args){ Heshangh=newHeshang(); h.dashui("孙悟空");

h.dashui("孙悟空","猪八戒");

h.dashui("孙悟空","猪八戒","沙和尚");}}（1）构造方法的重载classPerson{ Stringname;intage;floatheight,weight; publicPerson() { age=18; name="无名"; }

publicPerson(Stringname) { =name; } publicPerson(Stringname,intage,floatheight,floatweight) { =name; this.age=age; this.height=height; this.weight=weight; } voidout()//成员变量的操作只能放在方法中 {

System.out.println(“姓名:”+name+“年龄:”+age+“岁”+ "身高:" +height+"米"+"体重:"+weight+"斤");

System.out.println(); }

}classPersonTest{ publicstaticvoidmain(String[]args) { Personp1,p2,p3; p1=newPerson(); p2=newPerson("孙悟空");

p3=newPerson("猪八戒",300,2.8f,380); p1.out();p2.out();p3.out(); } }（1）构造方法的重载（续）（2）子类成员方法的覆盖publicclassPerson{Stringname;intage;publicvoidsetAge(intage){ this.age=age;}publicvoidout(){ System.out.println("姓名:"+name+"年龄:"+age+"岁"); }}publicclassStudentextendsPerson{intjava,flash;voidlearn(){System.out.println(name+"islearning!");}voidout(){ System.out.println("姓名:"+name+"年龄:"+age+"岁"+"java:"+java+ "\tflash:"+flash);}作业与上机训练要求1、创建父类Animal和子类Dog要求如下：（1）Animal（父类）中定义至少两个成员变量，一个带参数的构造方法，一个成员方法。（2）Dog（子类）中定义两个以上成员变量，隐藏父类中的一个成员变量，重写父类中的一个成员方法。（3）对子类进行实例化，输出对象的成员变量值（包括从父类继承而来的变量），调用对象的各成员方法（包括从父类继承来的方法）。2、按要求补充代码（附下页）classZuoye2{ privatefloatr;//r为圆的半径

/*补充代码段1 */ publicfloatcircle()//计算圆的面积 { return3.14f*r*r; }}classTest{ publicstaticvoidmain(String[]args) { Zuoye2z=newZuoye2();

/*补充代码段2，计算输出半径为10的圆的面积 */

} }技能训练2类的继承训练目的使学生了解类成员的访问权限设置与应用使用学生掌握子类的创建，理解子类的继承，成员变量的隐藏与成员方法的重写。相关知识点子类的构造方法与父类构造方法之间的关系：子类构造方法的第一条语句隐含调用父类的构造方法—super();子类继承父类中的非private成员（在同一个包中）子类继承父类中的非private与非友好成员（不同的包中）子类中的成员与父类中成员相同，则隐藏父类成员父类的对象变量（对象的上转型对象）可以引用子类的对象技能训练3方法的重载、类变量/类方法实验目的让学生掌握方法的重载让学生掌握类变量与实例变量，以及类方法与实例方法的区别。让学生掌握包的使用实验要求与内容3、抽象方法与抽象类用关键字abstract修饰的类就是抽象类。没有方法体的方法，且首部用关键字abstract修饰，就是抽象方法。声明抽象方法的格式：[修饰符…]abstract返回值类型方法名([形参列表]);publicabstractclassAAnimal { publicStringname; publicintage; publicvoidprint() { System.out.println("名字:"+name); System.out.println("大小:"+age); } publicabstractvoidrun(); publicabstractvoidcry();}（1）抽象方法与抽象类使用说明含有抽象方法的类必须定义为抽象类。publicclassAAnimal //错误{

publicStringname; publicintage; publicvoidprint() { System.out.println("名字:"+name); System.out.println("大小:"+age); } publicabstractvoidrun(); publicabstractvoidcry();}（1）抽象方法与抽象类使用说明(续)不能由抽象类直接创建对象。它只能做为父类使用，由它派生的子类必须实现抽象类中所有的抽象方法，才能创建对象。抽象方法的实现：子类重写父类的抽象方法，增加方法体，使之成为一个非抽象方法。可以空实现。classTest{ publicstaticvoidmain(String[]args){ AAnimala; a=newAAnimal(); //错误}}classDogextendsAAnimal{ Stringtype; publicDog() { type="宠物狗"; }

publicvoidrun(){ } publicvoidcry() { System.out.println("汪汪叫"); }}classTest{ publicstaticvoidmain(String[]args){ Doga; a=newDog(); ="欢欢";a.age=2; a.print(); a.cry(); System.out.println("这是一只"+a.type);}}续（1）抽象方法与抽象类使用说明(续)如果子类没有实现抽象基类(父类)中所有的抽象方法，则子类也必须定义成一个抽象类。即：抽象的子类也必须使用修饰符：abstract可以将没有任何抽象方法的类声明为abstract，避免由这个类直接创建任何的对象。abstractclassDogextendsAAnimal{ Stringtype; publicDog() { type="宠物狗"; }

//publicvoidrun(){ } publicvoidcry() { System.out.println("汪汪叫"); }}classBirdextendsAAnimal//定义鸟类继承动物类{

publicBird()//构造方法初始化 {

name="麻雀";

age=3; } publicvoidrun()//实现父类的抽象方法 {

System.out.println("会飞"); }

publicvoidcry() { System.out.println("叽叽喳喳"); }}创建鸟类对象：练习（例）鸟类抽象类：图形，抽象方法—求面积(指出：图形必须有求面积的方法，但因为不同图形求面积的方法不一样，因此将此方法声明为抽象方法)子类：梯形类，实现了抽象类中求面积的抽象方法。子类：圆，实现了抽象类中求面积的抽象方法。类：堆，求体积。应用程序类：创建梯形、圆、堆对象，分别进行计算。（2）小结用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。abstract类必须被继承，abstract方法必须被重写。抽象类不能被实例化（直接创建对象）。抽象方法只需声明，而不需实现（无方法体）。作业（三）作业二：按以下要求编写程序创建一个抽象的车类，包括各种车辆。至少包含一个抽象方法。成员变量：品牌、可载人数、轮子个数、能源等。抽象方法如：跑、加速、刹车等。通过继承车类重新声明公共汽车类和普通自行车类。在子类中实现父类中抽象方法构造方法对应区分为公共汽车和普通自行车。子类的构造方法中根据不同的类设置不同的默认值，如汽车类可以默认轮子个数是4个，可载人数50个，能源为汽油。技能训练4训练目的掌握抽象类与抽象方法的应该技巧实验要求：创建一个抽象的车类，包括各种车辆。至少包含一个抽象方法。成员变量：品牌、可载人数、轮子个数、能源等。抽象方法如：跑、加速、刹车等。通过继承车类重新声明公共汽车类和普通自行车类。在子类中实现父类中抽象方法构造方法对应区分为公共汽车和普通自行车。子类的构造方法中根据不同的类设置不同的默认值，如汽车类可以默认轮子个数是4个，可载人数50个，能源为汽油。实验中应解决的问题：含有抽象方法的类一定是抽象类吗？抽象类中一定要有抽象方法吗？如何实现抽象方法？4、接口及应用***温故***抽象方法abstract方法，并且没有方法体。抽象类abstract类，一般含有抽象方法。抽象类的一般用法只能做为父类被继承，不能直接实例化。只有通过子类实现抽象方法后，才能实例化。一般对于不同的子类可以有不同的实现过程。本讲要点接口的基本概念接口定义接口实现接口应用举例理解接口Jar文件（略）（1）接口的概念在《ThinkinginJava》一书中，作者对接口有这样的描述：“接口（interface）比抽象（abstract）的概念更进了一步。你可以把一个接口看成是一个纯的抽象类。”为什么使用接口？1、Java中不允许类的多继承，但在解决实际问题过程中，仅仅依靠单一继承在很多情况下都不能将问题的复杂性表述完整。通过接口可以实现多继承。如：Father类有playFootball()，Mother类有sing()，如果采用类的继承来产生一个Son类，则它只能从一个类中继承。要么继承Father，要么继承Mother。2、接口在面向对象的设计与编程中应用非常广泛，特别是实现软件模块间的连接方面有着巨大的优势。（2）接口的声明及注意事项如果一个抽象类中所有的方法都是抽象的，就可以将这个类用另外一种方式来定义，也就是接口定义。[public]interface接口名[extends父接口名列表]{ 数据类型常量名=常数;

返回值方法名([参数列表]);}几点说明：1、interface是接口的关键字，定义接口和定义类相似。并被编译为class文件。2、接口的访问控制符只有public，如果使用public修饰符，则可以被所有类和接口使用，且接口名与文件名相同。如果不使用public，则接口只能被同一个包中的类和接口使用。3、接口中所有的方法都是publicabstract即公共的抽象方法。4、接口中可以有数据成员，这些数据成员默认都是publicstaticfinal即公共类常量。（3）接口声明实例//Father.java文件名publicinterfaceFather//父亲会踢球{ publicabstractvoidplayFootball();}//Mother.java文件名publicinterfaceMother//母亲爱唱歌{ publicabstractvoidsing();}//Flyable.java能飞的动物publicinterfaceFlyable{ publicabstractvoidfly();}//Talkable.java能说话的动物publicinterfaceTalkable{ publicabstractvoidtalk();}（4）接口的实现与多继承接口的实现通过类来完成，在定义类时使用“implements接口名列表”短语，并在类体中实现接口中的抽象方法。接口和实现类之间的关系实质上是继承的关系1、一个类可以实现多个接口，从而实现多继承。publicclassSmartChild

implementsFather,Mother{ publicvoidplayFootball() { System.out.println("我会踢足球！"); }

publicvoidsing() { System.out.println("我会唱歌！"); }

publicstaticvoidmain(String[]args) { SmartChildchild=newSmartChild(); child.playFootball(); child.sing(); }}类实现接口时的注意事项注意：在类声明部分，用implements关键字指明该类将要实现哪些接口。实现接口的类必须在类体中给出所有方法的实现，否则该类应该声明为抽象类。接口中的方法都是public的，所以实现方法时也必须加上public，否则编译报错。总结：一个接口可以继承另一个接口Java中不允许类的多继承，但允许接口的多继承在java中一个类可以实现多个接口一个类在继承另一个类的同时，可以实现多个接口。例interfaceComputable{ finalintMAX=100; voidspeak(Strings); intf(intx); floatg(floatx,floaty);}classChinaimplementsComputable{ intxuehao; publicintf(intx) { intsum=0; for(inti=1;i<=x;i++) { sum+=i; } returnsum; } publicfloatg(floatx,floaty) { return6; } publicvoidspeak(Strings) { }}classJapanimplementsComputable{ intxuehao; publicintf(intx) { return68; } publicfloatg(floatx,floaty) { returnx+y; } publicvoidspeak(Strings) { }}publicclassExample4_26{ publicstaticvoidmain(String[]args){ Chinach; Japanja; ch=newChina();ja=newJapan(); ch.xuehao=991898;ja.xuehao=941448; System.out.println("xuehao:"+ch.MAX+ch.xuehao+ "1+2+...+100="+ch.f(100)); System.out.println("xuehao:"+ch.MAX+ja.xuehao+ "两数之和："+ja.g(12,23));}}接口应用实例—程序模块间的连接//PCI接口，可看成一种标准interfacePCI{ voidsetName(Strings); voidrun(); }//符合PCI接口标准的网卡，即实现了PCIclassNetworkCardimplementsPCI{ Stringname; publicNetworkCard() { name="D-Link"; } publicvoidsetName(Strings)//实现接口中的抽象方法 {

name=s; } publicvoidrun()//实现接口中的抽象方法 {

System.out.println(name+"网卡已开始工作！"); }}例：组装电脑，通过PCI接口将主板模块与网卡模块和声卡模块连接。（接口回调）//符合PCI标准的声卡，即实现了PCI接口classSoundCardimplementsPCI{ Stringname="SoundMax"; publicvoidsetName(Strings)//实现接口中的方法 {

name=s; } publicvoidrun()//实现接口中的方法 {

System.out.println(name+"声卡已开始工作!"); }}//集成PCI接口的主板classMainboard{ //usePCICard方法用来向主板插入一块PCI卡

publicvoidusePCICard(PCIp)//参数p就是一个PCI卡 {

p.run(); } publicvoidrun() { System.out.println("主板已开始工作！"); } }接口实例（续1）//组装一台电脑classComputer{ publicstaticvoidmain(String[]args) { Mainboardmb=newMainboard();//选一块主板

NetworkCardnc=newNetworkCard();//买一块网卡

nc.setName(“NEC”);//这是一块NEC牌的网卡

SoundCardsc=newSoundCard();//买了一块声卡

mb.usePCICard(nc);//将网卡插到主板上

mb.usePCICard(sc);//将声卡插到主板上

mb.run();//主板运行 }}接口实例（续2）红字部分注解：无论是网卡还是声卡，都是PCI接口的子类，所以，他们的对象能直接传递给usePCICard方法中的PCI接口的引用变量p，在参数传递过程中发生接口回调。理解接口接口只关心功能，不关心功能的具体实现收费接口与不同交通工具类具体收费情况项目主管、部门开发、speakLove方法教务管理系统中，教务处模块、各系部，如果教务处想调用各系的教学计划并打印，此时使用接口是必要的。教学计划（年号）小结1、接口的概念：如果一个方法中的所有方法都是抽象的，则可以以接口的形式进行定义。2、接口定义：使用interface关键字进行定义，数据成员隐含修饰符：publicstaticfinal，方法隐含修饰符：publicabstract3、接口实现：通过类来实现，使用implements短语。4、接口应用。作业（四）二、编程1、编写Animal接口，接口中声明run()方法2、编写Plant接口，接口中声明eatable()方法3、定义Bird类和Fish类实现Animal接口4、定义Grass类和Tomato类实现Plant接口三、上机训练1、编程序验证：一个类在继承另一个类的同时实现一个接口。2、在调试程序过程中总结接口定义、接口实现时应注意的问题。5、包的概念为了便于管理大型软件系统中数目众多的类，解决类命名冲突的问题，java引入了包。Java中的包与文件系统的目录层次结构是一一对应的。一个包中可以包含子包，包名与子包名间用“·”分隔。Java提供的类和接口是按不同的用途分别放在不同的包中。java.appletjava.awtjava.langjava.iojava.util（1）package语句功能：创建包格式：package包名[.子包名[…]];要求：此语句必须放在整个源程序第一条语句例：packagep;//(在当前目录下创建一个p包)packagea.b;//（在当前目录下创建a，在a下再创建b）注意：嵌套的包名之间以圆点分隔（“.”）。如果源文件中省略了package语句，则文件中定义的类隐含在一个无名包中，这个无名包就是源文件所在的位置。引入java包中的类和接口import语句一般情况下import语句紧跟在package语句之后功能：将其他包中的类引入到当前程序中。格式：import带包层次结构的类名;说明：1、引入包时，类名可以使用通配符“*”，表示包模块中某个层次的类全引入进来。例： importjava.io.*; importjava.awt.Graphics;2、java会自动引入lang包下的所有类和接口。3、前缀包名法：不用import语句也可以引入其他包中的类和接口。classArea//作业1{floatgetArea(floatr){ System.out.print("方法一：");

return3.14f*r*r;}doublegetArea(floatx,inty){ System.out.print("方法二：");

returnx*y;}floatgetArea(intx,floaty){ System.out.print("方法三：");

returnx*y;}doublegetArea(floatx,floaty,floatz){System.out.print("方法四：");return(x+x+y*y+z*z)*2.0;}}作业（五）1、将Area类补充为如右所示的程序。定义新类AreaTest，并创建Area类的对象调用每一个成员方法，观察不同的参数与调用方法的之间的关系。2、将作业1中Area与AreaTest类分别放在不同的包中重新编译运行。3、按程序模板（Test.java）要求编写源文件，将[代码x]按其后的要求替换为java程序代码。分析程序输出结果。作业3程序模板classA{ [代码1]//声明一个float型的实例变量a [代码2]//声明一个float型的类变量b voidsetA(floata) { [代码3]//将参数a赋值给成员变量a } voidsetB(floatb) { [代码4]//将参数b赋值给成员变量b } floatgetA() { returna; } staticfloatgetB() { returnb; } voidoutA() { System.out.println(a); } [代码5]//定义方法outB()，输出变量b}publicclassTest{ [代码6]//通过类名引用变量b，给b赋值为100 [代码7]//通过类名调用方法outB() Acat=newA(); Adog=newA(); [代码8]//通过cat调用方法setA()，将cat的成员变量a设置为200 [代码9]//通过cat调用方法setB()，将cat的成员变量b设置为300 [代码10]//通过dog调用方法setA()，将dog的成员变量a设置为400 [代码11]//通过dog调用方法setB()，将dog的成员变量b设置为500 [代码12]//通过cat调用outA() [代码13]//通过cat调用outB() [代码14]//通过dog调用outA() [代码15]//通过dog调用outB()}6、常用包和类常用包Java.langObjectMathSystem字符串StringStringBufferJava.ioJava.utilJava.awtJava.applet1Math类（数学类）

数学类包含了许多数学函数如sin、cos、exp、abs等。Math类是一个工具类，它在解决与数学有关的一些问题是有着非常重要的作用。1Math类（数学类）方法（均为静态方法）public

static

int

abs(

int

a

)public

static

long

abs(

long

a

)public

static

float

abs(

float

a

)public

static

double

abs(

double

a

)

求a的绝对值public

static

double

exp(

double

a

)exp求e的a次幂。1Math类（数学类）方法（均为静态方法）public

static

double

floor(

double

a

)floor返回

最大的

小于a的整数。public

static

double

pow(

double

a,

double

b

)pow求a的b次幂。public

static

double

sqrt(

double

a

)sqrt求a的开平方。publicstaticdoublerandom（）random产生0~1之间伪随机数。

Publicstaticdoubleround(doublea)round四舍五入。例

Math类的使用publicclassmathInstance{publicstaticvoidmain(Stringargs[]){System.out.println(Math.E);System.out.println(Math.PI);System.out.println(Math.exp(5.7));System.out.println(Math.random());System.out.println(Math.sqrt(9.08));System.out.println(Math.pow(2,3));Syst