第六节课

设计一个表示二维平面上点的类Point,包含有表示坐标位置的protected类型的成员变量x和y,获取和设置x
和y值的public方法。
(2) 设计一个表示二维平面上圆的类Circle,它继承自类Point,还包含有表示圆半径的protected类型的成员变量radius、获取和设置radius值的public方法、计算圆面积的public方法。
(3) 设计一个表示圆柱体的类Cylinder,它继承自类Circle,还包含有表示圆柱体高的protected类型的成员变量height、获取和设置height值的public方法、计算圆柱体体积的public方法。
(4) 建立若干个Cylinder对象,输出其轴心位置坐标、半径、高及其体积的值。
实验要求:
1) 每个类包含无参数和有参数的构造方法。构造方法用于对成员变量初始化,无参数的构造方法将成员变量初始化为0值。
2) 子类的构造方法调用父类的构造方法,对父类中的成员变量初始化。

多态与抽象类

程序如下:

【课前思考】
  1. 什么是对象?什么是类?什么是包?什么是接口?什么是内部类?
  2. 面向对象编程的特性有哪三个?它们各自又有哪些特性?
  3. 你知道java语言在面向对象编程方面有何独特的特点吗?

多态是java中一个比较重要的概念,在认识和理解它之前先熟悉一下下面的几个概念.

public class test {
    public static void main(String[] args) {
      Circle c1=new Circle(100,110,10);
        Cylinder c2=new Cylinder(12,32,34,13);
        System.out.println(“Circle center
point:(“+c1.center.x+”,”+c1.center.y+”)”);
        System.out.println(“Circle radius=”+c1.radius);
        System.out.println(“Circle area=”+c1.area());
        System.out.println(“Circle center
point:(“+c2.center.x+”,”+c2.center.y+”)”);
       System.out.println(“Circle radius=”+c2.radius);
       System.out.println(“Circle area=”+c2.area());

难点:
  1. 理解方法重载和方法重写,不要混淆了两者的使用。
  2. 类变量和类方法的使用。
  3. 接口的使用。

1.成员变量的隐藏和方法的重写

        System.out.println(“Cylinder valume=”+c2.valume());
         
        test test = new test();
    }
}
class point{
    protected int x;
 protected int y;
 public   point(int x,int y){
     this.x=x;
     this.y=y;
 }
public void show(){
    System.out.print(“x=”+x+”,”+”y=”+y);
}

3.1 面向对象技术基础

成员变量的隐藏:子类可以隐藏继承的成员变量,对于子类可以从父类继承成员变量,只要子类中定义的成员变量和父类中的成员变量

}
class Circle extends point{
    protected int radius;
    double PI=3.1415926;
    point center=new point(0,0);

3.1.1 面向对象的基本概念
  面向对象的基本思想
  面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继承、封装、消息等基本概念来进行程序设计。从现实世界中客观存在的事物(即对象)出发来构造软件系统,并且在系统构造中尽可能运用人类的自然思维方式。开发一个软件是为了解决某些问题,这些问题所涉及的业务范围称作该软件的问题域。其应用领域不仅仅是软件,还有计算机体系结构和人工智能等。

同名时,子类就隐藏了继承的成员变量.但不提倡这种做法,子类总是自己定义变量而隐藏父类的变量,这样会浪费很多空间.

    public Circle(int x,int y,int r){
       super(x,y);
      center.x=x;
      center.y=y;
        radius=r;
    }
    public double area(){
        return PI*radius*radius;
    }
}
class Cylinder extends Circle{
    protected int height;
    public Cylinder(int x,int y,int r,int h){
        super(x,y,r);
         height=h;
    }
    public int getCylinder(){
        return height;
    }
    public double valume(){
        return Math.PI*radius*radius*height;
    }
   
}

1. 对象的基本概念
  对象是系统中用来描述客观事物的一个实体,它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

方法的重写:子类可以隐藏已继承的方法,子类通过方法重写来隐藏继承的方法.具体是指,子类中定义一个方法,并且这个方法的名字

主动对象是一组属性和一组服务的封装体,其中至少有一个服务不需要接收消息就能主动执行(称作主动服务)。
2. 类的基本概念
类是具有相同属性和服务的一组对象的集合,它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分。在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性说明和服务说明两个主要部分。

,返回值类型,参数个数和类型与父类继承的方法完全相同.
注意:方法的重写与方法的重载要分清楚,回顾一下方法的重载的定义为方法名必须相同,参数的类型和个数必须不同.

3. 消息

用下面的程序好好体会一下方法的重写(还有重载)

消息就是向对象发出的服务请求,它应该包含下述信息:提供服务的对象标识、服务标识、输入信息和回答信息。服务通常被称为方法或函数。

程序代码:

3.1.2 面向对象的基本特征

class Chengji
{  float f(float x,float y)
{   return x*y;
   }
}
class Xiangjia  extends Chengji
{  
float f(float x,float y)
//方法的重写,方法的名字,返回值类型,参数个数和类型与父类完全相同
{   return x+y ;
   }

1.封装性
  封装性就是把对象的属性和服务结合成一个独立的相同单位,并尽可能隐蔽对象的内部细节,包含两个含义:
  ◇
把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象)。
  ◇
信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界〔或者说形成一道屏障〕,只保留有限的对外接口使之与外部发生联系。
  封装的原则在软件上的反映是:要求使对象以外的部分不能随意存取对象的内部数据(属性),从而有效的避免了外部错误对它的”交叉感染”,使软件错误能够局部化,大大减少查错和排错的难度。

//float f(float,x,int y) {return
x-y;}错误的语句,在方法名相同的情况下既不属于”重写”也不属于”重载”
//float f(int x,int y,int z){z=x-y; return
z;}方法的重写,琢磨一下定义就知道了
}
public class Example
{  public static void main(String args[])
{ Xiangjia sum;
     sum=new Xiangjia();
     float c=sum.f(4,6);//调用的是子类里的f(),因为子类重写了父类的f()
     //c=sum.f(1,2,3);
这个则是调用了重载的函数;当然具体调用那个要根据实参的个数和类型来判断喽
     System.out.println(c);
   }
}

2.继承性
  特殊类的对象拥有其一般类的全部属性与服务,称作特殊类对一般类的继承。

如果没有重写父类的方法,那使用父类中的方法时就正常使用,看看下面这个混合使用的例子

一个类可以是多个一般类的特殊类,它从多个一般类中继承了属性与服务,这称为多继承。

程序代码:

在java语言中,通常我们称一般类为父类(superclass,超类),特殊类为子类(subclass)。

class Area
{  float f(float r )
   {  return 3.14159f*r*r;
   }
   float g(float x,float y)
   {  return x+y;
   }
}
class Circle extends Area
{   float f(float r)
    { return 3.14159f*2.0f*r;//重写
    }  
}
public class Example4_17
{  public static void main(String args[])
   {  Circle yuan;
      yuan=new Circle();
      float length=yuan.f(5.0f);            
      float sum=yuan.g(232.645f,418.567f); //父类中的方法正常使用
      System.out.println(length);
      System.out.println(sum);  
   }
}

3.多态性
  对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后,可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。例如:”几何图形”的”绘图”方法,”椭圆”和”多边形”都是”几何图”的子类,其”绘图”方法功能不同。
3.1.3 面向对象程序设计方法
  OOA-Object Oriented Analysis     面向对象的分析
  OOD-Object Oriented Design      面向对象的设计
  OOI-Object Oriented Implementation  面向对象的实现
3.2 Java语言的面向对象特性

注意:重写父类的方法时,不可以降低方法的访问权限.下面的例子中,子类重写父类的方法f,该方法在父类中的访问权限实protected

3.2.1 类
  类是java中的一种重要的复合数据类型,是组成java程序的基本要素。它封装了一类对象的状态和方法,是这一类对象的原形。一个类的实现包括两个部分:类声明和类体

级别,子类重写时不允许级别低于protected级别.

1.类声明:
  [public][abstract|final] class className [extends
superclassName] [implements interfaceNameList]
  {……}
  其中,修饰符public,abstract,final
说明了类的属性,className为类名,superclassName为类的父类的名字,interfaceNameList为类所实现的接口列表。
 2.类体
  类体定义如下:
  class className
  {[public | protected | private ] [static]
  [final] [transient] [volatile] type
  variableName;                 //成员变量
  [public | protected | private ] [static]
  [final | abstract] [native] [synchronized]
  returnType methodName([paramList]) [throws exceptionList]
   {statements}                 //成员方法
  }
 3.成员变量
  成员变量的声明方式如下:
  [public | protected | private ] [static]
  [final] [transient] [volatile] type
  variableName;                 //成员变量
  其中,
  static: 静态变量(类变量);相对于实例变量
  final: 常量
  transient:
暂时性变量,用于对象存档,用于对象的串行化,见对象的串行化一节
  volatile: 贡献变量,用于并发线程的共享
 4.成员方法
  方法的实现包括两部分内容:方法声明和方法体。
  [public | protected | private ] [static]
  [final | abstract] [native] [synchronized]
  returnType methodName([paramList])
  [throws exceptionList]            //方法声明
   {statements}                //方法体
  方法声明中的限定词的含义:
  static: 类方法,可通过类名直接调用
  abstract: 抽象方法,没有方法体
  final: 方法不能被重写
  native: 集成其它语言的代码
  synchronized: 控制多个并发线程的访问
  ◇ 方法声明
  方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型,也可以是复合数据类型(又称引用数据类型)。
  对于简单数据类型来说,java实现的是值传递,方法接收参数的值,但不能改变这些参数的值。如果要改变参数的值,则用引用数据类型,因为引用数据类型传递给方法的是数据在内存中的地址,方法中对数据的操作可以改变数据的值。
  例3-1说明了简单数据类型与引用数据的区别。
【例3-1】
  import java.io.*;
  public 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.changeInt(val);                   //值参数
  System.out.println(“Int Value after Change is:” +val); /*值参数
                    值的修改,没有影响值参数的值*/
  pt.ptValue=101f;
  System.out.println(“Original ptValue is:”+pt.ptValue);
  pt.changeObjValue(pt); //引用类型的参数
  System.out.println(“ptValue after Change is:”+pt.ptValue);/*
引用参数值的修改,改变了引用参数的值*/
  }
  public void changeInt(int value){
  value=55;            //在方法内部对值参数进行了修改
  }
  public void changeObjValue(PassTest ref){
  ref.ptValue=99f;        //在方法内部对引用参数进行了修改
    }
  }

程序代码:

◇ 方法体
  方法体是对方法的实现,它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名,则类的成员变量被隐藏。
为了区别参数和类的成员变量,我们必须使用this。this—–用在一个方法中引用当前对象,它的值是调用该方法的对象。返回值须与返回类型一致,或者完全相同,或是其子类。当返回类型是接口时,返回值必须实现该接口。
5.方法重载
 方法重载是指多个方法享有相同的名字,但是这些方法的参数必须不同,或者是参数的个数不同,或者是参数类型不同。返回类型不能用来区分重载的方法。
  参数类型的区分度一定要足够,例如不能是同一简单类型的参数,如int与long。编译器会根据参数的个数和类型来决定当前所使用的方法。

class Chengji
{
protected float f(float x,float y)
{return x*y;}
}

6. 构造方法
  ◇ 构造方法是一个特殊的方法。Java
中的每个类都有构造方法,用来初始化该类的一个对象。
  ◇ 构造方法具有和类名相同的名称,而且不返回任何数据类型。
  ◇ 重载经常用于构造方法。
  ◇ 构造方法只能由new运算符调用

class Xiangjia extends Chengji
{
float f(float x,float y)//错误,friendly的权限低于protected
{return x+y;}
}

3.2.2 对象
  类实例化可生成对象,对象通过消息传递来进行交互。消息传递即激活指定的某个对象的方法以改变其状态或让它产生一定的行为。一个对象的生命周期包括三个阶段:生成、使用和消除。

class Xiangjian extends Chengji
{
public float f(float x,float y)//正确,public的权限高于protected
{return x-y;}
}

对象的清除
  当不存在对一个对象的引用时,该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区,把没有引用的对象作为垃圾收集起来并释放。
  System.gc( );  System.exit();//terminate the current JVM
  当系统内存用尽或调用System.gc(
)要求垃圾回收时,垃圾回收线程与系统同步运行。
3.2.3 面向对象特性
  java语言中有三个典型的面向对象的特性:封装性、继承性和多态性。

子类重写了父类中的方法后也有办法访问被隐藏的父类的方法的,这就要引入super关键字了

1. 封装性
  java语言中,对象就是对一组变量和相关方法的封装,其中变量表明了对象的状态,方法表明了对象具有的行为。通过对象的封装,实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限,实现了类中成员的信息隐藏。
◇ java类中的限定词
  java语言中有四种不同的限定词,提供了四种不同的访问权限。
  1) private
  类中限定为private的成员,只能被这个类本身访问。
  如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
  2) default
  类中不加任何访问权限限定的成员属于缺省的(default)访问状态:friend,可以被这个类本身和同一个包中的类所访问。
3) protected
  类中限定为protected的成员,可以被这个类本身、它的子类(包括同一个包中以及不同包中的子类)和同一个包中的所有其他的类访问。
4) public
  类中限定为public的成员,可以被所有的类访问。
【表3-1】 java中类的限定词的作用范围比较

1).使用关键字super调用父类的构造方法
子类不继承父类的构造方法,因此,子类如果想使用父类的构造方法,必须在子类的构造方法中使用,并且必须使用关键字super来表示

同一个类
同一个包
不同包的子类
不同包非子类

,而且super必须是子类构造方法中的头一条语句.例如:

private
*

default
*
*

protected
*
*
*

public
*
*
*
*

2. 继承性
  通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类,被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法,及命名与父类同名的成员变量。但Java不支持多重继承,即一个类从多个超类派生的能力。
◇ 成员变量的隐藏和方法的重写
  子类通过隐藏父类的成员变量和重写父类的方法,可以把父类的状态和行为改变为自身的状态和行为。
例如:
  class SuperClass{
    int x; …
    void setX( ){ x=0; } …
  }
  class SubClass extends SuperClass{
    int x;   //隐藏了父类的变量x
    …
    void setX( ) { //重写了父类的方法 setX()
    x=5; } ….
  }
  注意:子类中重写的方法和父类中被重写的方法要具有相同的名字,相同的参数表和相同的返回类型,只是函数体不同。
  ◇ super
  java中通过super来实现对父类成员的访问,super用来引用当前对象的父类。Super
的使用有三种情况:
  1)访问父类被隐藏的成员变量,如:
    super.variable;
  2)调用父类中被重写的方法,如:
    super.Method([paramlist]);
  3)调用父类的构造函数,如:
    super([paramlist]);

【例3-5】
  import java.io.*;
  class SuperClass{
    int x;
    SuperClass( ) {
     x=3;
     System.out.println(“in SuperClass : x=” +x);
    }
     void doSomething( ) {
     System.out.println(“in SuperClass.doSomething()”);
    }
  }
  class SubClass extends SuperClass {
    int x;
    SubClass( ) {
     super( );    //调用父类的构造方法
     x=5;      //super( ) 要放在方法中的第一句
     System.out.println(“in SubClass :x=”+x);
    }
     void doSomething( ) {
     super.doSomething( ); //调用父类的方法
     System.out.println(“in SubClass.doSomething()”);
     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();
    }
  }

3. 多态性
  在java语言中,多态性体现在两个方面:由方法重载实现的静态多态性(编译时多态)和方法重写实现的动态多态性(运行时多态)。
  1) 编译时多态
  在编译阶段,具体调用哪个被重载的方法,编译器会根据参数的不同来静态确定调用相应的方法。
  2) 运行时多态
  由于子类继承了父类所有的属性(私有的除外),所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方,都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。
  ◇
重写方法的调用原则:java运行时系统根据调用该方法的实例,来决定调用哪个方法。对子类的一个实例,如果子类重写了父类的方法,则运行时系统调用子类的方法;如果子类继承了父类的方法(未重写),则运行时系统调用父类的方法。
在例3-6中,父类对象a引用的是子类的实例,所以,java运行时调用子类B的callme方法。

【例3-6】
  import java.io.*;
  class A{
     void callme( ) {
      System.out.println(“Inside A’s callme()method”);
     }
  }
  class B extends A{
     void callme( ) {
      System.out.println(“Inside B’s callme() Method”);
     }
  }
  public class Dispatch{
     public static void main(String args[]) {
      A a=new B();
      a.callme( );
     }
  }
◇ 方法重写时应遵循的原则:
  1)改写后的方法不能比被重写的方法有更严格的访问权限(可以相同)。
  2)改写后的方法不能比重写的方法产生更多的例外。
4. 其它
  ◇ final 关键字
  final 关键字可以修饰类、类的成员变量和成员方法,但final
的作用不同。
  1) final 修饰成员变量:
  final修饰变量,则成为常量,例如
  final type variableName;
  修饰成员变量时,定义时同时给出初始值,且以后不能被修改,而修饰局部变量时不做要求。
  2) final 修饰成员方法:
  final修饰方法,则该方法不能被子类重写
  final returnType methodName(paramList){
  …
  }

  3) final 类:
  final修饰类,则类不能被继承
  final class finalClassName{
  …
  }
  ◇ 实例成员和类成员
  用static 关键字可以声明类变量和类方法,其格式如下:
  static type classVar;
  static returnType classMethod({paramlist}) {
  …
  }
 如果在声明时不用static 关键字修饰,则声明为实例变量和实例方法。
  1) 实例变量和类变量
  每个对象的实例变量都分配内存,通过该对象来访问这些实例变量,不同的实例变量是不同的。
  类变量仅在生成第一个对象时分配内存,所有实例对象共享同一个类变量,每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问,无需先生成一个实例对象,也可以通过实例对象访问类变量。
  2) 实例方法和类方法
  实例方法可以对当前对象的实例变量进行操作,也可以对类变量进行操作,实例方法由实例对象调用。
  但类方法不能访问实例变量,只能访问类变量。类方法可以由类名直接调用,也可由实例对象进行调用。类方法中不能使用this或super关键字。
  例3-7 是关于实例成员和类成员的例子。
【例3-7】
  class Member {
    static int classVar;
    int instanceVar;
    static void setClassVar(int i) {
     classVar=i;
     // instanceVar=i; // 类方法不能访问实例变量
    }
    static int getClassVar()
     { return classVar; }
    void setInstanceVar(int i)
     { classVar=i; //实例方法不但可以访问类变量,也可以实例变量
     instanceVar=i; }
     int getInstanceVar( )
     { return instanceVar; }
    }
    public class MemberTest{
     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(22);
        
System.out.println(“m1.InstanceVar=”+m1.getInstanceVar
              ()+”
m2.InstanceVar=”+m2.getInstanceVar());
     }
    }
◇ 类java.lang.Object
  类java.lang.Object处于java开发环境的类层次的根部,其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。下面,我们介绍一些常用的方法。
  equals() :比较两个对象(引用)是否相同。
  getClass():返回对象运行时所对应的类的表示,从而可得到相应的信息。
  toString():用来返回对象的字符串表示。
  finalize():用于在垃圾收集前清除对象。
  notify(),notifyAll(),wait():用于多线程处理中的同步。

3.2.4抽象类和接口

 1. 抽象类
  java语言中,用abstract
关键字来修饰一个类时,这个类叫做抽象类,用abstract
关键字来修饰一个方法时,这个方法叫做抽象方法。格式如下:
  abstract class abstractClass{ …} //抽象类
  abstract returnType abstractMethod([paramlist]) //抽象方法
  抽象类必须被继承,抽象方法必须被重写。抽象方法只需声明,无需实现;抽象类不能被实例化,抽象类不一定要包含抽象方法。若类中包含了抽象方法,则该类必须被定义为抽象类。

若一个类继承了一个抽象类,则抽象类的抽象方法必须被实现,否则子类必须声明为abstract.
 2. 接口
  接口是抽象类的一种,只包含常量和方法的定义,而没有变量和方法的实现,且其方法都是抽象方法。它的用处体现在下面几个方面:
  ◇ 通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系。
  ◇ 通过接口指明多个类需要实现的方法。
  ◇ 通过接口了解对象的交互界面,而无需了解对象所对应的类。
1)接口的定义
  接口的定义包括接口声明和接口体。
  接口声明的格式如下:
  [public] interface interfaceName[extends listOfSuperInterface] {
… }
  extends
子句与类声明的extends子句基本相同,不同的是一个接口可有多个父接口,用逗号隔开,而一个类只能有一个父类。
  接口体包括常量定义和方法定义
  常量定义格式为:type NAME=value; 该常量被实现该接口的多个类共享;
具有public ,final,
static的属性。在接口中只能声明常量,不可以声明变量。
  方法体定义格式为:(具有 public和abstract属性,不能声明为protected)
  returnType methodName([paramlist]);

注意:在接口的实现类中,实现的接口方法必须声明为public
,因为接口中定义的方法为public(默认)。所以其实现必须声明为public.否则编译不会通过。
2)接口的实现
  在类的声明中用implements子句来表示一个类使用某个接口,在类体中可以使用接口中定义的常量,而且必须实现接口中定义的所有方法。一个类可以实现多个接口,在implements子句中用逗号分开。
3) 接口类型的使用
  接口作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中,通过这些变量可以访问类所实现的接口中的方法。
3.2.5 内部类

 1. 内部类的定义和使用:
  内部类是在一个类的内部嵌套定义的类,它可以是其它类的成员,也可以在一个语句块的内部定义,还可以在表达式内部匿名定义。
  内部类有如下特性:
  ◇
一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称.名字不能与包含它的类名相同。
  ◇
可以使用包含它的类的静态和实例成员变量,也可以使用它所在方法的局部变量。
  ◇ 可以定义为abstract。
  ◇ 可以声明为private或protected。
  ◇ 若被声明为static,就变成了顶层类,不能再使用局部变量。
  ◇ 若想在Inner Class中声明任何static成员,则该Inner
Class必须声明为static。
例3-8】
  import java.awt.*;
  import java.awt.event.*;
  public class TwoListenInner {
    private Frame f;
    private TextField tf;
      public static void main(String args[]) {
       TwoListenInner that=new TwoListenInner();
       that.go();
    }
    public void go() {
       f=new Frame(“Two listeners example”);
       f.add(“North”,new Label(“Click and drag the mouse”));
       tf=new TextField(30);
       f.add(“South”,tf);
       f.addMouseMotionListener(new MouseMotionHandler());
       f.addMouseListener(new MouseEventHandler());
       f.setSize(300,300);
       f.setVisible(true);
    }
    public class MouseMotionHandler extends MouseMotionAdapter {
      public void mouseDragged(MouseEvent e){
       String s=”Mouse dragging:X=”+e.getX()+”Y=”+e.getY();
       tf.setText(s);
      }
    }
    public class MouseEventHandler extends MouseAdapter {
      public void mouseEntered(MouseEvent e){
       String s=”The mouse entered”;
       tf.setText(s);
      }
      public void mouseExited(MouseEvent e){
       String s=”The mouse left the building”;
       tf.setText(s);
      }
    }
  }

说明:Frame类的add方法来自于其祖先类Container类,addMouseMotionListener和addMouseListener方法来自于其祖先类Component,
addMouseListener方法的参数为MouseListener接口,MouseAdapter类是实现了MouseListener接口的类。可见图形界面对于外部事件的响应是通过添加listener实现的
2. 匿名类的定义和使用:
  匿名类是一种特殊的内部类,它是在一个表达式内部包含一个完整的类定义。通过对例6-7中go()部分语句的修改,我们可以看到匿名类的使用情况。
  public void go() {
         f=new Frame(“Two listeners example”);
         f.add(“North”,new Label(“Click and drag the
mouse”));
         tf=new TextField(30);
         f.add(“South”,tf);
         f.addMouseMotionListener(new MouseMotionHandler(){
         /*定义了一个匿名类,类名没有显式地给出,只是该类是
          MouseMotionHandler类的子类*/
           public void mouseDragged(MouseEvent e){
             String s=”Mouse dragging:X=”+e.getX()+”Y
             =”+e.getY();
             tf.setText(s);
           }
         });
         f.addMouseListener(new MouseEventHandler());
         f.setSize(300,300);
         f.setVisible(true);
         }
 3. 内部类的优缺点:
  ◇ 优点:节省编译后产生的字节码文件的大小
  ◇ 缺点:使程序结构不清楚