java随笔

[实用技巧]怎么在html中嵌入一个文件内容

angel — Mon, 10 Oct 2005 16:28:00 GMT

[实用技巧]怎么在html中嵌入一个文件内容

日期：2002:9:3 ·来源：52w.net 查看:[大字体中字体小字体]

在html文件引入其它html文件的几种方法
简介：在论坛中常常有网友问到，可以在一个html的文件当中读取另一个html文件的内容吗？答案是确定的，而且方法不只一种，在以前我只会使用iframe来引用，后来发现了另外的几种方法，那今天就总结这几种方法让大家参考一下，本人觉得第三种方式较好！
1.IFrame引入，看看下面的代码

--------------------------------------------------------------------------------
<IFRAME NAME="content_frame" width=100% height=30 marginwidth=0 marginheight=0 SRC="import.htm" ></IFRAME>
--------------------------------------------------------------------------------

你会看到一个外部引入的文件，但会发现有一个类似外框的东西将其包围，可使用

--------------------------------------------------------------------------------
<iframe name="content_frame" marginwidth=0 marginheight=0 width=100% height=30 src="import.htm" frameborder=0></iframe>
--------------------------------------------------------------------------------

但你会发现还会有点问题，就是背景色不同，你只要在引入的文件import.htm中使用相同的背景色也可以，但如果你使用的是IE5.5的话，可以看看这篇关于透明色的文章如果想引入的文件过长时不出现滚动条的话在import.htm中的body中加入scroll=no

2.<object>方式

--------------------------------------------------------------------------------
<object style="border:0px" type="text/x-scriptlet" data="import.htm" width=100% height=30></object>
--------------------------------------------------------------------------------

3.Behavior的download方式

--------------------------------------------------------------------------------
<span id=showImport></span>
<IE:Download ID="oDownload" STYLE="behavior:url(#default#download)" />
<script>
function onDownloadDone(downDate){
showImport.innerHTML=downDate
}
oDownload.startDownload('import.htm',onDownloadDone)
</script>

java调用外部命令

angel — Thu, 02 Jun 2005 15:37:00 GMT

--  作者：wnsaaa777
--  发布时间：2005-1-20 20:47:00

--  实用实例之（24）java调用外部命令

/*
* TestCmd.java
*
* Created on 2005年1月20日, 下午7:07
*/

/**
*
* @author  Administrator
*/
public class TestCmd {
    public TestCmd(){}
    public static void main(String args[]){
        try {
          Process process = Runtime.getRuntime().exec("cmd.exe  /c  start  http://www.hao123.net/");  //登录网站
         // Process process = Runtime.getRuntime().exec("cmd.exe  /c  start  ping 10.5.2.19");  //调用Ping命令
        }catch (Exception  e)
        {
            e.printStackTrace();
            }

      }
    }

在可执行jar 包中动态载入第三方jar class的有关问题王旭科

angel — Tue, 24 May 2005 06:35:00 GMT

一、前言

在商业化开发中经常是将开发的类打成jar包发布．由于有很多第三方的提供功能集合Jar包，所以经常会用到这些功能包．以下情景是很多Java开发人员经常碰到的:在开发，调试阶段，通过在CL

ASSPATH中设置第三方的jar包路径，自己编写的class工作正常．开发完毕,部署的时候，将开发的class打成一个可执行jar包,会发现通过Class.forName(String classname) 或ClassLoader.getSystemClassLoader().loadClass(String classname)来动态载入存在于第三方jar包中的class会抛出异常” ClassNotFoundException．

这种问题存在于通过jar –jar yourself.jar 来运行jar包,并在jar中的class中通过Class.forName(String classname)来动态载入第三方的class的时候．

常见的应用,比如根据用户的选择配置,动态载入不同厂商的JDBC Driver.

二、背景知识

自JDK 1.2以后,JVM采用了委托(delegate)模式来载入class．采用这种设计的原因可以参考http://java.sun.com/docs/books/tutorial/ext/basics/load.html

归纳来讲:是基于JVM sandbox(沙盒)安装模型上提供应用层的可定制的安全机制.

三、Java虚拟机(JVM)寻找Class的顺序

3.1 Bootstrap classes

属于Java 平台核心的class,比如java.lang.String等.及rt.jar等重要的核心级别的class.这是由JVM Bootstrap class loader来载入的.一般是放置在{java_home}\jre\lib目录下

3.2 Extension classes

基于Java扩展机制,用来扩展Java核心功能模块.比如Java串口通讯模块comm.jar.一般放置在{Java_home}\jre\lib\ext目录下

3.3 User classes

开发人员或其他第三方开发的Java程序包.通过命令行的-classpath或-cp,或者通过设置CLASSPATH环境变量来引用.JVM通过放置在{java_home}\lib\tools.jar 来寻找和调用用户级的class.常用的javac也是通过调用tools.jar来寻找用户制定的编译Java源程序.这样就引出了User class路径搜索的顺序或优先级别的问题.

3.3.1 缺省值:调用Java或javawa的当前路径(.),是开发的class所存在的当前目录

3.3.2 CLASSPATH环境变量设置的路径.如果设置了CLASSPATH,则CLASSPATH的值会覆盖缺省值

3.3.3 执行Java的命令行-classpath或-cp的值,如果制定了这两个命令行参数之一,它的值会覆盖环境变量CLASSPATH的值

3.3.4 -jar 选项:如果通过java –jar 来运行一个可执行的jar包,这当前jar包会覆盖上面所有的值.换句话说,-jar 后面所跟的jar包的优先级别最高,如果指定了-jar选项,所有环境变量和命令行制定的搜索路径都将被忽略.JVM APPClassloader将只会以jar包为搜索范围.有关可执行jar有许多相关的安全方面的描述,可以参考http://java.sun.com/docs/books/tutorial/jar/ 来全面了解.

这也是为什么应用程序打包成可执行的jar包后,不能引用第三方jar包的原因.

四、解决方案.

首先我们简要归纳一下,为了方便理解,简化一下上面描述的架构,

Java定义了三种级别的class,分别为BootStrap class,Extend Class,User class.

其中User class限制规则最复杂.在User class中可执行的jar包,更包含独立安全规则.所以解决方案基于Java三种不同级别的class扩展机制,有三种不同的方案.

4.1 BootStrap class扩展方案

Java 命令行提供了如何扩展bootStrap 级别class的简单方法.

-Xbootclasspath:基本核心的Java class 搜索路径.不常用,否则要重新写所有Java 核心class

-Xbootclasspath/a: 后缀在核心class搜索路径后面.常用.

-Xbootclasspath/p:前缀在核心class搜索路径前面.不常用,避免引起不必要的冲突.

语法如下:

java –Xbootclasspath/a:/path/myclass/account.jar: -jar yourself.jar(Unix用:号隔开)

java –Xbootclasspath:/d:/myclass/account.jar; -jar yourself.jar(Window用;号隔开)

4.2 extend class 扩展方案

Java exten class 存放在{Java_home}\jre\lib\ext 目录下.当调用Java时,对扩展class路径的搜索是自动的.总会搜索的.这样,解决的方案就很简单了,将所有要使用的第三方的jar包都复制到ext 目录下.

4.3 User class扩展方案

当使用-jar执行可执行Jar包时,JVM将Jar包所在目录设置为codebase目录,所有的class搜索都在这个目录下开始.所以如果使用了其他第三方的jar包,一个比较可以接受的可配置方案,就是利用jar包的Manifest扩展机制.步骤如下

1.将需要的第三方的jar包,复制在同可执行jar所在的目录或某个子目录下.

比如:jar 包在 d:\crm\luncher.jar 那么你可以把所有jar包复制到d:\crm目录下或d:\crm\lib 子目录下.

2.修改Manifest 文件

在Manifest.mf文件里加入如下行

Class-Path:classes12.jar lib/class12.jar

Class-Path 是可执行jar包运行依赖的关键词.详细内容可以参考http://java.sun.com/docs/books/tutorial/ext/index.html

另外编写自己的ClassLoader,来动态载入class,是更加复杂和高级技术.限于篇幅,不赘述.有兴趣了解可以去google一下custom classloader

4.4 推荐方案 4.1，扩展性非常好．

五、总结

Java的安全机制随不同的JDK版本有不同的变化,会影响很多核心CLASS,比如Thread,所以很多大型商业软件,要求JDK的版本很严格.部分原因也在此.这也要求在发布自己编写的应用时候,不管大小,都要说明开发和测试的JDK版本.

本文所测试基于jdk 1.4.1_03 for windows 。

servlet 在请求报头中添加属性时，是区分大小写的

angel — Sun, 15 May 2005 06:55:00 GMT

servlet 在请求报头中添加属性时，是区分大小写的

jbuilder 的servlet编程当前路径

angel — Wed, 11 May 2005 01:44:00 GMT

在使用jbuilder开发servlet时，在servlet中引用的当前路径是以tomcat文件夹为根目录的，这与其他的application编程不同（是以jbuilder的根目录为当前路径），编程时应注意这一点。

servlet 相关的Listener应用

angel — Sat, 07 May 2005 14:30:00 GMT

ZhangLiHai.Com Blog

servlet 相关的Listener应用

张利海于 2004年11月22日 23:27 发表

关键词 : servlet listener timer 定时器

从作用域范围来说,Servlet的作用域有ServletContext,HttpSession,ServletRequest.

Context范围:

ServletContextListener:
对一个应用进行全局监听.随应用启动而启动,随应用消失而消失主要有两个方法:
contextDestroyed(ServletContextEvent event)
在应用关闭的时候调用
contextInitialized(ServletContextEvent event)
在应用启动的时候调用

这个监听器主要用于一些随着应用启动而要完成的工作,也就是很多人说的我想在容器
启动的时候干..........
一般来说对"全局变量"初始化,如
public void contextInitialized(ServletContextEvent event){
    ServletContex sc = event.getServletContext();
    sc.setAttribute(name,value);
}
以后你就可以在任何servlet中getServletContext().getAttribute(name);
我最喜欢用它来做守护性工作,就是在contextInitialized(ServletContextEvent event)
方法中实现一个Timer,然后就让应用在每次启动的时候让这个Timer工作:
public void contextInitialized(ServletContextEvent event){
    timer = new Timer();
    timer.schedule(new TimerTask(){
        public void run(){
            //do any things
        }
    },0,时间间隔);
}

    有人说Timer只能规定从现在开始的多长时间后,每隔多久做一次事或在什么时间做
一次事,那我想在每月1号或每天12点做一项工作如何做呢?
你只要设一个间隔,然后每次判断一下当时是不是那个时间段就行了啊,比如每月一号做,那你
时间间隔设为天,即24小时一个循环,然后在run方法中判断当时日期new Date().getDate()==1
就行了啊.如果是每天的12点,那你时间间隔设为小时,然后在run中判断new Date().getHour()
==12,再做某事就行了.

ServletContextAttributeListener:

这个监听器主要监听ServletContex对象在setAttribute()和removeAttribute()的事件,注意
也就是一个"全局变量"在被Add(第一次set),replace(对已有的变量重新赋值)和remove的时候.
分别调用下面三个方法:
public void attributeAdded(ServletContextAttributeEvent scab)这个方法不仅可以知道
哪些全局变量被加进来,而且可获取容器在启动时自动设置了哪些context变量:

public void attributeAdded(ServletContextAttributeEvent scab){
    System.out.println(scab.getName());
}
  public void attributeRemoved(ServletContextAttributeEvent scab)

  public void attributeReplaced(ServletContextAttributeEvent scab)



Session范围:
HttpSessionListener:
这个监听器主要监听一个Session对象被生成和销毁时发生的事件.对应有两个方法:
  public void sessionCreated(HttpSessionEvent se)

  public void sessionDestroyed(HttpSessionEvent se)

  一般来说,一个session对象被create时,可以说明有一个新客端进入.可以用来粗略统计在线人
数,注意这不是精确的,因为这个客户端可能立即就关闭了,但sessionDestroyed方法却会按一定
的策略很久以后才会发生.

HttpSessionAttributeListener:
和ServletContextAttributeListener一样,它监听一个session对象的Attribut被Add(一个特定
名称的Attribute每一次被设置),replace(已有名称的Attribute的值被重设)和remove时的事件.
对就的有三个方法.
  public void attributeAdded(HttpSessionBindingEvent se)

  public void attributeRemoved(HttpSessionBindingEvent se)

  public void attributeReplaced(HttpSessionBindingEvent se)

  上面的几个监听器的方法,都是在监听应用逻辑中servlet逻辑中发生了什么事,一般的来说.
我们只要完成逻辑功能,比如session.setAttribute("aaa","111");我只要把一个名为aaa的变量
放在session中以便以后我能获取它,我并不关心当session.setAttribute("aaa","111");发生时
我还要干什么.(当然有些时候要利用的),但对于下面这个监听器,你应该好好发解一下:

HttpSessionBindingListener:
上面的监听器都是作为一个独立的Listener在容器中控制事件的.而HttpSessionBindingListener
对在一对象中监听该对象的状态,实现了该接口的对象如果被作为value被add到一个session中或从
session中remove,它就会知道自己已经作为一个session对象或已经从session删除,这对于一些非
纯JAVA对象,生命周期长于session的对象,以及其它需要释放资源或改变状态的对象非常重要.
比如:
session.setAttribute("abcd","1111");
以后session.removeAttribute("abcd");因为abcd是一个字符中,你从session中remove后,它就会
自动被垃圾回收器回收,而如果是一个connection:(只是举例,你千万不要加connection往session
中加入)
session.setAttribute("abcd",conn);
以后session.removeAttribute("abcd");这时这个conn被从session中remove了,你已经无法获取它
的句柄,所以你根本没法关闭它.而在没有remove之前你根本不知道什么时候要被remove,你又无法
close(),那么这个connection对象就死了.另外还有一些对象可以在被加入一个session时要锁定
还要被remove时要解锁,应因你在程序中无法判断什么时候被remove(),add还好操作,我可以先加锁
再add,但remove就后你就找不到它的句柄了,根本没法解锁,所以这些操作只能在对象自身中实现.
也就是在对象被add时或remove时通知对象自己回调相应的方法:

MyConn extends Connection implements HttpSessionBindingListener{
  public void valueBound(HttpSessionBindingEvent se){
    this.initXXX();
  }
  public void valueUnbound(HttpSessionBindingEvent se){

    this.close();
  }
}

session.setAttribute("aaa",new MyConn());
这时如果调用session.removeAttribute("aaa"),则触发valueUnbound方法,就会自动关闭自己.
而其它的需要改变状态的对象了是一样.

另外还有一个HttpSessionActivationListener监听器是实现分布式应用中session同步的.不作
多介绍,如果有要实现该功能的朋友可以和我联系.

在servlet2.4中,对于request范围已经实现对应的监听器:
ServletRequestListener，ServletRequestAttributeListener
但没有找到好的容器的支持所以没有做过多的测试.虽然从API可以掌握99%,但没有经过真正的
测试我是不会仅把API抄出来的.以后我会补齐这方面的内容

原作者:Axman

castor 中文问题

angel — Thu, 05 May 2005 08:20:00 GMT

castor 已经提供了很好的中文支持，如果在解析过程中出现乱码，很有可能是输入源出现错误，对于包含中文的输入源，建议使用流。
package castertest;
import java.io.*;
import org.exolab.castor.mapping.*;
import org.exolab.castor.xml.*;
import java.util.List;
import java.util.Iterator;
import org.xml.sax.InputSource;

public class testResponseProgram {
public static void main(String args[]) {
    try {
      // -- Load a mapping file
      Mapping mapping = new Mapping();
      mapping.loadMapping("src/mapresponse.xml");
      Unmarshaller un = new Unmarshaller(Streambus.class);
      un.setMapping(mapping);

      // -- Read in the Addressbook using the mapping

      FileInputStream input=new FileInputStream("src/response.xml");
      InputSource in=new InputSource(input);

//      FileReader in = new FileReader("src/response.xml");
      Streambus book = (Streambus) un.unmarshal(in);
      input.close();

// -- Display the addressbook
System.out.println(book.getVersion());

      Response persons = book.getResponse();
      System.out.println(persons.getType());
      Iterator list=persons.getPrograms().iterator();
      while(list.hasNext()){
        Program program=(Program)list.next();
        System.out.println(program.getId());
        System.out.println(program.getTitle());
        System.out.println(program.getUrl());
//        String gb=new String(program.getDescription(),"GB2312");
        System.out.println(program.getDescription());
        System.out.println(program.getPrice());
        System.out.println(program.getPromptionURL());
        System.out.println(program.getDuration());
      }
    }
    catch (Exception e) {
      System.out.println(e);
    }
}
}

品味Java子类型多态的魅力选择自 chensheng913 的 Blog

angel — Sat, 30 Apr 2005 06:00:00 GMT

“polymorphism(多态）”一词来自希腊语，意为“多种形式”。多数Java程序员把多态看作对象的一种能力，使其能调用正确的方法版本。尽管如此，这种面向实现的观点导致了多态的神奇功能，胜于仅仅把多态看成纯粹的概念。

　　Java中的多态总是子类型的多态。几乎是机械式产生了一些多态的行为，使我们不去考虑其中涉及的类型问题。本文研究了一种面向类型的对象观点，分析了如何将对象能够表现的行为和对象即将表现的行为分离开来。抛开Java中的多态都是来自继承的概念，我们仍然可以感到，Java中的接口是一组没有公共代码的对象共享实现。

　　多态的分类

　　多态在面向对象语言中是个很普遍的概念.虽然我们经常把多态混为一谈，但实际上有四种不同类型的多态。在开始正式的子类型多态的细节讨论前，然我们先来看看普通面向对象中的多态。

　　Luca Cardelli和Peter Wegner（"On Understanding Types, Data Abstraction, and Polymorphism"一文的作者，文章参考资源链接）把多态分为两大类----特定的和通用的----四小类：强制的，重载的，参数的和包含的。他们的结构如下：

　　在这样一个体系中，多态表现出多种形式的能力。通用多态引用有相同结构类型的大量对象，他们有着共同的特征。特定的多态涉及的是小部分没有相同特征的对象。四种多态可做以下描述：

　　强制的：一种隐式做类型转换的方法。

　　重载的：将一个标志符用作多个意义。

　　参数的：为不同类型的参数提供相同的操作。

　　包含的：类包含关系的抽象操作。

　　我将在讲述子类型多态前简单介绍一下这几种多态。

　　强制的多态

　　强制多态隐式的将参数按某种方法，转换成编译器认为正确的类型以避免错误。在以下的表达式中，编译器必须决定二元运算符‘+’所应做的工作：

　　2.0 + 2.0

　　2.0 + 2

　　2.0 + "2"

　　第一个表达式将两个double的操作数相加；Java中特别声明了这种用法。

　　第二个表达式将double型和int相加。Java中没有明确定义这种运算。不过，编译器隐式的将第二个操作数转换为double型，并作double型的加法。做对程序员来说十分方便，否则将会抛出一个编译错误，或者强制程序员显式的将int转换为double。

　　第三个表达式将double与一个String相加。Java中同样没有定义这样的操作。所以，编译器将double转换成String类型，并将他们做串联。

　　强制多态也会发生在方法调用中。假设类Derived继承了类Base，类C有一个方法，原型为m(Base)，在下面的代码中，编译器隐式的将Derived类的对象derived转化为Base类的对象。这种隐式的转换使m(Base)方法使用所有能转换成Base类的所有参数。

C c = new C();

Derived derived = new Derived();

c.m( derived );

　　并且，隐式的强制转换，可以避免类型转换的麻烦，减少编译错误。当然，编译器仍然会优先验证符合定义的对象类型。

　　重载的多态

　　重载允许用相同的运算符或方法，去表示截然不同的意义。‘+’在上面的程序中有两个意思：两个double型的数相加；两个串相连。另外还有整型相加，长整型，等等。这些运算符的重载，依赖于编译器根据上下文做出的选择。以往的编译器会把操作数隐式转换为完全符合操作符的类型。虽然Java明确支持重载，但不支持用户定义的操作符重载。

　　Java支持用户定义的函数重载。一个类中可以有相同名字的方法，这些方法可以有不同的意义。这些重载的方法中，必须满足参数数目不同，相同位置上的参数类型不同。这些不同可以帮助编译器区分不同版本的方法。

　　编译器以这种唯一表示的特征来表示不同的方法，比用名字表示更为有效。据此，所有的多态行为都能编译通过。

　　强制和重载的多态都被分类为特定的多态，因为这些多态都是在特定的意义上的。这些被划入多态的特性给程序员带来了很大的方便。强制多态排除了麻烦的类型和编译错误。重载多态像一块糖，允许程序员用相同的名字表示不同的方法，很方便。

　　参数的多态

　　参数多态允许把许多类型抽象成单一的表示。例如，List抽象类中，描述了一组具有同样特征的对象，提供了一个通用的模板。你可以通过指定一种类型以重用这个抽象类。这些参数可以是任何用户定义的类型，大量的用户可以使用这个抽象类，因此参数多态毫无疑问的成为最强大的多态。

　　乍一看，上面抽象类好像是java.util.List的功能。然而，Java实际上并不支持真正的安全类型风格的参数多态，这也是java.util.List和java.util的其他集合类是用原始的java.lang.Object写的原因（参考我的文章"A Primordial Interface?" 以获得更多细节）。Java的单根继承方式解决了部分问题，但没有发挥出参数多态的全部功能。Eric Allen有一篇精彩的文章“Behold the Power of Parametric Polymorphism”，描述了Java通用类型的需求，并建议给Sun的Java规格需求#000014号文档"Add Generic Types to the Java Programming Language."（参考资源链接）

　　包含的多态

　　包含多态通过值的类型和集合的包含关系实现了多态的行为.在包括Java在内的众多面向对象语言中，包含关系是子类型的。所以，Java的包含多态是子类型的多态。

　　在早期，Java开发者们所提及的多态就特指子类型的多态。通过一种面向类型的观点，我们可以看到子类型多态的强大功能。以下的文章中我们将仔细探讨这个问题。为简明起见，下文中的多态均指包含多态。

　　面向类型观点

　　图1的UML类图给出了类和类型的简单继承关系，以便于解释多态机制。模型中包含5种类型，4个类和一个接口。虽然UML中称为类图，我把它看成类型图。如"Thanks Type and Gentle Class," 一文中所述，每个类和接口都是一种用户定义的类型。按独立实现的观点（如面向类型的观点），下图中的每个矩形代表一种类型。从实现方法看，四种类型运用了类的结构，一种运用了接口的结构。

图1：示范代码的UML类图

　　以下的代码实现了每个用户定义的数据类型，我把实现写得很简单。

/* Base.java */

public class Base
{
　public String m1()
　{
　　return "Base.m1()";
　}

　public String m2( String s )
　{
　　return "Base.m2( " + s + " )";
　}
}

/* IType.java */

interface IType
{
　String m2( String s );
　String m3();
}

/* Derived.java */

public class Derived
extends Base
implements IType
{
　public String m1()
　{
　　return "Derived.m1()";
　}

　public String m3()
　{
　　return "Derived.m3()";
　}
}

/* Derived2.java */

public class Derived2
extends Derived
{
　public String m2( String s )
　{
　　return "Derived2.m2( " + s + " )";
　}
　public String m4()
　{
　　return "Derived2.m4()";
　}
}

/* Separate.java */

public class Separate
implements IType
{
　public String m1()
　{
　　return "Separate.m1()";
　}
　public String m2( String s )
　{
　　return "Separate.m2( " + s + " )";
　}

　public String m3()
　{
　　return "Separate.m3()";
　}
}

　　用这样的类型声明和类的定义，图2从概念的观点描述了Java指令。

Derived2 derived2 = new Derived2();

图2 ：Derived2 对象上的引用

　　上文中声明了derived2这个对象，它是Derived2类的。图2种的最顶层把Derived2引用描述成一个集合的窗口，虽然其下的Derived2对象是可见的。这里为每个Derived2类型的操作留了一个孔。Derived2对象的每个操作都去映射适当的代码，按照上面的代码所描述的那样。例如，Derived2对象映射了在Derived中定义的m1()方法。而且还重载了Base类的m1()方法。一个Derived2的引用变量无权访问Base类中被重载的m1()方法。但这并不意味着不可以用super.m1()的方法调用去使用这个方法。关系到derived2这个引用的变量，这个代码是不合适的。Derived2的其他的操作映射同样表明了每种类型操作的代码执行。

　　既然你有一个Derived2对象，可以用任何一个Derived2类型的变量去引用它。如图1所示，Derived, Base和IType都是Derived2的基类。所以，Base类的引用是很有用的。图3描述了以下语句的概念观点。

Base base = derived2;

图3：Base类引用附于Derived2对象之上
　
　　虽然Base类的引用不用再访问m3()和m4()，但是却不会改变它Derived2对象的任何特征及操作映射。无论是变量derived2还是base，其调用m1()或m2(String)所执行的代码都是一样的。

String tmp;
// Derived2 reference (Figure 2)
tmp = derived2.m1(); // tmp is "Derived.m1()"
tmp = derived2.m2( "Hello" ); // tmp is "Derived2.m2( Hello )"

// Base reference (Figure 3)

tmp = base.m1(); // tmp is "Derived.m1()"
tmp = base.m2( "Hello" ); // tmp is "Derived2.m2( Hello )"

　　两个引用之所以调用同一个行为，是因为Derived2对象并不知道去调用哪个方法。对象只知道什么时候调用，它随着继承实现的顺序去执行。这样的顺序决定了Derived2对象调用Derived里的m1()方法，并调用Derived2里的m2(String)方法。这种结果取决于对象本身的类型，而不是引用的类型。

　　尽管如此，但不意味着你用derived2和base引用的效果是完全一样的。如图3所示，Base的引用只能看到Base类型拥有的操作。所以，虽然Derived2有对方法m3()和m4()的映射，但是变量base不能访问这些方法。

String tmp;
// Derived2 reference (Figure 2)
tmp = derived2.m3(); // tmp is "Derived.m3()"
tmp = derived2.m4(); // tmp is "Derived2.m4()"

// Base reference (Figure 3)

tmp = base.m3(); // Compile-time error
tmp = base.m4(); // Compile-time error

　　运行期的Derived2对象保持了接受m3()和m4()方法的能力。类型的限制使Base的引用不能在编译期调用这些方法。编译期的类型检查像一套铠甲，保证了运行期对象只能和正确的操作进行相互作用。换句话说，类型定义了对象间相互作用的边界。

　　多态的依附性

　　类型的一致性是多态的核心。对象上的每一个引用，静态的类型检查器都要确认这样的依附和其对象的层次是一致的。当一个引用成功的依附于另一个不同的对象时，有趣的多态现象就产生了。（严格的说，对象类型是指类的定义。）你也可以把几个不同的引用依附于同一个对象。在开始更有趣的场景前，我们先来看一下下面的情况为什么不会产生多态。

　　多个引用依附于一个对象

　　图2和图3描述的例子是把两个及两个以上的引用依附于一个对象。虽然Derived2对象在被依附之后仍保持了变量的类型，但是，图3中的Base类型的引用依附之后，其功能减少了。结论很明显：把一个基类的引用依附于派生类的对象之上会减少其能力。

　　一个开发这怎么会选择减少对象能力的方案呢？这种选择是间接的。假设有一个名为ref的引用依附于一个包含如下方法的类的对象：

public String poly1( Base base )
{
　return base.m1();
}

　　用一个Derived2的参数调用poly(Base)是符合参数类型检查的：

ref.poly1( derived2 );

　　方法调用把一个本地Base类型的变量依附在一个引入的对象上。所以，虽然这个方法只接受Base类型的参数，但Derived2对象仍是允许的。开发这就不必选择丢失功能的方案。从人眼在通过Derived2对象时所看到的情况，Base类型引用的依附导致了功能的丧失。但从执行的观点看，每一个传入poly1(Base)的参数都认为是Base的对象。执行机并不在乎有多个引用指向同一个对象，它只注重把指向另一个对象的引用传给方法。这些对象的类型不一致并不是主要问题。执行器只关心给运行时的对象找到适当的实现。面向类型的观点展示了多态的巨大能力。

　　附于多个对象的引用

　　让我们来看一下发生在poly1(Base)中的多态行为。下面的代码创建了三个对象，并通过引用传给poly1(Base):

Derived2 derived2 = new Derived2();
Derived derived = new Derived();
Base base = new Base();

String tmp;

tmp = ref.poly1( derived2 ); // tmp is "Derived.m1()"
tmp = ref.poly1( derived ); // tmp is "Derived.m1()"
tmp = ref.poly1( base ); // tmp is "Base.m1()"

　　poly1(Base)的实现代码是调用传进来的参数的m1()方法。图3和图4展示了把三个类的对象传给方法时，面向类型的所使用的体系结构。

图4：将Base引用指向Derived类，以及Base对象

　　请注意每个图中方法m1()的映射。图3中，m1()调用了Derived类的代码；上面代码中的注释标明了ploy1(Base)调用Derived.m1()。图4中Derived对象调用的仍然是Derived类的m1()方法。最后，图4中，Base对象调用的m1()是Base类中定义的代码。

　　多态的魅力何在？再来看一下poly1(Base)的代码，它可以接受任何属于Base类范畴的参数。然而，当他收到一个Derived2的对象时，它实际上却调用了Derived版本的方法。当你根据Base类派生出其他类时，如Derived，Derived2，poly1(Base)都可以接受这些参数，并作出选择调用合适的方法。多态允许你在完成poly1(Base)后扩展它的用途。

　　这看起来当然很神奇。基本的理解展示了多态的内部工作原理。在面向类型的观点中，底层的对象所实现的代码是非实质性的。重要的是，类型检查器会在编译期间为每个引用选择合适的代码以实现其方法。多态使开发者运用面向类型的观点，不考虑实现的细节。这样有助于把类型和实现分离（实际用处是把接口和实现分离）。

　　对象接口

　　多态依赖于类型和实现的分离，多用来把接口和实现分离。但下面的观点好像把Java的关键字interface搞得很糊涂。

　　更为重要的使开发者们怎样理解短语“the interface to an object"，典型地，根据上下文，这个短语的意思是指一切对象类中所定义的方法，至一切对象公开的方法。这种倾向于以实现为中心的观点较之于面向类型的观点来说，使我们更加注重于对象在运行期的能力。图3中，引用面板的对象表面被标志成"Derived2 Object"。这个面板上列出了Derived2对象的所有可用的方法。但是要理解多态，我们必须从实现这一层次上解放出来，并注意面向类型的透视图中被标为"Base Reference"的面板。在这一层意思上，引用变量的类型指明了一个对象的表面。这只是一个表面，不是接口。在类型一致的原则下，我们可以用面向类型的观点，为一个对象依附多个引用。对interface to an object这个短语的理解没有确定的理解。

　　在类型概念中，the interface to an object refers 引用了面向类型观点的最大可能----如图2的情形。把一个基类的引用指向相同的对象缩小了这样的观点----如图3所示。类型概念能使人获得把对象间的相互作用同实现细节分离的要领。相对于一个对象的接口，面向类型的观点更鼓励人们去使用一个对象的引用。引用类型规定了对象间的相互作用。当你考虑一个对象能做什么的时候，只需搞明白他的类型，而不需要去考虑他的实现细节。

　　Java接口

　　以上所谈到的多态行为用到了类的继承关系所建立起来的子类型关系。Java接口同样支持用户定义的类型，相对地，Java的接口机制启动了建立在类型层次结构上的多态行为。假设一个名为ref的引用变量，并使其指向一个包含一下方法的类对象：

public String poly2( IType iType )
{
　return iType.m3();
}

　　为了弄明白poly2(IType)中的多态，以下的代码从不同的类创建两个对象，并分别把他们传给poly2(IType)：

Derived2 derived2 = new Derived2();
Separate separate = new Separate();

String tmp;

tmp = ref.poly2( derived2 ); // tmp is "Derived.m3()"
tmp = ref.poly2( separate ); // tmp is "Separate.m3()"

　　上面的代码类似于关于poly1(Base)中的多态的讨论。poly2(IType)的实现代码是调用每个对象的本地版本的m3()方法。如同以前，代码的注释表明了每次调用所返回的CString类型的结果。图5表明了两次调用poly2(IType)的概念结构：

图5：指向Derived2和Separate对象的IType引用

　　方法poly1(Base)和poly2(IType)中所表现的多态行为的相似之处可以从透视图中直接看出来。把我们在实现在一层上的理解再提高一层，就可以看到这两段代码的技巧。基类的引用指向了作为参数传进的类，并且按照类型的限制调用对象的方法。引用既不知道也不关心执行哪一段代码。编译期间的子类型关系检查保证了通过的对象有能力在被调用的时候选择合适的实现代码。

　　然而，他们在实现层上有一个重要的差别。在poly1(Base)的例子中（图3和图4），Base-Derived-Derived2的类继承结构为子类型关系的建立提供了条件，并决定了方法去调用哪段代码。在poly2(IType)的例子中（如图5），则是完全不同的动态发生的。Derived2和Separate不共享任何实现的层次，但是他们还是通过IType的引用展示了多态的行为。

　　这样的多态行为使Java的接口的功能的重大意义显得很明显。图1中的UML类图说明了Derived是Base和IType的子类型。通过完全脱离实现细节的类型的定义方法，Java实现了多类型继承，并且不存在Java所禁止的多继承所带来的烦人的问题。完全脱离实现层次的类可以按照Java接口实现分组。在图1中，接口IType和Derived,Separate以及这类型的其他子类型应该划为一组。

　　按照这种完全不同于实现层次的分类方法，Java的接口机制是多态变得很方便，哪怕不存在任何共享的实现或者复写的方法。如图5所示，一个IType的引用，用多态的方法访问到了Derived2和Separate对象的m3()方法。

　　再次探讨对象的接口

　　注意图5中的Derived2和Separate对象的对m1()的映射方法。如前所述，每一个对象的接口都包含方法m1()。但却没有办法用这两个对象使方法m1()表现出多态的行为。每一个对象占有一个m1()方法是不够的。必须存在一个可以操作m1()方法的类型，通过这个类型可以看到对象。这些对象似乎是共享了m1()方法，但在没有共同基类的条件下，多态是不可能的。通过对象的接口来看多态，会把这个概念搞混。

　　结论

　　从全文所述的面向对象多态所建立起来的子类型多态，你可以清楚地认识到这种面向类型的观点。如果你想理解子类型多态的思想，就应该把注意力从实现的细节转移到类型的上。类型把对象分成组，并且管理着这些对象的接口。类型的继承层次结构决定了实现多态所需的类型关系。

　　有趣的是，实现的细节并不影响子类型多态的层次结构。类型决定了对象调用什么方法，而实现则决定了对象怎么执行这个方法。也就是说，类型表明了责任，而负责实施的则是具体的实现。将实现和类型分离后，我们好像看到了这两个部分在一起跳舞，类型决定了他的舞伴和舞蹈的名字，而实现则是舞蹈动作的设计师。

作者Blog：http://blog.csdn.net/chensheng913/

相关文章

如何连接oracle数据库及故障解决办法

浅析Java中Data类的应用

探讨ORACLE数据库的数据导入方法

在Oracle9i中使用多种Block Size

JSP技巧：发送动态图像