第三章 类和对象.ppt.ppt

1、第三章 类和对象,本章主要内容： 3.1类和对象的概念重点 3.2 static关键字 3.3 this关键字 3.4 继承重点 3.5 final关键字 3.6 抽象方法和抽象类重点,3.7 接口重点 3.8 内部类和匿名类难点 3.9 包（package）了解 3.10 综合举例难点 3.11上机实验,3.1类和对象的概念,基本数据类型：如int,float等，系统已定义好其上的操作，如算术运算等。 复合数据类型：用户自己定义的数据类型，需要程序员自己定义一些方法，对该类型的实例进行所需要的操作。数据类型加上其上的操作就称为抽象数据类型。 Java语言中最重要的抽象数据类型由类来实现。,3

2、.1.1类和对象的概念,类：封装的实体 = 变量（数据）+方法(行为) 变量：描述属性或状态 方法: 作用于数据上的操作 对象：类的具体化，实例化。,类的结构,可以是基本类型或复合类型,3.1.2 类的定义,Java中类定义的一般格式为： 访问权限 class 类名 extends 父类名 ,访问权限 类型 成员变量1; 访问权限 类型 成员变量2; .,访问权限 类型 成员方法1（参数列表） 类型 局部变量; 方法体； .,【例3-1】定义一个日期类。,class Date int year; int month; int day; 上面定义的Date类只包含了year，month, day

3、三个成员变量，没有定义成员方法。,【例3-2】定义一个学生类。,class student /类名 /类体开始的花括号 int id; /学号 string name; /姓名 float score; /成绩 Date birthday; /生日,void setName(String sname) /成员方法 name=sname; String getName() /成员方法 return name; /类体结束的花括号 上面的student类定义里，既有成员变量，也有成员方法。,类的成员变量,成员变量：就是类中所包含的数据，一般根据实际问题的需求来决定某个类中需要定义哪些成员变量及其对

4、应的数据类型，成员变量的数据类型可以是Java数据类型中所规定的任意一种合法类型。 在例3-2中定义的学生类student中，就包括了四个不同类型的成员变量： id、name、score及birthday。,类的成员方法,成员方法：就是类中所包含的数据上的操作，类似于C语言中的函数，所以类中的成员方法也称为成员函数。 例如：中定义的学生类student中，就包括了两个成员方法： setName(String sname) 和getName() 。 但在 Java语言中，所有的成员方法的定义都必须在包括在类内，类外不允许定义任何方法。,4.类的实例化对象,对象是类的实例化，或者说是“类”类型的变

5、量。,对象的定义,对象声明一般格式如下： 类名 对象名列表； 例如： student s1,s2; /声明了两个student类类型的对象s1和s2,对象的成员变量和方法的调用,调用成员变量的格式： 对象名. 变量名; 例如：=“ZhangSan”; 调用成员方法的格式： 对象名. 方法名(实际参数表); 例如：s1.setName(“ZhangSan”);,3.1.3 构造方法,构造方法：是类的一个非常特殊的成员方法，主要用于在创建（构造）对象时初始化对象的数据成员。使得每个新创建的对象的数据成员都有初值。,构造方法的特点,构造方法的名称和类名同名； 构造方法没有返回值，voi

6、d都不能有； 构造方法可以根据需要定义多个，当然形参是不同的，即允许重载； 通常是public类型的，即公有的，允许外部访问；,【例3-3】构造方法的定义,class student /类名 /类体开始的花括号 int id; /学号 String name; /姓名 int age; /年龄 float score; /成绩 student( ) /无参的构造方法 id=0; name=” ；age=0 ； score=0; ,/有参的构造方法 student(int sid, String sname, int sage, float sc ) id=sid; /将id的值初始化为sid

7、name=sname; /将name的值初始化为sname age=sage; /将age的值初始化为sage score=sc; /将score的值初始化为sc /类结束括号,默认的构造方法,当在类中没有显式定义构造方法时，系统将自动为该类生成一个默认的构造方法。 默认构造方法还具有如下的特点： 没有形式参数，每个类只有一个默认构造方法 把对象的数据成员都初始化为0、0或null。 如果类中显示定义了无参的构造函数，那么这个无参的构造函数就是默认的构造方法，系统将不再自动生成。,3.1.4类的实例化对象的构造,1.无构造函数时对象的构造 当对应类中没有显示定义构造函数时，系统会自动增加一个默

8、认的构造函数。在实例化对象时，对象的数据也将按照默认的构造函数进行初始化。,【例3-4】默认构造函数的对象构造,class student /类名 /类体开始的花括号 int id; /int型成员变量，表示学号 String name; /String型成员变量，表示姓名 int age; /int型成员变量，表示年龄 f loat score; /float型成员变量，表示成绩 public static void main(String args) /主函数 student s1=new student( ); /构造student对象s1 student s2=new student(

9、 ); /构造student对象s2 /输出两个对象s1,s2的成员变量 System.out.println(“s1.id=”+s1.id+” s1. name=”++” s1.age=”+s1.age+” s1.score=” +s1.score); System.out.println(“s2.id=”+s2.id+” =”++” s2.age=”+s2.age+” s2.score=” +s2.score); ,运行结果,2. 有构造函数时对象的构造,调用student类的student()构造方法进行初始化s1的成员变量 student s1

10、=new student( ); 调用student类的student(int sid, string sname, int sage, float sc )构造方法 student s2=new student(1001，”Zhang”,20,90.0 ); new 是Java 语言提供的运算符，用于创建对象时使用。在创建对象时，系统会为该对象申请相应的内存空间，而且将自动调用该类的某个构造函数。,3.显式的成员初始化,在定义类时，如果在定义成员时就进行初始化，这样的初始化成为显式的初始化，这样的初始化也是允许的。 例如： class student int id=1001; /显式初始化成

11、员id string name=“ZhangSan”; /显式初始化成员name int age=20; /显式初始化成员age float score=90; /显式初始化成员score ,4. 对象构造时的初始化顺序,在使用new运算符创建对象时，就发生了对象的构造。构造调用构造方法时，会按下面顺序进行初始化工作： （1）为新对象分配内存空间，并进行默认的初始化； （2）执行显式的初始化； （3）执行显式的构造方法。,【例3-6】构造方法的顺序,class student /类名 /类体开始的花括号 int id=1000; /显式初始化成员id String name=“ZhangSan

12、”; /显式初始化成员name int age=20; /显式初始化成员age float score=90.0; /显式初始化成员score student(int sid, string sname, int sage, float sc ) /有参的构造方法 id=sid; /将数据成员id的值初始化为sid name=sname; /将数据成员name的值初始化为sname age=sage; /将数据成员age的值初始化为sage score=sc; /将数据成员score的值初始化为sc ,public class TestS public static void main(str

13、ing args) student s1=new student(1001,”LiSi”,19,80.0 ); System.out.println(“id=”+s1.id+” name=”++” age=”+s1.age+” score=”+s1.score); 【例3-6】的运行结果是： id=1001 name=LiSi age=19 score=80.0,3.1.5 访问权限,1.类成员的访问权限 在定义类的成员时，访问权限的修饰符有public, private, protected或者没有（缺省的），根据这些访问权限关键字出现的位置不同，它们既可以用来修饰类，也可以用

14、来修饰类中的成员变量或成员方法。不同的权限决定了在程序运行时被处理的方式。,表3-1 访问权限修饰符,【例3-7】类成员的访问权限,class Authority public int a; /定义了一个public型的成员变量a protected int b; /定义了一个protected型的成员变量b private int c; /定义了一个private型的成员变量c int d; /定义了一个缺省型的成员变量d public setData(int n1,int n2, int n3, int n4) a=n1; /在类内，将局部变量n1赋给成员变量a b=n2; /在类内，将局

15、部变量n2赋给成员变量b c=n3; /在类内，将局部变量n3赋给成员变量c d=n4; /在类内，将局部变量n4赋给成员变量d public printData () System.out.println(a+” ”+b+” ”+c+” ”+d); /输出成员变量a,b,c,d ,public class testAuthority public satic void main(String args) Authority objA1=new Authority(); objA1.a=1; /在类外，可以直接访问public型成员 objA1.b=2; /在类外但同一包内，可以直接访问pro

16、tected型成员 objA1.c=3; /在类外，不允许直接访问privaite型成员 objA1.d=4; /在类外但同一包内，可以直接访问缺省型成员 objA1. printData (); /在类外，可以调用public型的方法printData objA1. setData (10,20,30,40); /在类外，可以调用public型的方法setData objA1. printData (); /在类外，可以调用public型的方法printData ,2.类的访问权限,在Java 中，类前面的访问权限修饰词可以用于确定在某个程序库中的类哪些对于该库的使用者是可用的。对于类的访问

17、权限,仅有两个选择：public（公有的）或是缺省的（仅限同一包内允许访问）。 例如： public class A ; /类A是public型的权限,任何地方都可以使用 class B ; /类B是缺省型的权限，仅限同一包内使用,3.1.6 内存垃圾回收,在Java中，内存垃圾是指那些被对象占用的内存如果不再使用的话，将会被系统视为“内存垃圾”而进行回收。回收后的内存将进入系统空闲内存区，可以分配给其他申请内存的程序。 在Java中，使用垃圾回收器（System.gc()方法）在系统空闲时自动来回收无用对象占据的内存资源。并使用finalize( )方法完成在“垃圾回收时刻”做一些重要的清除

18、工作。,【例3-8】内存垃圾回收,class point int x, y; point(int a, int b) x=a; y=b; System.out.println(point constructor-); public void finalize( ) / 注意该方法 System.out.println(point finalizer-); ,public class testFinalize public static void main(String args ) point p1,p2; p1=new point(1,1); p2=new point(2,2); p1=nu

19、ll; p2=null; System.gc( );/垃圾收集 System.out.println(The end in main-); ,3.2 static关键字,3.2.1 static变量 在Java中，static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以定义静态static代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。,1.static变量的定义,格式如下： static 类型 变量名列表； 例如： class sV static int a,b=2; /定义了static变量 ,2

20、.static变量的访问方式,静态变量可以直接通过类名来访问，也可以通过对象来访问。 访问语法为： 类名.静态变量名 对象名.静态变量名； /不推荐，实例变量的访问一般只有这种方式,【例3-9】static变量的使用,public class sV static int a,b=2; /定义了static变量 public static void main() sV.a=sV.b+3; /通过类名.变量名访问，推荐 sV v=new sV(); v.b+; /通过对象.变量名访问，不推荐 System.out.println(sV.a+” ”+sV.b); ,3.2.2 static方法,静态

21、方法：可以直接通过类名调用，任何的实例对象也都可以调用，因此静态方法中不能用不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员方法)，只能访问所属类的静态成员变量和成员方法。,1.static方法的定义,定义格式如下： static 返回值类型 方法名（形参列表） 【局部变量】；/可以定义局部变量 其他语句；/可以使用静态变量，但不允许使用类的实例变量； ,2.static方法的访问方式,访问静态方法可以为： 类名.静态方法名(实参列表)； 对象名.静态方法名（实参列表）； /不推荐使用，非静态的方法只有这一种调用方式,【例3-10】static方法的使用,publi

22、c class staticF static int a; /定义static变量 int b=3; /定义了实例变量 static void fM() /定义static方法 int t; / 局部变量 staticF.a=2; /静态方法中使用类变量 t=staticF.b; /错误用法，b不是静态变量 staticF sf=new staticF(); t=sf.b; /这样可以用 System.out.println(staticF.a+” ”+sf.b+” ”+t); public static void main(String args) staticF.fM(); /通过类名调用

23、静态方法 ,3.2.3 static代码块,静态代码块：采用static修饰的代码块。Java虚拟机（JVM）加载类时，采用先加载静态的，再加载其它的代码，所以会优先执行static代码中的内容。 JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。,【例3-11】static代码块的使用,public class StaticTest private static int a; /静态成员变量a private int b; /一般成员变量b(非静态的) static /静态代码块 StaticTes

24、t.a=1; System.out.println(a); StaticTest t=new StaticTest (); t.f(); t.b=100; System.out.println(t.b); static StaticTest.a=2; StaticTest.b=200; /这个用法会出错！因为b不是静态成员变量 System.out.println(a); ,static StaticTest.a=3; System.out.println(a); public void f() System.out.println(Test in f!); public static voi

25、d main(String args) static int t=2; /编译会出错！static不能修饰方法中的局部变量 ,3.3 this关键字,在Java中，this关键字用于类的成员方法内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是 this。 因此，this只能在类中（非静态方法）使用，并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this。,一般在下面这三种情况下需要用到this关键字： 通过this调用类中的另一个构造方法； 表示对当前对象的引用。当方法中的局部变量和成员变量同名的情况下，成员变量被

26、屏蔽，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。 在成员方法中，需要引用该方法所属类的当前对象时候，直接用this。,【例3-12】this关键字的用法,public class testThis private int a=0; /int型成员变量a testThis(int a) /第一个构造方法 this.a=a+1; /此时this.a表示引用成员变量a，而非方法的形式参数a System.out.println(第一个构造方法输出a= +a+ 输出this.a=+this.a); /第二个构造方法：有一个String型形参 testThis(String

27、 s) System.out.println(第二个构造方法s=+s); /第三个构造方法：有一个int型形参和一个String型形参 testThis(int b,String s) this(s); /调用第二个构造方法 this(b); /调用第一个构造方法 this.a=b+; /this引用该类的成员变量 System.out.println(第三个构造方法a=+a+n+s=+s); ,public testThis thisCount() this.a+; return this;/返回的是当前的对象，该对象属于thisTest public static void main(St

28、ring args) testThis t1=new testThis(100); testThis t2=new testThis(second!); testThis t3=new testThis(200,third!); System.out.println(t1.thisCount().thisCount().a); /级联调用 /t1.thisCount()返回一个在t1基础上a+的testThis对象， /接着又返回在上面返回的对象基础上a+的testThis对象！ ,【例3-13】this关键字的第三种用法,public cla ss Date private int year

29、; /成员变量year private int month; /成员变量month private int day; /成员变量day Date ( int y, int m, int d) /构造方法 year = y; month = m; day =d; Date ( Date d) 带一个参数的构造方法 year = d.year; month = d.month; day = d.day; ,public void printDate() System.out.println(year + / + month + / + day); public Date tomorrow() Da

30、te d = new Date(this); d.day+; if (d.day d.daysOfMonth() d.day = 1; d.month +; if (d.month 12) d.month = 1; d.year +; return d; ,public int daysOfMonth() switch (month) case 1: case 3: case 5: case 7: case 8: case 10: case 12: return 31; case 4: case 6: case 9: case 11: return 30; default: if ( year

31、 % 100 != 0 ,public static void main (String args) Date d1 = new Date(2013,9, 1); System.out.print(The current date is (dd / mm / yy): ); D1.printDate(); System.out.print(Its tomorrow is (dd / mm / yy): ); Date d2=d1.tomorrow(); d2.printDate(); ,3.4继承,继承：所表达的就是一种类之间的“is-a”关系。 它使得子类对象可以继承父类对象的数据成员和成员

32、方法。 若类B继承类A，则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作)，我们称被继承的类为基类、父类或超类，而称派生自父类的新定义类为派生类或子类。继承关系也是“一般-特殊”的关系。,1.继承的特点,Java继承具有传递性，不支持多重继承，只支持单继承，即每个类只有一个直接父类。 类之间的继承关系具有如下特点： 继承具有传递性； 构造方法不能继承； 子类对象可以使用其父类中定义的公有（及保护）属性和方法； 子类不能直接存取其父类中的私有属性及方法，但可以使用公有（及保护）方法进行存取 。,2.Java中的系统类结构,Java语言是完全的面向对象的语言，系统在不同的JDK版本

33、中都已经预定义了许多系统类，系统类是一个树状的层次结构图，每个类都有一个唯一的父类，Object类是Java中所有类的直接或间接父类，处在类层次最高点，即根类，详见图3-9。所有其他的类都是从Object类直接或间接派生出来的，Object类包含了所有Java类的公共属性和方法，其构造方法是Object( ) 。,3.4.2 定义继承类,1. 继承的实现语法 继承的实现语法如下： 【访问权限】class 子类名 extends 父类名 成员变量； 成员方法； ,【例3-14】继承定义的示例,class Employee /定义雇员类 int ID; String name; int wage;

34、 /定义经理类Manager，继承自父类Employee class Manager extends Employee String department; String grade; Manager( ) /子类的构造方法 department=A dept.; grade=One; System.out.println(ID: +ID+ name: +name+ wage: +wage+ department:+department+ grade:+grade); ,/建立测试子类的主测试类Test public class Test public static void main(Str

35、ing agrs ) new Manager( ); /new 一个Manager对象( ) 【例3-14】的输出结果为： ID: 0 name: null wage: 0 department:A dept. grade:One,2. 子类对象的构造,Java是属于单继承的对象语言，子类可以继承并且使用其父类的所有变量和方法，非常典型的例子是Java中所有类都是继承于超级类Object，因此每一个类都可以使用Object类中的变量和方法。 子类的结构：本质上就是在实现父类的基础上，再加上子类本身特有的变量和方法，也就是说“子类=父类+新增的变量+新增的方法”。,3.4.3 super关键字,

36、子类对象的构造也和其结构是一致的，要构造一个子类对象，首先要初始化从父类继承的变量和方法，然后再初始化子类的新增变量和方法。 子类构造方法中一般是通过super关键字来调用父类的构造方法。 出于安全性考虑，Java中要求一个父类的对象要在子类运行前完全初始化，即父类的构造方法要先于子类构造方法执行。,super关键字的含义指父类（超类），可以用来调用父类的构造函数，还可以调用父类中被子类重写的方法。 总结如下： （1）可以调用父类的构造方法，并且该调用语句一旦使用，必须出现在子类构造方法的第一行，调用方式如下； super(形参表)； （2）可以调用父类中被重写的成员方法 super.方法名(

37、形参表)；,【例3-15】super关键字的使用,class Employee String name; public Employee(String s) name = s; void printInfo() System.out.println(name: +name); class Manager extends Employee String department; public Manager(String s,String d) super(s); /调用父类的构造方法，必须放在子类构造方法的第一句 department = d; ,void printInfo() super.p

38、rintInfo( ); /使用super调用父类中被覆盖的方法 printInfo( ) System.out.println(department: +department); /建立测试子类的主测试类Test public class testManager public static void main(String agrs ) Manager m=new Manager(Li,Computer ); /new 一个Manager对象( ) m.printInfo(); ,3.4.4 对象的类型转换,Java语言中允许子类对象向父类对象转换，这种转换在继承图中是向上移动，通常称为向上

39、类型转换。 例如： Employee e = new Manager( ); /子类Manager对象向父类Employee转换 向上类型转换是安全的，因为这是从特殊类型到通用类型的转换。进行向上类型转换时，出现的唯一问题是可能丢失子类中定义的方法和变量。反之，从父类向子类转换，在继承图中是向下移动，称为向下类型转换。Java语言不允许向下类型转换。 例如： Manager m = new Employee( ); /不允许！ 类型向下转换是不安全的，因为这是从一般类型到特殊类型的转换，子类对象的许多属性是父类没有的，因此不允许这种转换。,2.instanceof运算符,由于Java中支持对象

40、类型向上转换，因此一个对象的引用既可以指向本类的实例，又可以指向其子类的实例。可以通过instanceof运算符来判明一个引用到底指向哪个实例。如果用instanceof运算符已判明父类的引用指向的是子类实例，就可以转换该引用，恢复对象的全部功能。,【例3-16】instanceof运算符的使用,public class Employee extends Object public class Manager extends Employee public class Worker extends Employee public void method(Employee e) if (e in

41、stanceof Manager) /判断e到底是哪个类的对象 / 经理级人士 else if (e instanceof Worker) /判断e到底是哪个类的对象 / 工人 else / 其他雇员 ,3.4.5方法的重写(Override)和重载(Overload),1.方法重写 方法重写，也称方法覆盖，是指子类中定义方法所用的名字、返回类型及形参表和父类中方法使用的完全一样，则称子类方法重写了父类中的方法。,方法重写一般必须满足下列条件： 子类的方法的名称及参数必须和所重写的方法相同； 子类的方法返回类型必须和所重写的方法相同； 子类方法不能缩小所重写方法的访问权限； 子类方法不能抛出比

42、所重写方法更多的异常。,【例3-17】方法重写/覆盖,class Person /父类Person private String name; private int age; public void setName(String name)=name; public void setAge(int age) this.age=age; public String getName()return name; public int getAge()return age; public String getInfo() /父类中的getInfo()方法 return Name: +

43、 name + n +age: + age; class Student extends Person /子类Student private String school; public String getSchool() return school; public void setSchool(String school)this.school =school;,public String getInfo() /对父类中的方法重写 return Name: + getName() + nage: + getAge()+nschool: + school; public class Test

44、public static void main(String args) Student student = new Student(); Person person = new Person(); person.setName(none); person.setAge(1000); student.setName(John); student.setAge(18); student.setSchool(SCH); System.out.println(person.getInfo();/调用父类的方法getInfo() System.out.println(student.getInfo()

45、;/调用子类中重写的方法getInfo() ,2.方法重载,Java 中成员方法的重载是指同一个类中出现两个或两个以上的方法名相同，但形式参数不同的方法。 形式参数不同，可以是下面的几点不同： 参数个数不同； 参数个数相同，但类型不同； 参数个数和类型都不同； 和方法的返回值类型没有关系。,【例3-18】下面的例子中就给出了几个不同的方法重载,public class student1 /类名 /类体开始的花括号 int id; /int型成员变量，表示学号 String name; /String型成员变量，表示姓名 int age; /int型成员变量，表示年龄 float score;

46、/float型成员变量，表示成绩 student1( ) /无参的构造方法，构造方法重载 id=0; name=; age=0; score=0; ,student1(int sid, String sname, int sage, float sc ) /有参的构造方法，构造方法重载 id=sid; name=sname; age=sage; score=sc; String getName( ) / getName()方法，成员方法重载 return name; String getName( String s) /前面还有一个getName( string s)方法，成员方法重载 nam

47、e = s; return name; public static void main(String args) student1 s1 = new student1(1001,Li,20,85.0f); String str=s1.getName(); System.out.println(str); str=s1.getName(Wang); System.out.println(str); ,3.方法重写和方法重载的区别,两者的区别可以总结如下： 重写发生在父类和子类之间；重写可以在父类和子类之间，还可以是同一个类内的方法之间。 重写要求必须和被重写方法具有相同方法名称、参数列表和返回类

48、型；重载只要求方法名称相同，参数不同，与返回值无关。 重写方法不能使用比被重写方法更严格的访问权限，重载和访问权限没有关系。,3.5 final关键字,Java中的final关键字，代表“最终的”或“终极的”意思。可以用来修饰一个类，也可用于修饰类中的成员方法或成员变量，还可以修饰方法中的局部变量。 顾名思义，使用final修饰的类，代表该类为“终极的”类，不能被继承；使用final修饰的类中的成员方法，代表“终极的”方法，不能被重写；使用final修饰的类中的成员变量，代表“终极的”变量，不能修改其值，即该成员变量就成为了常量。,3.5.1.final类,final类的声明格式为： 【访问权

49、限】final class finalClassName . 特点：final型的类不能被继承，即不能定义其子类。,【例3-19】final类的不能被继承,final class finalFather void f( ) System.out.println(“In finalFather”); class child extends finalFather /出错，finalFather是final型类，不能被继承。 ,3.5.2 final方法,final方法的定义格式为： final 返回类型 方法名(形参列表) 方法体; . 特点：被标记final的方法将不能被重写,【例3-20】f

50、inal方法不能被重写,class finalFather final void f( ) System.out.println(“In finalFather class!”); class child extends finalFather void f()/出错，f()是final型方法，不能被重写。 System.out.println(“In child class!”); ,3.5.3 final变量,final变量声明格式： class 类名 final 类型 变量名; /final型成员变量 . 特点：final型变量就是常量，其值不允许修改。,【例3-21】final变量的用

51、法,class finalV final float PI = 3.14f; final String s= Hello World; public class UseFinalV public static void main(String args ) final int t=3; t=5;/ 出错，t是final型局部变量，即常量不能修改 finalV myVar = new finalV ( ); myVar.PI=3.1415926f;/ 出错，myVar.PI是常量不能修改 ,3.6 抽象方法和抽象类,3.6.1 抽象方法 抽象方法是类的一种特殊的成员方法，该方法仅进行方法的声明。

52、即仅声明：返回值类型、方法名和形参，但没有方法体。换句话说，一个抽象方法就是一个未被定义具体实现的方法。 声明格式如下： abstract 返回值类型 方法名（形参）； 例如： abstract void draw( ); /注意后面没有 ,3.6.2 抽象类,1.抽象类的定义 Java中可以通过abstract关键字把一个类定于为抽象类。抽象类中一般包含抽象方法，除了抽象方法外，也可以包括其他非抽象的方法。 抽象类的定义格式如下： abstract class 类名 /class前加abstract关键字 成员变量； 抽象方法； ,【例3-22】抽象类的定义,abstract class S

53、hape /抽象类 abstract void draw( );/ 抽象方法 void print() System.out.println(“print a shape.”); ,2.抽象类的特点,抽象类一般是提供一种父类，通常是在其子类中来实现父类中定义的抽象方法；若子类没有给出抽象方法的实现，则子类也必须声明为抽象类。 抽象类不能创建实例对象，必须要由其子类继承后，才能创建子类的实例对象，所以抽象类不能用final关键字修饰。 抽象类体现了多态性，通过继承可以从抽象类派生出具有相似操作的子类。 抽象类中一般包含抽象方法，但也可以包含非抽象方法；抽象方法一定包含在抽象类中。,3.7接口,3

54、.7.1 接口的概念 接口：是使用interface关键字定义的抽象类功能的另一种实现方法，可将其想象为一个“纯”的抽象类。接口中的所有方法都是抽象方法，接口中的所有成员变量都默认是常量，即默认为final、static类型的终极变量。,1.接口的定义,接口的声明格式如下： 【访问权限】 interface 接口名称 【extends 父接口名列表】 常量； 抽象方法； 注意：接口中的常量定义时一定要赋初值，且此值将不能再更改。接口中所定义的内容仅包括常量和抽象方法。,【例3-23】定义一个接口,interface Shape void Shape(); /抽象方法 void area();

55、/抽象方法 ,2.接口的特点,接口中所有的成员变量都隐含public、static、final属性，方法隐含public、abstract属性。 Java通过允许一个类实现（implements）多个接口从而实现了比多重继承更加强大的能力，并具有更加清晰的结构。,3.7.2类实现接口,接口定义完成后，就是需要一个由类来实现接口，一个类可以同时实现多个接口。实现接口的类必须实现接口中的所有抽象方法。 实现接口的类定义格式如下： public class 类名 implements 接口名列表 实现接口的方法； 新定义的方法和变量； ,【例3-24】类实现接口,interface Shape /

56、定义接口Shape public void draw(); /抽象方法 public float area(); /抽象方法 class Rectangle implements Shape /Rectangle类实现Shape接口 int a,b; /成员变量a、b代表矩形的常和宽 Rectangle(int a,int b) this.a=a; this.b=b; public void draw()/实现接口Shape的抽象方法 System.out.println(Draw a rectangle graph!); ,public float area() /实现接口Shape的抽象方

57、法 return a*b; /计算矩形面积 class Circle implements Shape /Circle类实现Shape接口 int r; /成员变量r代表圆形的半径 Circle(int r) this.r=r; public void draw( ) /实现接口Shape的抽象方法 System.out.println(Draw a circle graph!); public float area() /实现接口Shape的抽象方法 float PI=3.14f; return PI*r*r; /计算圆形面积 ,public class testShape public static void main(String args) Rectangle