24中模式详解

http://www.runoob.com/design-pattern/factory-pattern.html

菜鸟教程

1.工厂模式：

个人感觉就是利用 多态（例如动物，叫声那个例子）+工厂（创建各个类的实列的自定义工厂）+测试类（给定一种动物，调用后台代码）

package cn.edu.aynu;

public interface demo {
    public void  sound();

}

package cn.edu.aynu;

public class demo1 implements demo{
    public void sound() {
        // TODO Auto-generated method stub
        System.out.println("demo1");
        
    }

}

package cn.edu.aynu;

public class demo2 implements demo{
    @Override
    public void sound() {
        // TODO Auto-generated method stub
        System.out.println("demo2");
        
    }

}

package cn.edu.aynu;

public class demo3 implements demo {
    @Override
    public void sound() {
        // TODO Auto-generated method stub
        System.out.println("demo3");
        
    }
}

package cn.edu.aynu;

public class Factory {
    public demo getDemo(String demo) {
        if(demo.equals("demo1")) {
            return  new demo1();
        }else if(demo.equals("demo2")) {
            return new demo2();
        }else if(demo.equals("demo3")){
            return new demo3();
        }else {
            return null;
        }
    }

}

package cn.edu.aynu;

public class test01 {
    
    public static void main(String[] args) {
        //创建一个工厂对象
        Factory factory = new Factory();
        demo demo1 = factory.getDemo("demo1");
        demo1.sound();
        
        demo demo2 = factory.getDemo("demo2");
        demo2.sound();
        
        demo demo3 = factory.getDemo("demo3");
        demo3.sound();
        
    }

}

 2.抽象工厂模式，是建立在工厂模式之上的可以看出来，这个工厂是抽象的，你们就必定会有一个继承该抽象工厂的类，来实现工厂中的抽象方法，不直接对工厂进行操作

而且好i要创建一个工厂生成器，根据需求在工厂生成器中来创建工厂实现类的对象，个人觉得这么做的好处就是

通过抽象工厂就能知道这个工厂主要实现什么功能。在抽象工厂的实现类中对工厂的功能进行操作。可以将一个具体的功能放在一个类中。然后直接调用工厂生成器来调用工厂的

功能对象。

package cn.edu.aynu;

public interface demo {
    public void  sound();
}

package cn.edu.aynu;

public class demo1 implements demo{
    public void sound() {
        // TODO Auto-generated method stub
        System.out.println("demo1");
        
    }

}

package cn.edu.aynu;

public class demo2 implements demo{
    @Override
    public void sound() {
        // TODO Auto-generated method stub
        System.out.println("demo2");
        
    }

}

package cn.edu.aynu;

public interface Factory {
    public demo getSound(String demo);
    public jump getJump(String jump);
    
}

package cn.edu.aynu;

public class FactoryGenetory {
    public static Factory getFactory(String modul) {
        if(modul.equals("demo")) {
        return    new FactoryImpldemo();
        }else if(modul.equals("jump")) {
            
            return new FactoryImplJump();
        }
        return null;
        
        
    }

}

package cn.edu.aynu;

public class FactoryImpldemo implements Factory{
      @Override
    public demo getSound(String demo) {
        // TODO Auto-generated method stub
          if(demo.equals("demo1")) {
              return  new demo1();
          }else if(demo.equals("demo2")) {
              return new demo2();
          }else {
              return null;
          }
        
    }
      
      @Override
    public jump getJump(String jump) {
        return null;
        // TODO Auto-generated method stub
        
    }
}

package cn.edu.aynu;

public class FactoryImplJump implements Factory {
    @Override
    public jump getJump(String jump) {
        // TODO Auto-generated method stub
        if(jump.equals("jump1")) {
           return new jump1();
        }else if(jump.equals("jump2")) {
            return new jump2();
        }else {
            return null;
            
        }
        
    }
    @Override
    public demo getSound(String demo) {
        // TODO Auto-generated method stub
        
        return null;
    }

}

package cn.edu.aynu;

public interface jump {
     void getJump();
}

package cn.edu.aynu;

public class jump1 implements jump{
    public void getJump() {
        // TODO Auto-generated method stub
        System.out.println("jump1");
    }
}

package cn.edu.aynu;

public class jump2 implements jump{
    public void getJump() {
        // TODO Auto-generated method stub
        System.out.println("jump2");
    }

}

package cn.edu.aynu;

public class test01 {
    
    public static void main(String[] args) {
        //创建一个实现指定功能的工厂 生成器
         Factory demoFactory = FactoryGenetory.getFactory("demo");
         Factory jumpFactory = FactoryGenetory.getFactory("jump");
        
        demo demo1 = demoFactory.getSound("demo1");
        demo1.sound();
        
        demo demo2 = demoFactory.getSound("demo2");
        demo2.sound();
        
        jump jump1 = jumpFactory.getJump("jump1");
        jump1.getJump();
        
        jump jump2 = jumpFactory.getJump("jump2");
        jump2.getJump();
        
        
    }

}

 3.单例模式

这种模式应该是最好理解的，java 基础中就已经讲了。

就是将一个实体类的构造方法进行私有化，这样该类就不会被实例化，为了能让外界进行访问就声明一个静态方法 获取唯一可用的对象

package cn.edu.aynu;

public class jump2 {
    private jump2() {}
    
    public static jump2 getInstance() {
        return new jump2();
        
    }
    public void getMessage() {
        System.out.println("message");
    }
    

}

package cn.edu.aynu;

public class testnkw {

    public static void main(String[] args) {
       jump2 jump = jump2.getInstance();
       jump.getMessage();
    
    }

}

4.建造者模式  （使用多个简单的对象一步一步构建成一个复杂的对象）  

主要作用就是（一些基本部件不会变，而其组合经常变化的时候）

菜鸟教程上给的也是够复杂的，我这里简化一下，要不然不好记，记住思想就行

直接解释一下：就是麦当劳店有个套餐活动 ,有  包装（纸袋，瓶装），汉堡（蔬菜汉堡，非蔬菜汉堡）饮料（可乐，咖啡）

 

然后一个订单工厂  一个测试类

 待续。。。。。。。。。。。。。