面向对象编程OOP.docx
《面向对象编程OOP.docx》由会员分享，可在线阅读，更多相关《面向对象编程OOP.docx（20页珍藏版）》请在冰豆网上搜索。
面向对象编程OOP
面向对象编程（OOP）
●面向对象的三大特性
⏹封装:
隐藏实现细节
⏹继承:
一个类从另一个类中得到其授权的成员
⏹多态:
方法有多种形态
●封装
⏹类（抽象的概念）
◆普通类（实例类）：
能创建对象的类
如：
//实例类
classPerson{
}
◆抽象类
●以abstract所修饰的类
●抽象类不能构建对象
如:
//抽象类
abstractclassUser{
}
示例1：
publicclassClassExam{
publicstaticvoidmain（String[]args）{
Personzhangsan=newPerson（）;//引用实例类构建对象
Personjixufan=newPerson（）;
System.out.println（zhangsan）;
System.out.println（jixufan）;
//Userlisi=newUser（）;//错误!
asbstractnotcreateinstance
}
}
//实例类
classPerson{
}
//抽象类
abstractclassUser{
}
⏹对象（类的实例）
◆由属性和行为集合成的实例
◆由类构建的
示例2：
publicclassObjectExam{
publicstaticvoidmain（String[]args）{
Studentzs=newStudent（）;//构建对象
zs.studNo="0001";
zs.studName="张三";
zs.studAge=16;
zs.Registying（）;
zs.studying（）;
Studentlisi=newStudent（）;
lisi.studNo="0002";
lisi.studName="李四";
lisi.studAge=20;
lisi.Registying（）;
lisi.studying（）;
Studentww=newStudent（）;
ww.studNo="0003";
ww.studName="王老五";
ww.Registying（）;
}
}
classStudent{
//属性
publicStringstudNo="0000";
publicStringstudName="学生";
publicintstudAge=18;
publicvoidstudying（）{
System.out.println（studName+"正在学习"）;
}
publicvoidRegistying（）{
System.out.println（"学号:
"+studNo
+"\t姓名：
"+studName
+"\t年龄:
"+studAge）;
}
}
⏹成员字段
◆类中的数据项（属性）
◆实质上就是类中的变量
◆普通的成员字段（实例属性）
如:
classStudent{
//数据字段
StringsNo="0001";
StringsName="姓名";
intiAge=0;
}
示例3:
调用实例成员字段
publicclassMemberFieldExam{
publicstaticvoidmain（String[]args）{
MovieStarldh=newMovieStar（）;
//实例成员字段用对象调用
ldh.level="No.1";
ldh.bynl="一级棒";
ldh.hf=true;
Strings=（ldh.hf）?
"已婚":
"未婚";
System.out.println（ldh.level+ldh.bynl+s）;
}
}
classMovieStar{
//实例成员字段
publicStringlevel;
publicStringbynl;
publicbooleanhf=false;
}
◆静态的成员字段（类的属性）
●常用于公共类中的公共变量
如:
//静态属性
staticStringsShcool;
●调用时使用类名
如:
Student.sShcool="清华大学";
⏹成员方法
◆普通方法（实例方法）
如：
classStudent{
publicvoidstuding（）{
System.out.println（"正在学习!
!
!
!
"）;
}
}
示例4：
调用普通方法
publicclassMethodExam{
publicstaticvoidmain（String[]args）{
//调用实例方法
StudentobjZS=newStudent（）;
objZS.studing（）;
}
}
◆静态方法（类的方法）
●常应用于公共类中的公共方法
●静态方法中只能操作静态的数据
如:
classStudent{
staticStrings1="变量";
//静态方法
publicstaticvoidsleeping（）{
System.out.println（"正在睡觉!
!
!
!
"）;
System.out.println（s1）;
F1（）;
}
staticvoidF1（）{
System.out.println（"静态方法"）;
}
}
示例5：
调用静态方法
publicclassMemberMethodExam{
publicstaticvoidmain（String[]args）{
MStudentkx=newMStudent（）;
kx.studying（）;
MStudent.eating（）;
}
}
classMStudent{
staticStringstudName="康熙";
//实例方法
publicvoidstudying（）{
System.out.println（studName+"正在学习!
!
!
"）;
}
//静态方法
publicstaticvoideating（）{
Strings="雍正";
//静态方法中只能操作静态的数据
System.out.println（studName+"正在吃后悔药!
!
!
"）;
System.out.println（s+"正在吃后悔药!
!
!
"）;
MStudentyz=newMStudent（）;
yz.studying（）;
practice（）;
}
publicstaticvoidpractice（）{
System.out.println（studName+"正在实习!
!
!
"）;
}
}
◆抽象方法（abstract修饰的方法）
●定义在抽象类中
●只有方法声明没有执行体
如:
abstractclassUser{
//定义抽象方法
publicabstractbooleanlogin（）;
}
●使用其的派生类对象调用
示例6:
publicclassMethodExam{
publicstaticvoidmain（String[]args）{
//调用抽象方法
superUserobjSU=newsuperUser（）;
booleanbFlag=objSU.login（）;
if（bFlag）{
System.out.println（"登录成功"）;
}
else{
System.out.println（"登录失败"）;
}
}
}
//User的派生类
classsuperUserextendsUser{
publicbooleanlogin（）{
System.out.println（"超级管理员正在登录....."）;
returntrue;
}
}
⏹访问修饰符
◆public:
公有（同一项目中的类都能被访问）
◆protected:
受保护（不同包时，只能有继承关系的类中被访问,一般修饰类的成员）
◆默认:
（只在同一包中的类被访问）
◆private:
私有（只能在同一个类中被访问,只能修饰类的成员）
示例7:
publicclassModifierTest{
publicstaticvoidmain（String[]args）{
//public的类
GeralClassExamobjGCE=newGeralClassExam（）;
//不同包中默认的类
//StudentobjZS=newStudent（）;不充许被访问
//私有的类成员
objGCE.F1（）;
System.out.println（objGCE.s1）;
//受保护的类成员
AnimalobjP=newAnimal（）;
objP.speaking（）;
//objP.eating（）;//不能访问
}
}
⏹构造方法
◆没有返回类型，与类同名，是类Public的成员
◆用来创建对象
◆默认的构造（隐式）
◆自定义构造（显式）
示例8:
publicclassConsMethod{
publicstaticvoidmain（String[]args）{
BStudentzs=newBStudent（）;
}
}
classBStudent{
publicBStudent（）{//显式
System.out.println（"正在构造对象"）;
}
}
⏹包（package）
◆包是用来管理类名的。
◆打包package包名（小写）
◆Java中常用的包
●java.lang:
语言包（不用导入）
●java.util:
公用程序包
●java.awt:
抽象窗口工具包
●java.sql:
数据库组件包
●java.io:
输入输出流包
●:
网络编程包
●java.math:
数学公式包
●javax.swing:
轻量级组件包
⏹接口（Interface）
◆类似公用的静态的抽象类
◆接口中一般定义方法（类似抽象方法）只有声明没有方法体
示例8:
定义接口
//定义接口
publicinterfaceIAct{
Stringstatus="关";//类似于静态常量
publicbooleanON（）;//类似于抽象方法
publicbooleanOFF（）;
}
//接口默认的修饰符是隐式的public
interfaceIAct1{
}
示例9:
实现接口（implements）
publicclassImplementsInterface{
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
TVobjKJ=newTV（）;
objKJ.on（）;
ELightobjEL=newELight（）;
objEL.on（）;
//ISwitch.status="aba";//不能改变，因其为常量
System.out.println（ISwitch.status）;
}
}
//实现接口的类
classTVimplementsISwitch{
publicbooleanoff（）{
System.out.println（"关电视机"）;
returntrue;
}
publicbooleanon（）{
System.out.println（"开电视机"）;
returntrue;
}
}
classELightimplementsISwitch{
publicbooleanoff（）{
System.out.println（"关电灯"）;
returntrue;
}
publicbooleanon（）{
System.out.println（"开电灯"）;
returntrue;
}
}
●继承（extends）
⏹所类的根类:
Object
⏹基类与派生类
示例10:
//基类
publicclassAnimal{
}
//派生类
classPersonextendsAnimal{
}
////派生类
classChineseextendsPerson{
}
⏹成员继承性（私有的成员无法继承）
示例11:
//基类
publicclassAnimal{
publicvoidspeaking（）{
System.out.println（"yiyiyaya!
!
!
!
"）;
}
protectedvoideating（）{
System.out.println（"gegegege!
!
!
"）;
}
}
//派生类
classPersonextendsAnimal{
privatevoidspleep（）{
System.out.println（"zzzzzzzz!
"）;
}
}
////派生类
classChineseextendsPerson{
}
publicclassInheritTest{
publicstaticvoidmain（String[]args）{
ChineseobjP=newChinese（）;
objP.speaking（）;
objP.eating（）;
}
}
⏹子类调用父类的成员与构造
◆this.成员名（本类的对象）
◆super.成员名（父类的对象）
◆调用父类的构造:
super（）,且要放在第一行。
示例12:
publicclassClassExtendsExam{
publicstaticvoidmain（String[]args）{
//Chinesezs=newChinese（"张三",19）;
//Chinesels=newChinese（"李四",20）;
//zs.name="张三";
//System.out.println（zs.name）;
//zs.eating（）;
//zs.sleeping（）;
CatobjC=newCat（"猫咪1",3）;
CatobjC1=newCat（"猫咪2",4）;
}
}
//基类
classAnimal{
privateStringname;
privateintage;
publicAnimal（StringsName,intiAge）{
name=sName;
age=iAge;
System.out.println（"Animal的"+name+"\t"+age）;
}
}
//派生类
classCatextendsAnimal{
publicCat（StringsN,intiA）{
super（sN,iA）;//放在第一行
System.out.println（"猫的构造"）;
}
}
classDogextendsAnimal{
publicDog（）{
super（"狗狗",4）;//放在第一行
System.out.println（"狗的构造"）;
}
}
⏹接口之间的继承
示例13:
publicinterfaceIAct1extendsIAct2{
voidF1（）;
voidF2（）;
}
interfaceIAct2{
voidF3（）;
voidF4（）;
}
⏹Java中不允许类之间多重继承,而使用多重接口实现。
示例14:
classB{
publicvoiddoing（）{
System.out.println（"正在做...."）;
}
}
//一个接口继承一个类并实现多个接口
classAextendsBimplementsIAct2,IAct3{
publicvoideating（）{
//TODOAuto-generatedmethodstub
}
publicvoidsleeping（）{
//TODOAuto-generatedmethodstub
}
publicvoidwalking（）{
//TODOAuto-generatedmethodstub
}
publicvoidruning（）{
//TODOAuto-generatedmethodstub
}
}
interfaceIAct1{
publicvoidwalking（）;
publicvoidsleeping（）;
}
//接口的继承
interfaceIAct2extendsIAct1{
publicvoideating（）;
}
interfaceIAct3{
publicvoidruning（）;
}
●多态（polymorphically）
⏹方法重载
◆同一类中有同名的方法
示例15:
publicclassMethodFraughtExam{
publicstaticvoidmain（String[]args）{
Personzs=newPerson（）;
zs.eating（"苹果"）;
zs.eating（"苹果",3）;
zs.eating（）;
}
}
classPerson{
//方法重载
publicvoideating（）{
System.out.println（"吃后悔药"）;
}
publicbooleaneating（StringsFoot）{
System.out.println（"吃"+sFoot）;
returntrue;
}
publicvoideating（StringsFoot,intiHours）{
System.out.println（"吃了"+iHours+"小时的"+sFoot）;
}
}
⏹方法重写
◆子类中有父类中的同名方法
示例16:
publicclassMethodOverridExam{
publicstaticvoidmain（String[]args）{
BobjB=newB（）;
objB.gongfu（）;
}
}
classA{
publicvoidgongfu（）{
System.out.println（"打太极拳"）;
}
}
classBextendsA{
//重写了父类中的方法
publicvoidgongfu（）{
//super.gongfu（）;
System.out.println（"打少林拳"）;
}
}
升级会员 