我了解的java设计模式之工厂模式

欢迎批评指教


介绍:

工厂模式的目的在于程序的可扩展性,让程序有一个更好地封装,降低程序模块之间的耦合程度。
工厂模式分为三种:(head frist 设计模式----简单工厂是一种正常的编程思维) 
     - 简单工厂模式 (Simple Factory Pattern)
     -工厂方法模式(Factory Method Pattern)
     -抽象工厂(Abstract Factory Pattern)
  • 简单工厂模式:
    理解:在石器时代 人们没有先进的科技,思想没有开化,他们自己通过石头加木棒制作石斧自己创造。
    到了后来,随着科技文明的进步,有得人就不通过自己去创造,而是通过交给隔壁老王(手艺好)去制造,将制造石斧的事交给老王 ,自己不用关注石斧制造的具体细节。这时就有一个生产的工厂,并且相应的石铲也可以让老王生产。
    不多bb直接代码打下理解

        /**
         * 生产石具
         * @author lz
         *
         */
        public interface StoneTool {
           //生产
           void create();
        }
    ---------------------------------------------------------------------------------
        /**
         * 生产石斧
         * 
         * @author lz
         *
         */
        public class StoneAxe implements StoneTool{
    
            @Override
            public void create() {
                System.out.println("生产一把石斧");
            }
        }
    ---------------------------------------------------------------------------------
    
        /**
         * 生产石铲
         * 
         * @author lz
         *
         */
        public class StoneShovel implements StoneTool{
    
            @Override
            public void create() {
                System.out.println("生产一把石铲");       
            }
    
        }
    ---------------------------------------------------------------------------------
       /**
         * 简单工厂模式
         * 
         * 石斧石铲生产车间
         * 
         * @author lz
         *
         */
        public class SimpleFactoryPattern {
            //生产的方法
            public static StoneTool create(Class<?> st){
                if(st.getName().equals(StoneAxe.class.getName())){
                    return new StoneAxe();
                }else if(st.getName().equals(StoneShovel.class.getName())){
                    return new StoneShovel();
                }
                return null;
            }
        }
        ---------------------------------------------------------------------------------
    
        /**
         * i want 
         * @author admin
         *
         */
        public class main {
    
            public static void main(String[] args) {
                //我要一个石斧老王                 调用简单工厂生产
                StoneTool sAxe=SimpleFactoryPattern.create(StoneAxe.class);
                sAxe.create();
            }
    
        }
    

    但是随着时代发展,石具变化太大,可把老王忙坏啦,不停的去在工厂类添加else if 很麻烦不说
    这样违反啦开闭原则,即一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。
    所以 这样代码要重新设计

    -工厂方法模式:
    1.一个抽象产品类,可以派生出多个具体产品类。
    2.一个抽象工厂类,可以派生出多个具体工厂类。
    3.每个具体工厂类只能创建一个具体产品类的实例
    将工厂抽象-再根据具体的工厂去实现生产,当再有其他的石具时,只要实现上帝工厂接口就可以啦,不必去修改原有代码,扩展性也提高啦,代码结构更灵活。

       /**
         * 上帝工厂
         * 
         * @author lz
         *
         */
        public interface StoneFactory {
    
             StoneTool factoryCreate();
    
        }
    
        ---------------------------------------------------------------------------------
    
            /**
             * 生产石斧的工厂
             * 
             * @author lz
             *
             */
            public class StoneAxeFactory implements StoneFactory {
    
                @Override
                public StoneTool factoryCreate() {
                    return new StoneAxe();
                }
    
            }
    
            ---------------------------------------------------------------------------------
    
            /**
             * i want 
             * @author lz
             *
             */
            public class main {
    
                public static void main(String[] args) {
                    //我要一个石斧老王                 调用简单工厂生产
                    StoneTool sAxe=SimpleFactoryPattern.create(StoneAxe.class);
                    sAxe.create();
                    //我还要石斧           工厂方法
                    StoneFactory aAStoneTool=new StoneAxeFactory();
                    StoneTool factoryCreate = aAStoneTool.factoryCreate();
                    factoryCreate.create();
                }
    
            }
    

    -抽象工厂模式:
    1.多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
    2.一个抽象工厂类,可以派生出多个具体工厂类。
    3.每个具体工厂类可以创建多个具体产品类的实例。
    理解:
    随时代的再次发展,石具流行各种包装的样式,现在一个接口已经满足不了我们的需求了。工厂方法模式一般是针对于一种系列的抽象产品的生产,而把工厂方法模式进行扩充,变成可以对多种系列的产品进行生产,这就是抽象工厂模式了。对于产品族的理解,即石具分别有不同的组成,每一个都代表一系列列的产品类型。

    因此可以这样设计;
    我这里根据石具的包装和石具的种类来演示下

      /**
         * 石具
         * 
         * @author lz
         *
         */
        public interface StoneTool extends Tool {
            //组成结构
            void formStone();
    
            //使用说明
            void useMode();
        }
        ---------------------------------------------------------------------------------
    
       /**
         * 石斧
         * 
         * @author lz
         *
         */
        public class StoneAxe implements StoneTool {
    
            @Override
            public void toolName() {
                System.out.println("我是石斧");
            }
    
            @Override
            public void formStone() {
                System.out.println("我是石头组成");
            }
    
            @Override
            public void useMode() {
                System.out.println("单手操作即可");
            }
    
        } 
    ---------------------------------------------------------------------------------
       /**
         * 石铲
         * 
         * @author lz
         *
         */
        public class StoneShovel implements StoneTool {
    
            @Override
            public void toolName() {
                System.out.println("我是石铲");
            }
    
            @Override
            public void formStone() {
                System.out.println("我是石铲,我也是石头做的,但是我长");
            }
    
            @Override
            public void useMode() {
                System.out.println("双手使用");
            }
    
        }
    
    ---------------------------------------------------------------------------------
        /**
         * 工具包装
         * 
         * @author lz
         *
         */
        public interface ToolPacking {
            //包装颜色
            void ToolPackingColor();
        }
    
    ---------------------------------------------------------------------------------
        /**
         * 蓝色包装
         * 
         * @author lz
         *
         */
        public class ToolPackingblue implements ToolPacking {
    
            @Override
            public void ToolPackingColor() {
                System.out.println("我是蓝色包装");
            }
    
        }
    ---------------------------------------------------------------------------------
        /**
         * 红色包装
         * 
         * @author lz
         *
         */
        public class ToolPackingRed implements ToolPacking {
    
            @Override
            public void ToolPackingColor() {
                 System.out.println("我是红色的包装");
            }
    
        }
    ---------------------------------------------------------------------------------
        /**
         * 生产全套产品工厂
         * @author lz
         *
         */
        public interface ToolFactory {
            //生产石具
            StoneTool createStoneTool();
    
            //生产包装
            ToolPacking createToolPacking();
    
        }
    
    ---------------------------------------------------------------------------------
        /**
         * 生产蓝色包装石斧工厂
         * 
         * @author lz
         *
         */
        public class AxeBuleFactory implements ToolFactory{
    
            @Override
            public StoneTool createStoneTool() {
                return new StoneAxe();
            }
    
            @Override
            public ToolPacking createToolPacking() {
                return new ToolPackingblue();
            }
    
    
        }
    

        /**
         * 生产红色包装石铲工厂
         * 
         * @author lz
         *
         */
        public class ShovelRedFactory implements ToolFactory {
    
            @Override
            public StoneTool createStoneTool() {
                return new StoneShovel();
            }
    
            @Override
            public ToolPacking createToolPacking() {
                return new  ToolPackingRed();
            }
        }
    ---------------------------------------------------------------------------------
        /**
         * 客户
         * 
         * @author lz
         *
         */
        public class main {
    
            public static void main(String[] args) {
                //我要蓝色石斧
                ToolFactory toolaxe=new AxeBuleFactory();
                StoneTool createStoneTool = toolaxe.createStoneTool();
                createStoneTool.toolName();     
                ToolPacking createToolPacking = toolaxe.createToolPacking();
                createToolPacking.ToolPackingColor();
                System.out.println("-------------------------------");
                //我要红色石铲
                ToolFactory toolshvoel=new ShovelRedFactory();
                StoneTool createStoneTool2 = toolshvoel.createStoneTool();
                createStoneTool2.toolName();
                ToolPacking createToolPacking2 = toolshvoel.createToolPacking();
                createToolPacking2.ToolPackingColor();
            }
    
        }
    

    这样代码结束,再来想一下

    在理解产品族和产品等级:

               1. 石斧石铲是同一等级;红色蓝色包装是同一等级
               2.红色石斧,蓝色石铲 是同一产品族  
    

    再来理解下工厂方法和抽象模式:

               1.工厂方法模式针对的是一个产品等级结构,即石斧石铲
             2.抽象模式是面对多个产品等级,形成产品族。
           3.抽象工厂模式是对象的创建模式,它是工厂方法模式的进一步推广。
             比如你用工厂方法创建上面的例子,就会在写一个独立包装的工厂。
             如果再来很多的等级,那 么你的代码势必创建很多工厂。
        4.抽象模式下将产品的族抽象到工厂下,这样其作用不言而喻。
    

    欢迎批评再教育!!!

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值