少有人走的路勇哥注：
此贴为转载，转载地址不详，对作者抱歉。
此贴尾，勇哥写了带有C#代码的读书笔记。
面向对象设计原则之开闭原则 开闭原则的定义是：软件实体应当对扩展开放，对修改关闭。
我们通过例子来了解这个设计原则： 假如现在我们有一个Duck超类，它有嘎嘎叫、戏水、外观等方法。
当有外观颜色不同的鸭子时，都可以继承Duck类，然后再覆盖继承得到的外观方法即可。这样就实现了代码复用。
现在有个新的需求，要求让所有的鸭子都会飞，由于我们使用了继承，这很容易做到，只要在Duck超类中添加飞行方法即可。
现在需求改变，飞行方法会定期更新，并且要求黑色的鸭子可以飞，白色的鸭子不可以飞，这时，因为所有的鸭子都是派生于Duck超类，我们就需要重写白色鸭子的飞行方法，将白色鸭子的飞行方法重写成不能飞行。当Duck超类的派生类少的时候，完全可以这样做，可如果有几十个、甚至是上百个派生类时，这时工作量就是巨大的；而且每新增加Duck的子类时，都需要检查新增加的类是否可以飞，来决定是否需要重写飞行方法。
这时我们会想着，不如把飞行方法抽象出一个接口，可以飞行的实现接口就可以了。但是，这样就摧毁了代码复用，而且飞行方法还会定期更新。
这时，就要用到我们的设计原则了。开闭原则。
开闭原则的重点在于将应用中会变化的部分取出并封装，这样在以后就可以修改或者扩展这个部分，而不会影响其他不需要变化的部分。
在这个例子中，我们可以遵循开闭原则来对它进行修改。修改的步骤如下：
1.将Duck超类中变化的部分取出。即将飞行方法取出，抽象到一个飞行接口Fly中。（这里其实还用到了单一接口原则）
2.Duck超类需要声明抽象出去的接口变量。（即声明Fly类型变量fly）
3.根据飞行动作或是能否飞行来实现Fly接口。
4.创建子类继承Duck超类，并在构造方法中实例化fly变量。
这样，在创建子类时就可以通过实例化不同的Fly接口实现类，来确定其飞行方法。并且在后续更新方法时也只需更新Fly接口的实现类即可。
如果你已经看到了这里，那可以麻烦您点个赞支持下么，笔者在这里先行谢过
下面附上完整代码：
public interface Fly {
void fly();
}
public class AbleFly implements Fly{
@Override
public void fly()
{
System.out.println("我可以飞！正在飞行......");
}
}
public class NoFly implements Fly{
@Override
public void fly()
{
System.out.println("抱歉，我不会飞！");
}
}
public abstract class Duck
{
//创建Fly接口变量
public Fly fly;
public void quack()
{
System.out.println("嘎嘎叫！");
}
public void doFly()
{
fly.fly();
}
}
public class BlackDuck extends Duck
{
//黑色的鸭子可以飞
public BlackDuck()
{
this.fly = new AbleFly();
}
}
public class WhiteDuck extends Duck
{
//白色的鸭子不会飞
public WhiteDuck()
{
this.fly = new NoFly();
}
}下面是勇哥的读书笔记：
Duck类 方法有：嘎嘎叫、戏水； 属性有：颜色 需求1： 所有鸭子要会飞 需求2： 区分飞行方法，黑色的鸭子会飞，白色的只会走路 需求3： 有300种颜色的鸭子，飞行方式多种多样
下面的代码完成了需求1和2，但是需求3就遇到问题了。
显然，你不可能覆写全部300个类的fly
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication12
{
class Program
{
private static List<Duck> duckList = new List<Duck>();
static void Main(string[] args)
{
List<Duck> ducklist = new List<Duck>();
for (int i = 0; i < 5; i++)
{
ducklist.Add(new 白鸭());
ducklist.Add(new 黑鸭());
}
foreach(var m in ducklist)
{
m.Fly();
}
Console.ReadKey();
}
}
public class 白鸭:Duck
{
public override void Fly()
{
Console.WriteLine("白鸭不会飞。。。");
}
}
public class 黑鸭 : Duck
{
public override void Fly()
{
Console.WriteLine("黑鸭会飞。。。");
}
}
public class Duck
{
public enum colorEnum
{
白色, 黑色, 黄色, 红色
}
public void 嘎嘎叫()
{
Console.WriteLine("嘎嘎。。。");
}
public void 戏水()
{
Console.WriteLine("戏水。。。");
}
public colorEnum color { get; set; }
public virtual void Fly()
{
}
}
}弄个IFly接口。
下面这种写法只是不用每个子类去覆写fly方法了。
但是代码领会错了意思，需求真正的变化点是飞行方法
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication12
{
class Program
{
private static List<Duck> duckList = new List<Duck>();
static void Main(string[] args)
{
List<Duck> ducklist = new List<Duck>();
for (int i = 0; i < 5; i++)
{
ducklist.Add(new 白鸭() { color= Duck.colorEnum.白色 });
ducklist.Add(new 黑鸭() { color = Duck.colorEnum.黑色 });
}
foreach(var m in ducklist)
{
m.Fly();
}
Console.ReadKey();
}
}
public interface IFly
{
void Fly();
}
public class 白鸭:Duck
{
}
public class 黑鸭 : Duck
{
}
public class Duck: IFly
{
public enum colorEnum
{
白色, 黑色, 黄色, 红色
}
public void 嘎嘎叫()
{
Console.WriteLine("嘎嘎。。。");
}
public void 戏水()
{
Console.WriteLine("戏水。。。");
}
public void Fly()
{
switch(color)
{
case colorEnum.黑色:
Console.WriteLine("可以飞");
break;
default:
Console.WriteLine("不可以飞");
break;
}
}
public colorEnum color { get; set; }
}
}下面的代码，真正做到了对于飞行方法来讲，我们做到了开闭原则。
再增加新颜色鸭子时，不会对duck类进行改动。而是使用扩展的方法进行实现。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication12
{
class Program
{
private static List<Duck> duckList = new List<Duck>();
static void Main(string[] args)
{
List<Duck> ducklist = new List<Duck>();
for (int i = 0; i < 5; i++)
{
ducklist.Add(new 白鸭() { color= Duck.colorEnum.白色 });
ducklist.Add(new 黑鸭() { color = Duck.colorEnum.黑色 });
}
foreach(var m in ducklist)
{
m.Fly();
}
Console.ReadKey();
}
}
public interface IFly
{
void Fly();
}
public class 白鸭:Duck
{
public 白鸭()
{
base.flyFun = new FlyMethod2();
}
}
public class 黑鸭 : Duck
{
public 黑鸭()
{
base.flyFun = new FlyMethod1();
}
}
public class Duck
{
public IFly flyFun;
public enum colorEnum
{
白色, 黑色, 黄色, 红色
}
public void 嘎嘎叫()
{
Console.WriteLine("嘎嘎。。。");
}
public void 戏水()
{
Console.WriteLine("戏水。。。");
}
public void Fly()
{
flyFun.Fly();
}
public colorEnum color { get; set; }
}
public class FlyMethod2 : IFly
{
public void Fly()
{
Console.WriteLine("只会走路");
}
}
public class FlyMethod1:IFly
{
public void Fly()
{
Console.WriteLine("可以飞");
}
}
}
