《Java程序设计》电子课件模板

《Java程序设计》电子课件2019-5-111谢谢观赏《Java程序设计》电子课件2019-5-111谢谢观赏第1篇核心基础篇第3章Java面向对象特性2019-5-112谢谢观赏第1篇核心基础篇第3章Java面向对象特性2本章内容3.1类与对象3.2隐藏和封装3.3类的继承与多态3.4数组2019-5-113谢谢观赏本章内容3.1类与对象2019-5-113谢谢观赏学习目标掌握对象与类的基本概念了解对象的生命周期熟练掌握类的定义及实例化理解隐藏与封装熟练掌握类的继承与多态掌握数组的应用2019-5-114谢谢观赏学习目标掌握对象与类的基本概念2019-5-114谢谢观赏本章概要Java中类和对象的定义；Java对OOP三个主要特性——封装、继承和多态的支持机制；Java中的对象数组这种数据结构。2019-5-115谢谢观赏本章概要Java中类和对象的定义；2019-5-115谢谢观3.1类与对象类与对象的定义成员变量与局部变量成员方法对象的创建对象的使用对象的消除方法重载this构造方法2019-5-116谢谢观赏3.1类与对象类与对象的定义2019-5-116谢谢观赏3.1.1类和对象的定义Java程序是由一个或若干个类组成，类是Java程序的基本组成单位，包括：成员变量：描述对象的属性成员方法：描述对象的行为2019-5-117谢谢观赏3.1.1类和对象的定义Java程序是由一个或若干个类组类定义的结构2019-5-118谢谢观赏类定义的结构2019-5-118谢谢观赏1.类的声明格式[public][abstract|final]class<className>[extendssuperClassName][implementsinterfaceNameList]类的访问权限及其属性类定义关键字类名继承某个父类的关键字实现接口的关键字2019-5-119谢谢观赏1.类的声明格式[public][abstract2.类体构造和初始化新对象的构造方法；表示类及其对象状态的变量；

实现类及其对象的方法；进行对象清除的finalize()方法。2019-5-1110谢谢观赏2.类体构造和初始化新对象的构造方法；2019-5-13.1.2成员变量与局部变量成员变量（类）：在类体中声明的变量，且不属于任何一个方法时。局部变量：在方法体中声明的变量以及方法的参数则统称为方法的局部变量。2019-5-1111谢谢观赏3.1.2成员变量与局部变量成员变量（类）：2019-【例3-1】成员变量示例publicclassApple{

publicStringcolor; //公共变量color

publicstaticintnum; //静态变量num

publicfinalbooleanMATURE=true;//常量MATURE并赋值

publicstaticvoidmain(String[]args){System.out.println("苹果数量："+Apple.num);Appleapple=newApple();System.out.println("苹果颜色："+apple.color);System.out.println("苹果是否成熟："+apple.MATURE);}}num是类变量（即静态变量），可通过类名直接访问2019-5-1112谢谢观赏【例3-1】成员变量示例publicclassApple2.局部变量[final]<type><varibleName>;指定局部变量为常量局部变量的参数类型局部变量的名称2019-5-1113谢谢观赏2.局部变量[final]<type><varibl【例3-2】局部变量的使用publicclassApple{Stringcolor="Red";floatprice;publicStringgetColor(){returncolor;}publicfloatcount(){intnum;if(num<0)

return0;elsereturnprice*num;}成员变量错误语句，因为局部变量num还没有被赋值就使用2019-5-1114谢谢观赏【例3-2】局部变量的使用publicclassApplpublicstaticvoidmain(String[]args){Appleapple=newApple();System.out.println("苹果总价钱："+apple.count());}}2019-5-1115谢谢观赏publicstaticvoidmain(String概念：指该变量在程序代码中的作用区域，在该区域外不能直接访问变量。生命周期：指从声明一个变量并分配内存空间、使用变量开始，然后释放该变量并清除所占用内存空间的一个过程。3.变量的有效范围2019-5-1116谢谢观赏概念：3.变量的有效范围2019-5-1116谢谢观赏变量的种类：成员变量——类体中声明的成员变量在整个类中有效。局部变量——在方法内或方法内的复合代码块(方法内部，“{”与“}”之间的代码)声明的变量。2019-5-1117谢谢观赏变量的种类：2019-5-1117谢谢观赏【例3-3】变量的有效范围

publicclassOlympics1{privateintmedal_All=800;

publicvoidChina(){intmedal_CN=100;

if(medal_CN<1000){

intgold=50;

medal_CN+=30;

medal_All-=130;

}

}}成员变量代码块外、方法体内的局部变量代码块的局部变量允许访问本方法的局部变量

允许访问本类的成员变量

2019-5-1118谢谢观赏【例3-3】变量的有效范围publicclassOly3.1.3成员方法返回值类型方法名称{//方法开始标记}//方法结束标记方法主体(参数1，参数2，……

参数n)2019-5-1119谢谢观赏3.1.3成员方法返回值类型方法名称{注意：方法体中定义的局部变量的作用域只在方法内部；如果局部变量的名字和类的成员变量名字相同，则类的成员变量被屏蔽；如果要在方法中使类的成员变量有效，则可以使用this关键字。2019-5-1120谢谢观赏注意：方法体中定义的局部变量的作用域只在方法内部；2019-publicclassOlympics2{ privateintgold=0; privateintsilver=0; privateintcopper=0;

public

voidchangeModel(inta,intb,intc){

gold=a;//给类的成员变量赋值

intsilver=b;//使同名类成员变量silver隐藏

intcopper=50;//使同名类成员变量copper隐藏

System.out.println(“InchangModel:”+“金牌=”+gold+“银牌=”+silver+“铜牌"+copper);

this.copper=c;//给类成员变量z赋值

}2019-5-1121谢谢观赏publicclassOlympics2{2019-StringgetModel(){ return“金牌=”+gold+“银牌=”+silver+“铜牌="+copper;}2019-5-1122谢谢观赏StringgetModel(){2019-5-11publicstaticvoidmain(Stringargs[]){Olympics2o2=newOlympics2();System.out.println("BeforechangModel:"+o2.getModel()); o2.changeModel(100,100,100); System.out.println("AfterchangeModel:"+o2.getModel());}}BeforchangModel:金牌=0银牌=0铜牌=0gold=100silver=100copper=50InchangModel:金牌=100银牌=100铜牌=50AfterchangModel:金牌=100银牌=0铜牌=100如果在方法中对成员变量的值进行了修改，则这种修改将是永久的。gold=0silver=0copper=02019-5-1123谢谢观赏publicstaticvoidmain(Strin3.1.4对象的创建一个对象的生命周期包括三个阶段：对象的创建对象的使用对象的消除2019-5-1124谢谢观赏3.1.4对象的创建一个对象的生命周期包括三个阶段：20创建对象创建对象

声明实例化初始化类对象名称

＝

new

构造方法（参数）publicclassPoint{intx=1;inty=1;publicPoint(intx,inty){this.x=x;this.y=y;}}//实例化Point类，创建对象ptPointpt=

newPoint(2,3);2019-5-1125谢谢观赏创建对象创建对象声明实例化初始化类Pointpt=

newPoint(2,3);2019-5-1126谢谢观赏Pointpt=newPoint(2,3);20193.1.5对象的使用引用对象的变量objectReference.variableName;调用对象的方法objectReference.methodName(argumentList)2019-5-1127谢谢观赏3.1.5对象的使用引用对象的变量2019-5-1127【例3-6】对象使用的示例

publicclassPoint{intx=1;inty=1;publicvoidsetXY(intx,inty){……}publicintgetXY(){……}publicstaticvoidmain(String[]args){ Pointpt=newPoint(); pt.x=2;

System.out.println("x与y的乘积为："+pt.getXY()); pt.setXY(3,2); System.out.println("x与y的乘积为："+pt.getXY());}}成员变量成员方法声明并创建Point类的对象pt访问对象pt的成员变量x调用成员方法

2019-5-1128谢谢观赏【例3-6】对象使用的示例publicclassPoi3.1.6对象的消除在C++中，程序员要显式地删除不用的对象，即手动释放对象占用的存储空间。

Java提供了垃圾回收(garbagecollection)机制：自动判断对象是否还在使用，并自动销毁不再使用的对象，回收对象所占用的资源。2019-5-1129谢谢观赏3.1.6对象的消除在C++中，程序员要显式地删除不用的Java垃圾回收器执行机制的生命周期2019-5-1130谢谢观赏Java垃圾回收器执行机制的生命周期2019-5-1130谢3.1.7方法的重载在同一个类中定义了多个同名而内容不同的成员方法。

classScreen{ publicvoidprint(inti){…} publicvoidprint(floati){…} publicvoidprint(inti,Stringstr){…} }2019-5-1131谢谢观赏3.1.7方法的重载在同一个类中定义了多个同名而内容不同方法重载原则：参数表必须不同：方法参数的个数不同参数类型不同返回类型、修饰符返回类型2019-5-1132谢谢观赏方法重载原则：2019-5-1132谢谢观赏【例3-7】方法重载的示例

publicclassCalculate{finalfloatPI=3.14159f;

publicfloatgetArea(floatr){

returnPI*r*r;}

publicfloatgetArea(floatl,floatw){returnl*w;}

publicvoiddraw(intnum){

System.out.println("画"+num+"个任意形状的图形");}

publicvoiddraw(Stringshape){

System.out.println("画一个"+shape);}方法重载方法重载2019-5-1133谢谢观赏【例3-7】方法重载的示例publicclassCal

publicstaticvoidmain(String[]args){Calculatec=newCalculate();//创建Calculate类的对象

floatl=20; floatw=40; System.out.println("求长为"+l+"宽为"+w+"的矩形面积是："+c.getArea(l,w)); floatr=6; System.out.println("求半径为"+r+"的圆形面积是："+c.getArea(r));intnum=8;

c.draw(num);

c.draw(“矩形”);}}通过传递的参数判断调用哪个方法通过传递的参数判断调用哪个方法2019-5-1134谢谢观赏publicstaticvoidmain(Strin3.1.8关键词this用来指向对象自身用来访问当前对象的数据成员;用来访问当前对象的成员方法;重载构造方法时，用来引用同类的其他构造方法。2019-5-1135谢谢观赏3.1.8关键词this用来指向对象自身2019-5-【例3-8】this关键字的使用

publicclassFruit{ Stringcolor="绿色"; doubleprice; intnum;……publicdoublecount(doubleprice,intnum){ this.price=price; this.num=num; returnprice*num; }……}成员变量将参数值赋值给成员变量，即指向对象自身。2019-5-1136谢谢观赏【例3-8】this关键字的使用publicclass3.1.9类的构造方法功能：初始化类的成员变量特点：名称必须与类名相同不能有返回值必须用new自动调用2019-5-1137谢谢观赏3.1.9类的构造方法功能：初始化类的成员变量2019-【例3-9】在类Apple中定义两个构造方法publicclassApple{privateintnum;privatedoubleprice;publicApple(){ num=10; price=2.34;}publicApple(intnum,doubleprice){ this.num=num; this.price=price;}……publicstaticvoidmain(Stringargs[]){Applea1=newApple();Applea2=newApple(50,3.15)……}}参数化构造方法2019-5-1138谢谢观赏【例3-9】在类Apple中定义两个构造方法public2.缺省构造方法如果在类定义中无构造函数，在编译时可缺省加入构造方法。如：

publicApple(){};一旦在类中有一个自己声明的构造函数，则缺省的构造函数将不被加到源程序中。2019-5-1139谢谢观赏2.缺省构造方法如果在类定义中无构造函数，在编译时可缺省3.构造方法的重载功能：使类对象具有不同的初始值，为对象的初始化提供方便。可以使用this调用重载的构造方法。2019-5-1140谢谢观赏3.构造方法的重载功能：2019-5-1140谢谢观赏【例3-10】对类Apple的构造方法进行重载classApple{ privateStringcolor; privateintnum; publicApple(Stringc,intn){ color=c; num=n; } publicApple(Stringc){

this(c,0);

}调用两个参数的构造方法2019-5-1141谢谢观赏【例3-10】对类Apple的构造方法进行重载调用两个参数classApple{ privateStringcolor; privateintnum; …… publicApple(Stringc){ this(c,0); } publicApple(){ this("Unknown"); }}调用一个参数的构造方法2019-5-1142谢谢观赏classApple{调用一个参数的构造方法2019-classApple{ privateStringcolor; privateintnum;…… publicStringgetColor(){ returncolor; } publicintgetNum(){ returnnum; }}2019-5-1143谢谢观赏classApple{2019-5-1143谢谢观赏publicclassAppleDemo{ publicstaticvoidmain(String[]args){ Appleapplee=newApple(); System.out.println(“苹果颜色:”+e.getColor());System.out.println(“苹果数量:”+e.getNum()); }}调用无参数：this(“Unknown”);—〉1个参数：this(c,0);—〉2个参数的构造方法2019-5-1144谢谢观赏publicclassAppleDemo{调用无参数：3.2隐藏与封装封装访问控制package和import2019-5-1145谢谢观赏3.2隐藏与封装封装2019-5-1145谢谢观赏3.2.1封装封装，是指将对象的数据与操作数据的方法相结合，通过方法将对象的数据与实现细节保护起来。

在类的定义中设置访问对象属性及方法的权限，来限制该类对象及其他类的对象的使用范围。提供一个接口来描述其他对象的使用方法。2019-5-1146谢谢观赏3.2.1封装封装，是指将对象的数据与操作数据的方法相结3.2.2访问控制私有的——以private修饰符指定；保护的——以protected修饰符指定；公开的——以public修饰符指定；默认的，也称为default或package——不使用任何修饰符指定。2019-5-1147谢谢观赏3.2.2访问控制私有的——以private修饰符指定；表3-1：4种访问权限及其含义可否直接访问同一个同一个不同包中的任何控制等级类中包中子类中场合privateYesdefaultYesYesprotectedYesYesYespublicYesYesYesYes2019-5-1148谢谢观赏表3-1：4种访问权限及其含义可否直接访问同一个1.private修饰符其成员只能在所在类的内部使用，在其他的类中则不允许直接访问。同一个类的不同对象之间可以访问对方的private成员变量和方法；访问控制是在类的级别上，而不是在对象的级别上。2019-5-1149谢谢观赏1.private修饰符其成员只能在所在类的内部使用，在classParent{

private

intprivateVar;privatevoidprivateMethod(){

System.out.println(“IamprivateMethod!");}}classChild{

voidaccessMethod(){Parentp=newParent();p.privateVar=100;p.privateMethod();}}类中的私有成员非法：无法通过类Parent的对象访问它的私有成员

2019-5-1150谢谢观赏classParentclassChild类中的私有classParent{privateintprivateVar;publicParent(intp){ privateVar=p;}booleanisEqualTo(ParentanotherParent){if(this.privateVar==anotherParent.privateVar)returntrue;elsereturnfalse;}}当前对象实例的成员变量与方法的参数传递的另一个对象实例的成员变量是否相等？2019-5-1151谢谢观赏classParent{当前对象实例的成员变量与方法的publicclassPrivateDemo{publicstaticvoidmain(Stringargs[]){Parentp1=newParent(20);Parentp2=newParent(40); System.out.println(p1.isEqualTo(p2));}}执行结果：false2019-5-1152谢谢观赏publicclassPrivateDemo{执行结2.default如果一个类没有显式地设置成员的访问控制级别，则说明它使用的是默认的访问权限，称为default或package。允许被这个类本身，或者相同包中的其它类访问其default成员。

构造方法设置为default权限时，则除这个类本身和同一个包中的类以外，其他类均不能生成该类的对象实例。2019-5-1153谢谢观赏2.default如果一个类没有显式地设置成员的访问控制packagep1;classParent{intpackageVar;voidpackageMethod(){

System.out.println(“IampackageMethod!");}}packagep1;classChild{

voidaccessMethod(){Parentp=newParent();p.packageVar=10;p.packageMethod();}}类中的默认成员合法：因为Child与Parent在同一个包中，因此有权通过Parent的对象访问它的默认成员

2019-5-1154谢谢观赏packagep1;packagep1;类中的默认成员3.protected修饰符允许类本身、它的子类、以及同一个包中其余的类访问这些成员。2019-5-1155谢谢观赏3.protected修饰符允许类本身、它的子类、以及同packagep1;classParent{ protectedintprotectedVar; protectedvoidprotectedMethod(){ System.out.println(“IamprotectedMethod"); }}2019-5-1156谢谢观赏packagep1;2019-5-1156谢谢观赏packagep1;classPerson{ voidaccessMethod(){ Personp=newPerson(); tectedVar=100; tectedMethod(); }}由于Person类与Parent在同一个包中所以，可以创建它的对象，并实现访问。2019-5-1157谢谢观赏packagep1;由于Person类与Parent在同packagep2;importp1.*;classChildextendsParent{ voidaccessMethod(Parentp,Childc){ p.iamprotected=10; c.iamprotected=10;//子类 tectedMethod(); tectedMethod();//子类

}}X由于Child与父类Parent不在同一个包中，只能通过子类Child的对象来实现访问√X√2019-5-1158谢谢观赏packagep2;X由于Child与父类Parent不4.public修饰符带有public的成员可以被所有的类访问。一个成员只有在被外部对象使用后不会产生不良后果时，才被声明为public。2019-5-1159谢谢观赏4.public修饰符带有public的成员可以被所有的3.2.3package和import程序员可以将一组相关的类与接口包裹在一起形成一个包(package)。易于确定包中的类是相关的，根据功能可找到相应的类。防止类命名混乱。控制包中的类、接口、成员变量和方法的可见性。

2019-5-1160谢谢观赏3.2.3package和import程序员可以将一组相1.package语句指定程序中的类属于一个哪个包：packagepkg1[.pkg2.[pkg3…]];

包定义语句在每个源程序中只能有一条，即一个类只能属于一个包;包定义语句必须在程序的第一行(之前可有空格及注释);包名用“.”分隔。2019-5-1161谢谢观赏1.package语句指定程序中的类属于一个哪个包：20【例3-13】利用package关键词，将类Circle打包到com下的graphics包中。packagecom.graphics;publicclassCircle{finalfloatPI=3.14159f;//定义一个常量PI

publicstaticvoidmain(String[]args){System.out.println("画一个圆形！");}}包的创建2019-5-1162谢谢观赏【例3-13】利用package关键词，将类Circle打包comgraphicspackagecom.graphics;该Java程序所定义的类保存的路径为：C:\mypkg\com\graphicsclasspath=.;c:\mypkg包分隔符相当于目录分隔符，包存储的路径由包根路径加上包名指明的路径组成；包的根路径由CLASSPATH环境变量指出。2019-5-1163谢谢观赏comgraphicspackagecom.graphic编译和生成包编译之后拷贝javacCircle.java→Circle.class将Circle.class复制graphics子目录下简化的编译命令javac-dC:\mypkgCircle.java1、生成C:\mypkg\com\graphics；2、将Circle.class保存到该子目录下。2019-5-1164谢谢观赏编译和生成包编译之后拷贝1、生成C:\mypkg\com\g2019-5-1165谢谢观赏2019-5-1165谢谢观赏2.import语句功能：import语句告诉编译器要使用的Java类所在的位置；注意,包名也是类名的一部分。2019-5-1166谢谢观赏2.import语句功能：2019-5-1166谢谢观赏将package引入源程序，格式：

import包名.*；

import包名.类名；import语句必须在源程序之前，在package声明之后，Java程序的结构：

[package…..]//package.;[import….]//importjava.lang.*;[类声明…]2019-5-1167谢谢观赏将package引入源程序，格式：2019-5-1167谢3.3类的继承与多态类的继承方法的重写运行时多态对象类型的强制转换Object类2019-5-1168谢谢观赏3.3类的继承与多态类的继承2019-5-1168谢谢观3.3.1类的继承2019-5-1169谢谢观赏3.3.1类的继承2019-5-1169谢谢观赏继承其他类的类叫子类，被继承的类叫做超类（父类）。继承的特点层次结构子类继承父类的属性和方法2019-5-1170谢谢观赏继承其他类的类叫子类，被继承的类叫做超类（父类）。继承的例3-15：2019-5-1171谢谢观赏例3-15：2019-5-1171谢谢观赏classAnimal{

booleanlive=true;

publicvoideat(){System.out.println("动物需要吃食物");}

publicvoidmove(){

System.out.println(“动物会运动

");}}实现步骤：步骤１：编写父类步骤２：编写子类，使用关键字extends继承父类classBirdextendsAnimal{Stringskin=“羽毛"

publicvoidmove()

{

System.out.println(“鸟会飞翔

");}}父类名称子类名称2019-5-1172谢谢观赏classAnimal{实现步骤：步骤１：编写父类步骤publicclassZoo{

publicstaticvoidmain(String[]args){Birdbird=newBird();bird.eat();bird.move();System.out.println("鸟有："+bird.skin);}}访问父类的成员方法

访问子类的成员方法

【执行结果】动物需要吃食物鸟会飞翔鸟有：羽毛2019-5-1173谢谢观赏publicclassZoo{访问父类的成员方法2.单继承Java是单继承的，即只能从一个类继承，extends后类名只能有一个。单继承的优点：代码更可靠；可以用接口弥补，用一个类实现多个接口，达到多继承效果。2019-5-1174谢谢观赏2.单继承Java是单继承的，即只能从一个类继承，ext3.super关键字super可用于访问父类中定义的属性和成员方法；super可用于在子类构造方法中调用父类的构造方法；super的追溯不仅限于直接父类。2019-5-1175谢谢观赏3.super关键字super可用于访问父类中定义的属性【例3-16】使用super调用父类构造方法classAnimal{booleanlive=true;Stringskin="";publicAnimal(booleanl,Strings){live=l; skin=s;}}2019-5-1176谢谢观赏【例3-16】使用super调用父类构造方法classAnclassBirdextendsAnimal{publicBird(booleanl,Strings){super(l,s);}}publicclassZoo{publicstaticvoidmain(String[]args){Birdbird=newBird(true,"羽毛"); System.out.println("鸟有："+bird.skin);}}通过super调用父类的构造方法2019-5-1177谢谢观赏classBirdextendsAnimal{通过s注意：子类构造方法体的第一句通常要调用父类的一个构造方法。此时，如果不使用super指定，则将调用默认的父类构造方法(即不带参数的构造方法)。如果在父类中没有无参构造方法，则将产生编译错误。2019-5-1178谢谢观赏注意：子类构造方法体的第一句通常要调用父类的一个构造方法。2子类中父类成员的隐藏子类隐藏父类的成员当子类的成员变量与父类的成员变量同名时；当子类的成员方法与父类的成员方法具有相同的名字、参数列表、返回值类型；2019-5-1179谢谢观赏子类中父类成员的隐藏子类隐藏父类的成员2019-5-1179“隐藏”的含义通过子类对象调用子类中与父类同名的变量和方法时，有效的(操作)是子类中定义的变量和方法。如果要在子类中访问父类中被隐藏的成员变量或方法，要使用关键词super。2019-5-1180谢谢观赏“隐藏”的含义通过子类对象调用子类中与父类同名的变量和方法时3.3.2方法的重写在子类中对从父类继承的方法进行改造，称为方法的重写。子类中重写方法必须和父类中被重写方法具有相同的方法名、参数列表和返回值类型子类中重写方法的访问权限不能缩小子类中重写得方法不能抛出新的异常

2019-5-1181谢谢观赏3.3.2方法的重写在子类中对从父类继承的方法进行改造，classAnimal{……

public

voidcry(){

System.out.println("动物发出叫声！");}}classDogextendsAnimal{

publicvoidcry(){System.out.println("狗发出“汪汪”声！");}}classCatextendsAnimal{

publicvoidcry(){System.out.println("猫发出“喵喵”声！");}}重写重写【例3-18】重写的示例2019-5-1182谢谢观赏classAnimal{重重写【例3-18】重写的示例publicclassZoo{

publicstaticvoidmain(String[]args){Dogdog=new

Dog();System.out.println(“执行dog.cry()语句时的执行结果是：");dog.cry();

Catcat=new

Cat();System.out.println(“执行cat.cry()语句时的执行结果是：");cat.cry();}}访问子类Dog的重写后的成员方法

访问子类Cat的重写后的成员方法【执行结果】执行dog.cry();语句时地执行结果是：狗发出汪汪声！执行cat.cry();语句时地执行结果是：猫发出喵喵声！2019-5-1183谢谢观赏publicclassZoo{访问子类Dog的重写后3.3.3运行时多态多态性(Polymorphism)指在一个程序中相同名字的成员变量和方法可以表示不同的实现。方法重载：静态多态性，或称编译时多态；方法重写(覆盖)：动态多态性；变量覆盖：子类可以隐藏与父类中的同名成员变量。2019-5-1184谢谢观赏3.3.3运行时多态多态性(Polymorphism)指1.上溯造型通过引用子类的实例来调用父类的方法，从而将一种类型(子类)对象的引用转换成另一种类型(父类)对象的引用。Animala1=newParrot();Animala2=newDog();Animala3=newCat();2019-5-1185谢谢观赏1.上溯造型通过引用子类的实例来调用父类的方法，从而将一2.运行时多态通过一个父类变量发出的方法调用：该方法在父类中的实现该方法在某个子类中的实现只能在运行时，根据该变量指向的对象类型确定2019-5-1186谢谢观赏2.运行时多态通过一个父类变量发出的方法调用：只能在运行/*定义父类Animal*/import

java.util.*;classAnimal{

voidcry(){}

voidmove(){}}/*定Animal的子类Parrot*/classParrotextendsAnimal{

voidcry(){ System.out.println("狗发出汪汪声！");}

voidmove(){ System.out.println("小狗正在奔跑！");}}/*动物类Animal的子类Dog*/classDogextendsAnimal{

voidcry(){ System.out.println("狗发出汪汪声！");}

voidmove(){ System.out.println("小狗正在奔跑！");}}classCatextendsAnimal{/*定义Animal的子类Cat*/

voidcry(){ System.out.println("猫发出喵喵声！");}

voidmove(){ System.out.println("小猫正在爬行！");}}

子类重写父类Animal的成员方法

子类重写父类Animal的成员方法

子类重写父类Animal的成员方法

publicclassZoo{

staticvoidanimalsCry(Animalaa[]){for(inti=0;i<aa.length;i++){ aa[i].cry();}}

publicstaticvoidmain(String[]args){

Randomrand=new

Random(); Animala[]=newAnimal[8]; for(inti=0;i<a.length;i++){ switch(rand.nextInt(3)){ case0:a[i]=newParrot();break; case1:a[i]=newDog();break; case2:a[i]=newCat();break; } } animalsCry(a);}}父类变量a[i]指向子类对象Dog或Cat。aa[i].cry调用的为Dog或Cat类的cry()方法2019-5-1187谢谢观赏/*定义父类Animal*//*动物类Animal的子类Do3.3.4对象类型的强制转换下溯造型

将父类类型的引用转换为子类类型，称为下溯造型；下溯造型不一定是安全的，需要进行类型检查。2019-5-1188谢谢观赏3.3.4对象类型的强制转换下溯造型2019-5-111.instanceof运算符<引用类型变量>instanceof<引用类型>boolean表达式左侧是右侧给出的类型或子类型时，表达式为true2019-5-1189谢谢观赏1.instanceof运算符<引用类型变量>insclassCatextendsAnimal{}classDogextendsAnimal{}publicclassTestInstanceof{publicvoiddoSomething(Animala){ if(ainstanceofCat){ System.out.println("ThisisaCat"); }……}使用instanceof方法测试接收的对象是否是Cat类或其子类2019-5-1190谢谢观赏classCatextendsAnimal{}2.强制类型转换(SomeClass)aObjectVariable父类弱、子类强，指向父类的引用不能直接按子类引用，必须要强制类型转换后才能作为子类的引用使用。强制转换之前，一般先用instanceof对对象的类型进行测试。2019-5-1191谢谢观赏2.强制类型转换(SomeClass)aObjectVclassAnimal{Stringskin;}classBirdextendsAnimal{Stringskin="羽毛";publicStringgetSkin(){returnskin;}}publicclassCasting{publicvoidsomeMethod(Animala){System.out.println(a.getSkin());

if(ainstanceofBird){ Birdb=(Bird)a;

System.out.println(b.getSkin());

}}非法：使用父类变量a调用子类成员方法强制类型转换合法2019-5-1192谢谢观赏classAnimal{非法：使用父类变量a强制类型转换3.3.5Object类Object定义了所有对象都需要的状态和行为。例如：对象之间的比较将对象转换为字符串等待某个条件变量当某条件变量改变时通知相关对象返回对象的类2019-5-1193谢谢观赏3.3.5Object类Object定义了所有对象都需要1.equals方法equals方法用于判别某个指定对象与当前对象（调用equals方法的对象）是否等价；“数据等价”：两个数据的值相等引用类型数据比较的是引用基本数据类型比较值2019-5-1194谢谢观赏1.equals方法equals方法2019-5-119equals与“==”运算符equals()方法只能比较引用类型；“==”可以比较引用和基本类型；equals()方法对File、String、Date及封装类(WrapperClass)，是比较类型内容，而不考虑引用的是否是同一个实例；2019-5-1195谢谢观赏equals与“==”运算符equals()方法只能比较引publicclassTestEquals{ publicstaticvoidmain(String[]args){ Strings1=newString("Hello"); Strings2=newString("Hello"); if(s1==s2){ System.out.println("s1==s2"); }else{ System.out.println("s1!=s2"); }//输出：s1!=s22019-5-1196谢谢观赏publicclassTestEquals{

if(s1.equals(s2)){ System.out.println(“s1isequaltos2");}else{ System.out.println(“s1isnotequaltos2");} //输出：s1isequaltos2

s2=s1;if(s1==s2){ System.out.println(“s1==s2");}else{ System.out.println(“s1!=s2");}}//输出：s1==s2}2019-5-1197谢谢观赏if(s1.equals(s2)){2019-52.toString方法Object类中实现的toString()方法是返回当前对象的类型和内存地址信息。但在一些子类(如String、Date等)中进行了重写。在用户自定义类中通常都将该方法重写，以返回更适用的信息。2019-5-1198谢谢观赏2.toString方法Object类中实现的toStr3.4数组一维数组多维数组数组的复制2019-5-1199谢谢观赏3.4数组一维数组2019-5-1199谢谢观赏Java中数组的分类Java中的数组一维数组多维数组一维数组的定义一维数组的初始化一维数组的引用二维数组的定义二维数组的初始化二维数组的引用2019-5-11100谢谢观赏Java中数组的分类Java中的数组一维数组多维数组一维数组3.4.1一维数组定义：type

arrayName[]或type[]arrayName类型(type)可以为Java中任意的数据类型，包括简单类型和复合类如：intintArray[]；

DatedateArray[];2019-5-11101谢谢观赏3.4.1一维数组定义：2019-5-11101谢谢观赏注意：在声明数组时不能指定其长度：inta[5];//不合法原因：声明数组，只是在内存中为该类型数组变量分配引用空间，并没有为数组中每个元素分配数据空间。2019-5-11102谢谢观赏注意：在声明数组时不能指定其长度：2019-5-11102谢2.数组的创建arrayName=dataType[arraySize3.数组的长度arrayName.length;2019-5-11103谢谢观赏2.数组的创建arrayName=dataType4.静态初始化声明并创建了一个长度为3的double型的数组doubled[]={3.14,2.718,10.0};Strings[]={“Hello",“my",“Java"};声明并创建了一个长度为3的String型的数组d[0]=3.14；d[1]=2.718；d[2]=10.0s[0]="Hello"s[1]="my"s[2]="Java"静态初始化：在声明一个数组的同时，对该数组中每个元素进行赋值2019-5-11104谢谢观赏4.静态初始化声明并创建了一个长度doubled[5.动态初始化在声明(创建)一个数组类型对象时，只为其分配空间，而不同时对其中的各元素赋值。newdataType[arraySize];2019-5-11105谢谢观赏5.动态初始化在声明(创建)一个数组类型对象时，只为其分简单类型：inta[];a=newint[3];a[0]=1;a[1]=2;a[2]=3;声明数组变量a，为其分配定长的引用空间(值为null)nulla0x2a567ba0000x2a567b3212019-5-11106谢谢观赏简单类型：inta[];声明数组变量a，为其分配定长的引用类型：nulls0x2473c4snullnullnull0x2473c4Strings[];s=newString[3];S[0]S[1]S[2]地址值2019-5-11107谢谢观赏引用类型：nulls0x2473c4snullnullnul引用类型：0x2473c4s0x478b520x2473c4s[0]=newString(“Hello");s[1]=newString(“my");s[2]=newString(“Java");S[0]S[1]S[2]0x478b680x478b3c“my"“Java"0x4d78c9He...2019-5-11108谢谢观赏引用类型：0x2473c4s0x478b520x2473c46.数组元素的引用数组元素的引用方式为：arrayName[index]index为数组下标，它可以为整型常数或表达式，下标从0开始。每个数组都有一个属性length指明它的长度。2019-5-11109谢谢观赏6.数组元素的引用数组元素的引用方式为：【例3-24】int[]anArray; anArray=newint[10]; for(inti=0;i<anArray.length;i++){anArray[i]=i;System.out.print(anArray[i]+"");}声明数组创建长度为10的数组数组的长度为每个数组元素赋值2019-5-11110谢谢观赏【例3-24】int[]anArray; 3.4.2二维数组定义：

typearrayName[][]；

或type[][]arrayName;类型(type)可以为Java中任意的数据类型，包括简单类型和复合类例如：intintArray[][]；Date[][]dateArray;2019-5-11111谢谢观赏3.4.2二维数组定义：2019-5-11111谢谢观赏示例：inta[][]=newint[4][5];将创建一个有4个数组的数组，每个数组中又有5个整数，即4行5列的整数矩阵。2019-5-11112谢谢观赏示例：inta[][]=newint[4][静态初始化inta[][]={{2,3},{1,5},{3,4}};a[0][0]=2 a[0][1]=3a[1][0]=1 a[1][1]=5a[2][0]=3a[2][1]=42315342019-5-11113谢谢观赏静态初始化inta[][]={{2,3},{1,静态初始化inta[][]={{1,2},{3,4,0,9},{5,6,7}};a[0][0]=1 a[0][1]=2a[1][0]=3 a[1][1]=4a[1][2]=0a[1][3]=9a[2][0]=5a[2][1]=6a[2][2]=71234095672019-5-11114谢谢观赏静态初始化inta[][]={{1,2},{3,二维数组的动态初始化inta[][];a=newint[3][];a[0]=newint[2];a[1]=newint[4];a[2]=newint[3];1234095672019-5-11115谢谢观赏二维数组的动态初始化inta[][];122正确的说明示例：inta1[][]=newint[2][3];inta2[][]=newint[2][];inta3[][]=newint[4][6];将创建一个有2个数组的数组，每个数组中又有3个整数，即2行3列的整数矩阵2019-5-11116谢谢观赏正确的说明示例：inta1[][]=newint错误的说明示例interrarr1[2][3];不允许静态说明数组数组维数说明顺序应从高维到低维数组维数的指定只能在new运算符之后interrarr2[][]=newint[][4];interrarr3[][4]=newint[3][4];2019-5-11117谢谢观赏错误的说明示例interrarr1[2][3];不允许静态0x2473c4a0x478b520x2473c4inta[][];a=newint[3][3];a[0]a[1]a[2]0x478b680x478b3c0x4d78c90a[0][0]a[0][1]a[0][2]000a[2][0]a[2][1]a[2][2]002019-5-11118谢谢观赏0x2473c4a0x478b520x2473c4int【例3-25】int[][]aMatrix=newint[3][];将创建一个有3个数组的数组，每个数组中又有0~a[i].lengh-1个整数，即3行0~a[i].lengh-1列的整数矩阵2019-5-11119谢谢观赏【例3-25】int[][]aMatrix=newfor(inti=0;i<aMatrix.length;i++){

for(intj=0;j<aMatrix[i].length;j++){ aMatrix[i][j]=i+j;}控制矩阵的行数给每个数组元素赋值aMatrix[i]=newint[4];创建每个列数组，每个数组有4个元素2019-5-11120谢谢观赏for(inti=0;i<aMatrix.length;ifor(inti=0;i<aMatrix.length;i++){ for(intj=0;j<aMatrix[i].length;j++){ System.out.print(aMatrix[i][j]+""); } System.out.println();//换行}2019-5-11121谢谢观赏for(inti=0;i<aMatrix.length;i3.4.3数组的复制数组变量之间的赋值是引用赋值，不能实现数组数据的复制：inta[]=newint[3];intb[];b=a;0x4a678ba00x4a678ba[0]a[1]a[2]000x4a678bb2019-5-11122谢谢观赏3.4.3数组的复制数组变量之间的赋值是引用赋值，不能实数组的复制publicstaticvoidarraycopy(Object

src,int

src_position,Object

dst,int

dst_position,int

length)2019-5-11123谢谢观赏数组的复制publicstaticvoidarrayc本章小结本章围绕OOP三个基本特征：封装、继承、多态全面介绍了Java中：类的结构与定义对象的创建、使用与清除类的继承与多态理解并掌握数组的定义2019-5-11124谢谢观赏本章小结本章围绕OOP三个基本特征：2019-5-111242019-5-11125谢谢观赏2019-5-11125谢谢观赏《Java程序设计》电子课件2019-5-11126谢谢观赏《Java程序设计》电子课件2019-5-111谢谢观赏第1篇核心基础篇第3章Java面向对象特性2019-5-11127谢谢观赏第1篇核心基础篇第3章Java面向对象特性2本章内容3.1类与对象3.2隐藏和封装3.3类的继承与多态3.4数组2019-5-11128谢谢观赏本章内容3.1类与对象2019-5-113谢谢观赏学习目标掌握对象与类的基本概念了解对象的生命周期熟练掌握