-类对象和接口.ppt

《-类对象和接口.ppt》由会员分享，可在线阅读，更多相关《-类对象和接口.ppt（139页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、第章类、对象和接口,4.1 编程语言的几个发展阶段 4.2 类 4.3 对象 4.4 static 关键字 4.5 this 关键字 4.6 包 4.7 访问权限 4.8 类的继承 4.9 对象的上转型对象 4.10 多态性,4.11 abstract 类和abstract方法 4.12 super关键字 4.13 接口 4.14 内部类 4.15 匿名类 4.16 异常类 4.18 基本类型的类包装,4.1 编程语言的几个发展阶段,机器语言（如汇编语言） 计算机处理信息的早期语言是所谓的机器语言 指令都是由0,1组成的序列，称这样的序列为一条机器指令。 过程语言 语言把代码组成叫做过程或函数

2、的块。每个块的目标是完成某个任务 例如，一个C的源程序就是由若干个书写形式互相独立的函数组成。 面向对象编程 面向对象编程主要体现下列三个特性： 1.封装性 2.继承 3.多态 4、重载 Java语言是面向对象语言，它的源程序是由若干个类组成，源文件是扩展名为.java的文本文件,4.2 类,类是组成Java程序的基本要素。 类封装了一类对象的状态和方法。 封装的成员变量用来表示对象的状态；而成员函数表示对象的方法。 类的实现包括两部分:类声明和类体。,class 梯形 float 上底,下底,高,laderArea; /变量定义 float 计算面积() /方法定义 int a； lader

3、Area=(上底+下底)*高/2.0f; return laderArea; ,1.类声明,class People “class People”叫做类声明；“People” 是类名。习惯上类名的第一个字母大写，但这不是必须的。,2.类体,类声明之后的一对大括号“”，“”以及它们之间的内容称做类体。 类体的内容由两部分构成：变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。,class 梯形 float 上底,下底,高,laderArea; /变量定义 float 计算面积() /方法定义 int a； laderArea=(上底+下底)*高/2.0f; return laderA

4、rea; ,class 梯形 float 上底,下底,高,laderArea; /变量定义部分 int a； float 计算面积() /方法定义 int a； laderArea=(上底+下底)*高/2.0f; return laderArea; void 修改高(float h) /方法定义 高=h; ,3.成员变量和局部变量,类的成员变量。 局部变量：在方法体中定义的变量和方法的参数。 作用域对比：成员变量在整个类内都有效，局部变量只在定义它的方法内有效。 成员变量又分为： 实例成员变量（简称实例变量）和 类变量（也称静态变量） . 成员变量的类型前面加上关键字static对所有的此类实

5、例化的对象共享同一内存 如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效 . 这时如果想在该方法内使用成员变量，必须使用关键字this。,class 三角形 float sideA,sideB,sideC,lengthSum; void setSide(float sideA,float sideB,float sideC) this.sideA=sideA; this.sideB=sideB; this.sideC=sideC; this.sideA，this.sideB，this.sideC就分别表示成员变量sideA,sideB,sideC,4

6、.方法,方法的定义包括两部分：方法声明和方法体。 方法参数在整个方法内有效； 方法内定义的局部变量从它定义的位置之后开始有效。 -如果局部变量的定义是在一个复合语句中，那么该局部变量的有效范围是该复合语句，即仅在该复合语句中有效，如果局部变量的定义是在一个循环语句中，那么该局部变量的有效范围是该循环语句，即仅在该循环语句中有效 . 和C语言中写一个函数类似,class Area float getArea(float r) return 3.14f*r*r; double getArea(float x,int y) return x*y; float getArea(int x,float

7、y) return x*y; double getArea(float x,float y,float z) return (x*x+y*y+z*z)*2.0; ,方法：类方法和实例方法,类中的方法分为：实例方法和类方法. 实例方法：方法声明时，方法类型前面不加关键字static 加关键字static的是类方法。 构造方法不能用static修饰构造方法。,类方法和实例方法,加上static直接用类名来调用，所以成为类方法； 而没有static关键字的方法必须用对象实例来调用，成为实例方法。,构造方法,构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型，构造方法也可以重

8、载。,class 梯形 float 上底,下底,高; 梯形() 上底=60; 下底=100; 高=20; 梯形(float x,int y,float h) 上底=x; 下底=y; 高=h; ,缺省的构造方法,当没有构造函数时，系统提供缺省的构造方法,如果调用缺省的构造方法,成员变量的初始化值为缺省值 数值型 是0 Boolean型 false Char “0” 对象 NULL,构造方法,允许有两个不同的构造方法，调用哪一个，由主调函数的参数来决定。 -方法（函数）重载,方法重载,方法重载的意思是： 一个类中的方法具有相同的名字，但参数不同，即或者是参数的个数不同，或者是参数的类型不同。,4.

9、3 对象,类是创建对象的模板。 当使用一个类创建了一个对象时，我们也说我们给出了这个类的一个实例。,1.创建对象,创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)对象的声明。 一般格式为： 类的名字 对象名字; 如： People zhangPing;,(2)为声明的对象分配内存 使用new运算符 （）为声明的对象分配内存， （2）调用构造方法，没有构造方法，系统会调用默认的构造方法（默认的构造方法是无参数的。如： zhangPing=new People();,(3)对象的内存模型 使用例子1来说明对象的内存模型 class XiyoujiRenwu float height,w

10、eight; String head, ear,hand,foot, mouth; int speak(String s) System.out.println(s); class A public static void main(String args) XiyoujiRenwu zhubajie; /声明对象 zhubajie=new XiyoujiRenwu(); /为对象分配内存， /默认的构造方法 ,声明对象时的内存模型,当用XiyoujiRenwu类声明一个变量，即对象zhubajie时，如例子1中的对象zhubajie： XiyoujiRenwu zhubajie; 内存模型如

11、左图所示,对象分配内存后的内存模型,当系统见到： zhubajie=new XiyoujiRenwu(); 时，就会做三件事： 为height，weight，head，ear，mouth，hand，foot各个变量分配内存，即XiyoujiRenwu类的成员变量被分配内存空间 执行构造方法中的语句。 new运算符在为变量height，weight，head，ear，mouth，hand，foot分配内存后，将返回一个引用给对象变量zhubajie。,new 关键字的作用,为对象分配内存空间； 调用构造函数； 为对象返回一个引用,2.使用对象,对象：可以操作自己的变量；使用创建它的那个类中的方法

12、的能力。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 当对象调用方法时，方法中出现的成员变量就是指该对象的成员变量。,class 梯形 float 上底,下底,高; 梯形() 上底=60; 下底=100; 高=20; 梯形(float x,int y,float h) 上底=x; 下底=y; 高=h; ,梯形 t； t=new 梯形（）； t.上底； t.梯形（40f，50，60.5f）；,4.4 static 关键字,用static修饰的成员变量称为类变量 用static修饰的方法称为类方法,实例变量和类变量的区别,一个类通过使用new运算符可以创建多个不同的对象；不同

13、的对象的实例变量将被分配不同的内存空间； 如果类中的成员变量有类变量，那么所有的对象的这个类变量都分配给相同的一处内存，改变其中一个对象的这个类变量会影响其它对象的这个类变量。 类变量是和该类创建的所有对象相关联的变量，改变其中一个对象的这个类变量就同时改变了其它对象的这个类变量。 因此，类变量不仅可以通过某个对象访问也可以直接通过类名访问。 实例变量仅仅是和相应的对象关联的变量，也就是说，不同对象的实例变量互不相同，即分配不同的内存空间，改变其中一个对象的实例变量不会影响其它对象的这个实例变量。 实例变量可以通过对象访问，不能使用类名访问。,类方法只能操作类变量，而实例方法不受限制,clas

14、s 梯形 float 上底,下底,laderArea; /变量定义部分 float b，高； float 计算面积() /方法定义 int a； laderArea=(上底+下底)*高/2.0f; return laderArea; static void 设定高(float h) /方法定义 高=h; ,注意,静态的成员变量，可以被非静态的方法调用，反之则不行。 为什么main是定义成静态的？,.实例方法和类方法的区别,实例方法可以被类创建的任何对象调用执行。 类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用,4.5 this 关键字,this是Java的一个关键字，表示某个

15、对象。 this可以出现在实例方法和构造方法中，但不可以出现在类方法中。 this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。 this关键字出现在类的实例方法中时，代表正在调用该方法的当前对象。,class 三角形 float sideA,sideB,sideC,lengthSum; void setSide(float sideA,float sideB,float sideC) this.sideA=sideA; this.sideB=sideB; this.sideC=sideC; this.sideA，this.sideB，this.sideC就分别表示成员变量si

16、deA,sideB,sideC,4.6 包,包是Java语言中有效地管理类的一个机制。,1.包语句,通过关键字package声明包语句。package 语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。package语句的一般格式为： package 包名; 如果源程序中省略了package语句，源文件中你定义命名的类被隐含地认为是无名包的一部分，即源文件中定义命名的类在同一个包中，但该包没有名字。 包对应着文件系统的目录层次结构 包名可以是一个合法的标识符，也可以是若干个标识符加“.”分割而成 。,在G:javacnmybole,编译的位置：,运行的位置：,源文件的位置：,.

17、 import 语句,使用import 语句可以引入包中的类。 在编写源文件时，除了自己编写类外，我们经常需要使用Java提供的许多类，这些类可能在不同的包中。 在学习Java语言时，使用已经存在的类，避免一切从头做起，这是面向对象编程的一个重要方面。,/jre/lib/rt.jar 包, io, lang. java.lang自动导入，如其中的system类和String类，不需import语句,导入系统提供的类,类的说明符,public说明符 没有说明符,类名前没有public，则只能在同一个包中的类访问，否则必须声明为public类 也可以将此类在要访问它的类中被import，或给出完整

18、路径,4.7访问权限,类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。 所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。 访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。,class XiyoujiRenwu pubilc static float height,weight; String head, ear,hand,foot, mouth; public void speak(String s) S

19、ystem.out.println(s); class A public static void main(String args) XiyoujiRenwu zhubajie; /声明对象 zhubajie=new XiyoujiRenwu(); /为对象分配内存， XiyoujiRenwu.height; XiyoujiRenwu.height; ,1.私有变量和私有方法-private,一个类在另外一个类中创建一个对象后，该对象不能访问自己的私有变量和私有方法 对于一个类的私有类变量（静态成员变量），那么在另外一个类中，也不能通过类名来操作这个私有类变量。,.共有变量和共有方法,一个类在

20、另外一个类中创建一个对象后，该对象能访问自己的public变量和public方法 对于一个类的public类变量（静态成员变量），那么在另外一个类中，也能通过类名来操作这个public类变量。,3.友好变量和友好方法,不用private、public 、protected修饰符的成员变量和方法被称为友好变量和友好方法。 一个类在另外一个类中创建一个对象后，如果两个类在同一包中，该对象能访问自己的友好变量和友好方法 对于一个类的友好类变量（静态成员变量），如果两个类在同一包中，那么在另外一个类中，也能通过类名来操作这个友好类变量。,注意：,.受保护的成员变量和方法,一个类在另外一个类中创建一个对

21、象后，如果两个类在同一包中，该对象能访问自己的protected变量和protected方法 对于一个类的protected类变量（静态成员变量），如果两个类在同一包中，那么在另外一个类中，也能通过类名来操作这个protected类变量。,protected和“友好”之间区别？,在继承上,4.8类的继承,继承是一种由已有的类创建新类的机制。 先创建一个共有属性的一般类，根据该一般类再创建具有特殊属性的新类，新类继承一般类的状态和行为，并根据需要增加它自己的新的状态和行为。 由继承而得到的类称为子类，被继承的类称为父类（超类）。 Java不支持多重继承（子类只能有一个父类）。,1.子类,在类的声

22、明中，通过使用关键字extends来创建一个类的子类，格式如下: class 子类名 extends 父类名 例如： class Students extends People ,2.子类的继承性,类有可以有两种重要的成员：成员变量和方法。子类的成员中有一部分是子类自己声明定义的，另一部分是从它的父类继承的。 所谓子类继承父类的成员变量作为自己的一个成员变量，就好象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法操作. 所谓子类继承父类的方法作为子类中的一个方法，就象它们是在子类中直接声明一样，可以被子类中自己声明的任何实例方法调用。,子类和父类在同一包中的继承性,如果子类和父类

23、在同一个包中，那么，子类自然地继承了其父类中不是private的成员变量作为自己的成员变量； 并且也自然地继承了父类中不是private的方法作为自己的方法； 继承的成员或方法的访问权限保持不变。,子类和父类不在同一包中的继承性,子类继承了父类的protected、public成员变量做为子类的成员变量； 并且继承了父类的protected、public方法为子类的方法, 继承的成员或方法的访问权限保持不变。 子类不能继承父类的友好变量和友好方法。,访问权限小结,Private： -同包和不同包的其他类中创建的对象，均不得访问，只有在本类中创建的对象可以访问； 子类也不能继承； Protect

24、ed: -只要是同包中创建的对象就能访问； -同包和不同包中的子类均可继承； 缺省： -必须是同包中创建的对象可以访问； -同包中创建的子类可以继承； Public： -任何包中创建的对象均可访问； -任何包中创建的子类也可继承。,3.成员变量的隐藏和方法的重写,父类成员变量的隐藏：只要子类中定义的成员变量和父类中的成员变量同名。 方法重写是指：子类中定义一个方法，并且这个方法的名字、返回类型、参数个数和类型与从父类继承的方法完全相同。 如果子类重写了父类的方法，则运行时系统调用子类重写的方法,子类重写父类时，不能降低访问权限,4. final关键字,final关键字可以修饰类、成员变量、方法

25、和方法中的参数。 final类不能被继承，即不能有子类。如String类 方法被修饰为final，则这个方法不能被重写。 成员变量被修饰为final，就是常量，常量必须赋给初值，而且不能再发生变化；但也可以在构造函数中初始化 ； 方法的参数被修饰为final，该参数的值不能被改变。,final举例,final 可以定义常量， final PI=3.1415926；,4.9 多态性,多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为 . 为什么要多态？ （1）和上转型技术结合可以将做什么和怎么做分开 (2)后期绑定技术来保证编码无需提前知晓导出类就可编程 （3）程序扩展性好,d

26、,多态性缺陷,基类的私有方法无法覆盖，无法实现多态； 静态方法也无法实现多态；域也无法使用多态,构造器和多态,构造器的调用顺序： 调用基类构造器-无限递归调用成员初始化-导出类的构造器,多态小结,需要数据抽象、继承和动态绑定技术 编程时要考虑类和类之间的共性以及联系 可以使的程序具有更好的结构、扩展性和可维护性,4.10 abstract 类和abstract方法,abstract 类：用关键字abstract修饰的类（抽象类）。 abstract class A ,为什么要有抽象类？ （）形成不同子类的通用接口； （）在编译中确保不允许产生对象；,abstract类有如下特点,和普通的类相比

27、，abstract类可以有abstract方法。 对于abstract方法，只允许声明，不允许实现，而且不允许使用final修饰abstract方法。 abstract class A int min(int x,int y) int max(int x,int y) return xy?x:y; ,abstract类不能用new运算创建对象 对于abstract类，我们不能使用new运算符创建该类的对象； 需产生其子类，由子类创建对象; 如果一个类是abstract类的子类，它必须具体实现父类的abstract方法，这就是为什么不允许使用final修饰abstract方法的原因。,Abstr

28、act Class A . ,abstract方法,abstract void submethod(); 他所在的类必须标为abstract类,4.11 super关键字,子类不继承父类的构造方法； 子类使用父类的构造方法，必须： -在子类的构造方法中使用，必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。,在子类使用被子类隐藏了的父类的成员变量或方法就可以使用关键字super。比如：super.x、super.play()，就是被子类隐藏的父类的成员变量x和方法play()。,4.12 接口,Java不支持多继承性，即一个类只能有一个父类。单继承性使得Java简

29、单，易于管理程序。 为了克服单继承的缺点，Java使用了接口，一个类可以实现多个接口。,1.接口的声明与使用,使用关键字interface来定义一个接口。接口的定义和类的定义很相似，分为接口的声明和接口体。 接口体中包含常量定义和方法定义两部分。接口体中只进行方法的声明，不许提供方法的实现，所以，方法的定义没有方法体，且用分号“；”结尾。如： interface Printable final int MAX=100; void add(); float sum(float x ,float y); ,接口的使用,一个类通过使用关键字implements 声明自己使用一个或多个接口。如果使用多

30、个接口，用逗号隔开接口名。如： class A implements Printable,Addable 如果一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体 .,P80的例题,注意：,如果实现接口的类没有实现接口的所要的方法，则必须标为抽象类；,接口的回调,Videocard.java-定义接口,Dmeng.java-实现接口中的方法,Mainboard.java-,Computer.java,抽象类和接口的区别？,（1）单继承，多实现； （2）含有成员变量，只有常量； （3）成员方法可以部分实现，成员方法都不能实现。,尽量选inferface,4.14 内部

31、类,Java支持在一个类中声明另一个类，这样的类称作内部类，而包含内部类的类成为内部类的外嵌类。 内部类的类体中不可以声明类变量和类方法。 外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。,通过内部类可以访问外部类的 私有方法或私有成员变量,外部类成员变量、内部类成员变量和局部变量之间？,/在外部类的非static中,/内部类的方法中的局部变量,/内部类的成员变量,/外部类的成员变量,内部类的字节码文件名,Inner inner=new Inner();,内部类解决了多重继承问题如书上P204例子,内部类可以设计为private或protected，而普通类只可以是友好的和public，

32、 如果是private，除了他所在的外部类外其他的类中都不可以访问它， 而protected时候，只有外部类、外部类的继承类，和同包类，其他都不能访问 隐蔽了内部类,如果内部类放在某个方法里，就只有这个方法可以访问它,匿名类,C+如何处理错误的？ Java解决方案是常规的操作和错误处理操作分开。,4.16 异常类,程序运行出现异常时，Java运行环境就用异常类Exception的相应子类创建一个异常对象，并等待处理，例如，读取一个不存在的文件时，运行环境就用异常类IOException创建一个对象,异常对象可以调用如下方法得到或输出有关异常的信息： public String getMessa

33、ge() public void printStackTrace() public String toString(),trycatch语句的格式如下： try 包含可能发生异常的语句 catch(ExceptionSubClass1 e) catch(ExceptionSubClass2 e) ,使用trycatch语句来处理异常： 将可能出现的异常操作放在trycatch语句的try部分； 当try部分中的某个语句发生异常后，try部分将立刻结束执行，而转向执行相应的catch部分； 所以程序可以将发生异常后的处理放在 catch部分。trycatch语句可以由几个catch组成，分别处理

34、发生的相应异常。,4.18 基本类型的类包装,Java的基本数据类型包括：byte、int、short、long、float、double、char。Java同时也提供了基本数据类型相关的类，实现了对基本数据类型的封装。这些类在java.lang包中，分别是：Byte、Integer、Short、Long、Float、Double和Character类。,Integer a=new Integer(55);,int b=a.intValue();,1. Double和Float类,Double类和Float类实现了对double和float基本型数据的类包装。 可以使用Double类的构造方法

35、： Double (double num) 创建一个Double类型的对象； 使用Float类的构造方法： Float (float num) 创建一个Float类型的对象。 Double对象调用doubleValue()方法可以返回该对象含有的double型数据； Float对象调用floatValue()方法可以返回该对象含有的float型数据。,2. Byte、Integer、Short、Long类,下述构造方法分别可以创建Byte、Integer、Short和Long类型的对象： Byte(byte num) Integer(int num) Short(short num) Long

36、(long num) Byte、Integer、Short和Long对象分别调用byteValue ()、intValue()、shortValue ()和longValue ()方法可以返回该对象含有的基本型数据。,Java的异常处理 Java的异常处理是通过5个关键字来实现的：try，catch，throw，throws，finally。JB的在线帮助中对这几个关键字是这样解释的： Throws: Lists the exceptions a method could throw. Throw: Transfers control of the method to the exceptio

37、n handler. Try： Opening exception-handling statement. Catch： Captures the exception. Finally： Runs its code before terminating the program. try语句 try语句用大括号指定了一段代码，该段代码可能会抛弃一个或多个例外。 catch语句 catch语句的参数类似于方法的声明，包括一个例外类型和一个例外对象。例外类型必须为Throwable类的子类，它指明了catch语句所处理的例外类型，例外对象则由运行时系统在try所指定的代码块中生成并被捕获，大括号中包

38、含对象的处理，其中可以调用对象的方法。 catch语句可以有多个，分别处理不同类的例外。Java运行时系统从上到下分别对每个catch语句处理的例外类型进行检测，直到找到类型相匹配的catch语句为止。这里，类型匹配指catch所处理的例外类型与生成的例外对象的类型完全一致或者是它的父类，因此，catch语句的排列顺序应该是从特殊到一般。 也可以用一个catch语句处理多个例外类型，这时它的例外类型参数应该是这多个例外类型的父类，程序设计中要根据具体的情况来选择catch语句的例外处理类型。 finally语句 try所限定的代码中，当抛弃一个例外时，其后的代码不会被执行。通过finally语

39、句可以指定一块代码。无论try所指定的程序块中抛弃或不抛弃例外，也无论catch语句的例外类型是否与所抛弃的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。通常在finally语句中可以进行资源的清除工作。如关闭打开的文件等。 throws语句 throws总是出现在一个函数头中，用来标明该成员函数可能抛出的各种异常。对大多数Exception子类来说，Java 编译器会强迫你声明在一个成员函数中抛出的异常的类型。如果异常的类型是Error或 RuntimeException， 或它们的子类，这个规则不起作用， 因为这在程序的正常部分中是不期待出现的。 如果你想明确地

40、抛出一个RuntimeException，你必须用throws语句来声明它的类型。 throw语句 throw总是出现在函数体中，用来抛出一个异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。 class myException extends Exception String msg; myException(int age) msg=age can not be positive!; public String toString() return msg; class Age

41、 public void intage(int n) throws myException/ if(n120) myException e=new myException(n); throw e; /是一个转向语句，抛出对象实例，停止执行后面的代码 if(n=0) System.out.print(合理的年龄!); public static void main(String args) int a=-5; try /try catch 必需有 Age age = new Age(); age.intage(a);/触发异常 System.out.print(抛出异常后的代码) ;/这段代码是

42、不会被执行的，程序已经被转向 catch (myException ex) System.out.print(ex.toString(); finally/无论抛不抛异常，无论catch语句的异常类型是否与所抛出的例外的类型一致，finally所指定的代码都要被执行，它提供了统一的出口。 System.out.print(进入finally！ ); 结果：年龄非法！ 进入finally！ 又如： void fun()throws IOException,SQLException . 这表示 fun方法可能会丢两个异常出来，那么在调用fun的时候就会做好准备，比如可以这样 try fun();

43、catch(IOException e) catch(SQLException e) 区别一： throw 是语句抛出一个异常；throws 是方法抛出一个异常； throw语法：throw 在方法声明中，添加throws子句表示该方法将抛出异常。 throws语法：（）throws 其中：异常类可以声明多个，用逗号分割。 区别二： throws可以单独使用，但throw不能； 区别三： throw要么和try-catch-finally语句配套使用，要么与throws配套使用。但throws可以单独使 用，然后再由处理异常的方法捕获。 throws E1,E2,E3 只是告诉程序这个方法可能

44、会抛出这些个异常，方法的调用者可能要处理这些异常。而这些异常E1，E2，E3可能是该函数体产生的。 而throw是明确之处这个地方要抛出这个异常。 void doA() throws Exception1, Exception3 try catch(Exception1 e) throw e; catch(Exception2 e) System.out.println(出错了); if (a != b) throw new Exception3(自定义异常); 代码块中可能产生异常Exception1、Exception2和Exception3。 如果产生Exception1异常，则捕捉了之

45、后抛出由该方法的调用者去做处理； 如果产生Exception2异常，则该方法自己做了处理(打印出了说出错了)，所以该方法就不会再向外抛出Exception2异常了，void doA() throws Exception1,Excpetion3里面的Exception2也就不用写了； 而Exception3异常是该方法的某段逻辑出错，程序员自己作了处理在该段逻辑错误的情况下抛出异常Exception3，则调用者也需要处理。 throw语句用在方法体内,表示抛出异常,由方法体内的语句处理 throws语句用在方法声明后面,表示再抛出异常,由调用这个方法的上一级方法中的语句来处理 throws主要是

46、声明这个方法会抛出这种类型的异常，使其他地方调用它时知道要捕获这个异常。 throw是具体向外抛异常的动作，所以它是抛出一个异常实例。 throws说明你有哪个可能，倾向 throw的话，那就是你把那个倾向变成真实的了 同时： 1）throws出现在方法函数头；而throw出现在函数体； 2）throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常； 3）两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。 本文来自CSDN博客，转载请标明出处：,