亚洲欧洲精品成人久久曰,老子影院午夜伦不卡亚洲,亚洲第一永久AV网站久久精品男人的天堂AV

�l�构模式-Composite模式

陈睿 — Mon, 06 Aug 2012 09:49:00 GMT

一�Q��用场�?/strong>

1�Q��用的地方�Q�树(w��i)形结构，分支�l�构�{?/p>

2�Q��用的好处�Q�降低客��L(f��ng)��的��用，��Z��辑ֈ�元�g与组合�g使用的一致性，增加了元件的�~�码

3�Q��用后的坏处：(x��)代码不容易理解，需要你认真�ȝ��IӞ��发现元�g与组合�g是怎么�l�合�?br />

二：(x��)一个实际的例子

��d��形，�q�个模式�Q�稍微要隄��解一点，有了例子��p��明了一切，我画的图是用接口做的�Q�代码实现是抽象�c�Mؓ(f��)基类�Q�你自己选择了，接口也可以�?/p>

1�Q�先建立囑�Ş元�g

package com.mike.pattern.structure.composite;
/**
* 囑�Ş元�g
*
* @author taoyu
*
* @since 2010-6-23
*/
public abstract class Graph {
/**囑�Ş名称*/
protected String name;

public Graph(String name){
this.name=name;
}

/**��d��*/
public abstract void draw()throws GraphException;

/**��d��囑�Ş*/
public abstract void add(Graph graph)throws GraphException;

/**�U�L��囑�Ş*/
public abstract void remove(Graph graph)throws GraphException;

}

2)建立基础囑�Ş�?/strong>

package com.mike.pattern.structure.composite;
import static com.mike.util.Print.print;

/**
* 圆图�?br />*
* @author taoyu
*
* @since 2010-6-23
*/
public class Circle extends Graph {

public Circle(String name){
super(name);
}

/**
* 圆添加图�?br />* @throws GraphException
*/
@Override
public void add(Graph graph) throws GraphException {
throw new GraphException("圆是基础囑�Ş�Q�不能添�?);
}

/**
* 圆画�?br />*/
@Override
public void draw()throws GraphException {
print(name+"��d��?);
}

/**
* 圆移掉图�?br />*/
@Override
public void remove(Graph graph)throws GraphException {
throw new GraphException("圆是基础囑�Ş�Q�不能移�?);
}

}

3�Q�徏立基��囑�Ş长方�?/strong>

package com.mike.pattern.structure.composite;
import static com.mike.util.Print.print;
/**
* 长方�?br />*
* @author taoyu
*
* @since 2010-6-23
*/
public class Rectangle extends Graph {

public Rectangle(String name){
super(name);
}

/**
* 长方形添�?br />*/
@Override
public void add(Graph graph) throws GraphException {
throw new GraphException("长方形是基础囑�Ş�Q�不能添�?);
}

/**
* 画长方�Ş
*/
@Override
public void draw() throws GraphException {
print(name+"��d��?);
}

@Override
public void remove(Graph graph) throws GraphException {
throw new GraphException("长方形是基础囑�Ş�Q�不能移�?);
}

}

4�Q�最后简历组合图�?/strong>

package com.mike.pattern.structure.composite;

import java.util.ArrayList;
import java.util.List;
import static com.mike.util.Print.print;

/**
* 囑�Ş�l�合�?br />*
* @author taoyu
*
* @since 2010-6-23
*/
public class Picture extends Graph {
private List graphs;

public Picture(String name){
   super(name);
   /**默认�?0个长�?/
   graphs=new ArrayList();
}

/**
* ��d��囑�Ş元�g
*/
@Override
public void add(Graph graph) throws GraphException {
   graphs.add(graph);
}

/**
* 囑�Ş元�g��d��
*/
@Override
public void draw() throws GraphException {
   print("囑�Ş容器�Q?+name+" 开始创�?);
   for(Graph g : graphs){
    g.draw();
   }
}

/**
* 囑�Ş元�g�U�L��囑�Ş元�g
*/
@Override
public void remove(Graph graph) throws GraphException {
graphs.remove(graph);
}

}

5�Q�最后测�?/strong>

public static void main(String[] args)throws GraphException {
   /**��M��个圆�Q�圆里包含一个圆和长方�Ş*/
   Picture picture=new Picture("立方体圆");
   picture.add(new Circle("�?));
   picture.add(new Rectangle("长方�?));

   Picture root=new Picture("怪物囑�Ş");
   root.add(new Circle("�?));
   root.add(picture);
   root.draw();
}

6)使用心得�Q�的��降低了客户端的使用情况�Q�让整个囑�Ş可控了，当是你要深入�ȝ��解，才真名明白采用该模式的含义，不太�Ҏ(gu��)��理解�?/p>

陈睿 2012-08-06 17:49 发表评论

陈睿 — Mon, 06 Aug 2012 09:38:00 GMT

一�Q��用场�?/strong>
     1�Q��用的地方�Q�我想��用两个不同类的方法，�q�个时候你需要把它们�l�合��h��使用
     2�Q�目前��用的情况�Q�我�?x��)把两个�cȝ��L(f��ng)��合的方式攑ֈ�一��P��~�程思想think in java里已�l�提��C��Q�能��量用组合就用组合，�l�承一般考虑再后�?/p>
     3�Q��用后的好处：(x��)你不需要改动以前的代码�Q�只是新��装了一新类�Q�由�q�个�c�L��提供两个�cȝ��Ҏ(gu��)��Q�这个时候：(x��)一定会(x��)惛_��facade外观模式�Q�本来是多个�c�M��用的情况�Q�我新封装成一个类来��用，而这个类我采用组合的方式来包装新的方法。我的理解是�Q�设计模式本�w�就是�ؓ(f��)了帮助解决特定的业务场景而故意把模式划分对应的模式类别，其实大多数情况，都解决了同样的问题，�q�个时候其实没有必要过多的�U�缠到模式的名字上了�Q�你有好的注意，你甚臛_��一个新的名字来概括�q�样的��用场景�?/p>
    4�Q��用的坏处�Q�适配器模式，有两�U�方式来实现。一个是�l�合一个是�l�承�Q�我觉得�Q�首先应该考虑�l�合�Q�能用组合就不要用��承，�q�是�W�一个。第二个�Q�你采用�l�承来实玎ͼ�那肯定会(x��)加大�l�承�?w��i)结构，如果你的�l�承关系本��n��很复杂了，�q�肯定会(x��)加大�l�承关系的维护，不有利于代码的理解，或则更加�J�琐。��承是��Z��解决重用的�ؓ(f��)题而出现的�Q�所以我觉得不应该滥用��承，有机�?x��)可以考虑同样别的�Ҏ(gu��)��?br />
二：(x��)一个实际的例子
      兌��营销的例子，用户购买完商品后�Q�我又推荐他相关别的商品
      �׃��减少代码�Q�方法我都不采用接口�Q�直接由�c�L��提供�Q�代码只是一个范例而已�Q�都�_��了�?/p>
1)创徏订单信息
public class Order {
private Long orderId;
private String nickName;

public Order(Long orderId,String nickName){
   this.orderId=orderId;
   this.nickName=nickName;
}

/**
* 用户下订�?br />*/
public void insertOrder(){

}
}

2�Q�商品信�?/strong>
public class Auction {
/**商品名称*/
private String name;

/**刉��商*/
private String company;

/**刉��日�?/
private Date date;

public Auction(String name,String company, Date date){
   this.name=name;
   this.company=company;
   this.date=date;
}

/**
* 推广的商品列�?br />*/
public void commendAuction(){

}

}
3�Q�购�?/strong>
public class Trade {
/**用户订单*/
private Order order;

/**商品信息*/
private Auction auction;

public Trade(Order order ,Auction auction){
   this.order=order;
   this.auction=auction;
}

/**
* 用户产生订单以及后箋的事�?br />*/
public void trade(){
   /**下订�?/
   order.insertOrder();

   /**兌��推荐相关的商�?/
   auction.commendAuction();
}

}
   4�Q��用心得：(x��)其实外面采用了很多��承的方式�Q�order�l�承auction之后�Q�利用super .inserOrder()再加一个auction.recommendAuction(),实际上大同小异，我到觉得采用�l�合更容易理解以及代码更加优��点�?/p>

陈睿 2012-08-06 17:38 发表评论

创徏模式-Builder模式

陈睿 — Mon, 06 Aug 2012 09:37:00 GMT

一�Q��用场�?/strong>
   1)使用到的地方�Q�如果你惛_��建类似汽车这��L(f��ng)��对象�Q�首先要创徏轮子�Q�玻璃，桌椅�Q�发动机�Q�外廓等�Q�这些部仉��创徏好后�Q�最后创建汽车成品，部�g的创建和汽�R的组装过�E�本�w�都很复杂的情况�Q�希望把部�g的创建和成品的组装分开来做�Q�这��h��要做的事情分割开来，降低对象实现的复杂度�Q�也降低以后成本的维护，把汽车的部�g创徏和组装过�E�独立出两个对应的工厂来做，有点�c�M��建立两个对应的部件创建工厂和汽�R�l�装工厂两个工厂�Q�而工厂只是创��Z��个成品，�q�没有把里面的步骤也独立出来�Q�应该说Builder模式比工厂模式又�q�了一步�?/p>
    2�Q�采用Builder模式后的好处�Q�把一个负责的对象的创��E�分解，把一个对象的创徏分成两个对象来负责创建，代码更有利于�l�护�Q�可扩性比较好�?/p>
   3�Q�采用Builder模式后的坏处�Q�实现�v来，对应的接口以及部件的对象的创建比较多�Q�代码相�Ҏ(gu��)��Ԍ��比较多了�Q�估计刚开始你�?x��)有��?gu��)��Q�这个可以考虑代码�_��的问题，增加代码的可��L��?

二：(x��)一个实际的例子
汽�R的组�?/strong>
  1)首先创徏汽�R�q�个成品对象�Q�包含什么的成员
public class Car implements Serializable{

/**
* 汽�R序列�?br />*/
private static final long serialVersionUID = 1L;
/**汽�R轮子*/
private Wheel wheel;

/**汽�R发动�?/
private Engine engine;

/**汽�R�ȝ��*/
private Glass glass;

/**汽�R座椅*/
private Chair chair;

public Wheel getWheel() {
   return wheel;
}
public void setWheel(Wheel wheel) {
   this.wheel = wheel;
}
public Engine getEngine() {
   return engine;
}
public void setEngine(Engine engine) {
   this.engine = engine;
}
public Glass getGlass() {
   return glass;
}
public void setGlass(Glass glass) {
   this.glass = glass;
}
public Chair getChair() {
   return chair;
}
public void setChair(Chair chair) {
   this.chair = chair;
}

}
2�Q�创建对应汽车零部�g
public class Wheel {
public Wheel(){
   print("--汽�R轮子构徏完毕--");
}
}
public class Engine {
public Engine(){
   print("--汽�R发动机构建完�?-");
}
}
public class Glass {
public Glass(){
   print("--汽�R�ȝ��构徏完毕--");
}
}
public class Chair {
public Chair(){
   print("--汽�R座椅构徏完毕--");
}
}
3�Q�开始重点了�Q�汽车成品的�l�装�q�程
   public interface Builder {
/**�l�装汽�R轮子*/
public void buildWheel();

/**�l�装汽�R发动�?/
public void buildEngine();

/**�l�装汽�R�ȝ��*/
public void buildGlass();

/**�l�装汽�R座椅*/
public void buildChair();

/**�q�回�l�装好的汽�R*/
public Car getCar();
}
以及实现�c?/p>
public class CarBuilder implements Builder {
/**汽�R成品*/
private Car car;

public CarBuilder(){
   car=new Car();
}

/**�l�装汽�R轮子*/
@Override
public void buildChair() {
   car.setChair(new Chair());
}
/**�l�装汽�R发动�?/
@Override
public void buildEngine() {
   car.setEngine(new Engine());
}
/**�l�装汽�R�ȝ��*/
@Override
public void buildGlass() {
   car.setGlass(new Glass());
}
/**�l�装汽�R座椅*/
@Override
public void buildWheel() {
   car.setWheel(new Wheel());
}

/**�q�回�l�装好的汽�R*/
@Override
public Car getCar() {
   buildChair();
   buildEngine();
   buildGlass();
   buildWheel();
   print("--整个汽�R构徏完毕--");
   return car;
}
}
4�Q�最后汽车创建测�?/strong>
   public static void main(String[] args) {
   /**创徏汽�R�l�装*/
   Builder carBuilder=new CarBuilder();
   Car car=carBuilder.getCar();
}
   最后输出：(x��)
--汽�R座椅构徏完毕--
--汽�R发动机构建完�?-
--汽�R�ȝ��构徏完毕--
--汽�R轮子构徏完毕--
--整个汽�R构徏完毕--
   5�Q?strong>体会(x��)心得�Q?/strong>Builder模式实际的重点就把汽车的�l�装�q�程和零部�g的生产分开来实玎ͼ�雉��件的生成主要靠自��q��对象来实玎ͼ�我上面只是在构造函数里创徏了，比较��单，而重�Ҏ(gu��)��车的�l�装则交�l�C(j��)arBuilder来实玎ͼ�最�l�由builder来先负责雉��件的创徏�Q�最后返回出成品的汽车�?/p>

陈睿 2012-08-06 17:37 发表评论

创徏模式-singleon单例模式

陈睿 — Mon, 06 Aug 2012 09:33:00 GMT

一�Q��用场�?br />
    1�Q�经�怋�用的地方�Q�一个类只有一个实例，eg:��面讉K��l�计pv�Q�统计的个数��只能保证一个实例的�l�计�?/p>
    2�Q�我们目前��用的情况�Q�比如我惛_��Z��个对象，�q�个对象希望只有一份实例的�l�护�Q�在内存的保存也只有一份，也就是在同一个jvm的java堆里只保存一份实例对象，所以你�?x��)想一办法�Q�在创徏�q�个对象的时候，��已�l�能保证只有一份�?/p>
    3�Q�怎么改进�Q�定义该对象的时候，��׃��证是同一份实例，比如�Q�定义�ؓ(f��)�U�有构造函敎ͼ�防止通过new的方式可以创建对象，然后在对象里定义一个静态的�U�有成员�Q�本�w�对象的一个实例）�Q�然后再创徏一个外面访问该对象的方法就好了�?/p>
    4�Q�改�q�的好处�Q�代码在�~�译代码�q�个�U�别��p��控制了，不至于在jvm里运行的时候才来保证，把唯一实例的创��Z��证在�~�译阶段�Q�jvm里内存只有一份，从而内存占有率更低�Q�以及更方便java垃圾回收
    5�Q�改�q�后的坏处：(x��)只能是代码稍微需要更多点�Q�其实大家最后发现改�q�后的坏处，都是代码定义比之间要多一点，但以后的�l�护代码��降下来了，也短暂的代码量偏大来换取以后代码的精��?br />
二：(x��)一个实际的例子
��M��的例�?/p>
package com.mike.pattern.singleton;
/**
* �ȝ��
*
* @author taoyu
*
* @since 2010-6-22
*/
public class President {
private President(){
   System.out.println("�ȝ��已经选�D出来�?);
}

/**�ȝ��只有一�?/
private static President president=new President();

/**
* �q�回�ȝ��
*/
public static President getPresident(){
   return president;
}

/**
* �ȝ��宣布选�D成功
*/
public void announce(){
   System.out.println("伟大的中国�h民，我将成你们新的�ȝ��");
}
}
/**
* @param args
*/
public static void main(String[] args) {
   President president=President.getPresident();
   president.announce();
}

陈睿 2012-08-06 17:33 发表评论

创徏模式-工厂模式

陈睿 — Mon, 06 Aug 2012 09:28:00 GMT

1.使用场景
     1�Q�子�c�过多，不容易管理；构造对象过�E�过长；�_��代码创徏�Q?br />
    2)目前我们代码情况�Q?�~�写代码的时候，我们�l�常都在new对象�Q�创��Z��个个的对象，而且�q�有很多�ȝ��的创建方式，eg:HashMap grade=new HashMap(),�q�样的代码创建方式太冗长了，��N��你没有想�q�把�q�个创徏变的短一点么�Q�比如：(x��)HashMapgrade=HashMapFactory.new(),可以把你创徏�_��一点；你也可以�q�有别的需求，在创建对象的时候，你需要不同的情况�Q�创建统一�U�类别的对象�Q�eg:我想生成不同的汽车，创徏��车，创徏卡�R�Q�创建公交汽车等�{�，都属于同�U�类别：(x��)汽�R�Q�你��N��没有惌��Q�我把这些创建的对象在一个工厂里来负责创建，我把创徏分开化，交给一人来负责�Q�这样可以让代码更加�Ҏ(gu��)��理�Q�创建方式也可以��单点�?/p>
比如�Q�Car    BMW=CarFactory.create(bmw);   把创建new�׃��个统一负责�Q�这��L(f��ng)��理�v来相当方�?/p>
    3�Q�怎么改进�Q�这个时候，你会(x��)惛_��Q�创��样同�c�d��的东西，我把�q�个权利分出去，让一个�h来单独管理，它只负责创徏我的对象�q�个事情�Q�所以你单独��历一个对象来创徏同类的对象，�q�个时候，你想�q�个东西有点像工厂一��P��生成同样的��品，所以取了个名字�Q�工厂模式，��֐�思义�Q�只负责对象的创�?/p>
    4�Q�改�q�后的好处：(x��)代码更加�Ҏ(gu��)��理了，代码的创��z�很多�?/p>
    5�Q�改�q�后的坏处：(x��)那就是你需要单独加一个工厂对象来负责创徏�Q�多需要写点代码�?br />
2.一个实际的例子

   创徏宝马汽�R与奔驰汽车的例子
   1�Q�先提取��Z��个汽车的公用接口Car
       public interface Car{
          /**行驶*/
          public void drive();
        }

   2)宝马和奔驰汽车对�?/p>
public class BMWCar implements Car {
/**
* 汽�R发动
*/
public void drive(){
   System.out.println("BMW Car drive");
}
}
public class BengCar implements Car {
/**
* 汽�R发动
*/
public void drive(){
   System.out.println("BengChi Care drive");
}
}
    3)单独一个汽车工厂来负责创徏
     public class FactoryCar {
/**
* 刉��汽�?br />*
* @param company 汽�R公司
* @return 汽�R
* @throws CreateCarException 刉��汽车失败异�?br />*/
public static Car createCar(Company company)throws CreateCarException{
   if(company==Company.BMW){
    return new BMWCar();
   }else if(company==Company.Beng){
    return new BengCar();
   }
   return null;
}
}
    4�Q�最后的代码实现�Q?/p>
    Car BMWCar=FactoryCar.createCar(Company.BMW);
     BMWCar.drive();

陈睿 2012-08-06 17:28 发表评论

设计模式我的理解

陈睿 — Mon, 06 Aug 2012 09:22:00 GMT

1. 我说下我对设计模式的理解�Q��Q何一样事物都是因为有需求的驱动才诞生的�Q�所以设计模式也不例外，我们�q�x��在编写代码的时候，随着旉��的深入，发现很多代码很难�l�护�Q�可扩展性��差，以及代码的效率也比较低，�q�个时候你肯定�?x��)想办法让代码变的优��又能解决你��目中的问题�Q�所以在面向对象语言里，你肯定会(x��)��d��现很多可以重用的公用的方法，比如�Q�接口的存在�Q�你自然��想��C��Q�让你定义的�Ҏ(gu��)��与你的实现分开�Q�也可以很方便把不同的类与接口匹配�v来，形成了一个公用的接口�Q�你�?x��)发现这样做�Q�好处会(x��)是非常多的，解决了你�q�x��x��代码的申明与逻辑实现的分开�?/p>
    2. �q�个时候，你发��C��Q�本�w�面向对象的语言里，已经暗藏了很多好处，你肯定会(x��)仔细��d��析面向对象这个语�a��Q�认真去挖掘里面更多的奥�U�，最后，你发��C��Q�原来你可以把面向对象的�Ҏ(gu��)��提取成一个公用的实现案例�Q�这些案例里能帮助你解决你��^时编写代码的困扰�Q�而这样一��h�Q�就是所谓gof的成员，他们从��^时设计徏�{�方面找��C��灉|��Q�徏�{�的设计也可以公用化以及重用化，所以他们也提取了相关的软�g设计斚w��的公用案例，也就有了下面的相关的所�?3�U�设计模式，而里面这么多模式�Q�你也可以把他们归类��h��Q�最后发现就几类模式�Q�创建，�l�构�Q�行为等模式�c�d��Q�而这些现成的�Ҏ(gu��)��Q�也可以在实际应用中充分发挥作用�Q�随着大家的��用以及理解，发现其实�q�些所谓的模式里，你的��可以让你的代码变的更加优美与简�l��?/p>
    3. 我比较喜�Ƣ把代码变的更加优美与简�l�，优美的代码就是一看就懂，�l�构很清晎ͼ�而简历就是一目了�Ӟ��又可以解决你的问题，��是代码又少效率又高�Q�所以��^时要��L��写java doc的习(f��n)惯，�q�样的代码才为清晎ͼ�所以才�?x��)更加优��?/p>
    4. �q�些��是我对设计模式的理解，所以这么好的宝贝，我们不去深入的了解，的确可惜了，�q�就叫站到巨人的肩膀�?....

陈睿 2012-08-06 17:22 发表评论