第三章Java面向对象编程

1、第三章：面向对象程序设计,内容,什么是面向对象编程？ 类和对象 继承和多态 抽象类和接口,什么是面向对象程序设计？,面向过程程序设计分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。简而言之，面向过程程序设计是使用过程进行的程序设计。 面向对象程序设计(OOP) 对要处理的问题进行自然分割，按照人的思维方式建立问题领域的模型，对客观实体进行结构模拟和功能模拟，设计出尽可能自然地的表现问题求解方法的问题。面向对象程序设计是使用对象进行程序设计。 无论是面向过程还是面向对象，它们都是软件重用的一种思想而已,对象是什么？,类和对象对象是什么？,对象代表

2、现实世界中可以明确标识的一个实体。例如，一个学生，一张桌子，一个圆，一个按钮甚至一笔贷款都可以看作一个对象。 对象有自己独有的特性、状态和行为。 对象的状态是由具有当前值的数据域（属性）的集合构成的。 对象的行为是由方法的集合定义的。调用对象的一个方法就是要求对象执行一项任务。 例如，圆对象具有数据域radius，它是圆的特征属性。圆的一个行为就是使用getArea()方法计算它的面积。,类和对象对象和类的关系,类就是定义同一类型对象的结构。类是一个模版或蓝本，用来定义对象的数据和行为。一个对象就是类的一个实例。 我们可以从一个类中创建多个类的实例，创建实例的过程成为实例化,Name:Circ

3、le DataField: radius is_ Method: getArea();,Circle1 Radius is 10 getArea(),Circle2 Radius is 25 getArea(),实例化,类和对象类的创建,在Java类中，用变量来定义数据域，方法来定义行为。此外类中还有一个特殊的方法成为构造方法，调用它可以实现类的实例化。 因此，Java的类由数据、方法以及构造方法组成。 Java中定义类的语法格式为： class 类名 数据； 构造方法； 方法； ,类和对象数据域的定义,Java中数据域是用变量来定义的，因此我们可以用定义变量的方式来定义数据域，其格式如下：

4、数据类型 数据名；（数据名的定义遵循Java标识符的规则） 例如，我们需要对学生进行模拟建立学生的类，学生的属性是用数据域的集合来表示的，如下所示： public class Student private String name,deparment,sex; private int age; double length; ,类和对象方法的定义,类中定义的方法通常起到两种作用： 围绕着类的属性进行各种操作； 与其他的类或对象进行数据交流、消息传递等操作 方法的定义分为：方法声明和方法体 返回类型 方法名（） 方法体； ,类和对象类的定义实例,例如，定义圆对象的类如下: public class

5、 Circle double radius; public Circle() public double getArea() final double PI=3.14; return PI*radius*radius; ,数据域,构造方法,方法,构造方法是什么？,类和对象构造方法,构造方法是一种特殊的方法，构造方法的特殊之处在于： 一、构造方法必须与定义它的类的名字完全相同； 二、构造方法没有返回类型，甚至连void都没有; 三、构造方法的调用是在创建一个对象时使用new操作符进行的; 四、其他规则遵行方法的定义规则； 五、构造方法的作用是用来初始化对象; 类可以不声明构造方法。这种情况下，类

6、中隐含的声明了一个无参的构造方法，成为默认构造方法。,类和对象构造方法的重载,引例： public class Circle double radius; public Circle() public Circle(double r) radius=r; public double getArea() final double PI=3.14f; return PI*radius*radius; ,两个构造方法但参数列表不同，这是什么？,类和对象方法的重载,方法的重载是指若干个方法具有相同的名字而具有不同的参数列表。 public static int max (int x,int y) re

7、turn x=y?x:y; public static double max(double x,double y) if(x=y) return x; else return y; ,类和对象重载方法的调用,在一类中同时出现两个同名的方法时，系统在调用方法时会根据方法中的参数列表不同自动加载的相应的方法。 int max=max(3,4);double max=max(3.0,4.0); 当然构造方法的重载也遵行这些规则。,类和对象类的实例化,Java中创建对象的语法格式为： 类名 对象名=new 类名（）；(调用相应的构造方法进行实例化) Circle circle1=new Circle（

8、）； Cricle circle2=new Circle(3.25);,类和对象访问对象的数据和方法,对象已经创建后，我们就可以访问对象的数据和方法 对象的数据和方法可以用点运算符(.) 来访问。 访问对象的数据：对象名.数据域名 Circle circle1=new Circle(3.12); double radius=circle1.radius; 调用对象的方法：对象名.方法名（参数）（方法的调用遵行调用规则） Cricle circle2=new Circle(3.12); double area=circle2.getArea();,类和对象面向对象编程举例,public clas

9、s TestCricle public static void main(String args) Circle circle1=new Circle(); System.out.println(“The area of circle of radius ”+circle1.radius+“ is ”+circle1.getArea()）; Circle circle2=new Circle(6.0); System.out.println(“The area of circle of radius ”+circle2.radius+“ is ”+circle2.getArea(); clas

10、s Cricle double radius; public Circle() radius=1; public Circle(double newRadius) radius=newRadius; public double getArea() final double PI=3.14f; return PI*radius*radius; ,类和对象类成员的修饰符,在Java程序设计的过程中，我们需要类的成员的作用域以及类的成员归属问题做出限制，这样做将便于类的逻辑严密性。 Java中的修饰符可分为两类：访问控制修饰符用来控制对数据域、方法和类的访问；类型说明符用来定义类的成员的特殊性质。

11、访问控制修饰符有:public、protected、private、（default） 类型说明符有：final、abstract、static,类和对象访问控制符public、private、default,public修饰的类、数据和方法可以被任何类访问; private修饰的数据和方法只能被当前类中的成员使用； (defualt)修饰的类、数据和方法可以被包中任何类访问,public class C3 void aMethod() C1 o=new C1(); 能访问o.x; 不能访问o.y; 不能访问o.z; 能调用o.m1(); 不能调用o.m2(); 不能调用o.m3(); ,类和

12、对象访问控制符（default）,如果类没有声明为public，那么仅能同一包中被访问。,public class C3 不能访问C1的对象； 可以访问C2的对象； ,类和对象访问控制符应用举例,package p1; package p1; public class C1 class C2 public int x; public static void main(String args) int y; C1 o=new C1(); private int z; System.out.println(o.x); public void m1() System.out.println(o.y)

13、; System.out.println(“m1被调用”); System.out.println(o.z)； o.m1(); void m2() o.m2(); System.out.println(“m2被调用”); o.m3(); private void m3() System.out.println(“m3被调用”); package p2; import p1.*; public class C3 public static void main(String args) C1 o=new C1(); C2 o1=new C2(); ,类和对象类型说明符static,Circle c

14、1=new Cricle(); Circle c2=new Circle(2.5) c1中的radius独立于c2中的radius,存储在不同的内存空间上。 c1中radius的变化不会影响c2中的radius,反之亦然。 radius属于类中一个特定的实例，称为实例变量,类和对象静态成员,如果想让一个类中的所有实例共享数据，就可以用静态变量。 静态变量将变量值存储于类的公用内存中。如果某个对象修改了静态变量的值，同一个类的所有对象都会受到影响。 如果想无需创建类的实例就调用类的方法，同样我们也可以将方法定义为静态方法。 要声明一个静态变量或静态方法，只需在变量或方法说明中加上修饰符stati

15、c,类和对象静态变量、常量、方法,静态变量numberofObjects、常量PI和静态方法getNumberofObjects可以声明如下： public static int numberofObjects; public final static double PI=3.14; public static int getNumberofObjects() return numberofObjects; 静态成员的使用： 类名.静态数据名或对象名.静态数据名 类名.静态方法名（）或对象名.静态方法名（） 静态变量、常量既可以在静态方法中使用也可以在实例方法中使用，实例变量、常量只能在实例方

16、法中使用。,类和对象静态成员应用举例,public class Circle public static int numberOfObjects; public final static double PI=3.14; double radius; public Circle() numberOfObjects+; public Circle(double newRadius) radius=newRadius; numberOfObjects+; public static int getNumberOfObjects() return numberOfObjects; public dou

17、ble getArea() return PI*radius*radius; ,类和对象静态成员应用举例,public class TestCircle public static void main(String args) Circle c1=new Circle(); System.out.println(“Before creating c2”); System.out.println(“c1 is:radius(”+c1.radius+“)and number of Circle objects(”+c1.numberOfObjects+“)”); System.out.printl

18、n(“The number of Circle objects is ”+Circle.numberOfObjects); Circle c2=new Circle(5.0); c1.radius=9; System.out.println(“After creating c2 and modifying c1s radius to 9”); System.out.println(“c1 is:radius(”+c1.radius+“） and number of Circle objects(”+c1.numberOfObjects+“）”)； System.out.println(“c2

19、is:radius(”+c2.radius+“） and number of Circle objects(”+c2.numberOfObjects+“）”)； System.out.println(“The number of Circle Objects is”+Circle.numberOfObjects); ,类和对象参数传递,引例： public class Circle public double radius; public Circle(double newRadius) radius=newRadius; public double getArea() final doubl

20、e PI=3.14; return PI*radius*radius; ,类和对象参数传递,引例： public class example public static void main(String args) double radius=2.5; Circle c=new Circle(radius); double area1=getArea(radius); System.out.println(“The area is ”+area1); System.out.println(“After invoke,the radius is ”+radius); double area2=g

21、etArea(c); System.out.println(“The area is ”+area2); System.out.println(“After invoke,the radius is ”+c.radius); public double getArea(double radius) final double PI=3.14F; double area=PI*radius*radius; radius=radius+1.0f; return area; public double getArea(Circle circle) double area=circle.getArea(

22、); circle.radius=circle.radius+1.5f; return area; ,思考一下，两次求面积之后圆的半径发生的变化？,基本数据类型和引用数据类型,每个变量代表一个存储值的内存单元。 对于基本数据类型变量而言，对应内存所存储的值是基本数据类型,它的值为对应内存中的所存储的值。 对于引用数据类型变量而言，它的值是一个引用，是对象的存储地址。 基本数据类型 对象类型 int i=1; Circle c i c,1,引用,c:Circle radius=1,基本数据类型和引用数据类型的赋值,int i=1,j=2; Circle c1=new Circle(2.5); i

23、=j; Circle c2=new Circle(4.0); i j c1=c2; c1 c2 i j,1,2,2,2,c1：Circle radius=2.5,c1：Circle radius=4.0,类和对象参数传递,Java中参数的传递有两种方式： 按数值进行传递：传递的方向是单向的，只能有实参传给形参（将实参值的一个副本传给了形参），而不能有形参传给实参，因此，方法中形参发生的任何变化将不会影响到实参的值，如上例中double area1=getArea(radius)中采用的方式。 按引用值进行传递：将引用数据类型的引用值传入方法内部，形参在方法中的变化将会影响到实参中的内容。如上例

24、中double area2=getArea(c）中采用的方式。,类和对象对象作为方法的参数,对象作为方法的参数，实参与形参之间的参数传递是通过引用值的传递的来完成的。 以引例中的double area2=getArea(c）为例来详细说明其参数传递过程以及形参和实参之间的相互作用。,radius=2.5,c,int radius=2.5; Circle c=new Circle(radius);,circle=c;,circle,circle.radius=circle.radius+1.5f,double area2=getArea（c）,radius=2.5+1.5f=4.0f,类和对象应

25、用举例1,class dataEnity int i,j,k; public dataEnity() public dataEnity(int new_i,int new_j,int new_k) i=new_i; j=new_j; k=new_k; ,类和对象应用举例2,public class TestObject public static void main(String args) dataEnity db=new dataEnity(23,10,45); System.out.println (“Before changed:”); System.out.println(“db.i

26、= ”+db.i+” db.j=”+db.j+” db.k=”+db.k); s); System.out.println(“After changed:”); System.out.println(“db.i= ”+db.i+” db.j=”+db.j+” db.k=”+db.k); public static void s db) int temp; if(db.idb.j) temp=db.i; db.i=db.j; db.j=temp; if(db.idb.k) temp=db.i; db.i=db.k; db.k=temp; if(db,=.jdb.k) temp=db.j; db.

27、j=db.k; db.k=temp; System.out.println(“db.i= ”+db.i+” db.j=”+db.j+” db.k=”+db,k); ,类和对象this关键字的使用,变量定义的位置决定了变量的作用域，按照变量的作用域，变量可以分为类变量和局部变量； 请看下面的例子： public class example private int data; public example(int data) 将局部变量data的值赋给类变量data； ,当类变量和局部变量同名时，我们却要在定义局部变量的方法中使用类变量，怎么办？,类和对象this关键字的使用,当在一个方法中局部变

28、量和类变量重名时，类变量将会被局部变量所覆盖。如果要在该方法中使用类变量，this关键字将会是你的选择。 this指向当前对象的一个引用变量。即this表示的是当前对象本身，利用它可以调用当前对象的方法或者数据。 public example(int data) this.data=data; ,类和对象类的封装,引例: class Circle double radius; public circle(double radius) this.radius=radius; public double getArea() final double PI=3.14; return PI*radiu

29、s*radius; ,public class TestCircle public static void main(String args) Circle c=new Circle(2.5); System.out.println(c.radius); c.raidus=c.radius+1.5f; System.out.println(c.radius); c.radius=-1.0f; System.out.println(c.radius); ,类和对象引例分析,上例中对象c的半径可以通过c.radius=?来直接进行修改，这样做就导致以下问题： 第一，数据可能被篡改，我们知道对于一个

30、指定的圆，它的半径应该是事先测量好不可逆。 第二，它使类难于维护并且不易调试。上例通过c.radius=-1.0f将圆的半径修改一个负值。 因此，为了避免在其他类中直接修改对象的属性或数据，应该使用private 修饰为私有域，这个过程称为数据域封装，它是类的封装的一种简单形式。,类和对象数据域封装,如果我们将类的数据域定义为private的，有时使用对象的类还是要经常存取、修改数据域,因此，为了能够访问私有数据域，可以编写一个get方法返回数据域的值，为了修改它，可以编写一个set方法设置新值，这两个方法分别称为访问器和修改器。 get方法的签名如下: public 返回类型 get属性名(

31、) return 属性名; ,public double getRadius（） return radius; ,类和对象数据域封装,set方法的签名如下: public void set属性名(参数列表) 赋值语句; public void setRadius(double radius) this.radius=radius; ,类和对象数据域封装应用举例,public class Circle private double radius; public double getRadius() return radius; public void setRadius(double radiu

32、s) this.radius=radius; public Circle(double radius) this.radius=radius; public double getArea() final double PI=3.14f; return PI*radius*radius; ,类和对象数据域封装应用举例,public class TestCircle() public static void main(String args) Circle c=new Circle(5.0); System.out.println(“The radius of c is ”+c.getRadius

33、(); c.setRadius(4.0); System.out.println(“The radius after changed is”+c.getRadius(); ,类和对象类的封装,封装是指面向对象程序设计的基本特点。所谓封装性，是把具有功能和数据的组件作为一个“黑盒子”，该组件提供给用户某些调用接口，组件的使用者不必清楚组件内部的工作原理，只需调用暴露在组件外的接口即可。 面向对象强调的是对数据的抽象，因此更多的情况是隐藏成员变量，而暴露出成员的方法作为访问对象状态的接口。 数据域封装是类的封装的基本方式。,类和对象包,什么是包？包是类的组织方式，是Java提供的一种区别类命名空间

34、的机制。包对应一个文件夹，包中还可以再有包，称为包等级。 为什么要使用包？使用对象进行程序设计最重要的原因是为了提高程序中代码的重用率，因此公共资源可以重用是面向对象程序设计的一个重要特点。在Java中，当应用软件比较多时，如果将所有文件放在一个文件夹中，管理起来就比较麻烦，以后的软件资源重用就不方便，通过包可以方便的解决此类问题。,类和对象包的声明,Java中声明包的语法格式如下： package pkg1 包的声明语句必须放在Java文件的首行，“.”表示目录分隔符，它表示pgk3目录在pgk2下，pgk2目录在pgk1下，一次类推，这些目录形成了一个树状结构。 例如package cn.

35、edu.zjut语句声明了一个包，这将java文件的目录之下生成如下图所示的树状结构.,类和对象包的声明,在一个程序的声明一个包后，程序编译好的.class文件会自动存放在该所对应的文件夹下。 若要在编写Java程序时要声明包，建议使用诸如Jcreator之类的编程软件来进行编程。,类和对象包的使用,当一个类中要使用在另一个包下定义的类的时候，通过import语句来显式说明可以在一个类中使用在另一个包中的类。 利用import语句导入其他包中的类的语法格式如下： import pkg1.类名(*)；（“*”表示引入包中的所有类） 为了使用用户自定义的包中的类，用户必须配置ClassPath路径

36、,类和对象包的应用举例,package .zjut.circle; public class Circle private double radius; public double getRadius() return radius; public void setRadius(double radius) this.radius=radius; public Circle(double radius) this.radius=radius; public double getArea() return Math.PI*radius*radius; ,类和对象包应用举例,packa

37、ge .zjut.main; import .zjut.circle; public class TestPackage public static void main(Stringargs) Circle c1=new Circle(4.0); Circle c2=new Circle(2.5); CompareArea(c1,c2); public void CompareArea(Circel c1,Circle c2) double area1=c1.getArea(); double area2=c2.getArea(); if(area1=area2) Sy

38、stem.out.println(“The bigger one is c1(“+c1.getRadius()+”)”); else System.out.println(“The bigger one is c2(”+c2.getRadius()+”)”); ,重构java程序的基本单元,package pgk1;/声明一个包，以将该类包含在这个包中 import pgk1.className(*)/导入一个包，以使用包中的类 class 类名 数据域； 方法； ,继承和多态继承的概念,什么是继承？在面向对象程序设计中，可以从已有类中派生出新类，这就是继承。 例如，如果已经存在了一个人的类P

39、erson，我们就可根据这个Person类派生出一个新类一个公司的职员类。 为什么要继承？如果我们希望一个类拥有已有类的属性和行为，同时还需要具有自己独特属性和行为，就可以使用继承。 Java中所有类都来自于一个已存在的类，或者显示声明的，或是隐式的（java.lang.object）,继承和多态父类和子类,在java中，从另一个类C2中派生出的类C1称为子类或者次类、扩展类、派生类。类C2称为父类或基类、超类。 Java中对类的继承是单向的，也就是说一个类有且只能有一个父类。 继承完成以后，子类可以从它的父类中继承可访问的数据域和方法，同时也可以添加新的数据域和方法。 那么如何创建一个子类或

40、者派生类呢？,继承和多态子类的语法格式,Java中定义一个子类的语法格式如下: class 子类名 extends 父类 数据域； 方法； ,继承和多态继承应用举例,例如，我们考虑几何对象。假设要设计模拟几何对象的类，如圆和矩形。几何对象有很多共有的属性和行为，可以用什么颜色画出来、填充或不填充。 这样的话，我们需要编写一个通用的GeometricObject的类可以用来模拟所有几何对象。这个类包括属性color和filled，以及相应的get和set方法。假设该类中还包括dateCreated属性以及getDateCreated（）和toString（）方法。(toString()返回代表该

41、对象的字符串)。 圆是一种通用的几何对象，他和其他几何对象共享通用的属性和方法，因此，通过GeometricObject类来定义Circle就很具有意义，当然矩形类Rectangle也可以。,继承和多态几何对象的UML图,继承和多态继承的实现,父类GeometricObject的代码如下: 子类Circle的代码如下: 子类Rectangle的代码如下： 测试程序TestCircleRectangle： 从上述实例我们可以知道，子类不仅继承了父类中可访问的数据和方法，还具有自己独特的数据和方法。 子类访问继承于父类的的数据和方法的语法格式遵行对象访问数据和方法的规则,继承和多态super关键字

42、,子类从父类中继承了可访问的数据和方法，那么它能够继承父类的构造方法吗？我们能从子类中调用父类的构造方法吗？super关键字 this关键字指向对象本身，关键字super指向使用它的类的父类。 super可以用于一下两种途径：（1）调用父类的构造函数；（2）调用父类的方法 调用父类的构造方法的语法格式如下： super();或super()； super()调用父类的无参构造函数，super()调用与参数匹配的父类构造方法。,继承和多态调用父类的构造方法,public class Person private String name; private String sex; public Pe

43、rson() public Person(String name) =name; public Person(String name,String sex) =name; this.sex=sex; ,继承和多态调用父类的构造方法,public class employee extends Person public employee() super(); public employee(String name) super(name); public employee(String name,String sex) super(name,sex); 注：语

44、句super()或super()必须出现在子类构造方法的第一行，而且这 是调用父类构造方法的唯一方法。,当子类的构造方法没有显式的调用父类的构造方法时，编译器会将super()当做构造方法的第一条语句。 public employee() 等价于： public employee() super(); ,继承和多态利用super调用父类的方法,super 调用父类的方法的语法格式如下： super.方法名()； 例如，在子类Circle中可以通过下述语句调用父类GeometricObject中的getDateCreated()方法 super.getDateCreated(); 当然，我们明白

45、其实在Circle中，我若想调用getDateCreated()方法可以直接通过getDateCreated()语句即可调用没有必要使用super关键字，但是有些情况下，若想调用父类的方法必须使用super关键字。,继承和多态方法的覆盖与super,子类从父类中继承方法。有时，子类必须修改父类中定义的方法，这叫做方法的覆盖。 例如上例，GeometricObject类返回表示几何对象的字符串,这个方法就可以覆盖，返回表示圆的字符串。 public class Circle extends GeometricObject /原有属性和方法 /*重载父类GeometricObject中定义的toS

46、tring()方法*/ public void toString() System.out.println(super.toString() +”nradius is ”+radius); ,继承和多态重载和super,因此，当父类中的方法在子类中被重载之后；若在子类中还想调用父类中的原方法，只有通过super关键字才能进行。 子类并不能重载父类的任意方法，下述两个方法在子类是不能重载的: (1) 父类中的私有方法 (2)父类中的静态方法,继承和多态重载和覆盖的区别,方法的重载就是提供多个方法，这些方法具有相同的名字而不同的签名而已。 方法的覆盖就是在子类中定义一个方法，该方法与父类中的方法不

47、仅同名而且连方法的签名都相同、返回类型都相同。,继承和多态重载和覆盖举例,public class Test public static main(String args) A a=new A(); a.p(10); public class B public void print(int i) public class A extends B public void print(int i) System.out.println(i); ,public class Test public static void main(String args) A a=new A(); a.print(1

48、0); public class B public void print(int i) public class A extends B public void print(double i) System.out.println(i); ,方法的覆盖,方法的重载,继承和多态 关键字protected,protected修饰的数据和方法只能被该类的子类以及同一中的任何一个类使用，即使该子类不在同一个包中也可以。,public class C3 void aMethod() C1 o=new C1(); 能访问o.x; 不能访问o.y; 不能访问o.z; 不能访问o.s; 能调用o.m1();

49、不能调用o.m2(); 不能调用o.m3(); ,继承和多态关键字protected,public class B protected int x; protected void m() public class A extends B 能够访问 x； 能调用m(); ,public class C extends B 能访问x； 能调用m(); ,继承和多态访问控制符总结,继承和多态final关键字,final关键字除了能够用于修饰变量，同样它也可以用于修饰类和方法。 用final关键字修饰的类，说明该类是一个最终类，不能被其他的类继承。 用final关键字修饰的方法，说明该方法是一个最终的

50、方法，不能被它的子类覆盖。 最终类的语法格式如下: final class 类名 /类体； ,继承和多态对象的转换,对象和基本数据类型一样，也存在转换的问题。 面向对象程序设计中的转换是可以把一个类的对象转换成继承层中的另一个对象。 对象的转换存在一下两种情况： (1) 向上转换（隐式转换）：将一个类的实例转换为一个父类的变量；因为子类的实例永远是父类的实例。这种转换总是可行的，是自动的。 (2)向下转换（显式转换）：将父类的实例转换成子类的变量；这时必须进行显式转换。 显式转换的语法格式如下: （子类名）父类的对象名 student b=(student) o;,抽象类和接口abstract

51、关键字和抽象类,从一个父类中可以派生出多种子类，因此父类必须能够模拟子类所具有的共同特征。 有的时候，我们为了能够将一个父类设计的能够尽可能模拟的子类的共同特征，因此会将父类设计非常的抽象，以至于它没有具体的实例，这个类叫做抽象类 面向对象程序设计中，定义一个抽象类的语法格式如下： abstract class 类名 /类体； ,抽象类和接口抽象方法,abstract不仅能够修饰类而且能够修饰方法，被abstract关键字修饰的方法称为抽象方法 抽象方法的一个重要特征是：只有方法的声明而没有方法的实现过程。 例如， public abstract double getArea();,抽象类和接

52、口抽象类的定义举例,由前面可知Circle和Rectangle类都从GeometricObject中派生；而且这两个类都有getArea()和getPerimeter()方法，这两个方法只是在不同类中有不同的实现过程。 因此，我们何不将这两个方法定义为父类GeometricObject的抽象方法，其具体的实现过程在其子类实现。 public abstract class GeometricObject /原有的方法 public abstract double getArea();/抽象方法，求面积 public abstract double getPerimeter();/抽象方法，求周长 ,抽象类和接口抽象类的特征,抽象类和常规类一样，具有数据和方法，但是不能用new操作符创建它的实例。 抽象类中的抽象方法只有方法的生命而没有方法