BlogJava-如坐春风-随笔分类-Object Orient Programminghttp://www.blogjava.net/sitinspring/category/23516.html人生苦短，要紧跟自己的梦想，爱你所做的事业。zh-cnSat, 12 Apr 2008 02:37:04 GMTSat, 12 Apr 2008 02:37:04 GMT60三种权限设计方案的归纳和比较http://www.blogjava.net/sitinspring/archive/2008/04/10/191768.html如坐春风如坐春风Thu, 10 Apr 2008 02:20:00 GMThttp://www.blogjava.net/sitinspring/archive/2008/04/10/191768.htmlhttp://www.blogjava.net/sitinspring/comments/191768.htmlhttp://www.blogjava.net/sitinspring/archive/2008/04/10/191768.html#Feedback7http://www.blogjava.net/sitinspring/comments/commentRss/191768.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/191768.html阅读全文

如坐春风 2008-04-10 10:20 发表评论
]]>将阿拉伯数字转大写汉字程序的类http://www.blogjava.net/sitinspring/archive/2008/03/25/188587.html如坐春风如坐春风Tue, 25 Mar 2008 13:15:00 GMThttp://www.blogjava.net/sitinspring/archive/2008/03/25/188587.htmlhttp://www.blogjava.net/sitinspring/comments/188587.htmlhttp://www.blogjava.net/sitinspring/archive/2008/03/25/188587.html#Feedback1http://www.blogjava.net/sitinspring/comments/commentRss/188587.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/188587.html
阿拉伯数字等于：0 大写汉字等于：零整
阿拉伯数字等于：3.14159 大写汉字等于：叁点壹肆壹伍玖
阿拉伯数字等于：101.3 大写汉字等于：壹佰零壹点叁
阿拉伯数字等于：10203040506070809 大写汉字等于：壹萬兆零贰佰零叁兆零肆佰零伍億零陆佰零柒萬零捌佰零玖整
阿拉伯数字等于：7897645 大写汉字等于：柒佰捌拾玖萬柒仟陆佰肆拾伍整
阿拉伯数字等于：500000001000000 大写汉字等于：伍佰兆零壹佰萬整
阿拉伯数字等于：2435685 大写汉字等于：贰佰肆拾叁萬伍仟陆佰捌拾伍整
阿拉伯数字等于：5345438976 大写汉字等于：伍拾叁億肆仟伍佰肆拾叁萬捌仟玖佰柒拾陆整
  阅读全文

如坐春风 2008-03-25 21:15 发表评论
]]>设计构建一个软件程序的基本步骤探讨http://www.blogjava.net/sitinspring/archive/2008/01/26/177949.html如坐春风如坐春风Sat, 26 Jan 2008 13:19:00 GMThttp://www.blogjava.net/sitinspring/archive/2008/01/26/177949.htmlhttp://www.blogjava.net/sitinspring/comments/177949.htmlhttp://www.blogjava.net/sitinspring/archive/2008/01/26/177949.html#Feedback10http://www.blogjava.net/sitinspring/comments/commentRss/177949.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/177949.html数据的收集，整理，表现，存储和传输就是软件的主要任务，它们也是程序员的主要工作内容，也是程序员编写代码的最终目的。
那么该如何编写代码让软件完成它的主要任务呢？编写代码的过程是否有规律可循？编写代码需要注意那些方面的问题？本人想就这些问题罗列自己一些粗浅的看法，并大家进行一些探讨。  阅读全文

如坐春风 2008-01-26 21:19 发表评论
]]>使用泛型类简化服务层(Service)类的设计http://www.blogjava.net/sitinspring/archive/2007/12/28/171243.html如坐春风如坐春风Fri, 28 Dec 2007 08:47:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/12/28/171243.htmlhttp://www.blogjava.net/sitinspring/comments/171243.htmlhttp://www.blogjava.net/sitinspring/archive/2007/12/28/171243.html#Feedback2http://www.blogjava.net/sitinspring/comments/commentRss/171243.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/171243.html阅读全文

如坐春风 2007-12-28 16:47 发表评论
]]>一个解析文本中的信息并向对象赋值过程的思考.http://www.blogjava.net/sitinspring/archive/2007/12/07/166082.html如坐春风如坐春风Fri, 07 Dec 2007 08:35:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/12/07/166082.htmlhttp://www.blogjava.net/sitinspring/comments/166082.htmlhttp://www.blogjava.net/sitinspring/archive/2007/12/07/166082.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/166082.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/166082.html阅读全文

如坐春风 2007-12-07 16:35 发表评论
]]>私有的成员能被子类继承吗?http://www.blogjava.net/sitinspring/archive/2007/12/04/165288.html如坐春风如坐春风Tue, 04 Dec 2007 12:42:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/12/04/165288.htmlhttp://www.blogjava.net/sitinspring/comments/165288.htmlhttp://www.blogjava.net/sitinspring/archive/2007/12/04/165288.html#Feedback5http://www.blogjava.net/sitinspring/comments/commentRss/165288.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/165288.html
这个机制对于复杂的类体系中保护父类不被滥用很有好处.  阅读全文

如坐春风 2007-12-04 20:42 发表评论
]]>目录树的建立,遍历及批量删除http://www.blogjava.net/sitinspring/archive/2007/12/03/164988.html如坐春风如坐春风Mon, 03 Dec 2007 12:03:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/12/03/164988.htmlhttp://www.blogjava.net/sitinspring/comments/164988.htmlhttp://www.blogjava.net/sitinspring/archive/2007/12/03/164988.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/164988.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/164988.html阅读全文

如坐春风 2007-12-03 20:03 发表评论
]]>使用XML作为持久存储介质的解决方案续 http://www.blogjava.net/sitinspring/archive/2007/11/15/160696.html如坐春风如坐春风Thu, 15 Nov 2007 02:22:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/11/15/160696.htmlhttp://www.blogjava.net/sitinspring/comments/160696.htmlhttp://www.blogjava.net/sitinspring/archive/2007/11/15/160696.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/160696.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/160696.html阅读全文

如坐春风 2007-11-15 10:22 发表评论
]]>MVC1,MVC2简析http://www.blogjava.net/sitinspring/archive/2007/11/05/158343.html如坐春风如坐春风Mon, 05 Nov 2007 12:15:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/11/05/158343.htmlhttp://www.blogjava.net/sitinspring/comments/158343.htmlhttp://www.blogjava.net/sitinspring/archive/2007/11/05/158343.html#Feedback1http://www.blogjava.net/sitinspring/comments/commentRss/158343.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/158343.html阅读全文

如坐春风 2007-11-05 20:15 发表评论
]]>读写锁的OO分析http://www.blogjava.net/sitinspring/archive/2007/10/21/154652.html如坐春风如坐春风Sun, 21 Oct 2007 03:42:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/10/21/154652.htmlhttp://www.blogjava.net/sitinspring/comments/154652.htmlhttp://www.blogjava.net/sitinspring/archive/2007/10/21/154652.html#Feedback2http://www.blogjava.net/sitinspring/comments/commentRss/154652.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/154652.html1.不加任何限制,多见于读取写入都很快的情况,但有时也会出现问题.
2.对读写函数都加以同步锁,比如使用singleton模式,这下问题是没了,但效率也下去了,比如说两个读取线程不是非要排队进入不可.
3.读写锁,安全和效率都得到了解决,特别合适读线程多于写线程的情况.也就是下面将要展现的模式.

读写锁的本意是分别对读写状态进行互斥区分,有互斥时才加锁,否则放行.互斥的情况有:
1.读写互斥.
2.写写互斥.
不互斥的情况是:读读,这种情况不该加以限制.

我们只要让锁对象知道当前读写状态就可以了,再根据情况进行锁定和解锁,然后再分情况进行锁定.请看代码  阅读全文

如坐春风 2007-10-21 11:42 发表评论
]]>工人自动获取任务的OO分析http://www.blogjava.net/sitinspring/archive/2007/10/20/154437.html如坐春风如坐春风Sat, 20 Oct 2007 01:53:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/10/20/154437.htmlhttp://www.blogjava.net/sitinspring/comments/154437.htmlhttp://www.blogjava.net/sitinspring/archive/2007/10/20/154437.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/154437.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/154437.html
上次的情况是由调度员主动分配任务,但有些情况下需要工人自动取得任务而不是由调度员分配,这时需要对线程进行通知,使用的主要方法就是对象的wait(),notify(),notifyAll()三个函数,它们都必须从同步方法(synchronized method)中调用.  阅读全文

如坐春风 2007-10-20 09:53 发表评论
]]>调度员,工人及任务的OO分析过程.http://www.blogjava.net/sitinspring/archive/2007/10/05/150527.html如坐春风如坐春风Fri, 05 Oct 2007 04:52:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/10/05/150527.htmlhttp://www.blogjava.net/sitinspring/comments/150527.htmlhttp://www.blogjava.net/sitinspring/archive/2007/10/05/150527.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/150527.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/150527.html1.调度员将工件图纸交付给工人,这是任务的下达.
2.工人工作,完成工件,这是任务的进行过程.
3.工件完成后,工人将图纸和工件返还给调度员,或者到了确定的时间后由调度员去取.这是任务的完成.
4.重复上述三个步骤.

在这个流程中,还存在一些特征:
1.工人可以有多项任务,但他在一个时间只能做一个活,具体做那个由任务的优先级确定.
2.任务完成后要让调度员知道,现实中是工人来找调度员或者调度员找工人来实现的.

从上述情况分析,我们需要任务,工人,调度员三个类来完成建模,另外为了方便任务的存储和管理,还需要一个任务串类来辅助.
  阅读全文

如坐春风 2007-10-05 12:52 发表评论
]]>内容及其标志的OO分析过程(DB4O实现)http://www.blogjava.net/sitinspring/archive/2007/10/03/150284.html如坐春风如坐春风Wed, 03 Oct 2007 10:45:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/10/03/150284.htmlhttp://www.blogjava.net/sitinspring/comments/150284.htmlhttp://www.blogjava.net/sitinspring/archive/2007/10/03/150284.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/150284.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/150284.html阅读全文

如坐春风 2007-10-03 18:45 发表评论
]]>如何作出一个完善的分析复杂嵌套SQL语句的程序? (附上自己做的分析嵌套SQL语句的两个类)http://www.blogjava.net/sitinspring/archive/2007/09/17/145819.html如坐春风如坐春风Mon, 17 Sep 2007 05:12:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/09/17/145819.htmlhttp://www.blogjava.net/sitinspring/comments/145819.htmlhttp://www.blogjava.net/sitinspring/archive/2007/09/17/145819.html#Feedback4http://www.blogjava.net/sitinspring/comments/commentRss/145819.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/145819.html  阅读全文

如坐春风 2007-09-17 13:12 发表评论
]]>用分治法解决级联对象与相应XML之间的互相转化问题http://www.blogjava.net/sitinspring/archive/2007/09/17/145660.html如坐春风如坐春风Sun, 16 Sep 2007 16:25:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/09/17/145660.htmlhttp://www.blogjava.net/sitinspring/comments/145660.htmlhttp://www.blogjava.net/sitinspring/archive/2007/09/17/145660.html#Feedback4http://www.blogjava.net/sitinspring/comments/commentRss/145660.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/145660.html阅读全文

如坐春风 2007-09-17 00:25 发表评论
]]>使XML作为持久存储介质的解决方案http://www.blogjava.net/sitinspring/archive/2007/08/27/139918.html如坐春风如坐春风Mon, 27 Aug 2007 06:29:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/08/27/139918.htmlhttp://www.blogjava.net/sitinspring/comments/139918.htmlhttp://www.blogjava.net/sitinspring/archive/2007/08/27/139918.html#Feedback3http://www.blogjava.net/sitinspring/comments/commentRss/139918.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/139918.html
对一些需要将数据持久化的小型程序中,传统的关系型数据库显得庞大而不实用,而使用XML是一种较好的选择.本文将就设计一个合理的XML持久化的解决方案进行探讨.  阅读全文

如坐春风 2007-08-27 14:29 发表评论
]]>在C# WinForm程序中创建控件数组及相应的事件处理http://www.blogjava.net/sitinspring/archive/2007/08/04/134367.html如坐春风如坐春风Sat, 04 Aug 2007 00:18:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/08/04/134367.htmlhttp://www.blogjava.net/sitinspring/comments/134367.htmlhttp://www.blogjava.net/sitinspring/archive/2007/08/04/134367.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/134367.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/134367.html
总结起来,在C#中创建控件数组很简单,首先在类中创建一个控件类型的数组,然后初始化它,具体初始化是动态创建还是链接到已有控件可以根据情况自行选择,然后为数组元素添加事件,最后实现事件即可,在事件实现中即可以通过转化sender来得到相应控件.
  阅读全文

如坐春风 2007-08-04 08:18 发表评论
]]>更适合Swing程序的MVC方案http://www.blogjava.net/sitinspring/archive/2007/07/19/131268.html如坐春风如坐春风Thu, 19 Jul 2007 06:47:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/07/19/131268.htmlhttp://www.blogjava.net/sitinspring/comments/131268.htmlhttp://www.blogjava.net/sitinspring/archive/2007/07/19/131268.html#Feedback4http://www.blogjava.net/sitinspring/comments/commentRss/131268.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/131268.html
在Swing程序中,我们通常采用让View实现Observer接口,让Model继承Observable类来实现MVC1,而让Controller把它们创建及连接起来,具体代码如下:
public class XXXControl {
    private XXXModel model = null;
    private XXXView view = null;

    public XXXControl() {
        model = new XXXModel();
        view = new XXXView();
        model.addObserver(view);
     }

.
.
.
}

而Model进过处理后得到了结果,它采用Observable的notifyObservers()方法来通知View进行改变,而View的public void update(Observable o, Object arg)方法将相应这一改变,它通过解析Observable类型的对象o得到处理结果,再进行具体的表现层改变.

粗看起来MVC各司其职,很完美,但还有不和谐的隐患:
1.View必须知道解析Model,造成了二者的耦合.
2.View非得实现Observer接口,Model非得继承Observable类,这个处理不是必要的.
3.这种模式只适合即时处理,即相应很快的处理,对于耗时过程并不适合.
4.由于Model中数据众多,很多时候我们还需要建立一个常量类来区分各种情况和决定View更新的地方,进一步加重了类之间的耦合程度.

综上,我觉得对于稍大的Swing程序,MVC2+线程回调方式更适合,它的主要处理是:
1.依然由Controller创建View和Model,它们担负的职责也和原来一样,但是View不实现Observer接口,Model不继承Observable类,它们该怎么样还是怎么样,而让Controller来充当它们之间的中介者.
2.如果是即时处理,可以在Controller中添加事件处理时就直接写来.如果是耗时处理,可以将View和Model的引用(或Model中元素的引用)传递给一个线程处理类,具体的运算和界面反应在线程处理类中完成.
下面是一个调用例子:
new FetchTablesThread(model.getDataSource(), view,schema).start();

下面是线程类的例子:
public class FetchTablesThread extends BaseThread {
    private static Logger logger = Logger.getLogger(FetchTablesThread.class);

    private String schema;

    public FetchTablesThread(DataSource dataSource, SqlWindowView view,
            String schema) {
        super(dataSource, view);
        this.schema = schema;
    }

    public void run() {
        OutputPanel outputPanel = view.getTabbedPanel().getInputOutputPanel().getOutputPanel();

        try {
            if (dataSource.getDbtype().equals("mysql")) {
                // Specail Process for MySql
                new FetchTables4MySqlThread(dataSource, view, schema).start();
            } else {
                // Ordinary Process for other DB
                List tables = dataSource.getTablesInSchema(schema);

                if (tables.size() > 0) {
                    // Find tables under schema
                    view.getCatalogTablesPanel().getMultiTable().refreshTable(
                            tables);

                    outputPanel.showText(true);
                    String text = "Find " + tables.size()
                            + " tables under schema:" + schema
                            + " successfully!";
                    outputPanel.appendOutputText(text);
                    logger.info(text);
                } else {
                    // Can't find tables under schema
                    outputPanel.showText(true);
                    String text = "Can't find any table under schema:" + schema;
                    outputPanel.appendOutputText(text);
                    logger.info(text);
                }
            }
        } catch (Exception ex) {
            outputPanel.showText(true);
            String text = "Can't find any table under schema:" + schema+" and errorMsg="+ex.getMessage();
            outputPanel.appendOutputText(text);
            logger.info(text);            
        }
    }
}

这样做有两个好处一是使程序结构松散化,适于修改,二是相对传统的MVC2,Controller中事件处理的代码也容易变得简单而清晰,可维护性更佳.

综上,我认为MVC2+线程回调方式是一种值得推荐的Swing桌面程序写法.

关于线程回调方式,您可以参考:
http://www.blogjava.net/sitinspring/archive/2007/06/28/126809.html

关于MVC,您可以参考:
http://junglesong.yculblog.com/post.2665424.html

如坐春风 2007-07-19 14:47 发表评论
]]>关于权限系统的设计http://www.blogjava.net/sitinspring/archive/2007/06/11/123330.html如坐春风如坐春风Mon, 11 Jun 2007 02:55:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/06/11/123330.htmlhttp://www.blogjava.net/sitinspring/comments/123330.htmlhttp://www.blogjava.net/sitinspring/archive/2007/06/11/123330.html#Feedback6http://www.blogjava.net/sitinspring/comments/commentRss/123330.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/123330.html
对于这样的系统一种常见的处理方式是固化，就是按等级给定权限，比如部门经理拥有所有项目的CRUD权限，项目经理只对自己的项目有CRUD权限，一般成员只有R权限，这样的设计不能完全反映现实的关系。只能用于非常僵化的场合。

实际上，项目，成员的关系类似于房间的门和人的关系，载它们之间加上钥匙一切都迎刃而解。

钥匙定义如下
class Key{
       int projectId;// 项目的唯一ID
       boolean create;
       boolean read;
       boolean update;
       boolean delete;
}

钥匙串定义如下：
class KeyBunch{
      Map  buch;// 里面放的钥匙的hashMap
       
      boolean isCanAccess(Project project){
           .....
      }
}

然后把钥匙串作为Member类的一个子项就可以了,Key由Project类生成,然后附加到Member类的KeyBunch中,其它函数可以根据情况书写.

这样,有了Key类和KeyBunch类,Project类和Member类的权限关系就变得合乎自然了,Project类和Member类也进一步解耦.

老子曰"人法地,地法天,天法道,道发自然",真是一语中的.

如坐春风 2007-06-11 10:55 发表评论
]]>使用异常处理解决执行时有多种命令行参数的问题http://www.blogjava.net/sitinspring/archive/2007/06/08/122817.html如坐春风如坐春风Fri, 08 Jun 2007 04:23:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/06/08/122817.htmlhttp://www.blogjava.net/sitinspring/comments/122817.htmlhttp://www.blogjava.net/sitinspring/archive/2007/06/08/122817.html#Feedback1http://www.blogjava.net/sitinspring/comments/commentRss/122817.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/122817.html原执行方式是这样的:
>program  settingFilePath
其中settingFilePath是xml格式

要求追加这样的执行方式
>program param01 param02 ....

面对这样的需求,程序结构无需有大的变动,使用try...catch...来增加一种异常处理即可

变化后的程序结构如下:
try{
     // 进行原有处理
     ......
}catch(IllegalSettingFileException ex){
    // 进行命令行方式处理
}
....

因为原程序处理时会读取设定文件,取出其中信息,如果文件不存在或者取得的参数不正确则会抛出IllegalSettingFileException 异常,这时我们让它再执行追加的处理方式即可.即程序发现按第一种方式执行不了时,会按第二种方式运行.我觉得这比分支判断更简单且易于扩充,是比较好的一种处理方式.





如坐春风 2007-06-08 12:23 发表评论
]]>从一个例子的重构过程谈开来http://www.blogjava.net/sitinspring/archive/2007/06/06/122326.html如坐春风如坐春风Wed, 06 Jun 2007 03:37:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/06/06/122326.htmlhttp://www.blogjava.net/sitinspring/comments/122326.htmlhttp://www.blogjava.net/sitinspring/archive/2007/06/06/122326.html#Feedback2http://www.blogjava.net/sitinspring/comments/commentRss/122326.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/122326.html阅读全文

如坐春风 2007-06-06 11:37 发表评论
]]>能为你的程序锦上添花的五种程序组织形式http://www.blogjava.net/sitinspring/archive/2007/06/05/122119.html如坐春风如坐春风Tue, 05 Jun 2007 05:00:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/06/05/122119.htmlhttp://www.blogjava.net/sitinspring/comments/122119.htmlhttp://www.blogjava.net/sitinspring/archive/2007/06/05/122119.html#Feedback10http://www.blogjava.net/sitinspring/comments/commentRss/122119.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/122119.html形式二."只管结果,不顾过程":从集合中取区间元素时,直接从上下限之间取来,让try...catch...去处理越界的事.
形式三."奉旨行事":在查询中,如果把查询条件和遴选过程分开来更有益,程序也因此解耦合.这才是OO化的查询.
形式四."化繁为简":将多个分支语句变换为一个查表结构,这样做对扩充程序结构,修改具体数额都很方便,使程序更易于维护.还可以把归结出的表结构放在持久介质中如XML文件,数据库等,用到的时候再取,这样做在条件变化时不需要修改程序.
形式五."分而治之":将分支语句的执行部分分散到单独的类中处理,降低了系统耦合度,程序也更容易维护.  阅读全文

如坐春风 2007-06-05 13:00 发表评论
]]>以相声为切入点谈谈继承,接口和抽象类http://www.blogjava.net/sitinspring/archive/2007/06/04/121715.html如坐春风如坐春风Sun, 03 Jun 2007 17:33:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/06/04/121715.htmlhttp://www.blogjava.net/sitinspring/comments/121715.htmlhttp://www.blogjava.net/sitinspring/archive/2007/06/04/121715.html#Feedback1http://www.blogjava.net/sitinspring/comments/commentRss/121715.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/121715.html继承,接口,抽象类的区别是面试官最喜欢问的问题,因为编程中常用,这里不想说那些老生常谈,只想借相声打个比方.

继承好比家学渊源,所谓"忠厚传家久,诗书继世长",家长总会潜移默化的影响下一代,下一代也会在不经意中学习前辈的特点,但因为年少分辨能力不高加上世易时移有些优点已经不再是有点甚至会变成缺点,下一代会把前辈的优缺点不分良莠的继承下来.这也是日后出现问题的根源.

接口好比拜师学艺,"入了这个门,就得说这行话",比如相声界说学逗唱四门是必须要学的,但是"师傅领进门,修行在个人",学得怎么样还全看自己,指望不费力的继承什么是不可能的,具体功夫还得个人来过. 因为是自己来,具体实现成什么样自由度也很大,比如四门功课中的"唱",原指唱太平歌词,但因为爱听的少,现在相声演员已经不要求这个了,改为唱歌唱戏的唱,其实严格界定的话是"学"的一种.这也无所谓对错,郭德刚坚持唱太平歌词也行,笑林唱流行歌曲也不错,总之实现了就可以,实现得怎么样则留给实践来检验.一个类可以同时实现多个接口,就和艺人拜几个师傅是没有问题的,郭德刚就同时实现了大鼓和相声两个接口.

抽象类则介于继承和接口之间,既可不费力的从上一代继承,也可强制实现某接口,有如某大师收自己的孩子为徒,当然相声界不让这么干,其它曲艺行业还是可以的,比如京剧界的梅兰芳和其子梅葆玖,既有言传身教,也有强制实现,综合了继承和接口的特点.

具体怎么用它们要看实际需要,如果是为了实现继承体系,当然是用继承;如果只是强制子类必须和父类统一口径,自然是用接口;如果子类说统一口径行,但必须给我些东西,那还是用抽象类不可.


如坐春风 2007-06-04 01:33 发表评论
]]>使用XML文件作为Web系统持久层的OO分析过程http://www.blogjava.net/sitinspring/archive/2007/06/03/121640.html如坐春风如坐春风Sun, 03 Jun 2007 08:15:00 GMThttp://www.blogjava.net/sitinspring/archive/2007/06/03/121640.htmlhttp://www.blogjava.net/sitinspring/comments/121640.htmlhttp://www.blogjava.net/sitinspring/archive/2007/06/03/121640.html#Feedback0http://www.blogjava.net/sitinspring/comments/commentRss/121640.htmlhttp://www.blogjava.net/sitinspring/services/trackbacks/121640.html
最容易直接想到的是一个类完成节点的CRUD及IO操作,但这违反了类的设计原则--类应当只有一个中心任务.

所以按功能来分我们必须要两个类:
一个类负责节点CRUD操作;// 简称CrudClass
一个类负责节点的IO操作;// 简称IoClass

这样基本可以了,再细分下去没有必要.

再来看第一个类,它是直接与一批业务代码打交道的,
首先要求速度要快,如果把解析出来的Dom放在类里,一则CrudClass做了IoClass做的事,二再速度上也上不去,所以这里我把dom里面的节点对应成了一个链表,一个值和一个Map,业务代码实际处理的就是这三个东西,他们不关心也不必要知道是否存储到了文件里,而且速度上得到了充分保证.
其次各个业务代码处理的是同一事务,这里再把CrudClass做成单例(Singleton)形式的,做成全静态也可以,但这种做法不太上台面.

IoClass是CrudClass的持久化操作,他们之间实际是仓库管理员和物流调度间的关系,这种关系有以下三种实现方式:
1.在他们间实现观察者模式,由IoClass来观察CrudClass,变化后写入文件.初看这种方式很好的完成了解偶,实际上IoClass还是需要知道CrudClass的细节,否则无法更新,而且创建IoClass的过程比较麻烦,客观世界可没有这样的处理.所以说观察者处理当抛弃.
2.将IoClass作为CrudClass的成员,这种方式避免了IoClass创建的不必要的复杂过程,而且CrudClass知道IoClass的处理接口就行了,IoClass无需知道CrudClass的任何部分,实现了有效解偶,其三符合现实世界,IoClass确实应该是CrudClass的下级,只接受CrudClass指派的任务而外界无须知道IoClass,完全不必知道.
3.将IoClass独立处理出来,与CrudClass等做成JMS异步通信方式或WebService通信方式,这个想法更OO,但是成本比较高,复杂度大,在大型系统可以考虑实现这种方案.

综合上面的意见,选择方案2是最适合的.

至此对一个XML文件进行CRUD操作的系统设计完成,再适当剥离一些通用代码形成实用类就差不多了,这里不再赘述.

还是那句老话,道法自然.程序实现可以有N种实现方式,我们应该选择最符合自然的一种.


如坐春风 2007-06-03 16:15 发表评论
]]>