C#笔记—对于面向接口（抽象）编程的思考
先模拟如下业务场景：
定义一个manager（管理员）类，一个Article（文章）类，管理员分为普通管理员和超级管理员，文章有编辑功能，只有超级管理员有权限对文章进行编辑；下面用代码模拟场景：
//为了方便表示管理员权限，使用枚举方式
enum Level
{
normal = 0, //普通
super = 1 //超级
}
//管理员类
class Manager
{
private int _id;
private string _name;
private int _level;
public Manager(int id, string name, int level)
{
_id = id;
_name = name;
_level = level;
}
public bool CheckPower()
{
if (_level.Equals(Convert.ToInt32(Level.super)))
{
return true;
}
return false;
}
}
//文章类class Article
{
private int _id;
private string _title;
public Article(int id, string title)
{
_id = id;
_title = title;
}
public void Edit()
{
Console.WriteLine("{0} has been edited!", _title);
}
}
//客户端实现
static void Main(string[] args)
{
Manager manager = new Manager(1, "ycj", Convert.ToInt32(Level.normal));
Article art = new Article(1, "test");
if (manager.CheckPower())
{
art.Edit();
}
else
{
Console.WriteLine("Sorry, your have no RIGHT!");
}
Console.ReadKey();
}
我们在管理员类中实现了CheckPower()方法来判断是否具有相应权限来操作文章，现在假设需求变动， 需要增加一个writer（作者）类，也对作者类进行文章编辑的权限控制，代码如下：
class Writer
{
private int _id;
private string _name;
private int _level;
public Writer(int id, string name, int level)
{
_id = id;
_name = name;
_level = level;
}
public bool CheckPower()
{
if (_level.Equals(Convert.ToInt32(Level.super)))
{
return true;
}
return false;
}}
客户端修改如下：Manager manager = new Manager(1, "ycj", Convert.ToInt32(Level.normal));
Writer writer = new Writer(2, "jlf", Convert.ToInt32(Level.super));
Article art = new Article(1, "test");
if (manager.CheckManagerPower())
{
art.Edit();
}
else
{
Console.WriteLine("Sorry, your have no RIGHT!");
}
if (writer.CheckWriterPower())
{
art.Edit();
}
else
{
Console.WriteLine("Sorry, your have no RIGHT!");
}
发现在客户端实现较为冗长，可以在Art类中进行修改：class Article{
...//一些代码
public void Edit(Manager manager)
{
if (manager.CheckManagerPower())
{
Console.WriteLine("{0} has been edited!", _title);
}
else
{
Console.WriteLine("Sorry, your have no RIGHT!");
}
}
public void Edit(Writer writer)
{
if (writer.CheckWriterPower())
{
Console.WriteLine("{0} has been edited!", _title);
}
else
{
Console.WriteLine("Sorry, your have no RIGHT!");
}
}
}
我们对Article类中的Edit方法进行重载，即可实现同时满足manager和writer的方法 。
问题来了，如果新的需求需要实现一个形如Reader类，也对Article进行可编辑的权限控制呢？是否仍然继续添加对于Reader类的一个Edit的重载？这样是否太繁琐？
经过思考发现， 造成需求复杂的原因是，不断的会有新的实体类加进来，需要实现对于Edit()方法的权限判断，造成了新的实体类和Article类的耦合，因此需要借助一个中间层把新的实体类和Article类进行解耦；而这个中间层就是 接口！
我们可以引入如下接口进行解耦：interface ICheckPower
{
bool CheckPower();
}
对Manager类和Aritle类进行改造：
class Manager : ICheckPower
{
....// 一些代码
public bool CheckPower()
{
if (_level.Equals(Convert.ToInt32(Level.super)))
{
return true;
}
return false;
}
}
class Article
{
...//一些代码
public void Edit(ICheckPower check)
{
if (check.CheckPower())
{
Console.WriteLine("{0} has been edited!", _title);
}
else
{
Console.WriteLine("Sorry, your have no RIGHT!");
}
}}
我们将Manager类继承ICheckPower接口，实现CheckPower()方法，在Article类中，把Edit方法中的参数替换为接口的实现（ICheckPower check），这样就可以实现继承于ICheckPower接口的任何实体类的引用，客户端代码如下：
static void Main(string[] args)
{
Manager manager = new Manager(1, "ycj", Convert.ToInt32(Level.normal));
Article art = new Article(1, "test");
art.Edit(manager);
Console.ReadKey();
}
我们只需要在Edit()方法中载入Manager类即可，因为它继承了ICheckPower接口并且实现了方法CheckPower()；
假设新增了一个Writer类：
class Writer : ICheckPower
{
...//一些代码
public bool CheckPower()
{
if (_level.Equals(Convert.ToInt32(Level.super)))
{
return true;
}
return false;
}
}
只需要让Writer类继承ICheckPower即可，Article类本身并不需要做任何修改；
这样就实现了新的实体类和Article类的解耦，双方各自做变化，互不干扰，客户端实现为：
static void Main(string[] args)
{
Manager manager = new Manager(1, "ycj", Convert.ToInt32(Level.normal));
Writer writer = new Writer(2, "jlf", Convert.ToInt32(Level.super));
Article art = new Article(1, "test");
art.Edit(manager);
art.Edit(writer);
Console.ReadKey();
}
简单而优雅 :-)
总结：面向抽象或面向接口，其实就是对于变化的封装，通过引入接口这一个中间层，将两个原本耦合的类进行解耦，使其可以各自独立的变化；
