菜鸟学习设计模式——简单工厂

这段时间以来，作为一名学生的我，一直在学习设计模式。从最初的百度百科，到现在应用其中的设计模式大概有一个多月吧。作为菜鸟的我感觉，设计模式确实可以让系统更加优化，在学习的初期，一直想利用所学在自己的软件中运用，从而出现了很多问题。现在的话，看了很多介绍设计模式的书记之后觉得，设计模式就是在你觉得你的系统通过利用一定的模式之后可以比以前更加好（菜鸟的想法哈！）。下面是最近老师不值得一个作业——吉他小店的代码（C#）。其中所涉及到的是简单工厂模式，不过有所改动就是在选择实现的时候，并不是通过一般的if 或者switch来选择，而是通过函数重载的形式来实现的。不知道这算不算解决了如何实现动态参数的问题哈。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;


namespace homework_3
{
    class Program
    {


        static void Main(string[] args)
        {
            //调用初始化函数，设置乐器存储数组
            Inventory inventory =SetArrayList();


            //设置想要查找乐器的规格
            Spec guitarSpec = InstrumentFactory.GetSpec(Builder.FENDER, "Stratocastor", Type.ELECTRIC, 3, Wood.ALDER, Wood.ALDER);
            Spec pianoSpec = InstrumentFactory.GetSpec(PianoBuilder.HAILUN, PianoType.Electric_Piano);
            Spec diziSpec = InstrumentFactory.GetSpec(Length.M_LONG);


            //查找类似规格的该乐器型号，并保存 ,（暂时选择pianoSpec，读者可选择guitarSpec尝试）
            ArrayList FindInstrumentList = inventory.Search(guitarSpec);


            //判断查找结果，如果存在该乐器则输出型号与价格
            if (FindInstrumentList.Count != 0)
            {
                foreach (Instrument instrcument in FindInstrumentList)
                {
                    //输出乐器的信息
                    instrcument.Show();
                }
            }
            else
            {
                Console.WriteLine("Sorry,we have nothing for you !");
            }
            Console.Read();
        }


        //乐器存储数组 初始化函数
        static Inventory SetArrayList()
        {
            //初始化存储数组
            Inventory inventory = new Inventory();


            //设置某类型乐器的规格（吉他）
            Spec guitarSpec = InstrumentFactory.GetSpec( Builder.FENDER, "Stratocastor", Type.ELECTRIC, 3, Wood.ALDER, Wood.ALDER);
            
            //添加该规格的乐器相关信息（吉他）
            inventory.addInstrument("a23", 123, guitarSpec);


            //设置某类型乐器的规格（钢琴）
            Spec pianoSpec = InstrumentFactory.GetSpec(PianoBuilder.HAILUN, PianoType.Electric_Piano);


            //添加该规格的乐器相关信息（吉他）
            inventory.addInstrument("a25", 1432, pianoSpec);
            inventory.addInstrument("b23", 1432, pianoSpec);


            Spec diziSpec = InstrumentFactory.GetSpec(Length.M_LONG);
            inventory.addInstrument("b32", 1432, diziSpec);


            //返回初始化结果
            return inventory;
        }


    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace homework_3
{
    class InstrumentFactory
    {
        public static Spec GetSpec(  Builder builder,string model,
                                         Type type, int numString, Wood backWood, Wood topWood)
        {
            return new GuitarSpec(builder, model, type, numString, backWood, topWood);
        }


        public static Spec GetSpec(PianoBuilder pianoBuilder, PianoType pianoType)
        {
            return new PianoSpec(pianoBuilder, pianoType);
        }




        public static Spec GetSpec(Length length)
        {
            return new diziSpec(length);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Reflection;


namespace homework_3
{
    class Inventory
    {
        //乐器存储数组
        private ArrayList Instruments = new ArrayList();


        //增加乐器
        public void addInstrument(string serialNumber, double price, Spec instrument)
        {
            Instrument Instrument = new Instrument(serialNumber, price, instrument);


            Instruments.Add(Instrument);
        }


        //根据乐器的序列号获取相应乐器
        public Instrument getInstrument(string serialNumber)
        {
            foreach (Instrument Instrument in Instruments)
            {
                if (Instrument.SerialNumber.Equals(serialNumber))
                {
                    return Instrument;
                }
            }
            return null;
        }


        //根据乐器的规格查找类似的乐器，并返回
        public ArrayList Search(Spec searchInstrument)
        {
            //保存相似的乐器
            ArrayList matchingInstruments = new ArrayList();


            //遍历所有的乐器
            foreach (Instrument Instrument in Instruments)
            {
                
                //判断存储乐器的类型是否与想要查找的乐器类型相似
                if (Instrument.Spec.GetType() == searchInstrument.GetType())
                {


                    //判断规格是否与想要查找规格相似（吉他）
                    if (searchInstrument.matches(Instrument.GetInstrumentSpec()))
                        matchingInstruments.Add(Instrument);
                }
            }
             
            //返回查找结果
            return matchingInstruments;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;


namespace homework_3
{
    //乐器类
    class Instrument
    {
        private string serialNumber;
        private double price;


        //乐器规格类
        private Spec spec;


        public Instrument(string serialNumber, double price, Spec Spec)
        {
            this.SerialNumber = serialNumber;
            this.Price = price;
            this.spec = Spec;
        }


        public string SerialNumber
        {
            set { serialNumber = value; }
            get { return serialNumber; }
        }


        public double Price
        {
            set { price = value; }
            get { return price; }
        }


        public Spec Spec
        {
            set { spec = value; }
            get { return spec; }
        }


        //返回该乐器
        public  Spec GetInstrumentSpec() { return spec; }


        //展示乐器的所有信息
        public   void Show()
        {
            Console.WriteLine(SerialNumber + "," + Price);
            spec.Show();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System .Collections;


namespace homework_3
{
    //乐器类型


    //乐器规格
    class Spec
    {
        //判断俩个相同乐器的规格是否相同
        public virtual Boolean matches(Spec ISpec){ return false;}


        //返回该乐器的所有规格信息
        public virtual void  Show() {}
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;


namespace homework_3
{
    public enum Type
    {
        ACOUSTIC, ELECTRIC
    }


    public enum Builder
    {
        FENDER, MARTIN, GIBSON, COLLINGS, OLSON, RYAN, PRS, ANY
    }


    public enum Wood
    {
        INDIAN_ROSEWOOD, BRAZILIAN_ROSEWOOD, MAHOGANY, MAPLE,
        COCOBOLO, CEDAR, ADIRONDACK, ALDER, SITKA
    }


    class GuitarSpec:Spec
    {
        private string model;
        private Builder builder;
        private int numString;
        private Type type;
        private Wood backWood, topWood;


        //初始化函数
        public GuitarSpec(  Builder builder,string model,
                          Type type, int numString, Wood backWood, Wood topWood)
        {
           
            this.builder = builder;
            this.model = model;
            this.type = type;
            this.numString = numString;
            this.backWood = backWood;
            this.topWood = topWood;
        }


        public string Model()
        {
            return model;
        }


        public Builder Builder()
        {
             return builder; 
        }


        public int NumString()
        {
              return numString; 
        }


        public Type Type()
        {
             return type;
        }


        public Wood BackWood()
        {
             return backWood; 
        }


        public Wood TopWood()
        {
             return topWood; 
        }


        //判断吉他规格是否相同
        public override Boolean matches(Spec Spec)
        {
            GuitarSpec guitarSpec = (GuitarSpec)Spec;
            if (builder != guitarSpec.Builder())
            {
                return false;
            }


            if ((model != null) && !model.Equals("") && (!model.ToLower().Equals(guitarSpec.Model().ToLower())))
            {
                return false;
            }


            if (type != guitarSpec.Type())
            {
                return false;
            }


            if (numString != guitarSpec.NumString())
            {
                return false;
            }
            if (backWood != guitarSpec.BackWood())
            {
                return false;
            }


            if (topWood != guitarSpec.TopWood())
            {
                return false;
            }


            return true;
        }


        //返回吉他的所以规格信息
        public override  void  Show()
        {
            Console.WriteLine(  model.ToString() + "," + builder.ToString()+
                             numString.ToString() + type.ToString() + "," + backWood.ToString()+"," + topWood.ToString());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;


namespace homework_3
{
    public enum PianoType
    {
        CHILDREN_PIANO, Electric_Piano, Roll_up_Piano
    }


    public enum PianoBuilder
    {
        YAMAHA, PEARLRIVER, HAILUN, XINGHAI, KAWAI, SEJUNG
    }


    class PianoSpec:Spec
    {
        private PianoBuilder pianoBuilder;
        private PianoType pianoType;


        //初始化函数
        public PianoSpec( PianoBuilder pianoBuilder, PianoType pianoType)
        {
            this.pianoBuilder = pianoBuilder;
            this.pianoType = pianoType;
        }


        public PianoBuilder GetpianoBuilder()
        {
            return pianoBuilder;
        }


        public PianoType GetpianoType()
        {
            return pianoType;
        }


        //判断钢琴规格是否相同
        public override Boolean matches(Spec Spec)
        {
            PianoSpec pianoSpec = (PianoSpec)Spec;
            if (pianoBuilder != pianoSpec.pianoBuilder)
            {
                return false;
            }


            if (pianoType != pianoSpec.pianoType)
            {
                return false;
            }
            return true;
        }


        //返回钢琴的所以规格信息
        public override void  Show()
        {
            Console.WriteLine( pianoBuilder.ToString() + "," + pianoType.ToString());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace homework_3
{
    public enum Length
    {
         SHORT,LONG,M_LONG
    }
    class diziSpec:Spec
    {
        private Length length;
        public diziSpec( Length length)
        {
            this.length = length;
        }


        public Length Length()
        {
            return length;
        }


        public override Boolean matches(Spec Spec)
        {
            diziSpec diziSpec = (diziSpec)Spec;
            if (length != diziSpec.Length())
            {
                return false;
            }


            return true;
        }


        //返回吉他的所以规格信息
        public override void Show()
        {
            Console.WriteLine(length.ToString());
        }
    }
}