bill.end http://bill-end.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 Ext Grid bill.end 作者: bill.end  链接：http://bill-end.javaeye.com/blog/149214  发表时间: 2007年12月18日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Ext在和后端通信使用Json时，要使用"callback('Json');"这种形式，原因是
引用
grid提交分页数据的时候后面还会自动跟随一个可以说是标识的字段callback=stcCallback1001
每提交一次请求，callback就会自增，也就是说第二次就是callback=stcCallback1002
对应的，你的php文件回传json数据的时候也要带上这个值，来确定是哪次的请求所返回的结果
格式是：
stcCallback1001(
{ ‘results’: 2, ‘rows’: [
{ ‘id’: 1, ‘name’: ‘Bill’, occupation: ‘Gardener’ },
{ ‘id’: 2, ‘name’: ‘Ben’, occupation: ‘Horticulturalist’ } ]
}
);

他每次提交的数据是附加在网址后面的格式是
?start=0&limit=25&_dc=1185695314632&callback=stcCallback1001
statr：起始数据值
limit：每页数据条数
_dc：自动生成的时间戳
callback：回传的确认值

要注意的是JSON-CODE中要严格按照其格式定义：{"totalProperty:".总行数，“ROOT:".JSON_ENCODE($DATA)}
另外，在ext-js中，使用JsonReader声明所读的数据是日期时，也要注意，要不就不要声明，要声明就得确定jsondata中的日期格式与你声明的一致。

出自：http://www.centuryidea.cn/index.php?tag=php

所以对应的服务器端的实现：
String callback=request.getParameter("callback");
String json = callback+"({totalProperty:100,root:[";
json += "{col1:" + 1 + ",col2:'name" + i + "',col3:'descn" + 1 + "'}";
json += "]});";

回传的结果类似于：
stcCallback1001({totalProperty:100,root:[{col1:1,col2:'name1',col3:'descn1'}]});


在创建Ext.data.Store对象时，proxy属性使用Ext.data.ScriptTagProxy，不要使用Ext.data.HttpProxy。
引用

Ext API
Class Ext.data.HttpProxy
Note that this class cannot be used to retrieve data from a domain other than the domain from which the running page was served.


Class Ext.data.ScriptTagProxy
Note that if you are retrieving data from a page that is in a domain that is NOT the same as the originating domain of the running page, you must use this class, rather than HttpProxy.



很奇怪，使用这种形式proxy: new Ext.data.ScriptTagProxy({url:'PagingGrid.jsp'})可以正常显示，但proxy: new Ext.data.HttpProxy({url:'PagingGrid.jsp'})这种就不行（我理解错了？）。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 18 Dec 2007 18:09:30 +0800 http://bill-end.javaeye.com/blog/149214 http://bill-end.javaeye.com/blog/149214 使用snmp协议收集信息 bill.end 作者: bill.end  链接：http://bill-end.javaeye.com/blog/130839  发表时间: 2007年10月10日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

使用http://gicl.cs.drexel.edu/people/sevy/snmp/snmp.html 提供的“an open-source implementation of the SNMP protocol”。

实现功能之前，看了一些资料（网络管理，SNMP，SMI和MIB等），


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 10 Oct 2007 17:40:31 +0800 http://bill-end.javaeye.com/blog/130839 http://bill-end.javaeye.com/blog/130839 Notes On Javascript ( updating ) bill.end 作者: bill.end  链接：http://bill-end.javaeye.com/blog/127278  发表时间: 2007年09月26日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Data Type Conversion

1. Array length
Truncating an array by setting its length property is the only way that you can actually shorten an array. If you use the delete operator to delete an array element, that element becomes undefined, but the length property does not change.

2. Array.concat( )
If any of these arguments is itself an array, it is flattened and its elements are added to the returned array. Note, however, that concat( ) does not recursively flatten arrays of arrays. Here are some examples:
var a = [1,2,3];
a.concat([4,5],[6,7])   // Returns [1,2,3,4,5,6,7]
a.concat(4, [5,[6,7]])  // Returns [1,2,3,4,5,[6,7]]
   //indicate that concat( ) does not recursively flatten arrays of arrays

3. Object-to-Primitive Conversion
a. object->boolean:
whenever a non-null object is used in a boolean context, it converts to true. This is true for all objects (including all arrays and functions), even wrapper objects that represent primitive values that convert to false. For example:
a[0]=new Boolean(false)  // Internal value is false, but object converts to true
a[1]=new Number(0)
a[2]=new String("")
a[3]=new Array(  )
if(a[0]&&a[1]&&a[2]&&a[3]){
 document.write("all are true");
}
//output: all are true.

b. object->number:
objects are converted to numbers by first calling the valueOf( ) method of the object. Most objects inherit the default valueOf( ) method of Object, which simply returns the object itself. Since the default valueOf( ) method does not return a primitive value, JavaScript next tries to convert the object to a number by calling its toString( ) method and converting the resulting string to a number.

Array->number:
Call the toString( ) method of arrays converts the array elements to strings, then returns the result of concatenating these strings, with commas in between. Therefore, an array with no elements converts to the empty string, which converts to the number zero! Also, if an array has a single element that is a number n, the array converts to a string representation of n, which is then converted back to n itself. If an array contains more than one element, or if its one element is not a number, the array converts to NaN.For example:
b=new Array();
b[0]="1";
document.write(10-b); //output:9
document.write(10+b); //output:101

b[0]="w";
document.write(10-b); //output:NaN
document.write(10+b); //output:10w

b[1]=3;
document.write(10-b); //output:NaN
document.write(10+b); //output:10w,3

Strings ->Numbers
parseInt( ) and parseFloat( ) functions convert and return any number at the beginning of a string, ignoring any trailing non-numbers. (P.S. This point is different from Java which will throw  java.lang.NumberFormatException).
parseInt( ) can even take a second argument specifying the radix (base) of the number to be parsed. Legal values are between 2 and 36. For example:
  var a="12,3";
  document.write(a-1);                              // output: NaN
  document.write(parseInt(a));                // output:12
  document.write(parseInt(a-1));            // output: NaN
  document.write(parseInt("11", 2));      // output: 3 (1*2 + 1)         

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 26 Sep 2007 13:50:18 +0800 http://bill-end.javaeye.com/blog/127278 http://bill-end.javaeye.com/blog/127278 二叉树 bill.end 作者: bill.end  链接：http://bill-end.javaeye.com/blog/121770  发表时间: 2007年09月07日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

java 代码
  1. 这是我写的二叉树和四种遍历方式，请指教。   
  2. p.s. 编号是按照满进行编号(location)。   
  3.   
  4.   
  5.   
  6. public class BinaryTree {   
  7.     private static final int ROOT_LOCATION = 1;   
  8.   
  9.     private BinaryNode root;   
  10.   
  11.     public BinaryTree() {   
  12.     }   
  13.   
  14.     public BinaryNode getRoot() {   
  15.         return root;   
  16.     }   
  17.   
  18.     public void setRoot(BinaryNode root) {   
  19.         this.root = root;   
  20.         this.root.setLocation(ROOT_LOCATION);   
  21.         updateLocation(ROOT_LOCATION, root);   
  22.     }   
  23.   
  24.     public BinaryTree(BinaryNode root) {   
  25.         this();   
  26.         setRoot(root);   
  27.     }   
  28.   
  29.     public BinaryTree(BinaryNode root, int location) {   
  30.         this();   
  31.         this.root = root;   
  32.         this.root.setLocation(location);   
  33.         updateLocation(location, root);   
  34.     }   
  35.   
  36.     public boolean add(BinaryTree aTree, int location) {   
  37.         if (this == aTree) {   
  38.             return false;   
  39.         }   
  40.         BinaryNode aRoot = aTree.getRoot();   
  41.         return add(aRoot, location);   
  42.     }   
  43.   
  44.     public boolean add(BinaryNode node, int location) {   
  45.         if (location == ROOT_LOCATION) {   
  46.             root = getRoot();   
  47.             if (root == null) {   
  48.                 setRoot(node);   
  49.                 return true;   
  50.             }   
  51.             return false;   
  52.         }   
  53.         BinaryNode parent = getParent(location);   
  54.         if (parent == null) {   
  55.             return false;   
  56.         }   
  57.         if (location % 2 == 0) {   
  58.             BinaryNode curNode = parent.getL_Child();   
  59.             if (curNode != null) {   
  60.                 return false;   
  61.             }   
  62.             parent.setL_Child(node);   
  63.         } else {   
  64.             BinaryNode curNode = parent.getR_Child();   
  65.             if (curNode != null) {   
  66.                 return false;   
  67.             }   
  68.             parent.setR_Child(node);   
  69.         }   
  70.         updateLocation(location, node);   
  71.         return true;   
  72.     }   
  73.   
  74.     public BinaryNode getParent(int location) {   
  75.         int parentLoc = location / 2;   
  76.         BinaryNode parent = getNode(parentLoc);   
  77.         return parent;   
  78.     }   
  79.   
  80.     private BinaryNode getNode(int location) {   
  81.         GetNodeHandler handler = new GetNodeHandler(location);   
  82.         TraverseUtil.traverseByPre(this, handler);   
  83.         return handler.getNode();   
  84.     }   
  85.   
  86.     public void delete(int location) {   
  87.         BinaryNode parent = getParent(location);   
  88.         if (parent == null) {   
  89.             return;   
  90.         }   
  91.         if (location % 2 == 0) {   
  92.             parent.setL_Child(null);   
  93.         } else {   
  94.             parent.setR_Child(null);   
  95.         }   
  96.     }   
  97.   
  98.     public boolean update(Object value, int location) {   
  99.         if (value instanceof BinaryNode) {   
  100.             return false;   
  101.         }   
  102.         BinaryNode node = getNode(location);   
  103.         if (node == null) {   
  104.             return false;   
  105.         }   
  106.         node.setData(value);   
  107.         return true;   
  108.     }   
  109.   
  110.     private void updateLocation(int rootLocation, BinaryNode aRoot) {   
  111.         UpdateLocationHandler handler = new UpdateLocationHandler(rootLocation,   
  112.                 aRoot);   
  113.         TraverseUtil.traverseByPre(aRoot, handler);   
  114.     }   
  115.   
  116.     public int getTreeDepth() {   
  117.         MaxLocationHandler handler = new MaxLocationHandler(getRoot());   
  118.         TraverseUtil.traverseByPre(this, handler);   
  119.         int depth = getDepth(handler.getLocation());   
  120.         return depth;   
  121.     }   
  122.   
  123.     public int size() {   
  124.         SizeHandler handler = new SizeHandler(getRoot());   
  125.         TraverseUtil.traverseByPre(this, handler);   
  126.         return handler.getSize();   
  127.     }   
  128.   
  129.     private int getDepth(int max) {   
  130.         ++max;   
  131.         int depth = 1;   
  132.         while (max > 1) {   
  133.             max /= 2;   
  134.             ++depth;   
  135.         }   
  136.         return depth;   
  137.     }   
  138.   
  139.     public Object getData(int loc) {   
  140.         BinaryNode node = getNode(loc);   
  141.         if (node == null) {   
  142.             return null;   
  143.         }   
  144.         return node.getData();   
  145.     }   
  146.   
  147.     private class GetNodeHandler extends AbstractNodeHandler {   
  148.   
  149.         public GetNodeHandler(final int location) {   
  150.             super(location);   
  151.         }   
  152.   
  153.         public boolean handle(BinaryNode node) {   
  154.             if (node == null) {   
  155.                 return false;   
  156.             }   
  157.             if (node.getLocation() == getLocation()) {   
  158.                 setNode(node);   
  159.                 return true;   
  160.             }   
  161.             return false;   
  162.         }   
  163.     }   
  164.   
  165.     private class UpdateLocationHandler extends AbstractNodeHandler {   
  166.   
  167.         public UpdateLocationHandler(int location, BinaryNode root) {   
  168.             super(location);   
  169.             root.setLocation(location);   
  170.         }   
  171.   
  172.         public boolean handle(BinaryNode node) {   
  173.             if (node == null) {   
  174.                 return false;   
  175.             }   
  176.   
  177.             if (node.isExistL_Child()) {   
  178.                 BinaryNode l = node.getL_Child();   
  179.                 l.setLocation(node.getLocation() * 2);   
  180.             }   
  181.   
  182.             if (node.isExistR_Child()) {   
  183.                 BinaryNode r = node.getR_Child();   
  184.                 r.setLocation(node.getLocation() * 2 + 1);   
  185.             }   
  186.             return false;   
  187.         }   
  188.     }   
  189.   
  190.     private class MaxLocationHandler extends AbstractNodeHandler {   
  191.   
  192.         public MaxLocationHandler(BinaryNode root) {   
  193.             super(root.getLocation());   
  194.         }   
  195.   
  196.         public boolean handle(BinaryNode node) {   
  197.             if (node == null) {   
  198.                 return false;   
  199.             }   
  200.             int curLoc = node.getLocation();   
  201.             if (curLoc > getLocation()) {   
  202.                 setLocation(curLoc);   
  203.             }   
  204.             return false;   
  205.         }   
  206.     }   
  207.   
  208.     private class SizeHandler extends AbstractNodeHandler {   
  209.         private int size;   
  210.   
  211.         public int getSize() {   
  212.             return size;   
  213.         }   
  214.   
  215.         public SizeHandler(BinaryNode root) {   
  216.             super(root.getLocation());   
  217.         }   
  218.   
  219.         public boolean handle(BinaryNode node) {   
  220.             if (node == null) {   
  221.                 return false;   
  222.             }   
  223.             size++;   
  224.             return false;   
  225.         }   
  226.     }   
  227. }   
  228.   
  229. public class BinaryNode {   
  230.     public final static int SINGLENODE = 0;   
  231.   
  232.     private Object data;   
  233.   
  234.     private int location;   
  235.   
  236.     private BinaryNode l_Child;   
  237.   
  238.     private BinaryNode r_Child;   
  239.   
  240.     public BinaryNode() {   
  241.         super();   
  242.         this.location = SINGLENODE;   
  243.     }   
  244.   
  245.     public BinaryNode(Object data) {   
  246.         this();   
  247.         this.data = data;   
  248.     }   
  249.   
  250.     public Object getData() {   
  251.         return data;   
  252.     }   
  253.   
  254.     public void setData(Object data) {   
  255.         this.data = data;   
  256.     }   
  257.   
  258.     public BinaryNode getL_Child() {   
  259.         return l_Child;   
  260.     }   
  261.   
  262.     public void setL_Child(BinaryNode child) {   
  263.         l_Child = child;   
  264.     }   
  265.   
  266.     public BinaryNode getR_Child() {   
  267.         return r_Child;   
  268.     }   
  269.   
  270.     public void setR_Child(BinaryNode child) {   
  271.         r_Child = child;   
  272.     }   
  273.   
  274.     public boolean isExistL_Child() {   
  275.         if (getL_Child() == null) {   
  276.             return false;   
  277.         }   
  278.         return true;   
  279.     }   
  280.   
  281.     public boolean isExistR_Child() {   
  282.         if (getR_Child() == null) {   
  283.             return false;   
  284.         }   
  285.         return true;   
  286.     }   
  287.   
  288.     public int getLocation() {   
  289.         return location;   
  290.     }   
  291.   
  292.     public void setLocation(int location) {   
  293.         this.location = location;   
  294.     }   
  295. }   
  296.   
  297. public interface IHandler {   
  298.     /**  
  299.      * return true indicate stopping traversing, otherwise continuing.  
  300.      */  
  301.     boolean handle(BinaryNode node);   
  302. }   
  303.   
  304. public abstract class AbstractNodeHandler implements IHandler {   
  305.     private BinaryNode node;   
  306.   
  307.     private int location;   
  308.   
  309.     public AbstractNodeHandler(final int location) {   
  310.         super();   
  311.         this.location = location;   
  312.     }   
  313.   
  314.     public abstract boolean handle(BinaryNode node);   
  315.   
  316.     public BinaryNode getNode() {   
  317.         return node;   
  318.     }   
  319.   
  320.     public void setNode(BinaryNode node) {   
  321.         this.node = node;   
  322.     }   
  323.   
  324.     public int getLocation() {   
  325.         return location;   
  326.     }   
  327.   
  328.     public void setLocation(int location) {   
  329.         this.location = location;   
  330.     }   
  331.   
  332. }   
  333.   
  334. import java.util.LinkedList;   
  335.   
  336. public class TraverseUtil {   
  337.   
  338.     private TraverseUtil() {   
  339.     }   
  340.   
  341.     public static void traverseByPre(BinaryTree tree, IHandler handler) {   
  342.         BinaryNode root = tree.getRoot();   
  343.         if (root == null) {   
  344.             return;   
  345.         }   
  346.         traverseByPre(root, handler);   
  347.     }   
  348.   
  349.     public static void traverseByPre(BinaryNode node, IHandler handler) {   
  350.         boolean isStop = handler.handle(node);   
  351.         if (isStop) {   
  352.             return;   
  353.         }   
  354.         if (node.isExistL_Child()) {   
  355.             BinaryNode child = node.getL_Child();   
  356.             traverseByPre(child, handler);   
  357.         }   
  358.         if (node.isExistR_Child()) {   
  359.             BinaryNode child = node.getR_Child();   
  360.             traverseByPre(child, handler);   
  361.         }   
  362.     }   
  363.   
  364.     public static void traverseByInOrder(BinaryTree tree, IHandler handler) {   
  365.         BinaryNode root = tree.getRoot();   
  366.         if (root == null) {   
  367.             return;   
  368.         }   
  369.         traverseByInOrder(root, handler);   
  370.     }   
  371.   
  372.     public static void traverseByInOrder(BinaryNode node, IHandler handler) {   
  373.         if (node.isExistL_Child()) {   
  374.             BinaryNode child = node.getL_Child();   
  375.             traverseByInOrder(child, handler);   
  376.         }   
  377.   
  378.         boolean isStop = handler.handle(node);   
  379.         if (isStop) {   
  380.             return;   
  381.         }   
  382.   
  383.         if (node.isExistR_Child()) {   
  384.             BinaryNode child = node.getR_Child();   
  385.             traverseByInOrder(child, handler);   
  386.         }   
  387.     }   
  388.   
  389.     public static void traverseByPost(BinaryTree tree, IHandler handler) {   
  390.         BinaryNode root = tree.getRoot();   
  391.         if (root == null) {   
  392.             return;   
  393.         }   
  394.         traverseByPost(root, handler);   
  395.     }   
  396.   
  397.     public static void traverseByPost(BinaryNode node, IHandler handler) {   
  398.         if (node.isExistL_Child()) {   
  399.             BinaryNode child = node.getL_Child();   
  400.             traverseByPost(child, handler);   
  401.         }   
  402.   
  403.         if (node.isExistR_Child()) {   
  404.             BinaryNode child = node.getR_Child();   
  405.             traverseByPost(child, handler);   
  406.         }   
  407.   
  408.         boolean isStop = handler.handle(node);   
  409.         if (isStop) {   
  410.             return;   
  411.         }   
  412.     }   
  413.   
  414.     public static void traverseByLevel(BinaryTree tree, IHandler handler) {   
  415.         BinaryNode node = tree.getRoot();   
  416.         LinkedList<BinaryNode> level = new LinkedList<BinaryNode>();   
  417.         level.addLast(node);   
  418.         traverseByLevel(handler, level);   
  419.     }   
  420.   
  421.     private static void traverseByLevel(IHandler handler,   
  422.             LinkedList<BinaryNode> level) {   
  423.         if (level.isEmpty()) {   
  424.             return;   
  425.         }   
  426.         BinaryNode node = level.removeFirst();   
  427.         boolean isStop = handler.handle(node);   
  428.         if (isStop) {   
  429.             return;   
  430.         }   
  431.         if (node.isExistL_Child()) {   
  432.             level.addLast(node.getL_Child());   
  433.         }   
  434.         if (node.isExistR_Child()) {   
  435.             level.addLast(node.getR_Child());   
  436.         }   
  437.         traverseByLevel(handler, level);   
  438.     }   
  439. }   

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 07 Sep 2007 21:56:18 +0800 http://bill-end.javaeye.com/blog/121770 http://bill-end.javaeye.com/blog/121770 实践递归 bill.end 作者: bill.end  链接：http://bill-end.javaeye.com/blog/112681  发表时间: 2007年08月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

描述：1,2,3......n 从n中取出r个数。
例如：n=5，r=3
1-2-3，1-2-4，1-2-5，1-3-4，1-3-5，1-4-5
2-3-4，2-3-5，2-4-5
3-4-5

下面是我的解决方法，还有其他的方法么？

java 代码
  1. import java.util.ArrayList;   
  2. import java.util.Collections;   
  3. import java.util.HashSet;   
  4. import java.util.Iterator;   
  5. import java.util.List;   
  6. import java.util.Set;   
  7. import java.util.Stack;   
  8.   
  9. public class Combination {   
  10.     private List result;   
  11.     private int r = 4;   
  12.     private int n = 7;   
  13.   
  14.     public Combination() {   
  15.         result = new ArrayList();   
  16.         Stack permutation = new Stack();   
  17.         for (int i = 1; i < r + 1; i++) {   
  18.             permutation.push(i);   
  19.         }   
  20.         result.add(permutation);   
  21.     }   
  22.   
  23.     public static void main(String[] args) {   
  24.         Combination com = new Combination();   
  25.         com.compose(com.result.size());   
  26.         com.removeExisted();   
  27.         com.sortList();   
  28.         com.print();   
  29.     }   
  30.   
  31.     private void sortList() {   
  32.         List sorted = new ArrayList();   
  33.         for (Iterator iter = result.iterator(); iter.hasNext();) {   
  34.             Stack element = (Stack) iter.next();   
  35.             StringBuffer sb = new StringBuffer();   
  36.             for (Iterator iterator = element.iterator(); iterator.hasNext();) {   
  37.                 int i = (Integer) iterator.next();   
  38.                 sb.append(i + "-");   
  39.             }   
  40.             sb.deleteCharAt(sb.length()-1);   
  41.             sorted.add(sb.toString());   
  42.         }   
  43.         Collections.sort(sorted);   
  44.         result=sorted;   
  45.     }   
  46.   
  47.     private void removeExisted() {   
  48.         Set set = new HashSet();   
  49.         for (Iterator iter = result.iterator(); iter.hasNext();) {   
  50.             set.add(iter.next());   
  51.         }   
  52.         result.clear();   
  53.         result.addAll(set);   
  54.     }   
  55.   
  56.     private void print() {   
  57.         System.out.println("result:");   
  58.         for (Iterator iter = result.iterator(); iter.hasNext();) {   
  59.             String element = (String) iter.next();   
  60.             System.out.println(element);   
  61.         }   
  62.     }   
  63.   
  64.     private void compose(int size) {   
  65.         for (int i = 0; i < size; i++) {   
  66.             Stack element = (Stack) result.get(i);   
  67.             int max = (Integer) element.peek();   
  68.             if (max == n) {   
  69.                 return;   
  70.             } else {   
  71.                 Stack copyedS = copyStack(element);   
  72.                 ++max;   
  73.                 createNewComS(copyedS, max);   
  74.             }   
  75.         }   
  76.         compose(result.size());   
  77.     }   
  78.   
  79.     private void createNewComS(Stack original, int max) {   
  80.         for (int i = 0; i < r; i++) {   
  81.             Stack copyedS = copyStack(original);   
  82.             copyedS.remove(i);   
  83.             copyedS.push(max);   
  84.             result.add(copyedS);   
  85.         }   
  86.     }   
  87.   
  88.     private Stack copyStack(Stack element) {   
  89.         Stack copyed = new Stack();   
  90.         for (int i = 0; i < element.size(); i++) {   
  91.             int num = (Integer) element.get(i);   
  92.             copyed.push(num);   
  93.         }   
  94.         return copyed;   
  95.     }   
  96. }   

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 15 Aug 2007 23:12:43 +0800 http://bill-end.javaeye.com/blog/112681 http://bill-end.javaeye.com/blog/112681