工厂模式

希望对你有所帮助（C#）

首先是一个大体结构如下，

抽象工厂：
父类层：
      接口
      {//功能
void Create();//创建
         void Delete();//删除
      }

      抽象类
      {
          1.静态的自身类型的属性返回：实现类的对象

2.抽象的接口类型的属性
}

子类层：
      接口的实现类
      {
         //实现了具体功能 create()
      }

      抽象类的实现类
      {
         //重写接口类型的属性 get{ return new 接口实现类();}
           实际返回本层接口的实现类对象
      }

调用：
抽象类.自身类型的属性.接口类型属性.Create();

下面是一个项目结构的搭建（多层架构）：
1.新建类库Sys
文件夹DAL
{
接口：IUserDao
抽象类：DaoFactory
}

2.新建类库DAL
文件夹DAO
{
接口实现类：UserDao
抽象类实现类：DaoRealize
}

3.在Sys层新建文件夹BLL
{
接口：IUserBll
抽象类：BllFactory
}

4.新建类库BLL
{
接口实现类：UserBll
抽象类实现类：BllRealize
}

5.新建WebUI

6.将DAL、BLL程序集的生成路径改为/WebUI/bin
class Program
    {
        static void Main1(string[] args)
        {
            //普通实现接口
            MyClass myInter = new MyClass();
           // myInter.Fun();

            // 接口类型的引用指向实现类的对象
            //显示实现接口
            //MyInterface myInter2;//引用类型存储的是引用声明在栈
            //myInter2= new MyClass();//存储在堆中
            //myInter2.Fun();

MyInterface m1 = new MyClass();
m1.Fun();

MyInterface2 m2 = new MyClass();
m2.Fun();

}

        //抽象工厂
        static void Main()
        {
            AbstractFactory.Instanct.GetInterFather.Create();
        }
    }
    #region 接口、抽象类
    abstract class MyAbstract
    {
        string name;
        string Name;
        void Fun()
        {

        }
    }

    interface MyInterface
    {//功能
        void Fun();
    }
    interface MyInterface2
    {
        void Fun();
    }

    class MyClass:MyInterface,MyInterface2
    {
        //实现接口

        ////显示实现接口
        //void MyInterface.Fun()
        //{
        //    Console.WriteLine("22");
        //}
        void MyInterface.Fun()
        {

        }
        void MyInterface2.Fun()
        {

        }
    }
#endregion
}
父类层
//接口
    public interface InterFather
    {//功能
        void Create();
        void Delete();
    }

    //抽象类
    public abstract class AbstractFactory
    {
        //1.静态的自身类型的属性返回实现类的对象
        private static AbstractFactory _instanct;
        public static AbstractFactory Instanct
        {
            get
            {//只读属性返回私有字段
                return _instanct;
            }
        }
        //静态构造函数初始化静态成员
        static AbstractFactory()
        {
            //实例化实现类对象
            _instanct = new ChildFactory2();
        }

        //2.抽象的接口类型的属性
        public abstract InterFather GetInterFather { get; }
    }
}

子类层1
//接口的实现类
    public class ChildInter1 : InterFather
    { //具体的实现方法
        void InterFather.Create()
        {
            Console.WriteLine("子类层1的create方法执行");
        }

        void InterFather.Delete()
        {
            Console.WriteLine("子类层1的delete方法执行");
        }
    }

     //抽象类的实现类
    public class ChildFactory1 : AbstractFactory
    {
        public override InterFather GetInterFather
        {
            get
            { //返回本层接口的实现类
                ChildInter1 child = new ChildInter1();
                return child;
            }
        }
    }

}

子类层2
//接口的实现类
    public class ChildInter2 : InterFather
    { //具体的实现方法
        void InterFather.Create()
        {
            Console.WriteLine("子类层2的create方法执行");
        }

        void InterFather.Delete()
        {
            Console.WriteLine("子类层2的delete方法执行");
        }
    }

     //抽象类的实现类
    public class ChildFactory2 : AbstractFactory
    {
        public override InterFather GetInterFather
        {
            get
            { //返回本层接口的实现类
                ChildInter2 child = new ChildInter2();
                return child;
            }
        }
    }

}