BlogJava-生活源于奋斗不息 - 不在能知而在能行!!-随笔分类-编程思想

对视图与Tag的联想

姜利阳 — Tue, 30 Jan 2007 15:44:00 GMT

在数据库系统当中视图处于外模式状态（表为模式，　底层的数据结构为内模式）

在关系型数据库表设计当中，有几种设计范式，其最终的目的是，减少维护工作量.包括完整性约束
其的做法就是将一个实体拆分成一个个子实体，并由他们的ＩＤ及外键关系将他们组织起来，
如果一个子实体改变的话，维护起来，只要修改一个地方就可以了，非常方便.

但引来了新的问题，这些表里面所存的记录都是ＩＤ，并不是真正的值，　如学生表里面是班级字段是个ID,并不是名称，显示起来比较麻烦.

这时，视图出现了，弥补了这些不足（当然还有＂增值服务＂ : ) ）
视图就是在表的基础之上，按不同的角度去看待数据.　提取出所要求的数据

在ＶＣ＋＋编程当中，　ＭＦＣ也封装了一个Document/View模型，即文档／视图模型，其原理思想与数据库的视图大同小异.

那现在流行的Web2.0 Tag呢？　也一样.
Tag:　对于一件事情，站在不同的角度，立场　所看到的内容.　所联想到的关键字.
如：一则战争新闻，　Tag可以［战争　，　和平　，　美国　，　军事　...］都有可以.　在于你从中联想到什么.

一句话，对于这些，都是横看成岭侧成峰

姜利阳 2007-01-30 23:44 发表评论

谈对象之间的关系

姜利阳 — Tue, 30 Jan 2007 14:02:00 GMT

对象与对象之间的关系有以下几种关系
   1)继承
         1) 一种父子关系
         2) 有共同特点 , 或者有普通和特殊关系
         3) 如: 一种进化关系, 如: 有机物 --> 蛋白质 --> 微生物 --> 动物 --> 人

   2) 依赖
         1) 就是一个对象调用被依赖对象中的某些方法而得以完成这个对象的一些职责
         2) 这是一种比较松散的关系 , 并且这是短期的. 我们的过程与对象往往依赖于我们的实体域对象
         3) 如: WebWork中的Action 依赖于业务层中的方法 ,  业务层中的Service或者Bussiness依赖于持久层(DAO)中的方法等等 ( 如果碰到这种关系 , 通常用面向接口编程的方法来处理, 使其具有更好的扩展性, 维护性)

   3) 关联

         1) 指一个类指到另一个类中的属性.

         2) 而且是长期的

         3) 关联关系又可以分为以下几种
               0) 一般关联: 只要一个对象联系到另外一个对象就形成了关联关系

               1) 聚合关系 , 较强于一般关联 , 有整体与局部之间的关系,并且没有了整体,局部也可单独存在,如小组与小组里面的成员, 小组不存在, 成员也可单独存在 , 也可加入其它小组, 又如: 一个分子由多个原子按一定的结构,排列组织而成, 在化学变化时(针对原子的操作),按这个角度去看 , 原子之间会脱离开,另外合成另一种物质. 其组成关系可以共享

               2) 组合关系 , 也叫合成关系 , 是一种更强的整合与局部的关系 , 其关系更加紧密 ., 如: 一个分子由多个原子按一定的结构组织而成, 在物理变化中(针对分子的操作), 按这个角度去看 , 分子间发生变化 , 变成另一种状态, 但分子结构不变, 还是这种物质. 其组成关系多原子组成结构不可以共享.

----------------------------------------------------------------------------------------------------------------

姜利阳 2007-01-30 22:02 发表评论

[UML基础与Rose建模]-----读书笔记.面向对象

姜利阳 — Sat, 06 Jan 2007 04:34:00 GMT

面向对象方法使用对象,类,继承,封装等一些核心元素进行程序设计.客观实体与实体之间的联系构成了现实世界的所有问题.面向对象技术通过将客观实体抽象成对象的方法，尽可能地利用人类自然的思维方式构造软件系统

面向对象技术概述
1. 面向对象的基本概念
  1. 基本观点
    1. 客观世界由对象组成，任何客观实体都是对象，复杂对象可以由简单对象组成
    2. 具有相同数据和操作的对象可以归纳成类，对象是类的一个实例
    3. 类可以派生出子类，子类除了继承父类的全部特性外还可以有自己的特性
    4. 对象之间的联系通过消息传递来维系。由于类的封装性，它具有某些外界不可见的数据，这些数据只能通过消息请求调用可见方法来访问
    5. 面向对象的基本出发点就是尽可能地按照人类认识世界的方法和思维方式来分析和解决问题，使人们分析，设计一个系统的方法尽可能接近认识一个系统的方法
  2. 对象
    1. 客观世界里面的任何实体都可以被称之为对象
    2. 对象可以是有形的物，如汽车，飞机
    3. 也可以是无形的事物与概念，如事件，规则，计划，活动等等
    4. 复杂的对象可由相对比较简单的对象以某种方式组成，甚至整个世界也可以从一些最原始的对象开始，层层组合而成。
    5. 对象在软件生命周期当中的各个阶段可能有不同的表示形式。
      1. 如：在分析与设计阶段，对象表现为某种OOA／OOD方法给出的粗略定义
      2. 而在编程阶段表现为一种程序设计语言写出的详细而明确的源程序代码
    6. 如一台收音机对象的实例：
      1. 整个收音机封装也如下行为
        调节声音
        关闭
        打开
        调节频道
        ...
      2. 同时也封装了内部状态
        音量
        频道
        打开还是关闭
        ....
      3. 这些状态值可以，也只能通过上面的行为来得以改变。
  3. 封装
    1. 封装也是面向对象的一个重要原则
    2. 封装指把状态与行为，属性与操作，数据与方法封装到一个对象里面。它的内部信息对外隐藏，不允许外界直接修改对象的属性，只能通过对象提供的有限的接口来对对象的属性数据进行修改，操作。
    3. 对于外界而言，只能知晓对象的外部行为而无法了解对象内部实现细节，这样可以保证对象内部状态，属性，数据的安全性
    4. 总的来讲，封装有两层含义
      1. 结合性
        将对象的全部属性与方法结合起来，形成一个独立的不可分割的单位
      2. 信息隐蔽性
        即尽可能的隐蔽对象内部细节，对外形成了一个边界，只保留有限的对外接口使这与外部发生联系
    5. 封装的基本单位是对象
      1. 如：一块集成电路被封装起来，其内部电路是不可见的。
      2. 集成电路的使用者只关心芯片引脚的个数，引脚的电气参数以及引脚所提供的功能
      3. 通过这些引脚，使用者对这个电路芯片的功能就有大致的了解，便可以使用这块芯片组装成具有一定功能的产品
    6. 封装的目的在于将对象的使用者与设计制造者分离，使用者不必知道行为实际的细节，只需向这个对象发送相应的消息访问访对象即可。
    7. 将定义模块（即使用模块）与实现模块分开（可参考“开闭原则.面向接口编程”），可以大大提高软件的可维护性，可修改性。
  4. 消息
    1. 对象通过对外提供的服务在系统中发挥自己的作用
    2. 当系统中其它对象请求该对象执行某个服务时，些对象就响应这个服务以完成服务所需求的职责
    3. 消息就是面向对象发出的请求，一个消息包含
      1. 消息名
      2. 接收对象的标志
      3. 服务标志
      4. 输入信息
      5. 回答信息
    4. 当一个消息发送给某个对象时，包含要求接收对象去执行某些活动的信息。接收到消息的对象经过解释，然后予以响应。这种通信机制叫做消息传递。
    5. 面向对象技术的封装机制使得对象相互独立，各个对象要相互协作实现系统的功能就少不了消息传递机制。
    6. 某一个对象在执行相应的处理时，如果需要，它可以通过传递消息请求其它对象完成某些处理工作或者回答某些信息，其它对象在执行所要求的处理活动时，同样也可以通过传递消息与另的对象取得联系。
    7. 在对象传递消中只包含发送者的要求，它指示接收者需要完成哪些处理，但并不告诉接收者应该如何完成这些处理，接收者接收到消息后要独立决定采用什么方式完成所需的处理。
    8. 一个对象能够接收多种形式，内容不同的消息，相同形式的消息可以送往不同的对象，不同的对象对于形式相同的消息可以有不同的解释，做出不同的响应。
  5. 类
    1. 类是一组具有相同的数据结构和相同的操作的对象的集合。类是对象的抽象，它将一组属性和在数据上的一组合法操作抽象封装。
    2. 类好比是对象模板，模型，基于类就可以生成多个具有不同属性值的对象，在类的定义当中，可以为某个属性指定一个值，作为它的默认值。
  6. 继承
    1. 继承指子类可以拥有父类的全部属性与操作
    2. 这个使用已存在的定义作为基础建立新定义的技术使用父类与子类之间能够共享数据与方法
    3. 在现实世界建模时，可以根据事物的共性抽象出一批基类，在基类的基础之上，事物可以根据个性添加自己的属性与操作，抽象出新的对象类。
    4. 这些新类既有基类的全部属性与操作，又有自己的属性与操作，被称之为基类的子类或者派生类，基类被称之为父类或者超类。这种产生子类的方法叫继承
    5. 继承又可以分为两种：
      1. 单重继承
        一个子类只能有一个父类
        这种继承链最终关系结构是一棵自顶向下的树，顶部表示根基类，一直向下发展，延伸
      2. 多生继承
        一个子类有多于一个的父类
        这种继承链最终关系结构是图
    6. 继承简化了世界的描述，定义子类时不必重复定义那些在父类中已经定义过的属性与操作，而只需专注于自己特有的属性与操作
  7. 多态性
    1. 多态性是面向对象技术的一个重要概念。
    2. 同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。这就是多态。
    3. 多态性通常通过重载基类的方法来实现
    4. 多态性可以分为两种
      1. 编译时的多态。
        编译时的多态性是通过重载来实现的，系统在编译时，根据传递的参数信息决定实现何种操作。
      2. 运行时多态
        运行时的多态就是指到系统运行时，才根据实现情况决定实现何种操作
    5. 多态大致有以下3种实现方式
      1. 通过接口实现多态。
      2. 通过继承实现多态。主要是重写基类的操作以提供不同的实现
      3. 通过抽象类实现多态
        抽象类为多态的实现提供了极大的灵活性
        因为它同时提供继承和接口的元素。
    6. 结构与连接
      1. 为了使系统能够有效地映射问题域，系统开发者需认识并描述对象之间的以下几种关系
        对象的分类关系
        对象之间的组成关系
        对象属性之间的静态联系
        对象行为之间的动态联系
      2. 面向对象方法分别利用
        一般／特殊结构
        整体／部分结构
        实例连接／消息连接，来描述对象之间的上述四种关系
      3. 一般／特殊结构：
        又称为分类结构，是一组由一般／特殊关系的类所组成的结构
        它是以一个类为节点，以继承关系为边的连通有向图，
        由仅存在单继承的类构成的结构称为层次图。层次图是一种树形图
        由存在多继承的类构成的结构称为网络图，网络图是一个网状结构。
      4. 整体／部分结构
        又称为组装结构，如组装电脑一样。
      5. 实例连接
        实例连接反映了对象与对象间的静态关系。
      6. 消息连接
        消息连接描述对象之间的动态联系。
        若一个对象在执行服务时需要通过消息请求其它对象为它完成某个服务，则表明第一个对象与第二个对象之间存在着消息连接
        消息连接是有向的，从消息发送者指向消息接收者。
2. 面向对象的开发语言
  1. 面向对象的软件开发不仅限于编码，还包括系统前期分析与设计，
  2. 这里所说的设计就是第1
3. 面向对象的分析设计与开发工具

姜利阳 2007-01-06 12:34 发表评论

积累的过程....

姜利阳 — Mon, 04 Dec 2006 01:22:00 GMT

什么东西都有一个过程,
一个积累的过程
一个从量变到质变的过程
有的过程相对比较短暂,有的过程相对比较漫长

学一门Java语言可以只需要几个礼拜,但领会这里面的思想(这种思想是触类旁通的)却可能要几月,几年,甚至几十年........
象象棋一样,掌握它里面的游戏规则可能只要半天,一天,或者几天,但要想领会象棋的游戏规则,并在这一领域达到比较高的层次,可能要经过几年,几十年的不断领会与琢磨.

姜利阳 2006-12-04 09:22 发表评论

[设计模式]-----Factory Method模式

姜利阳 — Sat, 02 Dec 2006 05:59:00 GMT

一 ,  工厂方法（Factory Method）模式的之定义
工厂方法模式的意义就是定义创建产品对象的工厂接口,将实际的创建工作交给下一级具体工厂去负责.
核心的工厂类不再负责具体产品的创建,这样核心类就成为一个抽象工厂角色,仅仅负责(具体工厂要实现)接口定义.这样进一步抽象的好处就是:工厂方法模式可以使系统在不修改具体工厂角色的情况通过增加新的具体工厂角色下引进新产品.

二 , 工厂方法模式的角色关系
1) 抽象工厂(Creator)角色:
   工厂方法模式的核心,与应用程序相关逻辑无关,任何创建产品对象的具体工厂类都必须实现抽象工厂的接口

2) 具体工厂(Concrete Creator)角色:
实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建该产品对象

3) 抽象产品角色:
   工厂方法模式所创建的产品对象,这是一种产口超类,也就是产品对象的共同父类,或者是共同拥有的接口

4) 具体产品角色:
   这个角色实现了抽象产品所定义的接口,即抽象产品角色的实现类. 具体产品的创建由具体工厂来创建

三 , 示例
1) 抽象工厂角色:

1 //抽象工厂角色,工厂模式的核心,定义要生产何种产品! 在这里为该工厂生产手机和CPU
2 public interface   AbstractFactory
3 {
4     public Mobile createMobile();
5     public CPU createCPU();
6 }

2) 具体工厂角色:
工厂一:专门生产TCL手机与IntelCPU

1 public class FactoryNO1 implements AbstractFactory
2 {
3     public Mobile createMobile()
4     {
5         return new TCLMobile();
6     }
7     public CPU createCPU()
8     {
9         return new IntelCPU();
10     }
11 }
12

工厂二:专门生产Nokia手机与ADMCPU

1 public class FactoryNO2 implements AbstractFactory
2 {
3     public Mobile createMobile()
4     {
5         return new NOKIAMobile();
6     }
7     public CPU createCPU()
8     {
9         return new AMDCPU();
10     }
11 }
12

3) 抽象产品角色

1 //手机产品
2 public interface Mobile
3 {
4 }
5
6 //CPU产品
7 public interface CPU
8 {
9 }
10

4) 具体产品角色

1 public class TCLMobile implements Mobile
2 {
3 }
4
5 public class NOKIAMobile implements Mobile
6 {
7 }
8
9 public class IntelCPU implements CPU
10 {
11 }
12
13 public class AMDCPU implements CPU
14 {
15 }

5) 使用

1 public class TestFactoryMothod
2 {
3     AbstractFactory factory = new FactoryNo1();
4     Mobile tCLMobile = factory.createMobile();
5     //
6 }

总结：
工厂方法模式四种角色，当系统扩展需要添加引进新产品时，仅仅需要添加一个具体产品及具体工厂类即可，原有的工厂对象不用去修改它，这也符合了ＯＣＰ开闭原则,对扩展开放，对修改关闭.

参考: http://dev.yesky.com/48/2483548.shtml

姜利阳 2006-12-02 13:59 发表评论

[设计模式]-----概述

姜利阳 — Fri, 01 Dec 2006 15:20:00 GMT

设计模式,是前辈们经过长期的实践积累下来的宝贵的面向对象设计分析的经验
它不仅仅适用于Java语言,凡是面向对象的语言,Java , C++ , .Net等甚至是Javascript也可以采用这些模式.
这是一个编程思想,相对于古代武林高手而言,这是一种内功修行.在OOP领域要想更进一层,这可以说是必不可少的学习部分.
下面就简单地从大的方面列举各种模式
GOF的23种设计模式
1) 创建型 Creational patterns
Factory Method
Abstract Factory
Builder
Prototype
Singleton

2) 结构型 Structural patterns

Adapter_Class
Adapter_Object
Bridge
Composite
Decorator
Facade
Flyweight
Proxy

3) 行为型 Behavioral patterns
Interpreter
Template Method Bridge

Composite
Decorator
Facade
Flyweight
Proxy Chain of Responsibility
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor

姜利阳 2006-12-01 23:20 发表评论

[OO原则]-----开闭原则OCP

姜利阳 — Fri, 01 Dec 2006 02:15:00 GMT

Open-Close Priciple
软件实体应当对扩展开放，对修改关闭，即软件实体应当在不修改（在Java当中可能通过代理模式来达到这个目的）的前提下扩展
这一点对于软件的可维护性来说,能很灵活地适应软件的不断变化。对于评价软件的可维护性而言，提供了一个依据。
另一方面,开闭,也代表:能不开放的属性或者方法就不开放.仅仅开放必须的接口.

设计模式的应用就是使软件的结构在一定程度上面符合这个原则

开闭原则，仅仅是原则，并没有指明具体的实现方法，其实也很难指明，不同的编程语言，不同的应用领域可能实现的方法都不一样。

一, 面向对象编程我们常见的是“面向接口编程”
   1) 降低程序各部分之间的耦合性，使程序模块互换成为可能
   2) 使软件各部分便于单元测试，通过编制与接口一致的模拟类（Mock），可以很容易地实现软件各部分的单元测试
   3) 已于实现软件的模块的呼唤，软件升级时可以只部署发生变化的部分，而不会影响其它部分

二,封装变化
   将可以发生变化的部分封装成一个对象,如: 状态, 消息,,算法,数据结构等等 , 封装变化也是实现"开闭原则"的一个重要手段
如经常发生变化的状态值,如温度,气压,颜色,积分,排名,等等,可以将这些作为独立的属性,如果参数之间有关系,有必要进行抽象
对于行为,如果是基本不变的,则可以直接作为对象的方法,否则考虑抽象或者封装这些行为.
   封装尽可能变化的部分,在OOD当中,对象不仅仅是现实在存在的事物,任何可能的变化的部分都是候选对象...

三,采用组合来代替继承
   依据开闭原则,我们尽量不要修改类,只扩展类,但在有些情况下会出现一些比较怪异的状况.这时可以采用几个类进行组合来完成.

姜利阳 2006-12-01 10:15 发表评论

[设计模式]-----代理模式

姜利阳 — Thu, 30 Nov 2006 14:36:00 GMT

一 , 代理的定义

代理模式在设计模式中的定义: 为其它对象提供一种代理以控制对这个对象的访问
在一些情况之下客户不想或者不能直接引用一个对象,而代理对象可以在客户和目标对象之间起到了中介作用,
屏蔽客户不能看到的内容,服务或者添加客户需要的额外的服务

那在什么情况下使用代理模式呢?对原有方法使用时出现需要对原有方法进行修改,这时有两种改进方法:

   1) 修改原有方法以适应现在的使用方式.
   2) 使用"第三者"方法来调用原有方法并且对原有方法产生的结果进行控制.

第一种方法明显违背了开闭原则(对扩展开放,对修改关闭), 而且在原有的方法当中修改可能使得原有类的功能变得模糊和多元化
而使用第二种方法则将功能划分得更加清晰,有助于后面的维护.在一定的程度上选择第二种更加合适.

二 , 代理的分类

根据对代理的分类,常见的代理有:
1) 远程代理(Remote proxy) : 对一个位于不同的地址空间对象提供一个局域代表对象.如: 你可以将一个在世界某个角落中的计算机通过代理假象成你局域网的一个对象.

2) 虚拟代理(Virtual proxy): 根据需要将一个资源消耗很大或者比较复杂的对象,延迟加载,在真正需要的时候才创建.如一张很大的图片,需要很长的时间才能显示出来,那么当这个图片包含在文档当中时,用浏览器或者其它编辑器打开时,大图片可能影响了文档的阅读,这时就需要用一个图片Proxy来代替这个图片.

3) 保护代理(Protect or Access Proxy): 控制对一个对象的访问权限,比如在windows操作系统的用户在登陆系统时,普通用户和系统管理员,能做什么,不能做什么,拥有的权限是不一样的,使用代理模式可以控制权限.

4) 智能引用(Smart Reference Proxy): 提供比目标对象额外的服务,功能.如: 计数器.....提供一些友情提示...

三 , 结构

代理模式中的"代理"要想实现代理任务,就必须和被代理的目标对象使用共同的接口,比如说产品代理商要能够销售厂家的产品(共同的接口:厂家的销售部门也能够销售产品). 那么在Java当中使用抽象类或者接口来实现这个共同的接口.

那么代理模式就有三个角色组成了:

1) 抽象主题角色: 声明了真实主题和代理主题共同的接口

2) 代理主题角色: 内部包含了对真实主题的引用,并且提供对真实主题的角色的相同接口.

3) 真实主题角色: 定义真实的对象

它们之间的关系如下:

                     抽象主题角色
                     |                      |
          代理主题   --->   真实主题

这时,大家已经对代理模式应该有一个宏观的认识.

四 , 举例

以windows操作系统中用户 , 系统管理员具有添加用户功能,而普通用户则不行.

1) 抽象主题角色: IUserManager

1 public interface IUserManager
2 {
3 public void addUser(User user);
4 }

2) 真实主题角色: UserManager

1 public UserManagerImpl implements IUserManager
2 {
3      public void addUser(User user)
4      {
5         //TODO 实现代码
6      }
7 }

3) 代理主题角色: UserManagerProxy

1 public class UserManagerProxy implements IUserManager
2 {
3 　private IUserManager userManager;
4 　private int permission ; //权限值
5
6 　public UserManangerProxy(int permission)
7 　{
8 　　userManager = new UserManagerImpl()
9 　　this.permission = permission ;
10 　}
11
12 　//实现的接口
13 　public void addUser(User user)
14 　{
15 　　//满足权限设置的时候才能够执行操作
16 　　//Constants是一个常量类
17 　　if(Constants.ASSOCIATOR == permission)
18 　　{
19 　　　userManager.addUser(user);
20 　　}
21 　　else
22 　　{
23 　　　　//TODO 提示出错信息
24 　　}　　　　　
25 }

这样就实现了简单的代理模式功能...当然根据实际情况,我们也可以自定义一些额外的功能..

五 , 总结
代理模式能够协调调用者和被调用者,能够在一定程度上降低系统的耦合程度,当然实际当中要视当前的实际情况而定

-----参考:http://www.yesky.com/412/1919412.shtml

姜利阳 2006-11-30 22:36 发表评论