一個插排引發的設計思想 (二) 抽象類與介面

 

一個插排引發的設計思想 (一) 觀察者模式

一個插排引發的設計思想 (二) 抽象類與介面

一個插排引發的設計思想 (三) 委託與事件

...待續....

 

上一篇以完成任務式的方式實現了插排的功能.

其中插頭的規範部分值得思考, 上文采用了abstract class的方式, 

既然是定義規範, 為什麼不用介面方式呢?

一. 下面把上面的例子改造一下, 將原來的abstract class改為介面.

    public interface IGBElectricalAppliance
    {
        void Input(int left, int right);
    }

    public class OutPut
    {
        public OutPut()
        {
            this.EACollection = new List<IGBElectricalAppliance>();
        }
        private List<IGBElectricalAppliance> EACollection;
        public void powered(int left,int right)
        {
            foreach (var item in EACollection)
            {
                item.Input(left,right);
            }
        }
        public void AddInput(IGBElectricalAppliance item)
        {
            EACollection.Add(item);
        }

        public void RemoveInput(IGBElectricalAppliance item)
        {
            EACollection.Remove(item);
        }
    }



    public class TV : IGBElectricalAppliance
    {
        public void Input(int left, int right)
        {
            Show();
            Sound();
        }

        private void Show()
        {
            Console.WriteLine("I am showing");
        }
        private void Sound()
        {
            Console.WriteLine("I am sounding");
        }
    }

    public class ElectricKettle : IGBElectricalAppliance
    {
        public void Input(int left, int right)
        {
            Heat();
        }

        private void Heat()
        {
            Console.WriteLine("I am heating");
        }
    }

 

執行一下結果也是一樣, 看起來也沒啥不同的.

那麼到底該用那種方法呢?

二. 現在看一下 abstract class和interface的區別

二者都可以定義一些"規範", 都不可以例項化,

但abstract class中可以有實現的方法, 介面不可以

假如電器有一一些共用的方法例如功率計算(PowerCalculation)等, 可以在abstract class中實現, 非常方便, 這是interface無法實現的, 如下面程式碼所示

    public abstract class GBElectricalAppliance
    {
        public abstract void Input(int left, int right);

        /// <summary>
        /// 計算實時功率
        /// </summary>
        /// <param name="u">電壓</param>
        /// <param name="i">電流</param>
        public void PowerCalculation(int u ,int i)
        {
            Console.WriteLine("Power:" + (u * i).ToString());
        }

        //其他通用方法
    }

從另一個不同來看, interface允許繼承多個, 而abstract class不可以.

所以我們也可以這樣想, abstract class的含義是"是XX", 反映到例子總就是插座要求插上的裝置是國標電器.

如果我們把介面再改一下,

    public interface IGBElectricalable
    {
        void Input(int left, int right);
    }

    public class Other : IGBElectricalable
    {
        public void Input(int left, int right)
        {
            doSomeThing();
        }

        private void doSomeThing()
        {
            Console.WriteLine("I am other");
        }
    }

 

只是改了個名字, 大概意思是擁有符合國標標準插頭的, 注意這裡不再強調是電器了.

例如某些大型機械(上面程式碼中的Other), 用電部分可能只是輔助, 再定義為電器已經有點不合適了, 它也不需要繼承 GBElectricalAppliance.

 

三.原來的程式碼調整如下

    public class OutPut
    {
        public OutPut()
        {
            this.EACollection = new List<IGBElectricalable>();
        }
        private List<IGBElectricalable> EACollection;
        public void powered(int left,int right)
        {
            foreach (var item in EACollection)
            {
                item.Input(left,right);
            }
        }
        public void AddInput(IGBElectricalable item)
        {
            EACollection.Add(item);
        }

        public void RemoveInput(IGBElectricalable item)
        {
            EACollection.Remove(item);
        }
    }

    public abstract class GBElectricalAppliance:IGBElectricalable
    {
        public abstract void Input(int left, int right);

        /// <summary>
        /// 計算實時功率
        /// </summary>
        /// <param name="u">電壓</param>
        /// <param name="i">電流</param>
        public void PowerCalculation(int u, int i)
        {
            Console.WriteLine("Power:" + (u * i).ToString());
        }

        //其他通用方法
    }

    public class TV : GBElectricalAppliance
    {
        public override void Input(int left, int right)
        {
            Show();
            Sound();
        }

        private void Show()
        {
            Console.WriteLine("I am showing");
        }
        private void Sound()
        {
            Console.WriteLine("I am sounding");
        }
    }

    public class ElectricKettle : GBElectricalAppliance
    {
        public override void Input(int left, int right)
        {
            Heat();
        }

        private void Heat()
        {
            Console.WriteLine("I am heating");
        }
    }

 

原來的TV和Kettle依然可以繼承自 GBElectricalAppliance, 這樣它們的共用方法 PowerCalculation依然生效,

而GBElectricalAppliance繼承了介面 IGBElectricalable

測試一下將Other也插入插排

 

    class Program
    {
        static void Main(string[] args)
        {
            OutPut op = new OutPut();
            op.AddInput(new TV());
            op.AddInput(new ElectricKettle());
            op.AddInput(new Other());

            op.powered(220, 0);
        }
    }

 

可以看到結果中出現了 "I am other".

 

四:小結

 本次用介面的方式對原例子進行了改造, 進一步將插排和插入裝置解耦.

文一中, 插排要求插入的裝置是符合國標的電器.

本文中, 插排要求插入的裝置有符合國標的插頭即可, 無論什麼樣的裝置, 無論其是否是電器.

 

五.思考

由此, 現在進一步想一想, 既然是有符合國標的插頭即可.而插頭無非就是Input一個方法.

而前兩種方式無論是抽象類還是介面, 都是將裝置本身放入了插排的集合中, 

    即 AddInput(IGBElectricalable item), 然後再由插排呼叫集合中裝置的Input方法.

 這貌似搞得有點複雜, 耦合度還是高, 而且也不符合實際中直插入插頭而不是整個裝置的事實.

那麼我們是否可以將此處的引數用由插入裝置本身(觀察者)改為裝置的Input方法呢

  即 AddInput(Input _input), 然後再由插排直接呼叫集合中的Input方法.

下篇繼續討論..