《面向对象编程.ppt》由会员分享，可在线阅读，更多相关《面向对象编程.ppt（106页珍藏版）》请在三一文库上搜索。
1、第三章 面向对象编程,学习目标 掌握：掌握创建和使用类对象、使用包的基本方法。 理解：理解面向对象程序设计的基本思想和面向对象的概念。 了解：类的多态，接口的声明及实现方法。 重点 明确各种修饰符的作用，理解继承和复用的概念 理解父类和子类 学会Java类的定义和对象的创建。 难点 理解多态性是如何扩充和维护系统性能 类多态的实现。,本讲要点,面向过程和面向对象,面向过程程序设计示意图 面向对象程序设计示意图,1-4,3.1面向对象的思想,面向对象的基本概念 对象是具有某种特性和某种功能的东西。 将同一种类型的对象归为一个类。 类是对象的抽象，对象是类的实例。 类的特征和行为分别命名为属性和方
2、法,类是对象的模板，而对象是类的实例； 共性与个性的关系，是抽象与具体的关系 。,例如：电视机类 属性：尺寸 颜色 型号 方法：打开 关闭 选择节目,3.1面向对象的思想,一个类中定义的方法可被该类的对象调用，对象方法的每一调用被称作发送一个消息message给对象 。 对象间是相互独立，通过发送消息相互影响。一个消息由三部分组成： (1) 消息目标对象； (2) 执行方法的名字； (3) 执行方法所需要的参数（parameters）。,封装性 封装性就是把对象的属性和方法结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节。对外形成一个边界或者说形成一道屏障，只保留有限的对外接口使之与外部发
3、生联系。 继承性 特殊类的对象拥有其一般类的全部属性与方法，称作特殊类对一般类的继承 .一般类为父类（superclass,超类），特殊类为子类(subclass)。 多态性 对象的多态性是指在一般类中定义的属性或方法被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。,面向对象的特点,面向对象三大机制： 封装：隐藏内部实现 继承：复用现有代码 多态：改写对象行为,3.2类,类由数据成员和方法组成。类封装了一类对象的状态和方法 。,汽车(类) 品牌 型号 颜色 - 加速与减速设计 转向设计 刹车设计 ,类的声明,类的修饰符用于说明类的特征和访问权限，包括public，abstract，
4、final，friendly。public：表示此类为“公共”类 ; abstract：表示此类为“抽象”类 ; final：表示此类为“最终”类 . 类名是Java标识符。通常，类名的第一个字母为大写。,一个Java程序可以定义很多个类，但只能有一个public类，程序的主类必须是public类。每个程序都从主类开始执行。,class，extends，implements都是Java关键字。 class表明定义类。 extends表明目前定义的类是父类继承而来的子类，该父类必须存在。 implements表明类要实现某个接口。各接口名之间用逗号“，”分隔。 类体包含：实现类功能的Java语言
5、程序代码、成员变量、成员方法。 类的成员变量定义: 修饰符 数据类型 成员变量=初值; 成员变量的修饰符 访问控制修饰符public、protected、private； 存在修饰符static、abstract和final。,类的声明,其中： final：表示该变量不能再被修改，称为常量。 例如：final int a=3; static：表示该变量时静态变量，也称为类变量。属于这个类的所有对象的变量。而实例变量只属于某个对象。通过“类.变量名”和“对象.变量名”引用。 默认修饰符，如果某个成员变量没有设置访问权限，允许类自身以及在同一个包中的所有类的变量访问。,class Example
6、int i; static int j; public static void main(String args) Example a=new Example(); a.j=3; Example.j=2; a.i=4; Example.i=5; ,类的成员方法 定义的一般形式为： 方法修饰符 （） 方法体 成员方法修饰符 主要有public、private、protected、final、static、abstract和synchronized七种 。 成员方法的返回值类型 方法返回值用return语句来实现，返回的数据类型必须与方法说明中的方法返回值类型一致 ； 如果不需要返回值，则其返回值
7、类型被说明为void；,类的声明,final:为最终方法，不能在其所在类的子类中被重载，只能被继承，不能被重写。 static:不需要初始化该方法所在的类。也不能被它的子类所重载。 在一个static方法中，只能访问被定义为static的类变量和类方法。 abstract:抽象方法，只有方法说明，没有方法体。在它所在的类的子类中具体实现。抽象方法所在的类称为抽象类。 synchronized:同步方法，在多线程中使用。,方法名 成员方法名是Java语言合法的标识符。 参数列表 成员方法的参数列表是由逗号分隔的类型及参数名组成，是可选项。 方法体 方法体是一个方法定义的主要部分，包含了所有实现方
8、法功能的Java语言程序代码，方法体用“ ”括起来 。 例3-2 ：源程序名为TestCir.java；定义一个方法，其功能是根据参数r的大小，返回圆的面积。 运行结果：,类的声明,public class TestCir public static void main(String args) /main方法 double k; TestCir mj=new TestCir(); k=mj.area(5); System.out.println(k); public double area(int r) /定义area方法，带有一个参数r final double PI=3.14; /定义常
9、量PI为3.14 return PI*r*r; /由r的值，计算面积，返回面积值 ,类的声明,项目任务：,定义一个正方形，它的数据成员包括长和宽，成员函数包括设置长和宽的值，求长方形的面积。在主方法中定义正方形对象，求长是5，宽是3的面积。然后再求长是8，宽是4的面积。 定义一个职员类Emplyee（姓名，年龄，性别，薪水），一个显示信息的方法，并输出职员信息。,构造方法,构造方法是一种特殊的方法，其名称与类名相同。Java语言中每个类都有构造方法 。 构造方法的特点 构造方法没有返回值类型，没有void。其修饰符只能是访问控制修饰符，即public、private、protected中的任一
10、个。 构造方法不能从父类中继承。 构造方法可以重载，一个类可以有任意多个构造方法。不同的构造方法根据参数的不同状态来选择合适的构造方法。 构造方法不能直接通过方法名引用，必须通过new运算符。 在构造方法中调用当前类和其父类的构造方法，但必须在方法体的第一条语句。,在前一个任务的基础上，构造3个构造函数。,this对象本身,表示对象本身 在不同方法中表示调用这个方法的对象 在构造方法中表示新创建的对象 作用 使用this访问域及方法 使用this解决局部变量与成员变量同名 在构造方法中，用this调用另一个构造方法 必须放在第一句 不能通过this引用类变量、类方法,class Person
11、String name; public void ex1(String name) /name=name; this.name=name; public void ex2() ex1(“XMJ”);/? this.ex1(“XMJ”);/? /局部变量与成员变量同名,public class A public A(int i) public A(int i,int j) this(5);/第一句 /调用另一个构造方法,super直接父类,使用super访问父类被子类隐藏的同名的成员 使用父类的构造方法super()必须放在第一句,class A int i; void value() i=10
12、; System.out.println(i); ,class B extends A int i; void value() i=20; super.value(); System.out.println(i); System.out.println(super.i); ,this与super的区别 this使用当前类的构造方法，super使用其父类的构造方法。 this用以指代一个对象自身，它的作用主要是将自己当成对象作为参数，传送给别的对象中的方法； super为了访问父类的成员变量或方法，采用super加上点和成员变量或方法的形式。,构造方法,例3-3：源程序名为Inheritance
13、.java，是构造方法的例子。,/*定义一个父类superclassname*/ class superclassname int x; superclassname() /父类无参数构造方法 x=3; System.out.println(“在父类中x=“+x); void dosomething() /父类中成员方法 System.out.println(“在父类中dosomething()“); ,/*定义一个子类subclass，从superclassname继承而来*/ class subclass extends superclassname int x; subclass() s
14、uper(); /调用父类无参数构造方法 x=5; System.out.println(“在子类中x=“+x); void dosomething() /子类中成员方法 super.dosomething(); /调用父类中成员方法 dosomething() System.out.println(“在子类中dosomething()“); System.out.println(“super.x=“+super.x+“ sub.x=“+this.x); /*利用super引用父类对象，利用this引用当前对象*/ ,/*定义主程序类inheritance*/ class Inheritanc
15、e public static void main(String args) subclass subc=new subclass(); /调用子类构造方法创建一个对象subc subc.dosomething(); /调用子类的成员方法 dosomething() ,运行结果：,3.3对象,对象的定义 = new（参数1，参数2，）； 或者： ； = new （参数1，参数2，）； 创建对象实际执行了三个操作：说明对象、实例化对象和初始化对象。 说明对象：就是给对象命名，也称定义一个实例变量。 一般形式为： ； 实例化对象：给对象分配存储空间，用来保存对象的数据和代码。new运算符用来实现对
16、象的实例化。 = new （参数1,参数2,）；,对象的使用,初始化对象通过调用该对象所在类的构造方法来实现的。 引用对象的方法一般形式： （,）; 例3-4：程序TwoArea.java，是引用对象的例子。,执行结果：,/*定义一个类Point*/ class Point public int x; /定义成员变量 public int y; /定义成员变量 public Point() /Point构造方法，不带参数 this.x=0; /引用当前x this.y=0; /引用当前y public Point(int x,int y) /Point构造方法，带两个参数 this.x=x;
17、/引用当前x this.y=y; /引用当前y ,/*定义一个类Graph*/ class Graph public int width=0; /定义成员变量 public int height=0; /定义成员变量 public Point origin; /定义成员变量 public Graph() /Graph构造方法1，不带参数 origin=new Point(0,0); public Graph(Point p) /Graph构造方法2，带一个参数 origin=p; public Graph(Point p,int w,int h) /Graph构造方法3，带三个参数, orig
18、in=p; width=w; height=h; ,public void move1(int x,int y) /成员方法move1 origin.x=x; origin.y=y; public void move2(int a,int b) /成员方法move2 origin.x+=a; origin.y+=b; public int area() /成员方法area return width * height; ,public class TwoArea /*定义主程序类*/ public static void main(String args) int x=3,y=4; int w=
19、4,h=5; Point p1=new Point(x,y); /将原点p1定在(3，4)坐标点 Point p2=new Point(6,8); /将原点p2定在(6，8) 坐标点 Graph r1=new Graph(p1,w,h); Graph r2=new Graph(p2,8,10); r1.move1(4,6); /把矩形r1的原点移到（4，6） r2.move2(-2,4); /把矩形r2的原点x坐标减2，y坐标加4 System.out.println(“两个矩形面积差=“+(r2.area() - r1.area(); /*调用成员方法计算矩形r2与r1面积差*/ Syste
20、m.out.print(“r1的原点为(“+r1.origin.x+“,“); System.out.println(r1.origin.y+“)“); System.out.print(“r2的原点为(“+r2.origin.x+“,“); System.out.println(r2.origin.y+“)“); ,3.4继承与多态,继承性 子类可以沿用父类的某些特征。子类也可以具有自己独立的属性和操作。 继承分单继承和多继承。,什么是继承,在日常生活中，经常遇到如下问题。有一辆自行车，自行车有颜色和型号大小之分，而公路赛车也有颜色和型号大小之分，公路赛车多了一项速度的优势。自行车有的东西公
21、路赛车全都有，而公路赛车有的东西自行车不一定有，它们相同地方有很多。在Java中，对于这种情况下就采用继承来完成这个功能。,/这是一个类，表述的是一个自行车 public class bike public String color; /自行车的颜色 public int size; /自行车的大小,即型号 /这是一个类，表述的是一个公路赛类 pubic class racing_cycle public String color; /自行车的颜色 public int size; /自行车的大小,即型号 public String speed; /公路赛车的速度 ,/这是一个类，表述的是一个
22、自行车 public class bike public String color; /自行车的颜色 public int size; /自行车的大小，即型号 /这是一个类，表述的是一个公路赛车，它继承于自行车 pubic class racing_cycle extends bike public String speed; /公路赛车的速度 ,在Java中，被继承的类叫超类（superclass），继承超类的类叫子类（subclass）。因此，子类是超类的一个功能上的扩展，它继承了超类定义的所有属性和方法，并且添加了特有功能方法。 Java是单继承的，子类可以有很多，父类只能有一个。上面的
23、例子，如果加一个Friend类，Son只能继承自Father，要么继承Friend，不能同时继承Father和Friend。 Java的继承是多层继承的，是一个类可以有很多子类，而子类下面又可以有很多子类。 父类没有定义一个无参的构造器，那么编译器就默认生成一个无参的构造器，也可以在子类构造器里显示使用super方法调用父类构造器，super方法里写几个参数就可以表示调用的是父类的哪一个构造器。,当父类中没有构造方法或只有不带参数的构造方法时，系统会在子类构造器自动加上super语句，可以不显式地添加对父类构造器方法的调用，但如果父类中有带参数的构造器方法，那么，必须显式在构造器中使用supe
24、r调用父类的带参数的构造器方法，否则编译出错。,继承性,继承的目的：实现代码重用。 子类不能继承父类中访问权限为private的成员变量和方法。 子类可以继承父类方法和成员变量，但它不能继承构造方法。 创建子类格式：,Public class SubClass extends SuperClass ,访问权限 class 类名 extends 父类,例3-5：源程序名Car Demo .java，是类的继承。,class Car int car_number; void set_number(int car_num) car_number=car_num; void show_number()
25、 System.out.println (“My car No. is :“+car_number); ,继承性,class Bus extends Car int capacity; void set_capacity(int bus_car_capacity) capacity=bus_car_capacity; void show_capacity() System.out.println(“My capacity is: “+ capacity); ,class CarDemo public static void main(String args) Bus DemoBus = new
26、 Bus(); DemoBus.set_number(6868); DemoBus.show_number(); DemoBus.set_capacity(30); DemoBus.show_capacity(); ,运行结果：,继承性,项目任务：,多态性,多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。 方法重写：指方法的含义被重写后替代 。 子类通过隐藏父类的成员变量和重写父类的方法，可以把父类的状态和行为改变为自身的状态和行为。 子类中重写的方法和父类中被重写的方法要具有相同的名字，相同的参数表和相同的返回类型，只是函数体不同。 方
27、法重写时应遵循的原则： 改写后的方法不能比被重写的方法有更严格的访问权限（可以相同）。改写后的方法不能比重写的方法产生更多的例外。,自行车的移动和公路赛车的移动都是靠外力来移动，二者是相同的。公路赛车继承了这一特点，但公路赛车的移动速度就不相同了，移动的快慢就是由它们各自移动特性不相同决定的，,class bike /自行车的移动速度 public void move() System.out.println(“速度慢的!“); ,public class racing_cycle extends bike /公路赛车的移动速度 public void move() System.out.pr
28、intln(“速度快的!“); ,public static void main(String args) racing_cycle rc = new racing_cycle(); /创建了一个公路赛车的对象,对象引用为rc rc.move(); /执行了move()方法 ,例3-6：源程序名Rewritex.java,，是方法的重写的例子。,class SuperClass int x; void setF( ) x=0; System.out.println(“Super的变量x的值“+x); ,void setF( ) /重写了父类的方法 setF() x =6; System.out
29、.println(“Son的变量x的值“+x); ,class SubClass extends SuperClass int x;/隐藏了父类的变量x,多态性,class Rewritex public static void main(String args) SubClass Son = new SubClass (); Son.setF(); SuperClass Father= new SubClass (); Father.setF(); ,运行结果：,多态性,方法重载 方法重载是指同样方法在不同的地方具有不同的含义。 方法重载使一个类中可以有多个相同名字的方法。编译器根据参数的不
30、同来静态确定调用相应的方法。 方法重载中这些方法的参数必须不同，或是参数的数量不同，或是参数的类型不同。 例3-8:源程序名TestLoad.java，方法重载的例子。,多态性,/*定义一个方法重载的类*/ class Load void receive(int i) / receive方法，带有int类型参数1个 System.out.print(“Receive one data!：“); System.out.println(“i=“+i); ,void receive(int x,int y) / receive方法，带有int类型参数2个 System.out.print(“Rece
31、ive two datas!：“); System.out.println(“x=“+x+“,y=“+y); void receive(double d) / receive方法，带有double类型参数1个 System.out.print(“Receive one double data!：“); System.out.println(“d=“+d); void receive(String s) / receive方法，带有string类型参数1个 System.out.print(“Receive a sting!：“); System.out.println(“s=“+s); ,/*
32、主程序类*/ public class TestLoad public static void main(String args) Load mo=new Load (); /创建对象mo mo.receive(1); /调用receive方法，带int类型参数1个 mo.receive(2,3); /调用receive方法，带int类型参数2个 mo.receive(3.14159); /调用receive方法，带double类型参数1个 mo.receive(“It is a Test!“); /调用receive方法，带string型参数1个 ,运行结果：,项目任务,设计一个math类，
33、通过它可以实现整数的加法运算和实数的加法运算。 设计一个employee类，包括数据成员（姓名，年龄，工号，工资），构造方法，addsalary方法增加工资（加薪10%），list显示信息。再设计一个manager类，增加数据成员position，改写addsalary方法增加工资（加薪20%）。,3.5抽象类和接口,抽象类（见Animal.java) 只给出抽象结构，不给出每个成员函数的完整实现的类。 抽象方法：是指该方法只有方法说明却没有方法体。 用abstract 关键字来修饰一个抽象类，用abstract 关键字来修饰一个抽象方法。 抽象类必须被继承，抽象方法必须被重写。 例3-9源程
34、序Abstract.java，一个带有抽象成员函数的类。 abstract class A abstract void callme( ); void me( ) System.out.println(“在A的me成员函数里“); ,抽象类,class B extends A void callme( ) System.out.println(“在B的callme成员函数里“); public class Abstract public static void main(String args) A a = new B( ); a.callme( ); a.me ( ); ,运行结果：,抽象类
35、,用关键字abstract修饰的类称为抽象类 abstract class A /类A为抽象类 ,不能直接被实例化,因此一般作为其它类的父类,定义目的是提供可由其子类共享的一般形式。,抽象类需要继承,子类根据自身需要扩展抽象类。,抽象类,用关键字abstract修饰的方法称为抽象方法 abstract class A abstract int aa(int x,int y);/方法aa为抽象方法 ,抽象类中可以没有抽象方法或某个方法不是抽象方法,有抽象方法的类一定是抽象类抽象方法只能位于抽象类。,接口,Shape.java Java语言不支持多继承性，即一个子类只能有一个 父类，但有时子类需要
36、继承多个父类的特性，因此， 引入了接口。 接口(Interface)，是一些抽象方法和常量的集合。 接口的定义 使用关键字interface。 接口定义的一般形式为：,接口修饰符 interface extends 接口体 ,public abstract class aaa /抽象类里的抽象方法 abstract public void show(); /抽象类里的方法 public int getMax() /定义int类型的私有变量i int i = 123; /将变量i返回出去并退出方法 return i; ,public class test extends aaa public s
37、tatic void main(String args) test t=new test(); t.show(); public void show() System.out.println(“实现了抽象类中的方法”); ,接口,首先来举一个例子，汽车的移动就好比一个接口，在以后生产的汽车中都遵循这个接口进行制造。而接口中只定义了汽车移动的形式，没有具体的去定义是怎么进行移动的，所以接口就好比是一个规定。 接口修饰符 interface 接口名称 /成员变量和方法的申明 ,接口修饰符和类的修饰符是一样的。 interface是定义接口的关键字。 接口里的成员变量默认为public static
38、 final类型的 接口不能声明为final的，因为final类型的必须要实现。 接口就是一个特殊的抽象类，抽象类里有抽象的方法和普通的方法，而接口里方法全为抽象的，需要在其子类进行具体的方法实现。类就是一个产品的详细功能说明，而接口就是这些功能的简要说明。,接口,如果一个抽象类中的所有方法都是抽象的,就可以将这个类用另外一种方式来定义,也就是接口定义。 接口是抽象方法和常量值的定义的集合,从本质上讲，接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。,可以使用extends来继承接口的常量和抽象方法，但它与类中的extends不同，它可以继承有多个父接口(多
39、重继承)，各父接口间用逗号隔开。 接口中的所有常量必须是public static final，方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。,接口的定义,接口修饰符 接口修饰符为接口访问权限，有public和缺省两种状态。 public状态 ：用public指明任意类均可以使用这个接口。 缺省状态： 在缺省情况下，只有与该接口定义在同一 包中的类才可以访问这个接口，而其他包中的类无权访问该接口。 父类接口列表 一个接口可以继承其他接口，可通过关键词extends来实现，其语法与类的继承相同。被继承的类接口称为父类接口，当有多个父类接口时
40、，用逗号“，”分隔。 接口体 接口体中包括接口中所需要说明的常量和抽象方法。,接口的实现,使用关键字implements 。 在实现一个接口时，类中对方法的定义要和接口中的相应的方法的定义相匹配，其方法名、方法的返回值类型、方法的访问权限和参数的数目与类型信息要一致。 例3-10源程序名interfacetest.java，是接口的例子。,interface superinterface1 /*定义接口1*/ static final double PI=3.14; /说明常量 public double Area(); /public状态方法 interface superinterface
41、2 /*定义接口2*/, double bulk(); /缺省状态方法 ,/*定义一个主程序类实现接口*/ public class interfacetest implements superinterface1,superinterface2 double r; double l; public interfacetest() /不带参数构造方法 this.r=0.0; this.l=0.0; public interfacetest(double r,double l) /带两个参数的构造方法 this.r=r; this.l=l; ,接口的实现,public double Area()
42、 /实现接口方法 return 2*PI*(r+1); public double bulk() /实现接口方法 return PI*r*r*l; public static void main( String args ) interfacetest c1=new interfacetest(10.0,6.0); /创建类对象 double arearesult; arearesult=c1.Area(); double bulkresult; bulkresult=c1.bulk(); System.out.println(“面积为“+arearesult); System.out.pri
43、ntln(“体积为“+bulkresult); ,包,所谓包，就好比日常生活中的箱子，是一个存放东西的空间。在Java中包的概念就好比Windows里的目录的概念，是一层一层的关系。按照功能的分类分别存放在各个包里。,使用包是为了更好地将代码进行分别管理，首先介绍如何创建一个包，语法为： package 包名; 例如下面的程序语句。 package a.b; 创建包时有几个注意事项。 package为Java保留的关键字，不能使用别的符号进行代替。 package语句必须在第一行。 package语句只能有一个，不能有多个。 如果包有多层的话用句点”.”分隔,包的定义,包定义的一般形式为： p
44、ackage .； package语句通过使用“”来创建不同层次的包，这个包的层次对应于文件系统的目录结构。 例如：package java.awt.image 表明这个包存储在javaawtimage目录中。 在JDK环境下创建一个包，编译Java程序的命令为： javac d ,使用-d参数，编译结束后，扩展名为class的文件被存储在package语句所指明的目录中。,包名全部用小写字母,包的引入,使用关键词import语句来引入一个包 。 如果有package语句，则import语句紧接在其后，否则import语句应在程序首位。 引入import语句的一般形式: import .包名2
45、.包名3.(类名|*)； 包的访问权限 包中封装了类和其他的包， Java语言提供了许多不同级别的访问权限修饰符来控制对成员变量和成员方法的访问权限。因此，Java语言的包中也存在访问权限问题。,例3-11源程序TestMan.java，创建包和引用包的例子 .,package mypackage; public class Man String name; int age; public Man(String n,int a) name=n; age=a; public void show() if (age18) System.out.println(name+“的年龄是“+age); ,
46、/TestMan.java文件代码 import mypackage.*; public class TestMan public static void main(String args) Man test=new Man(“李阳“,15); test.show(); ,Java API API是系统提供的类库，它不是用户定义的，而是Java系统自带的，供程序员编程时直接使用。使用过程中，程序员只需要根据实际情况安排若干个API实例对象，再调用这些对象的各种方法，就可以完成相应任务。 Java提供了编程所需的一些基础API类，这些类分布在不同的包中。,3.7系统常用类,系统常用包 Java.
47、lang包：主要含有与语言相关的类 。 J包：含有与网络操作相关的类。 Java.io包：主要含有与输入输出相关的类Java.util包：包括许多具有特定功能的类，有Arrays、Date、Calendar和Stack等 。 Java.swing包：提供了创建图形用户界面元素的类。 Java.applet包：含有控制HotJava 浏览器的类。 Object类 Object类处于Java开发环境的类层次树的根部。,Object类,Object类的常用方法： clone ( ) ：生成并返回当前对象的一个拷贝。 equals (Object obj)：比较两个对象是否相同，结果为一布尔值。 getClass( )：返回一个对象在运行时所对应的类的表示，从而得到相关的类的信息。 finalize( )：定义回收当前对象时所需完成的清理工作。 toString( )：返回描述当前对象的字符串信息。,例3-12源程序ObjectExam.java，Object类的常用方法示例。,Rect(double len, double width) /定义有两个参数的构造方法 a=len;b=width; double area() return a*b; class O