当你开始学习java的时候，你需要很好地理解基本概念。特别是我下面列出的这五个任何java砖家都必须掌握的概念：

1. 面向对象
2. 运行时多态
3. 接口
4. I/O流
5. 事件处理

在这个名为《JAVA编程基础》的系列文章中，我会针对每个概念，分别通过简明的解释与实际的例子，来给初学者（也包括那些希望能让自己掌握更多技能的有经验的软件工程师）打下一个坚实的java基本知识的基础。 这个系列的第五篇文章介绍事件处理。

子乌注：很喜欢第一个关于结婚的例子，说实话，我觉得是这系列文章中最通俗易懂的例子了-__-。

事件处理的组件

对每个java专家来说很好地理解事件处理的机制是非常必要的。现在事件处理编程出现在许多场景中——而不仅仅是GUI程序。你也可以在使用servlet、MDB等技术的应用程序中发现它的身影。

在java中，事件处理机制的组件有以下几个组成：

• 一个事件类（event class），描述了事件的类型（它会有一个数据成员，该成员存放着一个指向引发该事件的源对象的引用。它也重写了方法 toString() 。）
• 一个 监听器接口（listener interface）, 指定了处理方法的原型（该处理方法有一个事件类对象作为参数。）
• 一个实现了监听器接口的监听器类（Listener classes）（也许会有多个监听器类，每个都用自己独立的方式处理相同的事件。）
• 一个事件源类（Event source class）， 它生成了这个事件。（它有一个数据成员用于维持已订阅的监听器列表。也许会有其他数据成员来描述它的状态变亮。它有一个事件生成器方法用于应对引发的事件。当一个事件被引发时，一个事件类的对象会被创建，而所有已订阅的监听器都会被调用各自的回调方法——刚创建的事件类对象引用将作为参数传递进去——来被提醒发生了什么。）
  注意: 为简单起见，上面的描述假设一个事件源类只生成唯一一个事件。而事实上，一个事件源类可能生成更多的事件。比如，类List会在一个项目被选中或被取消选中时生成一个ItemEvent事件，而当它的某个项目被双击时则会产生一个ActionEvent事件。
• 一个 客户端类，保存创建的源和监听器对象，以及订阅了源类事件的监听器（也会有引发源类事件生成方法的代理语句存在。）

实践事件处理

一个真实的示例能够帮助澄清事件处理机制中几个组件的相互关系。设想一下有4个朋友，甲、乙、丙、丁。假设现在要发生的事件是甲要结婚了。甲的朋友，乙、丙、丁，需要响应这个红色炸弹。响应的做法（协议）就是出席婚礼并送个礼物给甲。他们都必须遵循这个响应协议，但他们可以自由选择他们要带的礼物。乙打算带一个价值$15的艺术品。而丙和甲的关系会更亲密些，他决定送一条价值$200的金项链。丁并不是甲关系那么铁的哥们，他也许就只会带一张写着“最真诚祝愿”的贺卡，只值$2。不过无论如何，他们都遵循了同样的协议。

下面是这个模拟中提到的事件处理组件：

• 事件类：结婚啦
• 监听器接口方法原型：出席婚礼并送一个礼物
• 监听器类：乙、丙、丁（他们通过选择自己想带的礼物来实现监听器接口）
• 事件源：甲

Java事件处理组件（续）

下面的列表 1-7 进一步澄清这些概念。它们涉及到监控一个化工厂反应堆内部的压力。反应堆可以承受一定范围内的压力，如5（即5倍房间压力）。如果压力达到临界值或即将超过临界值，应该要打开阀门、关闭加热器并且警铃应该开始报警。

在这个例子中，事件处理组件是：

• 事件类：HiPrEvent
• 监听器接口原型方法：void respond(HiPrEvent evObj)
• 监听器类：阀门（Valve），加热器（Heater）和警铃（AlarmBell） (都以自己的方式实现了方法respond())
• 事件源：反应堆（Reactor）

列表 1: hiprpack/HiPrEvent.java

Language:  Java

package hiprpack;
 
public class HiPrEvent {
    private Object evSrc;
 
    public HiPrEvent(Object obj){
        evSrc=obj;
    }
 
    public Object getEvSrc(){
        return evSrc;
    }
 
    public String toString(){
       return "HiPrEvent 被触发..."+evSrc;
    }
}

列表 2: hiprpack/HiPrListener.java

Language:  Java

package hiprpack;
 
public interface HiPrListener {
    void respond(HiPrEvent evObj);
}

列表 3: hiprpack/Valve.java

Language:  Java

package hiprpack;
 
public class Valve implements HiPrListener{
    public void respond(HiPrEvent evObj){
       System.out.print(evObj);
       System.out.println("...阀门打开了...");
    }
}

列表 4: hiprpack/Heater.java

Language:  Java

package hiprpack;
 
public class Heater implements HiPrListener{
    public void respond(HiPrEvent evObj){
       System.out.print(evObj);
       System.out.println("...加热器关闭...");
    }
}

列表 5: hiprpack/AlarmBell.java

Language:  Java

package hiprpack;
 
public class AlarmBell implements HiPrListener{
    public void respond(HiPrEvent evObj){
       System.out.print(evObj);
       System.out.println("...警铃开始报警...");
    }
}

列表 6: hiprpack/Reactor.java

Language:  Java

package hiprpack;
 
import java.util.List;
import java.util.ArrayList;
 
public class Reactor{
      private int rId;
      private double rPr;
 
      //用于维持事件的订阅者列表
      private List<HiPrListener> subList=new ArrayList<HiPrListener>();
 
      public Reactor(int i, double d){
        rId=i;  rPr=d;
      }
 
      public double getRPr(){
         return rPr;
      }
 
      public int getRId(){
         return rId;
      }
 
      public String toString(){
        return "反应堆Id: "+rId+"  反应堆压力: "+rPr;
      }
 
      public void addHiPrListener(HiPrListener sub){
         subList.add(sub);
      }
 
      public void increasePr(double n, double safePr){
        rPr +=n;
        if(rPr>=safePr){
          HiPrEvent evObj=new HiPrEvent(this);//Generate event
          for(HiPrListener sub:subList){
             sub.respond(evObj); //通过调用回调方法提醒每个订阅者
           }
         }
       }
}

列表 7: TestHiPr.java (在hiprack目录上一级）

Language:  Java

import hiprpack.*;
 
class TestHiPr{
     public static void main(String[] args){
      Reactor rObj=new Reactor(1000,1);
      Valve vObj=new Valve();
      Heater hObj=new Heater();
      AlarmBell aObj=new AlarmBell();
 
      rObj.addHiPrListener(vObj);//Valve 对事件 HiPrEvent 的订阅
      rObj.addHiPrListener(hObj);//Heater 对事件 HiPrEvent 的订阅
      rObj.addHiPrListener(aObj);//Alarm bell 对事件 HiPrEvent 的订阅
 
      double safePr=5;//简单起见，这里硬编码
                                                             // 可以从额外的源，如一个文件中获取该配置。
 
                                System.out.println("初始压力: "+rObj);
 
                   while(rObj.getRPr()<safePr){
              rObj.increasePr(1, safePr);//模拟压力监控，每次提升1点
                                   //在真实生活中，该内部压力值来自于外部传感器。
 
              System.out.println("当前压力: "+rObj);
      }
    }
}

当你能够编写并运行这个程序时，你会对java中事件处理机制的原理有个深刻的理解。

Conclusion

对一个java程序员来说，深刻理解事件处理是非常必要的。通过学习，处理任何事件处理场景会变得相当容易，无论是使用Swing的GUI开发，使用servlet，或者使用MDB（目的接收到消息后触发一个事件）。

鸣谢

见原文……

关于作者

Gurunath Kalamadi是班加罗尔的Infosys Technologies Ltd.的教育与研究的现任分组管理者。（详细见原文……）

]]> http://sheneyan.com/blog/2010/09/java-basics-event-handling/feed/ 1 http://sheneyan.com/blog/2010/09/java-basics-io-streams/ http://sheneyan.com/blog/2010/09/java-basics-io-streams/#comments Sun, 19 Sep 2010 16:52:37 +0000 子乌 http://sheneyan.com/blog/?p=1135 在这个名为《JAVA编程基础》的系列文章中，我会针对每个概念，分别通过简明的解释与实际的例子，来给初学者（也包括那些希望能让自己掌握更多技能的有经验的软件工程师）打下一个坚实的java基本知识的基础。 这个系列的第四篇文章介绍I/O流。
[......]
]]>
• 作者： Gurunath Kalamadi
• 译者：Sheneyan(子乌)
• 时间：2010.9.20
• 英文原文：Java Programming Basics: I/O Streams

当你开始学习java的时候，你需要很好地理解基本概念。特别是我下面列出的这五个任何java砖家都必须掌握的概念：

1. 面向对象
2. 运行时多态
3. 接口
4. I/O流
5. 事件处理

在这个名为《JAVA编程基础》的系列文章中，我会针对每个概念，分别通过简明的解释与实际的例子，来给初学者（也包括那些希望能让自己掌握更多技能的有经验的软件工程师）打下一个坚实的java基本知识的基础。 这个系列的第四篇文章介绍I/O流。

在JAVA中为理解I/O流进行的分类

Java中大量的I/O数据流类让新手面对不同的应用场景正确使用正确的流难以抉择。一个可以让你对I/O数据流类有概念的方法时将这些流分为两个类别：

1. “边界”流（”Boundary” streams）: 边界流通过基础底层的I/O例程实现I/O（如果必要，会通过通过底层操作系统进行I/O操作）

2. “中间”流（”Intermediate” streams）: 中间流通过“链接”到边界流来实现数据的转换。

（注: 这种将流划分为“边界”和“中间”的分类只是为了逻辑上的理解，你可能没法在任何文档上找到这种分类。）

为了写入数据，中间流会从应用程序中取得数据，将它“转换”为边界流所期望的格式，然后将其交由边界流进行写入。类似的，读取数据时，中间流从边界流那取得数据（边界流从源读取数据）并“转换”为应用程序可接收的格式。

下列的两个表格展示了一些边界流和中间流

一些“边界”流

一些“中间”流(“Intermediate” Streams)

请注意，中间流必须链接到合适类型的边界流以使I/O操作顺利进行。中间流不能自行处理到设备——如文件或内存——的I/O操作因为它们并不拥有底层I/O函数

自定义流的链接

边界流和中间流之间关联的分割导致在任意给定的应用场景中自定义流的链接很容易。一般的做法是：

1. 定义一个合适类型的边界流，将它绑定到一个边界对象（通常在构造时搞定这个）。
2. 定义一个合适类型的中间流，将其链接到刚才创建的边界流（一样在构造函数中搞定）。

假设你打算将类Employee的对象eObj写入到叫Object.Data的磁盘文件中，就像下面这样：

FileOutputStream fOut=new FileOutputStream("Object.Data");
ObjectOutputStream oOut=new ObjectOutputStream(fOut); // 链接“中间”流到“边界”流上
...
oOut.writeObject(eObj);

现在，假设你需要从一个叫做Data.in的磁盘文件中读取一个双精度数字。

FileInputStream fIn=new FileInputStream("Data.in");
DataInputStream dIn=new DataInputStream(fIn); // 链接“中间”流到“边界”流上
...
double n=dIn.readDouble();

你可以扩展链接到多余2个的流上。例如，如果你需要缓存输入上例中的双精度数字，然后创建一个FileInputStream，你可以这么做：

1. 创建一个BufferedInputStream。
2. 链接BufferedInputStream 到 FileInputStream。
3. 链接BufferedInputStream 到 DataInputStream。

代码如下:

FileInputStream fIn=new FileInputStream("Data.in");
BufferedInputStream bIn=new BufferedInputStream(fIn);
DataInputStream dIn=new DataInputStream(bIn); 
...
double n=dIn.readDouble();

当你掌握了边界流和中间流它们的概念与区别，利用I/O流进行开发就相对容易些了。

结论

你能够掌握给java中所有的I/O数据流类分类的技巧并为你特定的应用场景选择正确的那一个。

鸣谢

见原文……

关于作者

Gurunath Kalamadi是班加罗尔的Infosys Technologies Ltd.的教育与研究的现任分组管理者。（详细见原文……）

当你开始学习java的时候，你需要很好地理解基本概念。特别是我下面列出的这五个任何java砖家都必须掌握的概念：

1. 面向对象
2. 运行时多态
3. 接口
4. I/O流
5. 事件处理

在这个名为《JAVA编程基础》的系列文章中，我会针对每个概念，分别通过简明的解释与实际的例子，来给初学者（也包括那些希望能让自己掌握更多技能的有经验的软件工程师）打下一个坚实的java基本知识的基础。 这个系列的第三篇文章介绍接口。

接口：实施服务合同

许多程序员认为在java中，接口这个有些错位的概念是用于实现多继承应用。在接口中没有什么默认行为是可以被实现类继承的！将接口当成时实现一个服务合同的机制会更加合适。也就是说，将接口中提供的方法原型当成服务提供商（实现类）所必须坚持的服务合同。每个服务提供商可以使用它自己的方式来提供这个服务合同上强制要求的服务。

集合相关的接口可以作为一个解释这个概念的好例子。一个集合接口定义了方法add() 和 remove() ，而非一大堆其他的方法。每个集合类（例如Stack，Queue，List等等）会根据接口实现被服务合同所要求的方法，但每个类可以以它自己的方式自由地提供服务。对于一个Stack类，方法add()将一个元素放置于堆的顶层，而方法remove()则将元素从顶层抽离，这实现了后进先出（LIFO）原则。而对于一个Queue类， 方法add()将一个元素放置于队列的最后，而方法remove()将元素从队列的开头移出，这实现了先进先出（FIFO）原则。

下面的代码(Flyer.java 和 TestFlyer.java) 定义了一个接口Flyer,它提供了一个方法原型 fly() 。每个描述飞行对象的类都必须实现这个Flyer接口(可以用自己的方式实现fly()这个在接口Flyer中指定的，在服务合同中强制要求的方法)。Airplane和Bird是两个实现了接口Flyer的类。类Airplane通过“使用喷气发动机”来实现了方法fly()，而类Bird则通过“使用翅膀”来实现方法 fly()！

列表 1. Flyer.java

public interface Flyer{
     void fly();
}

列表 2. TestFlyer.java

class TestFlyer{
   public static void executeFly(Flyer fRef){
      fRef.fly();
   }
   public static void main(String[] args){
	  Airplane aObj=new Airplane();
	  Bird bObj=new Bird();
 
	  executeFly(aObj);
	  executeFly(bObj);
   }
}
class Airplane implements Flyer{
   public void fly(){
	  System.out.println("飞机通过喷气式发动机飞翔...");
   }
}
 
class Bird implements Flyer{
   public void fly(){
	  System.out.println("鸟通过它们的翅膀飞翔...");
   }
}

方法 executeFly(Flyer fRef) 演示了在使用接口引用时运行时多态如何起作用。就如同一个基类引用能够指向一个衍生类对象，一个接口引用也指向它的实现类的对象。当一个Airplane对象作为参数传递给executeFly(), 调用fRef.fly()会执行类Airplane的方法 fly() 。与此同时，如果一个对象Bird作为参数传递，相同的调用 fRef.fly() 会执行类Bird的方法 fly() 。

结论

示例说明了接口的目的就是指定一个服务合同。它也解释了运行时多态运用于接口引用时的优势。掌握了这些概念，你会更快地掌握java。

鸣谢

见原文……

关于作者

Gurunath Kalamadi是班加罗尔的Infosys Technologies Ltd.的教育与研究的现任分组管理者。（详细见原文……）

当你开始学习java的时候，你需要很好地理解基本概念。特别是我下面列出的这五个任何java砖家都必须掌握的概念：

1. 面向对象
2. 运行时多态
3. 接口
4. I/O流
5. 事件处理

在这个名为《JAVA编程基础》的系列文章中，我会针对每个概念，分别通过简明的解释与实际的例子，来给初学者（也包括那些希望能让自己掌握更多技能的有经验的软件工程师）打下一个坚实的java基本知识的基础。 这个系列的第二篇文章介绍运行时多态。

运行时多态的本质

运行时多态的核心就是引用的能力，基类引用可以像指向它本身的类对象一样指向衍生类对象。通常，一个java新手会把握不住运行时多态 — 为什么它被称作运行时多态以及它的工作原理。

作为一个例子，下面的程序(TestRTPoly.java)包含了一个抽象基类Shape，有2个数据成员和一个抽象方法 calculateArea() 。还有两个衍生类，Rectangle 和 Triangle ，它们都扩展了类Shape，并实现了 calculateArea() 以满足其几何形状的需求。

class TestRTPoly{
     public static double getArea(Shape sRef){
   return sRef.calculateArea();
     }
     public static void main(String[] args){
   Rectangle rectObj=new Rectangle(3,4);
   Triangle triObj=new Triangle(3,4,5);
                System.out.println("rObj: "+ getArea(rectObj));
   System.out.println("tObj: "+getArea(triObj));
    }
}
abstract class Shape{
    protected double side1, side2;
    public Shape(){
   side1=side2=0;
    }
    public Shape(double n1, double n2){
   side1=n1;side2=n2;
    }
    public double getSide1(){
   return  side1;
    }
    public double getSide2(){
   return  side2;
    }
   public void setSide1(double n){
   side1=n;
   }
   public void setSide2(double n){
   side2=n;
  }
 
   abstract public double calculateArea();
 }
class Rectangle extends Shape{
   public Rectangle(){
         super();
   }
   public Rectangle(double n1, double n2){
         super(n1,n2);
   }
   public double calculateArea(){
         return side1*side2;
   }
}
class Triangle extends Shape{
   private double side3;
   public Triangle(){
        super();  side3=0;
   }
   public Triangle(double n1, double n2,double n3){
       super(n1,n2);  side3=n3;
   }
   public double getSide3(){
       return side3;
   }
   public void setSide3(double n){
       side3=n;
   }
   public double calculateArea(){
      double s=(side1+side2+side3)/2.0;
      return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));
   }
}

类 TestRTPoly 包含方法 main() 以及静态方法 getArea() ，它有一个Shape类的引用 sRef 作为参数。它调用 sRef.caculateArea() 并将返回值作为结果传出。方法 sRef.caculateArea() 演示了运行时多态的概念.

当程序编译时下列的信息将提供给编译器，这有助于解释运行时多态：

• 抽象类Shape有一个抽象方法calculateArea()和两个衍生类， Rectangle 和 Triangle ，它们扩展了类Shape，这意味着它们以自己的方式实现了方法 calculateArea() 。
• 方法 getArea(Shape sRef) 调用了 sRef.calculateArea() 。当程序编译时，该调用无法被识别，因为方法calculateArea()有两个实现: 分别在类Rectangle和Triangle中，而且参数sRef可以传递给类 Rectangle 或类 Triangle 的任何一个实体类 (因为该参数是一个基类引用，它也可以指向衍生类). 取决于传入的对象类型，相应的 calculateArea() 实现会被调用。但在方法 getArea() 编译时，是无法知道对象 sRef 会指向哪个类型的引用。 只有在运行时接收到调用参数时才能知道（类型），因此，调用 sRef.calculateArea() 只有在运行时才会被识别。

商业应用中的运行时多态

拿一个银行应用做例子。当一个客户登录时，会显示一个欢迎界面。该应用程序有一个基类Customer和两个衍生类，HVCustomer (高价值客户)和UVCustomer (超价值客户)。在类Customer中有一个显示欢迎界面的方法display()。衍生类HVCustomer和UVCustomer都重写了方法 display() ，用于展示不同的欢迎界面。

HVCustomer会提供比普通Customer更多的特色功能和操作，而UVCustomer则会比HVCustomer提供更多的。但是这里只会有一个方法，show()，在这个应用类中(包含了main())会拿一个Customer作为参数(叫做cRef)并调用它的方法cRef.show()。基于传入参数的对象的类型，方法 show()能够给普通Customrer、HVCustomer或UVCustomer展示不同的欢迎界面。

结论

正如这个银行应用程序例子所展示的，运行时多态的本质是一个基类引用可以指向衍生类对象以及它自己类（基类）的对象。但愿这篇文章阐明了为什么这个概念被称作运行时多态以及它的工作原理。

鸣谢

见原文……

关于作者

Gurunath Kalamadi是班加罗尔的Infosys Technologies Ltd.的教育与研究的现任分组管理者。（详细见原文……）

子乌注：翻译这个系列的初衷是因为看到最后一篇，觉得那个比喻非常的棒，再加上似乎没人翻译过这个系列的文章，于是，随便翻翻，也算是加深自己对java的理解吧。

子乌注：下面这个表是一些可能存在争议的翻译用词对照。

• method—>方法
• protptype—>原型
• implementation—>实现
• signature—>签名
• mangled name—>重整名字
• call—>调用
• override—>重写
• layout—>布局
• method table—>方法表
• method body—>方法主体
• take away—>结论（take away在英语中应该是外卖，或者打包的意思，我猜作者是取后者的引申）

当你开始学习java的时候，你需要很好地理解基本概念。特别是我下面列出的这五个任何java砖家都必须掌握的概念：

1. 面向对象
2. 运行时多态
3. 接口
4. I/O流
5. 事件处理

在这个名为《JAVA编程基础》的系列文章中，我会针对每个概念，分别通过简明的解释与实际的例子，来给初学者（也包括那些希望能让自己掌握更多技能的有经验的软件工程师）打下一个坚实的java基本知识的基础。 这个系列的第一篇文章介绍面向对象。

面向对象的基础

对于一个java初学者来说，首重就是彻底理解面向对象的概念。面向对象的特征是：封装、多态和继承。封装将类的数据与类的方法进行绑定，使得“私有”的数据只能通过“公共”的方法来获取。

而多态是一个能让一个通用方法作用于不同类型的数据之上的机制。多态让程序员能够对同一个方法名定义并使用多个实现（前提是这些实现采用了不同的签名）。比如，方法的重写就是编译时（静态）多态。

对多态的理解的核心是方法签名的概念（也称为重整名字）。一个方法签名包括了方法名和它的参数类型（返回值类型不是这个签名的一部分）。下面这个表格将方法签名的概念进行了分类。

程序员指定原型及其实现，而编译器从一个方法调用中推断出方法签名，然后在实现中搜索匹配的签名以完成调用。

java对象布局

同一个类的数个对象会存放在不同的内存空间以保持他们自己的状态（实例变量值），但是一个类的所有对象会共享相同的方法实现。为了让这一点比较容易理解，我会解释一下执行时内存中的对象布局——运行时堆、栈、方法表和方法主体。

下面的代码是一个示例文件TestPoint3D.java，在其中定义了一个基类Point2D给一个几何平面中的点建模）和一个扩展自Point2D的派生类Point3D（给一个空间的点建模）。Point3D重写了父类的方法getDistance() 和 show()。 TestPoint3D 是个外部类，它包含的main()里面创建了Point2D 和 Point3D 的对象并调用了它们的方法。

Code Listing: TestPoint3D.java

class TestPoint3D{
   public static void main(String[] args){
     Point2D p21=new Point2D(3,4);
     Point2D p22=new Point2D(7,8);
     Point3D p31=new Point3D(1,5,9);
 
     System.out.print("Coords of p21: ");p21.show();
     System.out.print("Coords of p22: ");p22.show();
     System.out.print("Coords of p31: ");p31.show();
 
     System.out.println("The distance of p31 from
                                          origin is "+p31.getDistance());
    }
}
class Point2D{
   protected double x,y;
 
   public Point2D(){
       x=0;y=0;
  }
 
  public Point2D(double n1, double n2){
      x=n1;y=n2;
  }
 
  public double getX(){
      return x;
  }
 
  public void setX(double n){
       x=n;
  }
 public double getY(){
       return y;
  }
 
  public void setY(double n){
       y=n;
  }
 
  public void show(){
      System.out.println("x="+x+"  y="+y);
  }
 
  public double getDistance(){
     return Math.sqrt(x*x+y*y);
  }
}
class Point3D extends Point2D{
    private double z;
    public Point3D(){
        super();
        z=0;
   }
 
   Point3D(double n1, double n2, double n3){
        super(n1,n2);
        z=n3;
   }
 
   public double getZ(){
       return z;
   }
 
   public void setZ(double n){
        z=n;
   }
 
   public void show(){
      super.show();
      System.out.println("z="+z);
   }
 
   public double getDistance(){
      double tmp=super.getDistance();
      return Math.sqrt(tmp*tmp+z*z);
   }
}

一张图表可概念性地说明面向对象的基本特征是如何实现地。图1展示了上述实例代码在运行时的对象内存布局。

图 1. 运行时的对象内存布局

所有的面向对象的概念，可以使用上面的图表阐述。（即便是更进一步的概念，如更多层的继承如何影响性能负载也可以用上图解释。）

结论

下面是总结面向对象概念的要点：

• 当类加载的时候，每个类都会备好一个方法表。这个方法表会逐个包含加载的方法签名及相应地址。
• 当开始处理一个对象方法调用时，这个对象类的方法表会被关联并得到匹配方法签名的方法地址，然后执行该方法。
• 因此，一个类的所有对象共享相同的方法实现。
• 一个类的每个对象拥有独立的内存空间以保持实例变量x和y（在栈中）。只有引用保留在运行时堆中。
• 当一个类中找不到某方法时，将搜索它父类方法表（每个方法表储存了指向它上一级的指针）中的匹配签名。如果找到，该匹配签名将被执行。（这能够解释当子类未重写父类方法时父类的实现是如何和子类共享的）。

鸣谢

见原文……

关于作者

Gurunath Kalamadi是班加罗尔的Infosys Technologies Ltd.的教育与研究的现任分组管理者。（详细见原文……）

先说明一下现在的状况：

我们的b/s系统是jsp的，里面有一种“表码表”，里面存放的是一些需要经常使用而且比较少发生改变的内容，表码表是一些Map对象，而这些表码表会存放在jsp的ServletContext中。

初始化的大致代码如下：

class SysInit  extends HttpServlet implements ServletContextListener{
  public void contextInitialized(ServletContextEvent sce) {
    Map myTablePool= new HashMap();
    servletContext = sce.getServletContext();
    //往myTablePool里面塞数据
    ...
    servletContext.setAttribute("m1",myTablePool);
    ...
  }
}

然后在需要调用这些表码表的那些BO类中从request的serveletContext中获取，再进行操作：

class MyBO {
  public MyBO(HttpServletRequest req){
    Map myTablePoo l= (Map) req.getSession().getServletContext.getAttribute("m1");
    //然后就开始使用myTablePool里面的操作
  }
}

可是，今天在写BO类的时候突然想起来，这样子的做法和我在BO类里设置一个静态的私有变量有什么区别？？
下面是我假想的代码，首先还是我的SysInit类：

class SysInit  extends HttpServlet implements ServletContextListener{
  public void contextInitialized(ServletContextEvent sce) {
    servletContext = sce.getServletContext();
    MyBO.init();//调用BO类的静态方法，初始化BO里的静态私有变量
    ...
  }
}

这是我的BO类：

class MyBO {
  private static Map myTablePool = null;//我的静态表码表池
  public MyBO(){
    //先判断一下myTablePool是否为空……
    //测试过，除非initPool抛错，没对myTablePool初始化，否则不会为空
    if (myTablePool == null){
      initPool();
    }
    //直接操作myTablePool里面的数据
  }
 
  public static initPool(){
    myTablePool = new HashMap();
    //往myTablePool里面塞数据
    ...
  }
}

最早设计这套系统，使用ServletContext的家伙早就跳槽另谋高就，另外找了几个人问，都没有比较令人满意的答复，最多就是说静态变量放在内存里，如果web容器里跑的另外一个应用程序中也有一个同名的静态变量，会发生冲突……

谁能给我一个比较好的解释：类里的静态变量比较好，还是在全局的ServletContext里放着比较好？

java的abstract类的构造函数如果没有默认的构造函数，它的子类也就必须实现一个构造函数（是不是默认的无所谓）,下面是一个典型的错误示例：

Base.class

public abstract class Base{
  public Base(String t){
    System.out.println("here:"+t);
  }
}

Child.class

public class Child extends Base{
}

A.class

public class A{
  public static void main(String[] args){
    Base b=new Child("t");
  }
}

结果会抛两个错误出来：

• cannot resolve symbol constructor Child (java.lang.String)
• cannot resolve symbol constructor Base ()

搞不懂是什么原因哦。。。莫名其妙的。谁给个解释的？

注：现在的解决方式就是在子函数里写上构造函数，不过。。。这个构造函数所有的子函数都一样啊。。为啥子不能继承？