【文档说明】课件：面向对象编程.pptx，共(92)页，1.246 MB，由小橙橙上传

转载请保留链接：https://www.ichengzhen.cn/view-44855.html

以下为本文档部分文字说明：

PART1封装什么是封装封装,就是隐藏实现细节将属性私有化，提供公有方法访问私有属性通过这些公有方法访问私有属性publicclassJavaTeacher2{privateStringname;//教员姓名//返回教员姓名publicStringgetName(){returnnam

e;}//设定教员姓名publicvoidsetName(Stringname){this.name=name;}}JavaTeacher2teacher=newJavaTeacher2();teacher.setName("

李芳");StringtName=teacher.getName();通过setter、getter方法访问name属性this代表当前类的实例生活中的继承•生活中，继承的例子随处可见动物食草动物食肉动物谁是父类？谁是子类？能说出

继承的特点吗？继承需要符合的关系：is-a，父类更通用、子类更具体生活中的继承•子类具有父类的一般特性（包括属性和行为），以及自身特殊的特性巴士是汽车吗？卡车是汽车吗？出租车是汽车吗？最大载客数量报站引擎数量外观颜色刹车加速汽车最大载重量卸货所属公司最大载客数量打发票属性行为请问：

出租车包含哪些属性和行为呢？类和类的继承•类的设计其实是对现有世界的模仿•在继承中，一般常见的有属性继承，属性隐藏，方法继承，方法覆盖，方法重载等技术。–在Java语言中，用extends关键字来表示一个类继

承了另一个类–在父类中只定义一些通用的属性与方法–子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法–子类的构造方法中，通过super关键字调用父类的构造方法–方法重写后，通过super关键字调用父类的方法–在Java中，所有的Java类都直接或间接地继承了ja

va.lang.Object类如何实现继承3-1•在Java语言中，用extends关键字来表示一个类继承了另一个类，例如：publicclassWomanextendsHuman{//其余代码省略}•在父类中只定义一些通用的属性不方法，例如：publiccl

assHuman{privateStringname;privateStringschool;publicHuman(Stringname,Stringsex,intage){//初始化属性值}publicv

oidcanEat(){}publicvoidbreath(){}}如何实现继承3-2•子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法publicclassHuman{privateStr

ingname;//教员姓名privateStringsex;//所在中心publicHuman(StringmyName,StringmySex){//初始化属性值}publicvoidsayHello(){//方法的具体实现}}publiccl

assFatherextendsHuman{publicFather(StringmyName,StringmySex){super(myName,mySex);}publicvoidsayHello(){System.out.print

ln(“你好，我是爸爸");super.sayHello();}}由于sayHello()方法与父类的实现有所不同，因此重写了该方法方法重写：子类和父类的方法具有相同的名称、参数列表、返回类型父类中的属性和方法可以被子类继承publicc

lassFatherextendsHuman{publicFather(StringmyName,StringmySex){super(myName,mySex);}}如何实现继承3-3•子类的构造方法中，通过super关键字调

用父类的构造方法方法重写后，通过super关键字调用父类的方法publicclassFatherextendsHuman{publicvoidsayHello(){System.out.println(“你好，我是爸爸");super.sayHello();}}通过调用父类的构造方法，完成对属性

值的初始化一切类的“祖先”——Object•在Java中，所有的Java类都直接或间接地继承了java.lang.Object类publicclassMyObject{//…}publicclassMyObectextendsObject{//…}在Eclipse中

调用MyObject对象的成员，会自动弹出继承自Object的所有方法4.6.1类和类的继承•函数的覆盖和重载的区别为什么需要多态5-1•在Woman/Man类的基础上，开发一个类用来判断，负责对Woman、Man中的方法进行判断：1、打招呼为什么需要多态5-2•第一

种解决方案publicclassJudge{publicvoidjudge(Manman){man.sayHello();man.isFather();}publicvoidjudge(Womanwoman){woman.sayHello(

);woman.isMother();}publicstaticvoidmain(String[]args){Manlisi=newMan("李四","男");Womanlili=newWoman("李丽","女");Judgejudge

=newJudge();judge.judge(lisi);judge.judge(lili);}}我继承于Human类，是个男性大家好，我是李四，是个男人我继承于Human类，是个女性大家好，我是李丽，是个女人控制台输出为什么需要多态5-3•

现在，升级人类，增加一种新类型：Boy•同时，Judge也负责对这类进行评估为什么需要多态5-4•如果在第一种解决方案的基础上去解决，我们需要如下两个步骤：–建立Boy类–修改Judge类，增加方法：judge(Boyboy)每增加一种新

的人类型，都要修Judge类，增加相应的judge(评估)方法，代码的可扩展性及可维护性极差能找到这个解决方案的弊端吗？为什么需要多态5-5•第二种解决方案——使用多态publicclassJudgeAll{publicvoidjudge(Humanhuman){

human.sayHello();}publicstaticvoidmain(String[]args){JudgeAlljudgeall=newJudgeAll();judgeall.judge(lisi);judgeall.judge(lili);judgeall

.judge(xiaoming);}}可以接收子类类型根据实际创建的对象类型调用相应方法我继承于Human类，是个男性大家好，我是李四，是个男人我继承于Human类，是个女性大家好，我是李丽，是个女人我继承于Human类，是个男孩，控制台输出使用多态之后，当需要增加新的子类类型

时，无需更改Judge类，程序的可扩展性及可维护性增强什么是多态简单来说，多态是具有表现多种形态的能力的特征同一个实现接口，使用不同的实例而执行不同操作彩色打印机打印机黑白打印机打印效果：彩色打印效果：黑白打印打印

publicclassHuman{publicvoidsayHello(){System.out.println("大家好，我是"+name+"，是个"+sex+"人");}}publicclassTest{publicstaticvoidmain(String[]args){Judg

eAlljudgeall=newJudgeAll();judgeAll.judge(newBoy());}}3如何实现多态1、子类重写父类的方法2、编写方法时，使用父类定义的方法3、运行时，根据实际创建的对象

类型动态决定使用哪个方法publicclassBoyextendsHuman{publicvoidsayHello(){System.out.println("我继承于Human类，是个男孩，还没有成年");}}1publicclass

JudgeAll{publicvoidjudge(Humanhuman){human.sayHello();}}2总结2-1给定如下Java代码，编译运行后，输出结果是什么？classBase{publicStringname;publicBase(){n

ame="Base";}publicBase(StringpName){name=pName;}publicvoidmethod(){System.out.println(name);}}classChildextendsBase{p

ublicChild(){super("Child1");name="Child2";}}publicclassSample{publicstaticvoidmain(String[]args){Childc=newChild();c.method();}}Chi

ld2控制台输出123总结2-2给定如下Java代码，编译运行后，输出结果是什么？publicclassHuman{publicvoidsayHello(){System.out.println(“你好，我

是人类");}}publicclassBoyextendsHuman{publicvoidsayHello(){System.out.println(“你好，我是男孩");}}12publicclassTest{pub

licstaticvoidmain(String[]args){Humant=newBoy();t.sayHello();}}控制台输出你好，我是男孩4.6.2类的运行时多态•当不同的对象接受到相同的消息名(或

者说当不同的对象调用相同的名称的成员函数)时，可能引起不同的行为(执行不同的的代码)。这种现象称为多态性.•多态包括编译时多态和运行时多态两种。•编译时多态和运行时多态的区别。编译时的多态,是指参数列表的不同,来区分不同的函数,在编译后,就自动变成两个不同的函数名.在运行时谈

不上多态。运行时多态:用到的是后期绑定的技术,在4.7接口和抽象类控制复杂性是计算机编程的本质.——BrianKernigan（Unix操作系统的先驱）4.7.1抽象类•java语言中，用abstract关键字来修饰一个类时，这个类叫做抽象类•用abst

ract关键字来修饰一个方法时，这个方法叫做抽象方法•格式如下：–抽象类publicabstractclassabstractClass{…}abstractreturnTypeabstractMethod([paramlist])

;4.7.1抽象类•抽象类声明时采用的语法：•例子：人类是个很典型的抽象类参看课本例4.18•错误的声明方法：publicabstractclassPerson{privateStringname;public

abstractStringgetDescription();publicStringgetName(){returnname;}}Personperson=newPerson();抽象类抽象方法抽象类是不能实例化对象的[修饰符]abstrac

tclass类名{}4.7.2抽象方法•抽象方法也是由abstract修饰，它属于一种不完整的方法，只含有一个声明，没有方法主体。语法：•抽象方法作为抽象类重要的组成部分，它通常描述这各个子类都拥有但又彼此

互不相同的方法。[访问修饰符]abstract[返回值类型]方法名();4.7.1抽象类•抽象类不能被实例化•若类中包含了抽象方法，则该类必须被定义为抽象类publicabstractclassPerson{privateStringname;publicabstractString

getDescription();publicStringgetName(){returnname;}publicPerson(Stringn){name=n;}}publicclassEmployeeextendsPerson{privatedoublesalary;pub

licEmployee(Stringn,doubles){//传递信息到父类构造函数super(n);salary=s;}publicdoublegetSalary(){returnsalary;}publicStringgetD

escription(){return"员工的工资是："+salary;}}抽象类必须被继承抽象方法必须被重写抽象方法只需声明，无需实现抽象类不一定要包含抽象方法4.7.2抽象方法•例：完整的抽象类实例：参看课本例4.204.7.3接口•接口（Inter

face）是对符合接口需求的类的一套规范•接口主要作用是可以帮助实现类似于类的多重继承的功能。•Java中声明接口的语法如下：4.7.3接口•一个Java接口是一些方法特征的集合，但没有方法的实现•接口是由常量和抽象方法组成的特殊类参看例4.21publicinterfaceShape{

publicabstractdoublearea();publicabstractdoublevolume();publicabstractStringgetName();}这是Java接口4.7.3接口publicclassPoin

textendsObjectimplementsShape{………//返回面积publicdoublearea(){return0.0;}//返回体积publicdoublevolume(){return0.0;}//返回类名称publicStringget

Name(){return"Point";}}Java接口中定义的方法在不同的地方被实现可以具有完全不同的行为参看课本例4.224.7.3接口•接口的定义–接口的定义包括接口声明和接口体–接口体包括常量定义和方法定义•接口的实现–在类的声明中用implements子句来表示一

个类使用某个接口–在类体中可以使用接口中定义的常量，而且必须实现接口中定义的所有方法–一个类可以实现多个接口,在implements子句中用逗号分开•接口类型的使用接口特性•接口可以多重实现•接口可以继承其

它的接口，并添加新的属性和抽象方法•通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。•通过接口可以指明多个类需要实现的方法。•通过接口可以了解对象的交互界面，而不需了解对象所对应的类•与继承关系类似，接口与实现类之间存在多态性生活中的接口•电脑主板上的PCI插槽的规范就类似

于Java接口声卡显卡网卡每种卡的内部结构都不相同，可以把声卡、网卡、显卡都插在PCI插槽上，而不用担心哪个插槽是专门插哪个卡的主板什么是Java接口2-1•一个Java接口是一些方法特征的集合，但没有方法的实现publicinterfacePCI{publicvoidstart();publ

icvoidstop();}classSoundCardimplementsPCI{publicvoidstart(){System.out.println("Dudu...");}publicvoidstop(){System.out.pri

ntln("Soundstop!");}}Java接口中定义的方法在不同的地方被实现，可以具有完全不同的行为这是Java接口，相当于主板上的PCI插槽的规范classNetworkCardimplementsPCI{publicvoidstart(){System.out.println("

Send...");}publicvoidstop(){System.out.println("Networkstop!");}}声卡、网卡都实现了PCI插槽的规范，但行为完全不同什么是Java接口2-2publicclassAssembler{publicsta

ticvoidmain(String[]args){PCInc=newNetworkCard();PCIsc=newSoundCard();nc.start();sc.start();}}可以使用Java接口标识类型运行时，根据实际创建的对象类

型调用相应的方法实现Dudu...Send...控制台输出21为什么需要Java接口5-1•为班级开发这样一个小系统，包含类型：学生、老师、打印机，具体要求如下：–学生、以及老师都具有方法：输出详细信息–老师具有属性

：打印机，能够通过老师的打印机打印学生或老师的详细信息–系统要具备良好的可扩展性与可维护性打印学生老师老师详细信息学生详细信息detail方法（输出详细信息）为什么需要Java接口5-2•以下这个解决方案中存在着什

么问题？publicclassStudent1{//输出学生的详细信息publicStringdetail(){return“本人是学生";}}publicclassTeacher1{privatePrinte

rprinter=newPrinter();//输出老师的详细信息publicStringdetail(){return“这里是老师";}//使用打印机打印学生信息publicvoidprint(Students){printer.print(s.de

tail());}//使用打印机打印老师信息publicvoidprint(Teachert){printer.print(t.detail());}}publicclassPrinter{publicvoidprint(Strin

gcontent){System.out.println("开始打印：");System.out.println(content);}}每增加一种新类型，都需要增加相应的print(类型名称var)方法——程序的可扩展性及可维护性极差——这不符

合系统的要求为什么需要Java接口5-3•可以通过多态性解决这个问题吗?显然，本系统符合使用多态性的条件教员中心detail方法（负责输出详细信息）学生详细信息老师详细信息1221回顾多态的含义：实现同一个接口，使用不同的实例而执行不同操作为什么需要Java接口

5-4在这个系统中，存在继承关系吗？学生、老师属于两种不同的类型，无法通过“is-a”找到一个合适的父类学生、老师都存在一个共同的方法特征：detail，它们对detail方法有各自丌同的实现——这完全符合Java接口的定义定义一个Ja

va接口，在其中定义detail方法，但没有具体实现实现这个Java接口，不同的类对detail方法有不同的具体实现IntroduceableStudent(学生)Teacher(老师)为什么需要Java接口5-5使用了Java接口之后，这个系统有了怎样的改进？publici

nterfaceIntroduceable{publicabstractStringdetail();}publicclassTeacherimplementsIntroduceable{privatePrint

erprinter=newPrinter();//输出中心的详细信息publicStringdetail(){return“这里是老师";}//使用中心打印机打印信息publicvoidprint(Introduceable

intro){printer.print(intro.detail());}}publicclassStudentimplementsIntroduceable{//输出教员的详细信息publicStringdetail(){return“本人是学生";}}

通过Java接口，我们同样可以享受到多态性的好处，大大提高了程序的可扩展性及可维护性使用print方法时，参数可以是任何Introduceable接口的实现类的对象，不必再为不同的类型建立不同的print方法了什么是面向接口编程•开发系统时，主体构架使用接口，接口构成系统的骨架•这样就可以通过更

换接口的实现类来更换系统的实现publicclassTeacherimplementsIntroduceable{privatePrinterprinter=newPrinter();publicStringdetail(){r

eturn“这里是老师";}Introduceableintro=newTecher();//使用中心打印机打印信息publicvoidprint(Introduceableintro){printer.print(intro.detail());}}IntroduceableStudent(学

生)Teacher(老师)面向接口编程的示例4-1升级上述的系统，要求：打印机有多种类型，比如：黑白打印机、彩色打印机等老师可能配备其中任意一款打印机，负责打印学生、戒者老师的详细信息系统要具备良

好的可扩展性与可维护性print方法（打印）彩色打印机黑白打印机黑白内容学生/老师详细信息彩色内容面向接口编程的示例4-2•采用面向接口编程的方式实现，以下是三个步骤中的第一步：抽象出Java接口1、分析：黑白、彩色打印机都存在一个共同的方法特征：print黑白、彩色打印机对pr

int方法有各自不同的实现2、结论：抽象出Java接口PrinterFace，在其中定义方法print3、具体实现：publicinterfacePrinterFace{publicvoidprint(Stringcontent);}面向接口编程的示例4-3•采用面向

接口编程的方式实现，以下是三个步骤中的第二步：publicclassColorPrinterimplementsPrinterFace{publicvoidprint(Stringcontent){System.out.println("彩色打印：");System.out

.println(content);}}publicclassBlackPrinterimplementsPrinterFace{publicvoidprint(Stringcontent){System.out.println("黑白打印：");System.out.pri

ntln(content);}}实现Java接口1、分析：已经抽象出Java接口PrinterFace，并在其中定义了print方法黑白、彩色打印机对print方法有各自不同的实现2、结论：黑白、彩色打印机都实现PrinterFace

接口，各自实现print方法3、具体实现：面向接口编程的示例4-4•采用面向接口编程的方式实现，以下是三个步骤中的第三步：使用Java接口1、分析：主体构架使用接口,让接口构成系统的骨架2、结论：更换实现接口的类就可以更换系统的实现publicclassTeach

erimplementsIntroduceable{privatePrinterFaceprinter;//打印机publicvoidsetPrinter(PrinterFacep){this.printer=p;}publicStringdetail(){

return“这里是老师";}publicvoidprint(Introduceableintro){printer.print(intro.detail());}}publicclassTest{publicstaticvoidmain(Str

ing[]args){//创建中心实例Teacherteacher=newTeacher();//为该老师配备黑白打印机school.setPrinter(newBlackPrinter());scho

ol.print(school);//为该老师配备彩色打印机school.setPrinter(newColorPrinter());school.print(school);}}为什么需要常量•生活中，一周有七天，如何用代码表示？publicclassWeek{privatein

tdays=7;publicstaticvoidmain(String[]args){Weekw=newWeek();System.out.println("一周有"+w.days+"天");}}publicclassWeek{p

rivateintdays=7;publicstaticvoidmain(String[]args){Weekw=newWeek();w.days++;System.out.println("一周有"+w.day

s+"天");}}一周有7天控制台输出然而，总有丌尽人意的事情发生：一周有8天控制台输出如何保证变量的值在运行期无法被改变？——使用常量什么是常量•常量是一种标识符，它的值在运行期间恒定不变•常量标识符在程序

中只能被引用，而不能被重新赋值常量圆周率PI圆周率PI代码表示方式publicstaticfinaldoublePI=3.14159265358979323846;用法将ang角度转换成径度publicstaticdou

bletoRadians(doubleang){returnang/180.0*PI;}常量的优点•如果不使用常量，直接在程序中填写数字或字符串，将会有什么麻烦？publicstaticdoubletoRadians(doubleang){ret

urnang/180.0*3.14159265358979323846;}publicstaticdoubletoDegrees(doubleang){returnang*180.0/3.14159265358979323846;}pu

blicstaticfinaldoublePI=3.14159265358979323846;//圆周率publicstaticdoubletoRadians(doubleang){returnang/180.0*PI;}pu

blicstaticdoubletoDegrees(doubleang){returnang*180.0/PI;}程序的可读性变差：用户很难理解数字戒字符串的意思程序的可维护性变差：如果数值改变，则需要在很多

地方改动，既麻烦又易出错使用常量可以增强程序的可读性、可维护性Java中常量的定义规则•加入final关键字代表常量，加入static关键字代表类变量•尽量使用含义直观的常量来表示那些将在程序中多次出现的数字或字符串publi

cclassStudent{publicstaticfinalintFEMALE=1;//代表女性publicstaticfinalintMALE=2;//代表男性privateintsex;//性别publicvoidsetSex(intsex){if(sex==FEMALE

)System.out.println("这是一名女学生");elseif(sex==MALE)System.out.println("这是一名男学生");this.sex=sex;}}在Java接口中声明常量•在Java

接口中声明的变量在编译时会自动加上staticfinal的修饰符，即声明为常量，因而Java接口通常是存放常量的最佳地点publicinterfaceSchool{publicstaticfinalStringSTU=“我是学生";publicstatic

finalStringTECH=“我是老师";}publicinterfaceSchool{StringSTU=“我是学生";StringTECH=“我是老师";}等同于OO思想总结OO基本特征定义具体实现方式优势封装隐藏实现细节，对外提供公共的访问接口属性私有化、添加公有的

setter、getter方法增强代码的可维护性继承从一个已有的类派生出新的类，子类具有父类的一般特性，以及自身特殊的特性继承需要符合的关系：is-a1、实现抽象（抽出像的部分）2、增强代码的可复用性多态同一个实现接口，使用不同的实例而执行不同操作

通过Java接口/继承来定义统一的实现接口；通过方法重写为不同的实现类/子类定义不同的操作增强代码的可扩展性、可维护性4.7.4接口与抽象类比较•接口和抽象类的联系与区别4.7.5final关键字•final是最终修饰符，可

以修饰类、属性和方法。它几乎和abstract是完全相反的概念:•final类不能被继承，没有子类，final类中的方法默认是final的。•final方法不能被子类的方法覆盖，但可以被继承。•final成员变量表示常量，只能被赋值一次

，赋值后值不再改变。•final不能用于修饰构造方法4.7.5final关键字•最终类–如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。例子：String的类声明：定义一个类继承最终类String:参看

课本例4.234.7.5final关键字•最终属性final字段，只能存储一个数据，而且不得改变。例：最终变量的使用：参看课本例4.244.7.5final关键字•最终方法为方法“上锁”，防止任何继承类改变它的本来含义。调用fin

al方法时候会转入内嵌机制，大大提高执行效率。参看课本例4.254.7.5final关键字•最终参数当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。例：试图改变最终参数参看课本例4

.26总结publicinterfaceIntroduceable{publicStringdetail();publicvoidintroduction(){detail();}privatevoidshowMessage();voidspeak();}Java接口中的方法必须是publicJ

ava接口中不能有方法体实现编译器会自动加上public修饰符请指出下列Java代码中的错误。4.9总结•Java的面向对象思想和开发技术•Java语言本身的所有基本性能课程回顾•抽象类、抽象方法的声明•接

口主要作用•finalpublicabstractclassabstractClass{…}abstractreturnTypeabstractMethod([paramlist]);接口主要作用是可以帮助实现类似于类的多重继承的功能final类不能被继承，没

有子类，final类中的方法默认是final的。final方法不能被子类的方法覆盖，但可以被继承。final成员变量表示常量，只能被赋值一次，赋值后值不再改变。final不能用于修饰构造方法本章主要内容•5.1简介•5.2异

常处理•5.3自定义异常•5.4常见异常及处理方法•5.5总结生活中的异常•正常情况下，小王每日开车去上班，耗时大约30分钟但是，异常情况迟早要发生！一路畅通堵车！撞车！程序中的异常publicclass

TestException{publicstaticvoidmain(String[]args){System.out.print("请输入课程代号(1至3之间的数字):");Scannerin=newScanner(System.in);int

courseCode=in.nextInt();//从键盘输入整数switch(courseCode){case1:System.out.println("C#编程");break;case2:System.out.println("Java编程");brea

k;}}}输入：2输出：Java编程输入：B程序中断运行！正常情况：异常情况：什么是异常•异常就是在程序的运行过程中发生的不正常的事件，它会中断正在运行的程序绕行戒者等待请求交警解决异常！面对异常该怎么办呢？通常情况下，我们会这样处理：程序运行程序中断运行堵车！撞车！生活中，我们会根据丌

同的异常迚行相应的处理，而丌会就此中断我们的生活什么是异常处理•Java编程语言使用异常处理机制为程序提供了错误处理的能力程序中预先想好了对付异常的处理办法异常！程序运行处理完毕，程序继续运行对异常进行处理

5.1简介•在Java中，提供了错误捕捉和处理机制，即异常处理机制。•在程序运行过程中发生错误时，Java允许其不按照正常路径完成任务，由发现错误的方法抛出封装了错误信息的对象（异常）到其调用程序，发出已经发生问题的信号，然后立即退出•而且，程序并不在调用该方法的代码处继续执行，而是由异常处

理机制开始搜索一个能够处理这种特定错误情况的异常处理器。5.2异常处理•异常处理类结构图•Throwable类是Java语言中所有错误或异常的父类。•Error类被认为是不能恢复的严重错误，如系统内部

错误和资源耗尽错误等。•Exception类定义可能遇到的轻微错误，分为派生自RuntimeException类的异常和非派生自RuntimeException类的异常，简称为运行时异常和非运行时异常异常

处理类结构图说明5.2.1声明抛出异常•Exception类有下面几个常用的构造方法：5.2.1声明抛出异常•声明抛出异常是通过throws语句来完成的。语法如下：[修饰符]返回值类型方法名(参数列表)throws异常1，异常2，…•例：声明抛出异常，并打出异常详细消息。参看课本例5.15.2.

2捕获异常•捕捉异常的语法如下：Java中如何进行异常处理•Java的异常处理是通过5个关键字来实现的：try、catch、finally、throw、throws捕获异常catchtryfinally执行可能产生异常的代

码捕获异常无论是否发生异常，代码总能执行手动抛出异常抛出异常throw声明异常声明方法可能要抛出的各种异常throws5.2.2捕获异常•使用try/catch块捕获异常，分为三种情况：trycatchtry/catch块后的代

码段publicvoidmethod(){try{//代码段(此处不会产生异常)}catch(异常类型ex){//对异常进行处理的代码段}//代码段}第一种情况具体代码publicclassCatchExc{publicstaticvoidmain(Str

ing[]args){try{intscore=Integer.parseInt(args[0]);if(score>100||score<0){//抛出异常对象thrownewException("你输入的分数不正确！");}else{System.out.println("你

输入了正确的分数！");}}catch(Exceptione){//捕获异常，并且打印它的内容System.out.println("捕获到异常："+e.getMessage());}}}输入：10你输入了正确的分数！控制台输出5.2.2捕获异常trycatch

异常类型匹配try/catch块后的代码段publicvoidmethod(){try{//代码段1//产生异常的代码段2//代码段3}catch(异常类型ex){//对异常进行处理的代码段4}//代码段5}第二种情况产生异常对象程序

继续执行异常是一种特殊的对象，类型为java.lang.Exception戒其子类具体代码publicclassCatchExc{publicstaticvoidmain(String[]args){try{intscore=Integer.

parseInt(args[0]);if(score>100||score<0){//抛出异常对象thrownewException("你输入的分数不正确！");}else{System.out.println("你输入了正确的分数！");}}catch

(Exceptione){//捕获异常，并且打印它的内容System.out.println("捕获到异常："+e.getMessage());}}}输入：-10捕获到异常：你输入了不正确的分数！控制台输出5.2.2

捕获异常trycatch异常类型不匹配try/catch块后的代码段程序中断运行发生异常publicvoidmethod(){try{//代码段1//产生异常的代码段2//代码段3}catch(异常类型ex){//对异常进行处理的代码段4}//代码段5}第三种情况产生异常

对象具体代码publicclassCatchExc{publicstaticvoidmain(String[]args){try{intscore=Integer.parseInt(args[0]);if(score>100||score<0){//抛出异常对象thrownewEx

ception("你输入的分数不正确！");}else{System.out.println("你输入了正确的分数！");}}catch(Exceptione){//捕获异常，并且打印它的内容System.out.p

rintln("捕获到异常："+e.getMessage());}}}输入：a程序中断运行5.2.2捕获异常•在try/catch块后加入finally块，可以确保无论是否发生异常，finally块中的代码总能被执行try

块finally块catch块无异常有异常publicclassCatchExc{publicstaticvoidmain(String[]args){try{intscore=Integer.parseInt(args[0]);if(score>100||s

core<0){//抛出异常对象thrownewException("你输入的分数不正确！");}else{System.out.println("你输入了正确的分数！");}}catch(Exceptione){//捕获异常，并且打印它的内容System.

out.println("捕获到异常："+e.getMessage());}finally{System.out.println(“分数check完毕！”);}}}输入：-10控制台输出分数check完毕！捕获到异常：你输入了不正确的分数！控制台输出publicvoidmeth

od(){try{//代码段//产生异常(异常类型2)}catch(异常类型1ex){//对异常进行处理的代码段}catch(异常类型2ex){//对异常进行处理的代码段}catch(异常类型3ex){//对异常

进行处理的代码段}//代码段}多重catch块2-1•一段代码可能会引发多种类型的异常•当引发异常时，会按顺序来查看每个catch语句，并执行第一个与异常类型匹配的catch语句•执行其中的一条catch语句之后，其后的catch语句将被忽略tr

y与异常类型1不匹配try/catch块后的代码段发生异常产生异常对象catch与异常类型2匹配catchcatch程序继续执行多重catch块2-2publicclassException4{publicstaticvoidmain(String[]args){Scanne

rin=newScanner(System.in);try{System.out.print(“请输入S1的总学时：");inttotalTime=in.nextInt();//总学时System.out.prin

t(“请输入S1的课程数目：");inttotalCourse=in.nextInt();//课程数目System.out.println(“S1各课程的平均学时为："+totalTime/total

Course);}catch(InputMismatchExceptione1){System.out.println("输入不为数字!");}catch(ArithmeticExceptione2){System

.out.println("课程数目不能为零!");}catch(Exceptione){System.out.println("发生错误:"+e.getMessage());}}}输入：270H在安排catch

语句的顺序时，首先应该捕获最特殊的异常，然后再逐渐一般化，即先子类后父类输出：输入不为数字!进入第一个catch块输入：2700输出：课程数目不能为零!进入第二个catch块抛出异常•如果在当前环境无法解决一个异常，就要将其抛出

，把异常交给调用者处理publicclassTeacher{privateStringid;//教员编号，长度应为7publicvoidsetId(StringpId){//判断教员编号的长度是否为7if(pId.length()==7){id=pId;}else{throwne

wIllegalArgumentException("参数长度应为7！");}}}publicclassTeacherTest{publicstaticvoidmain(String[]args){AccpTeacherteacher=new

AccpTeacher();try{teacher.setId("088");}catch(IllegalArgumentExceptionex){System.out.println(ex.getMessage());}}}抛出异常捕获异常参数长度应为7！控制台输出声明异常publ

icclassTeacher{privateStringid;//教员编号,长度应为7publicvoidsetId(StringpId)throwsIllegalArgumentException{//判断教员编号的长度是否为7if(pId.length()==7){id=pId;}else{t

hrownewIllegalArgumentException("参数长度应为7！");}}}publicclassTeacherTest{publicstaticvoidmain(String[]args){Teac

herteacher=newTeacher();try{teacher.setId("088");}catch(IllegalArgumentExceptionex){System.out.println(e

x.getMessage());}}}由调用者捕获异常声明该方法可能会产生异常5.3自定义异常•创建方法：继承现有的异常类•例：参看课本例5.35.4常见异常及处理方法•如何避免异常和分析修改异常。publicclass

TeacherTest{publicstaticvoidmain(String[]args){Teacherteacher=newTeacher();try{teacher.setId("088");}catch(IllegalArgumentE

xceptionex){System.out.println(ex.getMessage());}}}控制台输出参数长度应为7！如果要在控制台与文件中同时输出错误信息，该如何处理？使用log4j可以解决这个问题

，log4j是一个流行的日志记录工具这是使用log4j后，存储在文本文件中的日志信息使用log4j记录日志信息什么是日志•日志：用来记录一些重要的操作信息•有价值的日志数据能够帮助用户提前发现和避开灾难，并且找到事件发生的原因publ

icclassTeacherTest{publicstaticvoidmain(String[]args){AccpTeacherteacher=newAccpTeacher();try{teacher.setId("0

88");}catch(IllegalArgumentExceptionex){System.out.println(ex.getMessage());}}}在控制台输出日志信息，提示用户出现错误的原因如何使用log4j记录日志•

第一步：在工程中加入log4j所使用的jar文件项目属性：弹出项目的属性窗口Java构建路径库添加外部JAR：弹出选择JAR的窗口通过选择JAR的窗口，找到log4j-1.2.x.jar，并确认回到项目的属性窗口，点击确定12

34如何使用log4j记录日志•第二步：创建log4j.properties文件选择欲使用log4j的项目右键点击src新建其他：弹出选择向导窗口在选择向导窗口中，选择常规文件下一步：弹出新建文件的窗口在新建文件窗口中，输入文件名log

4j.properties完成：创建工作结束123如何使用log4j记录日志•第三步：使用log4j记录日志信息importorg.apache.log4j.Logger;publicclassTeacherLog4j{publicstaticvoidmain(Stri

ng[]args){Teacherteacher=newTeacher();Loggerlogger=Logger.getLogger(TeacherLog4j.class.getName());try{logger.

debug("设置教员的编号。");teacher.setId("088");}catch(IllegalArgumentExceptionex){logger.info(ex.getMessage());}}}获取日志记录器，这个记录器将负责控制日志信息使用Logger对象的debug、i

nfo方法输出日志信息•第四步：编写log4j.properties文件，配置日志信息###把日志信息输出到控制台###log4j.appender.stdout=org.apache.log4j.ConsoleAppenderlog4j.appender.stdout.Ta

rget=System.outlog4j.appender.stdout.layout=org.apache.log4j.PatternLayoutlog4j.appender.stdout.layout.Conversio

nPattern=%d{yyyy-MM-ddHH:mm:ss}%m%n###把日志信息输出到文件：accp.log###log4j.appender.file=org.apache.log4j.FileAppenderlog4j.a

ppender.file.File=accp.loglog4j.appender.file.layout=org.apache.log4j.PatternLayoutlog4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd

HH:mm:ss}%l%m%n###设置优先级别、以及输出源###log4j.rootLogger=debug,stdout,file日志信息将写到文件中指定日志输出的文件名指定输出格式：显示日期和log信息设置优先级别为debug、日志被输出到多个输出源日

志信息将写到控制台信息打印到System.out上指定输出格式：显示日期，日志发生位置和日志信息输出源名称优先级从高到低分别是ERROR、WARN、INFO、DEBUG在此处，如果优先级别设为info，那么使用debug方法打印的日志信息将不被输出•运行效果展示控制台输出效

果包含日期与日志信息文件输出效果包含日期、日志发生位置、与日志信息12