类、对象和接口

1. 类、对象和接口

2. 本章主要内容 • 类及方法 • 对象 • static this关键字 • 包 • 访问权限 类的继承 • 对象的上转型对象 • 多态性 • 抽象类和抽象方法 • 接口和异常处理

3. 类及方法 • 类：是现实世界某些对象的共同特征(属性和操作)的表示，是用来创建对象的模板，对象是类的实例。 • 类的属性：就是类的静态属性的简称，指类内包含的各项数据，如变量或其他类的对象。 • 类的功能：类的成员函数或方法。 一、类

4. 二、类的声明 类的基本定义方法如下： [修饰符] class 类名 [extends 父类] [implements 接口名] { 类成员变量声明 类方法声明 } 接口名跟在implements关键字后面，用来说明当前类中实现了哪个接口定义的功能和方法。 接口是Java语言用来实现多重继承的一种特殊机制，我们将在后面详细介绍它的使用方法。 类的修饰符用来说明类的特殊性质。分为三种： 访问控制符：public 公共类 抽象类说明符：abstract 最终类说明符：final

5. 1.类头 • class关键字表明一个类的开始，在它的后面，应跟随新数据类型的名称。（注意不要把class写成Class）。 • 类名最好采用见名知意的原则，如果类名是一个单词，首字母最好用大写字母，若由几个单词复合而成，每个单词的首字母最好都用大写字母。如：BeiJingTime, HelloChina等。 • 父类名跟在extends关键字后面，用来说明当前类是哪个已经存在类的子类，存在继承关系。继承是类与类之间的一种非常重要的关系。

6. 2.类的修饰符 • 缺省：这样的类被称为友好类，在其它类中使用友好类创建对象时，要保证它们在同一个包中 • public：可以在任何另外一个类中，使用public类创建对象。 • abstract：一个抽象类只关心它的子类具有哪些功能，并不关心功能的具体行为，功能的具体行为由子类负责实现。 • final：一个final类中只能定义常量。

7. 3.接口名 接口名跟在implements关键字后面，用来说明当前类中实现了哪个接口定义的功能和方法。接口是Java语言用来实现多重继承的一种特殊机制，我们将在后面详细介绍它的使用方法。

8. 4.类体 类体的定义要包括类的具体内容，包括类的属性与方法。 class <class name> { <member Field declarations> <member Method declarations> }

9. 5.类的属性 Java中声明类属性为简单变量的语法如下： [修饰符] 变量类型 变量名 [=变量初值]； 变量类型和变量名是声明一个变量必不可少的部分；变量的类型可以是简单数据类型或类类型，如int、double、People等。

10. 二、方法 • 用来描述类的功能，类中定义的方法（又称成员函数）通常起到两种作用： • 一是围绕着类的属性进行各种操作； • 二是与其他的类或对象进行数据交流、消息传递等操作。 1. 方法的声明： [修饰符] 返回值类型 方法名(参数列表) [throws 例外名1，例外名2，…] { 局部变量声明； 语句序列； }

11. 2.方法头 方法头一般由方法名、参数列表、返回类型、方法修饰符和方法抛出的例外五部分组成。 （1）方法名可以是任何有效的标识符，命名规则与标识符命名规则相同。 • 方法名由一个单词组成时，首字母用小写。 • 方法名由多个单词组成时，从第2个单词开始其它单词的首写字母用大写。 （2）类型说明符用来指定方法返回值的类型，方法最多只能返回一个值。 （3）参数列表是方法的输入接口，它列出了一系列形式参数的类型和名称，在方法参数表的右括号后加一个分号是语法错误。 （4）参数表以逗号为分隔符，其中包含了方法被调用时传递给方法的参数说明。对于方法定义中的每一个参数，方法调用时必须有一个参量与之对应，而且该参量的类型必须与对应参数类型相一致。

12. 3.方法体 方法头定义了方法的性质，方法体则定义了方法的具体内容。 注： （1）方法调用中参数用来传递数值、传递引用，同时方法还可以嵌套、递归调用。 （2）在一个方法中定义另一个方法将产生语法错误。 （3）方法头中如果指定了非void的返回值类型，方法体中就必须包含一条return语句保证任何情况下都有返回数值。

13. 4.方法的调用 (1)方法的类型 • 一类是需要程序书写专门的调用命令来调用的方法，称为程序调用方法，例如isPrime(); • 另一类是运行过程中系统自动调用的方法，称为系统方法，例如: action()、paint()、init()等。 • (2)方法的调用形式 • 系统方法由系统自动调用，不需要用户显示调用。 • 程序调用方法必须由用户显示调用，在类中调用类自身的方法，可以直接使用方法名进行调用；调用其他类的方法时，需要使用这个类的实例对象进行调用。

14. 例1： public class SumPrime { public static void main(String args[]) {int n=10; IsPrime isprime=new IsPrime(); System.out.println("the sum of prime is: " +isprime.sum_n(n)); } } class IsPrime {int sum_n(int m) { int i,j,sum=0; for(i=2;i<=m;i++) {for(j=2;j<i;j++) if(i%j==0) break; if(j==i) sum+=i; } return sum; } }

15. 三、成员变量和局部变量 • 类的属性称为成员变量（或实例变量） • 方法内定义的变量和方法的参数称为局部变量 • 成员变量在整个类内有效，局部变量只在所定义的方法内有效 • 成员变量与它在类体中书写的位置无关 • 若局部变量与成员变量同名，则在方法体内成员变量被隐藏 • 可以使用关键字this使被隐藏的变量起作用

16. x,y,z的作用范围 a,b的作用范围 成员变量 例2： class VarFun { int a,b; int mul(int x,int y) { int z; z=x*y; return z; } int sum() { return a+b; } } public class varb { public static void main(String args[]) { VarFun varfun=new VarFun(); System.out.println(varfun.mul(21,3)); System.out.println(varfun.sum()); } } 局部变量 输出 63 0

17. 例3： class VarFun { int a=10,b=20; int mul(int a,int b) { return a*b; } int sum() { return a+b; } } public class varb { public static void main(String args[]) { VarFun varfun=new VarFun(); System.out.println(varfun.mul(21,3)); System.out.println(varfun.sum()); } } return this.a*a*b; 输出 63 30 输出 630 30

18. 四、构造方法 构造方法是一种特殊的方法，其特殊性主要体现在以下几个方面： （1）构造方法的方法名与其所在类的类名相同。 （2）构造方法可以带有参数，但没有返回类型。 （3）一个类可以有多个构造方法。 （4）构造方法的主要作用是完成对类对象的初始化工作。 （5）构造方法不能由编程人员显式地直接调用。 （6）构造方法总是和new运算符一起使用。 （7）在创建一个类的新对象的同时，系统会自动调用该类的构造方法为新对象初始化。 （8）如果定义类时没有显示的定义构造方法，则系统提供不带数的默认构造方法，默认构造方法将成员变量初始化为默认值。

19. 例4： public class Constru { int i,k; boolean m; public static void main(String[] args) { Constru Con=newConstru(); System.out.println(Con.i+" "+Con.k); System.out.println(Con.m)； } } 调用默认的构造函数 输出：0 0 false

20. 例5： public class Constru { int i,k; public Constru( ) { i=100;k=20;} public static void main(String[] args) { Constru Con=new Constru( ); System.out.println(Con.i+" "+Con.k); } } 输出：100 20

21. 例6： public class Constru { int i,k; public Constru(int n,int m) { i=n*n;k=m*m;} public static void main(String[] args) { Constru Con=new Constru(10,20); System.out.println(Con.i+" "+Con.k); } } 输出：100 400

22. 例7： public class Constru { int i,k; public Constru( ) {i=-12;k=-14;} public Constru(int n,int m) {i=n*n;k=m*m;} } class Main { public static void main(String[] args) { Constru Con1=new Constru( ); Constru Con=new Constru(-30,20); System.out.println(Con1.i+" "+Con1.k); System.out.println(Con.i+" "+Con.k); } } 输出：-12 -14 900 400

23. public class Constru { int i,k; public Constru(int n,int m) {i=n;k=m;} public int gcd() {int r; do {r=i%k;i=k;k=r;}while(r!=0); return(i); } } class Main { public static void main(String[] args) { Constru Con=new Constru(13,21); System.out.println(Con.gcd()); } } 例8：

24. 对 象 一、创建对象 • 创建一个对象包括对象的声明和为对象分配内存两步 • 声明对象 • 一般格式： 类的名字 对象名字； • 声明对象后，该对象在内存中还没有任何数据，我们称这 • 样的对象为空对象。空对象不能使用，因为它没有任何“实 • 体”，必须为对象分配内存空间。 • 2. 为对象分配内存 • 一般格式： 对象名字=new 类的名字();

25. 二、使用对象 1.对象操作自己的变量（对象的属性） 对象创建后，就有了自己的变量，即对象的实 体。通过运算符“.”，对象可以实现对自己的变量 访问。 2.对象调用类中的方法（对象的功能） 对象创建后，可以使用运算符“.”，调用创建 它的类中的方法，从而产生一定的行为功能。当对象 调用类中的一个方法时，方法中的局部变量被分配内 存空间。方法执行完毕，局部变量即刻释放内存。

26. 例1： class XiyoujiRenwu { float height,weight; String head; void speak(String s) { head="歪着头"; System.out.println(s); } }

27. public class Example { public static void main(String args[]) { XiyoujiRenwu zhubajie,sunwukong; zhubajie =new XiyoujiRenwu(); sunwukong =new XiyoujiRenwu(); zhubajie.height=1.80f; zhubajie.head="大头"; sunwukong.weight=1000f; sunwukong.head="绣发飘飘"; System.out.println("zhubajie的身高："+zhubajie.height); System.out.println("zhubajie的头："+zhubajie.head); System.out.println("sunwukong的重量："+sunwukong.weight); System.out.println("sunwukong的头："+sunwukong.head); zhubajie.speak("俺老猪我想娶媳妇"); System.out.println("zhubajie现在的头："+zhubajie.head); sunwukong.speak("老孙我重1000斤，我想骗八戒背我"); System.out.println("sunwukong现在的头："+sunwukong.head); } }

28. static和this 一、static • 用static修饰的变量（方法）叫类变量（类方法） • 1.实例变量和类变量的区别 • 不同对象的实例变量被分配不同的空间，彼此互不影响。 • 类变量在该类被加载到内存时，就分配了相应的空间。由该类创建的所有对象共享类变量的内存空间。 • 实例变量必须由对象进行访问。 • 类变量可以直接通过类名进行访问。

29. 例2： class VarStatic { static int a; int b; public VarStatic(int x,int y) {a=x;b=y; } } public class Vari {public static void main(String args[]) { VarStatic var1=new VarStatic(12,30); VarStatic var2=new VarStatic(40,50); System.out.println(var1.a+" "+var2.a); System.out.println(var1.b+" "+var2.b); } } 类变量 实例变量 构造方法 System.out.println(VarStatic.a+" "+var2.a); 输出： 40 40 30 50

30. 例3： class VarStatic { static int a; int b; public VarStatic(int x,int y) {a=x;b=y; } } public class Vari {public static void main(String args[]) {System.out.println(VarStatic.a); VarStatic var1=new VarStatic(12,30); VarStatic var2=new VarStatic(40,50); System.out.println(var1.a+" "+var2.a); System.out.println(var1.b+" "+var2.b); } } 输出： 0 40 40 30 50

31. 2. 实例方法和类方法的区别 • 类的实例方法，只有在该类的对象创建后才分配入口地址。从而该实例方法可以被该类创建的任何对象调用执行。 • 类方法，在该类被加载到内存时，就分配了入口地址。从而类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。 • 类方法只能操作类变量，不能操作实例变量，也不能调用实例方法。 • 实例方法既能对类变量进行操作也能对实例变量进行操作。 • 实例方法可以调用该类中的其他方法，类方法只能调用该类中的其他类方法。

32. 输出： 121 121 34.0 例4： class StaticFun { static int a; float y; static int setA(int x) { a=x; return a; } float setY(float x) { y=x; return y; } public static void main(String args[]) { System.out.println(setA(121)); StaticFun fun=new StaticFun(); System.out.println(fun.setA(121)); System.out.println(fun.setY(34)); } } 类方法 实例方法

33. 输出： 121 121 74.0 例5： class StaticFun { static int a; float y; static int setA(int x) { a=x; return a; } float setY(float x) { y=setA((int)x+40); return y; } public static void main(String args[]) { System.out.println(setA(121)); StaticFun fun=new StaticFun(); System.out.println(fun.setA(121)); System.out.println(fun.setY(34)); } }

34. 二、this • this关键字可以出现在类的实例方法中，代表使用该类的当前对象。 • this关键字也可以出现在类的构造方法中，代表使用该类所创建的对象。 • this关键字不能出现在类方法中。

35. class ThisKey { void f() { System.out.println("it is f function"); this.g(); } void g() { System.out.println("it is g function"); } public static void main(String args[]) { ThisKey key=new ThisKey(); key.f(); } } this代表当前对象,此语句也可写成 g(); 不能写成 f()，因为main方法为类方法

36. 包 一、包的概念 • 包是由.class文件组成的一个集合。 • 程序中如果有package语句，则该语句的前面只能有注释或空行。 • 一个文件中最多有一条package语句。 • 包名有层次关系，各层之间用点分割。 • 包名习惯用小写字母且保证包名唯一。 • 包是类的容器，用于分割类名空间。 • 缺省值为当前文件夹。

37. 二、包的创建 创建包语句的语法是： package pkg1[.pkg2[.pkg3…]]; 例如：package com.javaworld； 例1： package f1; class File1 { public static void main(String args[]) { System.out.println("this is the File!"); } } 包的创建的语句，此语句必须是第一个语句

38. 例2： package f1; public class File2 { public void setValue() {System.out.println("this is the class in package F2"); } } 该文件编译产生的字节码文件File2.class也在子目录f1中。 修改例1，调用例2中的方法setValue()

39. 例3： package f1; class File1 { public static void main(String args[]) {System.out.println("this is the File!"); File2 ff=new File2(); ff.setValue(); } } 如果将例2的第一个创建包的语句改为： package f2; 如何在例3中调用File2中的方法setValue()？

40. 三、包的引入 使用包的全名 使用import语句 包引入的方式： • 注： • 在一个java源程序中可以有多个import语句。 • import语句必须写在package语句和源文件中类的定义语句之间。 • import的语法是： • import pkg1[.pkg2[.pkg3…]].(类名| * ); • 例如：import java.awt.*;

41. 包的全名 package f1; class File1 { public static void main(String args[]) { System.out.println("this is the File!"); f2.File2 ff=new f2.File2(); ff.setValue(); } } package f2; public class File2 { public void setValue() { System.out.println("this is the class in package F2"); } } 方法一：

42. 也可以写成 import f2.File2 方法二： package f1; class File1 { public static void main(String args[]) { System.out.println("this is the File!"); File2 ff=new File2(); ff.setValue(); } } package f2; public class File2 { public void setValue() { System.out.println("this is the class in package F2"); } } import f2.*; f2. f2.

43. 三、JAVA API中的包 为了简化面向对象的编程过程，Java系统事先设计并实现了一些体现常用功能的标准类，如用于输入/输出的类、用于数学运算的类、用于图形用户界面设计的类、用于网络处理的类等。这些系统标准类根据实现功能的不同，可以划分成不同的集合，每个集合是一个包，合称为类库。可以引用这些包，也可以创建自己的包。 Java编程能力的强弱相当大的程序上取决于对Java类库的熟悉和掌握程度。Java类库是系统提供的已实现的标准类的集合，是Java编程的API，它可以帮助开发者方便、快捷地开发Java程序。

44. 常见的JAVA API: • java.lang 提供基本的数据类型及操作，此包由编辑器自动地导入所有程序。 • java.util 提供高级数据类型及操作，如日期和时间操作。 • java.io 提供输入/输出流控制，含有支持输入和输出的类。 • java.awt 提供图形界面控制。 • java.awt.event 提供窗口事件处理，包括剪贴板、字符串发送器等。 • java.net 提供支持Internet协议的功能。利用java.net包，开发者可以编写自己的具有网络功能的程序。 • java.applet 提供实现浏览器环境中Applet的有关类和方法。 • java.sql 提供与数据库连接的接口。 • java.security 提供安全性方面的有关支持。利用其中的类可以对java程序加密，也可以把特定的Java Applet标记为“可信赖”，使它能够具有与Java Application相近的安全权限。

45. 访问权限 我们已经知道，当用一个类创建了一个对象之后，该对象可以通过“ .”运算符访问自己的变量，并使用类中的方法。但访问变量和使用方法有一定的限制，限制范围由修饰符public、private、protected说明。 一、private • 用private修饰的变量叫私有变量 • 用private修饰的方法叫私有方法 • private不能用来做类的修饰符 • 私有变量和私有方法只能被定义在该类内部的该类的对象访问和修改

46. class Tom { private float weight; private float f(float a,float b) { ... } } class Jerry { void g( ) { Tom cat=new Tom( ); cat.weight=23f; //非法 cat.f(3f,4f); //非法 } } class Tom { private float weight; private float f(float a,float b) { ... } void g( ) { Tom cat=new Tom( ); cat.weight=23f; cat.f(3f,4f); } }

47. class Example4_9 { private int money; Example4_9( ) { money=2000; } private int getMoney( ) { return money; } public static void main(String args[]) { Example4_9 exa = new Example4_9( ); exa.money=3000; int m=exa.getMoney( ); System.out.println("money="+m); } } 私有变量 构造方法 私有方法 输出：money=3000

48. class Example4_9 { private int money; Example4_9( ) { money=2000; } private int getMoney( ) { return money; } public static void main(String args[]) { Example4_9 exa = new Example4_9( ); int m=exa.getMoney( ); System.out.println("money="+m); } } exa.money=3000; 输出：money=2000

49. class Example4_9 { private int money; private int getMoney( ) { return money; } public static void main(String args[]) { Example4_9 exa = new Example4_9( ); exa.money=3000; int m=exa.getMoney( ); System.out.println("money="+m); } } Example4_9( ) { money=2000; } 输出：money=3000

50. class Example4_9 { private int money; private int getMoney( ) { return money; } public static void main(String args[]) { Example4_9 exa = new Example4_9( ); int m=exa.getMoney( ); System.out.println("money="+m); } } Example4_9( ) { money=2000; } exa.money=3000; 输出：money=0