js23---工厂模式1

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Untitled Document</title>
        <!-- 引入的核心js公共文件 -->
        <script type=text/javascript charset=utf-8 src=../commons/../commons/CommonUtil.js></script>
        <script type=text/javascript charset=utf-8>
        //既可以当成java的类用,也可以当成c++函数用

        function CarShop(){};//卖车类,没有工厂模式
        CarShop.prototype = {
            constructor : CarShop ,
            sellCar:function(type){
                var car ; // 声明一个变量
                switch(type){
                    case ‘Benz‘: car = new Benz(); break;
                    case ‘Bmw‘ : car = new Bmw();  break;
                    case ‘Audi‘: car = new Audi(); break;
                    default: ‘not buy it ‘;
                }

                BH.Interface.ensureImplements(car ,CarInterface);//接口检测,当函数用BH.Interface.ensureImplements = function(object){},java的接口检测是虚拟机做的,js接口检测是我们自己写的。
                return car ;
            }
        };

        // 接口对象的实例,当类用BH.Interface = function(name,methods){}
        var CarInterface = new BH.Interface(‘CarInterface‘ ,[‘start‘,‘run‘]);

        // SuperClass  implements CarInterface
        function BaseCar(){};
        BaseCar.prototype = {//父类方法都在原型对象中
            constructor:BaseCar ,
            start:function(){
                alert(this.constructor.name + ‘ ..start‘);//this是调用方法的子类,java多态(通过父类方法里面的this实现)
            },
            run:function(){
                alert(this.constructor.name + ‘ ..run‘);
            }
        };

        function Benz(){};
        BH.extend(Benz,BaseCar); //BH.extend=function(sub ,sup){},当函数用
        Benz.prototype.driveBenz = function(){alert(‘Benz..drive‘)};
        //Benz.prototype.run = function(){alert(‘Benz..run‘)};

        function Bmw(){};
        BH.extend(Bmw,BaseCar);
        Bmw.prototype.driveBmw = function(){alert(‘Bmw..drive‘)};
        //Bmw.prototype.run = function(){alert(‘Bmw..run‘)};    

        function Audi(){};
        BH.extend(Audi,BaseCar);
        Audi.prototype.driveAudi = function(){alert(‘Audi..drive‘)};
        //Audi.prototype.run = function(){alert(‘Audi..run‘)};    

        var shop = new CarShop();
        var car = shop.sellCar(‘Benz‘);
        car.start();
        car.run();
        car.driveBenz();

        var car2 = shop.sellCar(‘Bmw‘);
        car2.start();
        car2.run();
        car2.driveBmw();
        </script>
    </head>
    <body>
    </body>
</html>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
        <title>Untitled Document</title>
        <!-- 引入的核心js公共文件 -->
        <script type=text/javascript charset=utf-8 src=../commons/../commons/CommonUtil.js></script>
        <script type=text/javascript charset=utf-8>
            // 万事万物都是Object  : 卖车的商店 -> 卖车 -> 生产车 -> Factory

            function CarShop(){};// 商店
            CarShop.prototype = {
                constructor : CarShop ,
                sellCar:function(type){
                /*   面向对象   */
                    // 销售人员...
                    var car = CarFactory.createCar(type);//工厂
                    // 保险、相关的售后服务
                    return car ;
                }
            };

            //工厂,单体模式
            var CarFactory = {
                    createCar:function(type){
                            var car ; // 声明一个变量
                            switch(type){
                                case ‘Benz‘: car = new Benz(); break;
                                case ‘Bmw‘ : car = new Bmw();  break;
                                case ‘Audi‘: car = new Audi(); break;
                                default: ‘not buy it ‘;
                            }
                            //检验接口 交给工厂
                            BH.Interface.ensureImplements(car ,CarInterface);
                            return car ;
                    }
            };

            // 接口对象的实例
            var CarInterface = new BH.Interface(‘CarInterface‘ ,[‘start‘,‘run‘]);

            // SuperClass  implements CarInterface
            function BaseCar(){};
            BaseCar.prototype = {
                constructor:BaseCar ,
                start:function(){
                    alert(this.constructor.name + ‘ ..start‘);
                },
                run:function(){
                    alert(this.constructor.name + ‘ ..run‘);
                }
            };

            // Class benz bmw audi (都是车)
            // 注意关键问题:子类先继承父类 子类在扩展子类自己特有的方法

            function Benz(){};
            BH.extend(Benz,BaseCar);
            Benz.prototype.driveBenz = function(){alert(‘Benz..drive‘)};
            //Benz.prototype.run = function(){alert(‘Benz..run‘)};

            function Bmw(){};
            BH.extend(Bmw,BaseCar);
            Bmw.prototype.driveBmw = function(){alert(‘Bmw..drive‘)};
            //Bmw.prototype.run = function(){alert(‘Bmw..run‘)};    

            function Audi(){};
            BH.extend(Audi,BaseCar);
            Audi.prototype.driveAudi = function(){alert(‘Audi..drive‘)};
            //Audi.prototype.run = function(){alert(‘Audi..run‘)};    

            var shop = new CarShop();
            var car = shop.sellCar(‘Benz‘);
            car.start();
            car.run();
            car.driveBenz();

            var car2 = shop.sellCar(‘Bmw‘);
            car2.start();
            car2.run();
            car2.driveBmw();
        </script>
    </head>
    <body>
    </body>
</html>
时间: 2024-08-20 02:53:00

js23---工厂模式1的相关文章

抽象工厂模式

思考:工厂方法模式:http://www.cnblogs.com/maggiejyt/p/7561253.html 工厂方法模式UML: 问题:如果这家工厂不止要生产Ball(球),还要还有Sneakers(球鞋)等 则UML图为 当Product有多种类时则是抽象工厂模式 代码(Ball的代码见简单工厂模式:http://www.cnblogs.com/maggiejyt/p/7561253.html) Sneakers(球鞋抽象类) package com.maggie.FactoryMet

设计模式 2/23 工厂模式

工厂模式是最常用的设计模式之一,用好了,代码优雅,可维护性高,对系统设计会上一个台阶 为什么这么说,因为工厂模式可以牵扯出抽象工厂模式,也有大家都会聊到的简单工厂模式 我们要了解一点,23中设计模式中,不包含简单工厂模式,之所以大家会去聊这个,四个字,渐进明细 通过对简单工厂模式的了解,我们引入工厂这个词,不然一个写代码的,天天给他讲工厂,工厂,工厂,西厂,东厂,会晕 同时,通过逐步的深入,从简单工厂,到工厂模式,再到抽象工厂,渐进明细的过程,逐步深入的理解,比较优劣,择优而为我们所用. 试想我

简单工厂模式

目前正在看<大话设计模式>,写此系列的文章记录下学习的经过. 简单工厂模式 先看如下代码,使用面向对象的原理实现计算器功能 Operation运算类 1 public class Operation 2 { 3 private double numberA = 0; 4 private double numberB = 0; 5 6 public double NumberA 7 { 8 get { return numberA; } 9 set { numberA = value; } 10

设计模式——介绍与工厂模式(扁平管理模式VS职业经理人模式)

本文主要对设计模式进行大概解说.特别是对工厂模式进行简明的解析: 一.设计模式的分类 创建型模式,共五种:工厂方法模式.抽象工厂模式.单例模式.建造者模式.原型模式. 结构型模式,共七种:适配器模式.装饰器模式.代理模式.外观模式.桥接模式.组合模式.享元模式. 行为型模式,共十一种:策略模式.模板方法模式.观察者模式.迭代子模式.责任链模式.命令模式.备忘录模式.状态模式.訪问者模式.中介者模式.解释器模式. 事实上还有两类:并发型模式和线程池模式. 二.设计模式的六大原则 1.开闭原则(Op

工厂模式

工厂模式属于创建型模式,由一个工厂对象决定创建出哪一种产品类的实例. 角色: IProduct: 产品共同的接口 Product1:具体的产品类 Creator:工厂类,可根据参数决定创建的产品类型 示例: public interface IProduct { void myfunction(); } --- class Product1 implements IProduct{ public void myfunction(){ System.out.println("function1&q

Java设计模式—工厂方法模式&amp;抽象工厂模式

工厂方法模式与抽象工厂模式都是设计模式中重要而且常见的模式.       工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使一个类的实例化延迟到其子类. 通用类图如下: 在工厂方法模式中,抽象产品类Product负责定义产品的共性,实现对事物最抽象的定义:Creator为抽象创建 类,也就是抽象工厂,具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的. 工厂方法模式的扩展方式有很多种,下边是工厂方法模式一个比较实用的源代码: 抽象产品类: pub

java设计模式--工厂模式

总结 (1)简单工厂模式是由一个具体的类去创建其他类的实例,父类是相同的,父类是具体的. (2)工厂方法模式是有一个抽象的父类定义公共接口,子类负责生成具体的对象,这样做的目的是将类的实例化操作延迟到子类中完成. (3)抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无须指定他们具体的类.它针对的是有多个产品的等级结构.而工厂方法模式针对的是一个产品的等级结构. 一.工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的. 工厂模式在<Java

大话设计模式:简单工厂模式

由于面向过程编程造成的代码膨胀问题越来越严重,使其维护的代价高,灵活性很低.为了使代码易维护.易扩展.易复用和灵活性好,所以我们在采用面向对象编程的时候,防止采用面向对象的语言实际上却做着面向过程的事儿,更需要采用某种设计模式,核心就是使程序变得高内聚,低耦合,这样的程序才能达到上面的四个优点.而简单工厂模式的出现也正是为了达到这样一种效果,将工厂和产品分块,具体解决了实例化那个对象(具体产品)的需求.从而实现了高内聚,低耦合.使程序易维护.易扩展.易复用和灵活性好.同时也用到了面向对象编程的三

大话设计模式:抽象工厂模式

抽象方法模式:提供一个创建一系列相关或互相依赖对象的接口,而无需指定他们具体的类. 三种模式的对比:   简单工厂模式 工厂模式 抽象工厂模式 产品 可以有多个但是都属于同一类, 同一等级.都继承产品抽象类. 可以有多个但是都属于同一类,同一等级. 都继承产品抽象类. 可以有不同种类的产品,每类有多中 具体产品: 抽象产品 只能有一个 只能有一个; 多个抽象产品类:每个抽象产品类可 以派生多种具体产品: 抽象工厂类   只能有一个,可以派生出多个具体工厂类: 只有一个,可派生出多个具体工厂类:

【设计模式】1、抽象工厂模式

对于这个抽象工厂的相应的代码实现 /** * 功能:抽象工厂模式的作用 适用性 1.一个系统要独立于它的产品的创建.组合和表示时. 2.一个系统要由多个产品系列中的一个来配置时. 3.当你要强调一系列相关的产品对象的设计以便进行联合使用时. 4.当你提供一个产品类库,而只想显示它们的接口而不是实现时. * 时间:2016年2月11日22:18 * 作者:cutter_point */ package com.shejimoshi.create.AbstractFactory; public in