java类的设计与详解

1、1第4、5章 类和对象设计2主要内容4.1 面向对象的基本概念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类34.1面向对象的基本概念面向对象程序设计围绕的几个主要概念:n抽象数据类型n类、类型层次（子类）n对象，消息和方法n封装性，继承性、多态性4抽象数据类型class Car int color_number; int door_number; int speed; void brake() void speedUp() ; void slowDown() 计算机中的对象的原型 现实生活中的对象5类n类是描

2、述对象的“基本原型”，它定义一种对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是程序的基本单元。 程序中的对象是类的一程序中的对象是类的一个实例，是一个软件单个实例，是一个软件单元，它由一组结构化的元，它由一组结构化的数据和在其上的一组操数据和在其上的一组操作构成作构成。variablesmethods6变量，方法，消息n变量：即指对象所知道的状态n方法：指对象的功能单元。n软件对象通过相互间传递消息来相互作用和通信n消息由三部分组成:n1. 接受消息的对象n2. 要完成方法的名字n3. 方法需要的参数对象对象B对象对象 Amessage7例子n在程序中操作对象是类的一个实例:即

3、对象n创建一个对象 Hello obj=new Hello();n调用方法 obj.changeString(“Hello World!”)class Hello private String s；public void showString (） System.out.println(s);public void changeString(String str) s=str; 8封装n什么是封装?n封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方封装实际上使用方法将类的数据隐藏法将类的数据隐藏起来，控制用户对起来，控制用户对类的修改和访问数类的修改和访问数

4、据的程度。据的程度。私有数据私有数据方法方法方法方法数据数据对象对象A对象对象B公有数据公有数据9子类n什么是子类?n子类是作为另一个类的扩充或修正所定义的一个类.bicycle(super class)Mountain bikesRacing bikesTandem bikessub class10继承n什么是继承?n继承是子类利用父类中定义的方法和变量就像它们属于子类本身一样.class Car int color_number; int door_number; int speed; push_break() add_oil() class Trash_Car extends Car d

5、ouble amount; fill_trash() 11何时选择继承性n一个很好的经验: “C是一个A吗?”n如果是则让C做A的子类.常犯的错误常犯的错误A有一个有一个C吗吗? 例如让汽例如让汽车轮子成为汽车的子类是错误的车轮子成为汽车的子类是错误的12主要内容4.1 面向对象的基本概念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类134.2 定义Java 类n包括类声明和类体n类声明： publicabstract|final class className extends superclassName i

6、mplements interfaceNameList 14Java类体 class className public | protected | private static final transient volatile type variableName; /成员变量 public | protected | private static final | abstract native synchronized returnType methodName(paramList) statements /成员方法 15成员变量 Type variableName; /成员变量 例如：定义一

7、个名为Rect表示长方形的类，它仅包含double类型的长length和宽width两个数据成员： class Rect double length; double width; 16成员方法returnType methodName(paramList) statements /方法体class Rectangle double length; double width; double area() return length * width; void setDim(double w, double l) width = w; length = l; 17成员方法(值参传递)public

8、class PassTest float ptValue; public static void main(String args) int val; PassTest pt=new PassTest(); val=11; System.out.println(“Original Int Value is:”+val); pt.changedInt(val); System.out.pringln(“Int Value after Change is:” +val); pt.ptValue=101f; System.out.println(“Original ptValue is:”+pt.p

9、tValue); pt.ChangeObjValue(pt); System.out.println(“ptValue after Change is:”+pt.ptValue); 18成员方法(值参传递)public void changeInt(int value) value=55;public void changeObjValue(PassTest ref) ref.ptValue=99f;19成员方法(值参传递)n运行结果c:java PassTestOriginal Int Value is : 11Int Value after Change is: 11Original pt

10、Value is: 101.0ptValue after Change is : 99.020成员方法(方法体)n方法体包括局部变量的声明以及所有合法的Java指令。n局部变量的作用域在该方法内部。n若局部变量与类的成员变量同名，则类的成员变量被隐藏。nthis用在一个方法中引用当前对象，它的值是该方法所在的对象。n返回值须与返回类型一致，或是其子类21成员方法(方法体)实例(1)class Variable int x=0,y=0,z=0; /类的成员变量 void init(int x,int y) this.x=x; this.y=y; int z=5; /局部变量，隐藏全局变量 Sys

11、tem.out.println(“* in init*”); System.out.(“x=”+x+“ y=”+y+“ z=”+z) 22成员方法(方法体)实例(2)public class VariableTest public static void main(String args) Variable v=new Variable(); System.out.println(“*before init*”); System.out.println(“x=”+v.x+ “y=”+ v.y+“z=”+v.z); v.init(20,30); System.out.println(“*afte

12、r init*”); System.out.println(“x=”+v.x+ “y=”+ v.y+“z=”+v.z);23成员方法(方法体)实例(3)运行结果 c:java VariableTest *before init* x=0 y=0 z=0 * in init * x=20 y=30 z=5 *after init* x=20 y=30 z=024方法重载(Method Overloading)n方法重载指多个方法享有相同的方法名n区别在于：参数类型不同，或个数不同；n返回类型不能用来区分重载的方法。25方法重载public class OverLoad int i = 3, j=

13、4; int sum( ) return i+j; int sum(int a, int b) return a+b; int sum(int a,int b, int c) return a+b+c; double sum(double a, double b) return a+b; public static void main(String args) OverLoad o = new OverLoad(); System.out.println(o.sum(); System.out.println(o.sum(5,6); System.out.println(o.sum(5,8,4

14、); System.out.println(o.sum(3.2,2.15); 26构造方法n构造方法具有和类名相同的名称，而且不返回任何数据类型n构造方法只能由new运算符调用n利用构造方法进行初始化n构造方法不能被继承n重载经常用于构造方法27构造方法n示例class Point int x,y; Point() x=0; y=0; Point(int x, int y) this.x=x; this.y=y; 完整例子28主方法与命令行参数npublic static void main(String args)n该方法被定义为public static void也就是公开的静态的无返回值

15、的方法，且参数args为一个字符串数组，用来接收从命令行输入的参数。n参数之间使用空格隔开。nJava解释器会自动处理，把用空格隔开的各个参数通过args数组传递给main方法。n参数的下标从0开始，args0表示传入的第一个参数，args1表示传入的第二个参数，以此类推。29Example：public class TestJava public static void main(String args) for (int i=0; args != null & iJavajava TestJava this is a parameter test第0个参数：this第1个参数：is

16、第2个参数：a第3个参数：parameter第4个参数：test30finalize()方法n在父类java.lang.Object中实现n对对象进行垃圾收集前，系统自动调用n自己重写时需要调用父类的finalize()方法n该方法最常见的作用是确保释放实例占用的全部资源。 nprotected void finalize() throws throwable /本类的资源清除代码 super.finalize(); 31主要内容4.1 面向对象的基本概念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类324.3

17、 Java对象n一旦定义了所需的类，就可以创建该类的变量，创建类的变量称为类的实例化，类的变量也称为类对象、类的实例等。n对象通过消息传递来进行交互n消息传递即激活指定的某个对象的方法以改变其状态或让它产生一定的行为。33对象的生命周期n对象是在程序运行中创建生成的，其所占的空间在程序运行中动态分配。当一个类的对象完成了它的使命，为节省资源，Java的垃圾收集程序就会自动收回这个对象所占的空间。即类对象有自己的生命周期。n生成n使用n清除34对象的生成n包括声明、实例化和初始化 Type objectName=new type(paramlist);n(1)声明：Type objectName

18、 n声明并不为对象分配内存空间，而只是分配一个引用空间；n(2)实例化：运算符new为对象分配内存空间，它调用对象的构造方法，返回引用；一个类的不同对象分别占据不同的内存空间。n(3)生成：自动执行构造方法，进行初始化；根据参数不同调用相应的构造方法。35对象的使用n对象的引用指向一个中间的数据结构，它存储有关数据类型的信息以及当前对象所在的堆的地址，而对于对象所在的实际的内存地址是不可操作的，这就保证了安全性。n通过运算符“.”可以实现对变量的访问和方法的调用。36调用对象的变量n格式：objectReference.variablenobjectReference是一个已生成的对象，也可以

19、是能生成对象的表达式n例： n Rectangle r = new Rectangle();n r.length=10；n r.width=12； 37调用对象的方法n格式：objectReference.methodName(paramlist);class RectDemo2 public static void main(String args) Rectangle rect1 = new Rectangle(); Rectangle rect2 = new Rectangle(); double ar; rect1.setDim(20, 10); / 初始化每个长方形 rect2.se

20、tDim(6, 3); ar = rect1.area(); System.out.println(第一个长方形的面积是： + ar); ar = rect2.area(); System.out.println(第二个长方形的面积是： + ar); 38对象的清除n对象的清除是指释放对象占用的内存空间。n使用new操作符创建对象之后，Java虚拟机自动为该对象分配内存并保持跟踪。Java虚拟机能判断出对象是否还被引用，对不再被引用的对象，释放它所占用的内存。n我们也可以自行标明一个对象不在使用，只要把一个空值null赋给这个对象引用即可：Obj=null;39主要内容4.1 面向对象的基本概

21、念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类404.4 Java包（package）n一组相关的类和接口集合称为包,包体现了Java语言面向对象特性中的封装机制。n包将java语言的类和接口有机地组织成层次结构，这个层次结构与具体的文件系统的目录树结构层次一致。41n 包由语句package创建，其语法格式如下：n package 包名1.包名2.n Java中，package语句必须是程序的第一条非空格、非注释语句。通过package语句，可将Java程序分层次地存放在不同的目录下，目录名称与包的名称相同

22、。n package book.ch05; n class Rectn 将类Rect放在当前目录的子目录book/ch05下创建包42nJava中，若要用到某些包中的类或接口，一种方法是在程序的开始部分写出相应的引入（import）语句，指出要引入哪些包的哪些类。 n另一种方法不用引入语句，直接在要引入的类和接口前给出其所在包名。n 无论采用哪种方法，使用系统类的前提是这个系统类应该是用户程序可见的类。使用包43n1.使用import语句n 用于灵活地实现在编译中使用外部类和接口的引入机制。n import 包名；n import 包名.标识符；n import 包名.*； n2.直接使用包n

23、一般用在程序中引用类和接口次数较少的时候，在要引入的类和接口前直接给出其所在包名。n java.applet.Applet ap = new java.applet.Applet();使用包44包的使用示例npackage DF;public class Person private String name; public Person(String name) = name; public String getName() return name; 45包的使用示例nimport DF.Person;public class Hello public static voi

24、d main(String args) Person person = new Person(Mike); System.out.println(person.getName(); 46主要内容4.1 面向对象的基本概念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类474.5 面向对象特性n封装性n继承性n多态性48封装性n类定义publicabstract|final class className public | protected | private static final type variable

25、Name; /成员变量 public | protected | private static final | abstract returnType methodName(paramList) throws exceptionList statements /成员方法 49封装性类的修饰nabstract类不能直接产生属于这个类的对象nfinal类不能被其他任何类所继承(安全的考虑)npublic类不但可以被同一程序包中的其它类使用,别的程序包中的类也可以使用.n缺省缺省：类只能被本包中的其它类使用（即便import也不行）50封装性java访问控制n变量和方法的修饰字public、prot

26、ected、privatenpublic: 任何其它类、对象只要可以看到这个类的话，那么它就可以存取变量的数据，或使用方法。class ABC public int pub_i=5； public void show)() System.out.println (“pub_i”+pub_i);51封装性例子class Demo public static void main(String args) ABC abc=new ABC(); System.out.println(“abc.pub_i”+abc.pub_i); abc.pub_i=10; abc.show(); abc.pub_i=

27、5pub_i=10;52封装性-protectedn如果一个类中变量或方法有修饰字protected，同一类，同一包可以使用。不同包的类要使用，必须是该类的子类可以存取变量或调用public class ABC protected int pro_i=5; protected void show() System.out.println (“pro_i=” +pro_i;) 53封装性-protectedn同一个包中的类能使用class DEF public static void main(String args) ABC abc=new ABC(); System.out.println

28、(“_i=“+_i); abc.pub_i=10; abc.show(); 54import mytest.pack.ABC;class DEF extends ABC public static void main(String agrs) DEF def=new DEF(); System.out.println(def. pro_i); def. pro_i=10; def.show(); 封装性-protectedn不同包但是是子类也可以55封装性nprivaten不允许任何其他类存取和调用n“前边无修饰字的情况”，称为缺省控制，也称包权限n在同一包中出现的

29、类才可以直接使用它的数据和方法.56封装性-修饰符与访问控制同一个类同一个包不同包的子类不同包非子类private空白protectedpublic57继承性n通过继承实现代码复用 n父类包括直接或者间接被继承的类nJava不支持多重继承n子类不能访问父类中访问权限为private的成员变量和方法。n子类可以重写父类的方法，及命名与父类同名的成员变量58创建子类n格式：class SubClass extends SuperClass 59继承性示例60继承性示例61继承性示例62继承性示例class A int i, j; void showij() System.out.println(i

30、 and j: + i + + j); /创建一个继承超类A的子类B class B extends A int k; void showk() System.out.println(k: + k); void sum() System.out.println(i+j+k: + (i+j+k); 63继承性示例class SimpleInheritance public static void main(String args) A superOb = new A(); B subOb = new B(); superOb.i = 10; superOb.j = 20; System.out.

31、println(Contents of superOb: ); superOb.showij(); System.out.println(); subOb.i = 7; subOb.j = 8; subOb.k = 9; System.out.println(Contents of subOb: ); subOb.showij(); subOb.showk(); System.out.println(); System.out.println(Sum of i, j and k in subOb:); subOb.sum(); Contents of superOb: i and j: 10

32、20Contents of subOb: i and j: 7 8k: 9Sum of i, j and k in subOb:i+j+k: 2464方法重写（overridden）n子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型65方法重写示例66成员变量的隐藏和方法的重写class SuperClass int x; void setX( ) x=0; class SubClass extends SuperClass int x; /hide x in SuperClass void setX( ) /override method setX() x=

33、5; . 67Super (1)nsuper用来引用当前对象的父类(1) 访问父类被隐藏的成员变量，如： super.variable; (2)调用父类中被重写的方法，如： super.Method(paramlist);(3)调用父类的构造函数，如： super(paramlist);68Super (2)class SuperClass int x; SuperClass( ) x=3; System.out.println(“in SuperClass : x=“ +x); void doSomething( ) System.out.println(“in SuperClass.doS

34、omething()”); 69Super(3)class SubClass extends SuperClass int x; SubClass( ) super( ); /call constructor of superclass x=5; /super( ) 要放在方法中的第一句 System.out.println(“in SubClass :x=“+x); void doSomething( ) super.doSomething( ); /call method of superclass System.out.println(“in SubClass.doSomething()

35、”); System.out.println(“super.x=”+super.x+“sub.x=”+x) public class inheritance public static void main(String args) SubClass subC=new SubClass(); subC.doSomething(); 70Super (4)n运行结果c: java inheritancein SuperClass: x=3in SubClass: x=5in SuperClass.doSomething()in SubClass.doSomething()super.x=3 sub

36、.x=571方法重写应遵循的原则n(1)改写后的方法不能比被重写的方法有更严格的访问权限n(2)改写后的方法不能比重写的方法产生更多的例外72方法重写应遵循的原则class Parent public void function( ) class Child extends Parent private void function( ) /出错，访问权限变小public class OverriddenTest public static void main(String args) Parent p1=new Parent(); Parent p2=new Child(); p1.funct

37、ion(); p2.function(); 73多态性n是由封装性和继承性引出的面向对象程序设计语言的另一特征。n静态多态性（编译时多态 由方法重载(overload)实现n动态多态性（运行时多态）n子类对象可以作为父类对象使用。在程序中凡是需要父类对象的地方，都可以用子类对象代替。n由方法重写(overridden)实现n调用规则：根据实例的类型决定调用的方法。74class A int i, j; A(int a, int b) i = a; j = b; void show(String msg) System.out.println(msg + i + + j); class B ex

38、tends A int k; B(int a, int b, int c) super(a, b); k = c; void show(String msg) System.out.println(msg + k); class test public static void main(String args) A subOb = new B(1, 2, 3); subOb.show(This is B: ); / 调用B中的方法show() A sub = new A(1, 2); sub.show(This is A: ); / 调用B中的方法show() 运行结果：This is B:

39、3This is A: 1 275对象状态的确定（instanceof)nManager和Contractor都是Employee的子类n使用instanceof来测试一个对象的类型。 public void method(Employee e) if (e instanceof Manager) Manager m = (Manager)e; System.out.println( This is the manager of + m.department); else if ( e instanceof Contractor) /do something as a Contractor76

40、对象的类型转换n用类型转换来恢复一个对象的全部功能。n向上类型转换是将子类对象强制类型转换为父类类型，这总是允许的，而且不需要强制类型转换运算符。n对于向下类型转换（将父类类型强制转换为子类类型 ），编译器必须满足类型转换至少是可能的这样的条件。比如，任何将Manager转换成Contractor引用的尝试是肯定不允许的，因为Contractor不是一个Manager。类型转换发生的类必须是当前引用类型的子类。77对象类型转换实例class Base public String str = hello Base.; public void hello() System.out.println(

41、str); class Sub extends Base public String str = hello Sub.; public void hello() System.out.println(str); public class two public static void main(String args) Base base = new Base(); base.hello(); / hello Base. Sub sub = new Sub(); sub.hello(); / hello Sub. Base bs = new Sub(); bs.hello(); / hello

42、Sub. Base s = new Sub(); Sub s1=(Sub)s; s1.hello(); / hello Sub. Sub sb = (Sub) new Base(); sb.hello(); / error 78课堂习题课堂习题Given the following codeclass Base class Ag extends Base public String getFields() String name = Ag; return name; public class Avf public static void main(String argv) Base a = n

43、ew Ag(); /Here 下面哪行代码放在注释处，可以输出下面哪行代码放在注释处，可以输出 Ag?1) System.out.println(a.getFields();2) System.out.println();3) System.out.println(Base) a.getFields();4) System.out.println( (Ag) a).getFields();79构造方法在继承中的使用n构造方法不能继承n如父类中只有默认的无参构造方法，写子类的构造方法时不需要用super来初始化父类，它会自动调用父类的默认构造函数。n当父类重写了构造函数后，父类默认的

44、构造函数就被屏蔽，此时在子类写构造函数时必须调用父类的某个(当父类有多个构造函数时)80构造方法在继承中的使用示例class A A() System.out.println(Inside As constructor.); class B extends A / 创建创建A的以个子类的以个子类. B() System.out.println(Inside Bs constructor.); class C extends B / 创建另一个子类继承创建另一个子类继承B. C() System.out.println(Inside Cs constructor.); class Calling

45、Cons public static void main(String args) C c = new C(); 程序运行结果：Inside As constructor.Inside Bs constructor.Inside Cs constructor.81class Books String name; Books(String na) =na; class Book extends Books String author; Book(String author) super(“john”); /如果没有这句，编译出错 this.author=author; /局部变

46、量和成员变量同名时， this用于表示当前对象 构造方法在继承中的使用示例82public class test public static void main(String args) Book b=new Book(mike); System.out.println(name=+); System.out.println(author=+b.author); 构造方法在继承中的使用示例运行结果：name=johnauthor=mike83final关键字n(1) final修饰变量,则成为常量n final type variableName;n 修饰成员变量时，定义时同时给出

47、初始值，而修饰局部变量时不做要求。n(2)final修饰方法，则该方法不能被子类重写n final returnType methodName(paramList)n n n 84final关键字n(3)final修饰类，则类不能被继承n final class finalClassNamen n 85实例成员和类成员n实例成员为特定实例所有，通过对象名访问；类成员为类所有，不属于某一个对象，可以通过类名访问。n类成员的格式（static）：nstatic type classVar;nstatic returnType classMethod(paramlist) nn n86实例变量和类变

48、量n每个对象的实例变量都分配内存n通过对象来访问这些实例变量n类变量仅在生成第一个对象时分配内存，所有实例对象共享同一个类变量。n类变量可通过类名直接访问，无需先生成一个实例对象n也可以通过实例对象访问类变量87实例变量和类变量class ABCD char data; static int_share_data; class Demo ABCD a,b,c,d;object bchar dataobject cchar dataObject bchar datastatic intshare_dataobject bchar data88实例方法和类方法n类（static）方法不能访问实例变

49、量，只能访问类变量n类方法可以由类名直接调用n类方法中不能使用this或super89实例方法和类方法class member static int classVar; int instanceVar; static void setClassVar(int i) classVar=i; / instanceVar=i; /cant access nostatic member static int getClassVar() return classVar; void setInstanceVar(int i) classVar=i; instanceVar=i; int getInstan

50、ceVar( ) return instanceVar; 90实例方法和类方法public class test public static void main(String args) member m1=new member(); member m2=new member(); m1.setClassVar(1); m2.setClassVar(2); System.out.println(m1.classVar=+m1.getClassVar()+m2.ClassVar=+m2.getClassVar(); m1.setInstanceVar(11); m2.setInstanceVar

51、(22); System.out.println(m1.InstanceVar=+m1.getInstanceVar()+m2.InstanceVar=+m2.getInstanceVar(); 91实例方法和类方法n运行结果c: java memberTestm1.classVar=2 m2.classVar=2m1.InstanceVar=11 m2.InstanceVar=2292课堂练习课堂练习Which of the following statements are true? 1) static methods do not have access to the implicit

52、variable called this 2) A static method may be called without creating an instance of its class3) A static method may not be overriden to be non-static 4) A static method may not be overloaded93课堂练习课堂练习写出输出结果：写出输出结果：class Vehicle public void drive() System.out.println(Vehicle: drive);class Car exten

53、ds Vehicle public void drive() System.out.println(Car: drive);94public class Test public static void main (String args ) Vehicle v;Car c;v = new Vehicle();c = new Car();v.drive();c.drive();v = c;v.drive();95主要内容4.1 面向对象的基本概念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类964.6 抽象类-a

54、bstractn用abstract来修饰类或方法n abstract class abstractClass n abstract returnType abstractMethod(paramlist)n抽象类不能被实例化，必须被继承，抽象方法必须被重写，生成它的子类。n抽象方法只需声明，无需实现；n抽象类不一定要包含抽象方法，若类中包含了抽象方法,则该类必须被定义为抽象类97抽象类实例abstract class A abstract void callme(); void callmetoo() System.out.println(This is a concrete method.)

55、; class B extends A void callme() System.out.println(Bs implementation of callme.); class AbstractDemo public static void main(String args) B b = new B(); b.callme(); b.callmetoo(); 98主要内容4.1 面向对象的基本概念4.2 定义Java类4.3 Java对象4.4 Java包4.5 Java的面向对象特性4.6 抽象类4.7 接口4.8 内部类994.7 接口n接口类似抽象类，只包含常量和方法的定义，而没有变量

56、和方法的实现 interface Collection int MAX_NUM=100; void add(Object obj); void delete(Object obj); Object find(Object obj); int currentCount( ); 100接口定义n完整的接口声明:n public interface interfaceNameextends listOfSuperInterface n接口体包括常量定义和方法定义n常量定义: type NAME=value; 该常量被实现该接口的多个类共享; 具有public ,final, static的属性.n方

57、法体定义:(具有 public和abstract属性，因此接口中的所有方法都是抽象的) returnType methodName(paramlist)101接口的实现n在类的声明中用implements子句来表示一个类使用某个接口.n一个类可以实现多个接口,在implements子句中用逗号分开n必须实现接口中定义的所有方法102接口的实现 interface Irect double w=3,l=4; void compute(); class Crect implements Irect public void compute() System.out.println( 边长分别为边长分

58、别为3和和4的长方形面积为：的长方形面积为：+w*l); public class InterfaceDemo public static void main(String args) Crect r = new Crect(); pute(); 103接口作用n(1)通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系.n(2)通过接口指明多个类需要实现的方法n(3)利用接口的多态性，动态加载不同类的实例104一个类实现多个接口的例子105动态加载不同类的实例public interface Person public double calcuMonthlySalary(double

59、sal, int type); public class Manager implements Person public Manager () public double calcuMonthlySalary(double sal, int type) System.out.println(Manager: +(sal*type*3); return sal*type*2; public class Employee implements Person public Employee () public double calcuMonthlySalary(double sal, int ty

60、pe) System.out.println(Employee: +(sal*type*2); return sal*type*1.5; 106public class SalaryManageTest public static void main(String args) throws Exception Person personService = (Person)Class.forName(args0).newInstance(); if (args1 != null & args1 != & args2 != null & args2 != ) int sal = Integer.valu