设计模式--抽象工厂

///设计模式--抽象工厂
///我们都知道，设计模式的优势就是应对需求的不断变化而更改较少的代码或者
/// 不更改代码的结构直接添加新的代码来满足需求的变化。
/// 抽象工厂应对“多系列对象需求”的变化，比如说，下面的四个类 路、房屋
/// 、隧道、丛林这四个类之间相互都有依赖，如路与房屋的依赖等等。
/// AbstractFactory主要应用于“新系列”需求的变动，也就是上面的四个类如
/// 果一起都有变动的话，抽象工厂(AbstractFactory)是你最好的选择，如果程
/// 序需要不断的添加新对象的话，不要使用抽象工厂，如果使用会很累。
///下面的例子说明，我每添加一系列路、房子、隧道、丛林都不需要更改原有的

///代码，我只需要增加一些代码就可以了，最基本的满足了“开放更新关闭更改”

///抽象工厂的例子
/// 下面是我写的抽象工厂的例子。。
///

//定义抽象类，路
public abstract class Road
{
    public abstract void show();
}

//定义抽象类，房子
public abstract class House
{
    public abstract void show();
}

//定义抽象类，隧道
public abstract class Tunnel
{
    public abstract void show();
}

//定义抽象类，丛林
public abstract class Jungle
{
    public abstract void show();
}

//定义抽象工厂
public abstract class AbstractFactory
{
    //抽象方法负责创建新的对象
    public abstract Road CreateRoad();
    public abstract House CreateHouse();
    public abstract Tunnel CreateTunnel();
    public abstract Jungle CreateJungle();
}

//实现抽象类，路
public class ARoad : Road
{
    public override void show()
    {
        System.Console.WriteLine("ARoad.show");
    }
}

//实现抽象类，房子
public class AHouse:House
{
    public override void show()
    {
        System.Console.WriteLine("AHouse.show");
    }
}

//实现抽象类，隧道
public class ATunnle:Tunnel
{
    public override void show()
    {
        System.Console.WriteLine("ATunnel.show");
    }
}

//实现抽象类，丛林
public class AJungle : Jungle
{
    public override void show()
    {
        System.Console.WriteLine("AJungle.show");
    }
}

//实现抽象工厂
public class GetAbstractFactory : AbstractFactory
{
    //方法中返回一系列的新对象
    public override Road CreateRoad()
    {
        return new ARoad();
    }

    public override House CreateHouse()
    {
        return new AHouse();
    }

    public override Tunnel CreateTunnel()
    {
        return new ATunnle();
    }

    public override Jungle CreateJungle()
    {
        return new AJungle();
    }
}

 

//实现抽象类，路
public class BRoad:Road
{
    public override void show()
    {
        System.Console.WriteLine("BRoad.show");
    }
}

//实现抽象类，房子
public class BHouse:House
{
    public override void show()
    {
        System.Console.WriteLine("BHouse.show");
    }
}

//实现抽象类，隧道
public class BTunnel:Tunnel
{
    public override void show()
    {
        System.Console.WriteLine("BHouse.show");
    }
}

//实现抽象类，丛林
public class BJungle:Jungle
{
    public override void show()
    {
        System.Console.WriteLine("BJungle.show");
    }
}

//实现抽象工厂
public class GetAbstractFactoryB:AbstractFactory
{
    //方法中返回一系列新对象
    public override Road CreateRoad()
    {
        return new BRoad();
    }

    public override House CreateHouse()
    {
        return new BHouse();
    }

    public override Tunnel CreateTunnel()
    {
        return new BTunnel();
    }

    public override Jungle CreateJungle()
    {
        return new BJungle();
    }
}

//开始使用上面的抽象工厂
public class Create
{
    private AbstractFactory af;
    public Road road;
    public House house;
    public Tunnel tunnel;
    public Jungle jungle;

    //以抽象工厂的类做为构造方法的参数
    public Create(AbstractFactory af)
    {
        this.af = af;
    }

    private Create()
    {
       
    }

    public void GetCreate()
    {
        road = af.CreateRoad();
        house = af.CreateHouse();
        tunnel = af.CreateTunnel();
        jungle = af.CreateJungle();
    }
}

public class program
{
    static void Main()
    {
        Create cc = new Create(new GetAbstractFactory());
        cc.GetCreate();
        cc.road.show();
        cc.house.show();
        cc.tunnel.show();
        cc.jungle.show();
        System.Console.ReadLine();
        System.Console.WriteLine("-------------------------------");
        Create cc2 = new Create(new GetAbstractFactoryB());
        cc2.GetCreate();
        cc2.road.show();
        cc2.house.show();
        cc2.tunnel.show();
        cc2.jungle.show();
        System.Console.ReadLine();
    }
}