面向对象设计原则

单一职责原则

类或模块的职责应该唯一。

比如需要接收数据， 存储数据， 发送数据， 不应将三个功能直接放在 DataHandler 类中， 而是建立DataReceiver等三个类， 在DataHandler类中使用。

开闭原则

对扩展开放， 对代码修改封闭。

即需要添加新功能时， 不应通过修改源代码实现。 已经实现的代码不能因添加新功能修改。

抽象工厂模式为其应用。

参考资料

接口隔离原则

客户端不应该依赖它不需要的接口。一个类对另一个类的依赖应该建立在最小的接口上。

接口应只提供该类型用户需要的功能， 而不应包含多余的功能。

使用多个专门的接口比使用单一的总接口要好。

interface IOrderForPortal{
    String getOrder();
}
interface IOrderForOtherSys{
    String insertOrder();
    String getOrder();
}
interface IOrderForAdmin{ 
    String deleteOrder();
    String updateOrder();
    String insertOrder();
    String getOrder();
}

class Order implements IOrderForPortal,IOrderForOtherSys,IOrderForAdmin{
    private Order(){
        //--什么都不干,就是为了不让直接 new,防止客户端直接New,然后访问它不需要的方法.
    }
    //返回给Portal
    public static IOrderForPortal getOrderForPortal(){
        return (IOrderForPortal)new Order();
    }
    //返回给OtherSys
    public static IOrderForOtherSys getOrderForOtherSys(){
        return (IOrderForOtherSys)new Order();
    }
    //返回给Admin
    public static IOrderForAdmin getOrderForAdmin(){
        return (IOrderForAdmin)new Order();
    }
    //--下面是接口方法的实现.只是返回了一个String用于演示
    public String getOrder(){
        return "implemented getOrder";
    }
    public String insertOrder(){
        return "implemented insertOrder";
    }
    public String updateOrder(){
        return "implemented updateOrder";
    }
    public String deleteOrder(){
        return "implemented deleteOrder";
    }
}
public class TestCreateLimit{
    public static void main(String[] args){
        IOrderForPortal orderForPortal =Order.getOrderForPortal();
        IOrderForOtherSys orderForOtherSys =Order.getOrderForOtherSys();
        IOrderForAdmin orderForAdmin = Order.getOrderForAdmin();
        System.out.println("Portal门户调用方法:"+orderForPortal.getOrder());
        System.out.println("OtherSys外部系统调用方法:"+orderForOtherSys.insertOrder());
        System.out.println("Admin管理后台调用方法:"+orderForAdmin.getOrder()+";"+orderForAdmin.insertOrder()+";"+orderForAdmin.updateOrder()+";"+orderForAdmin.deleteOrder());
    }
}

参考资料

里氏替换原则

子类替换父类不应出现变化或其他问题。

为了遵循这一原则， 实现子类时需要一些约束。

• 子类不得重写父类非抽象方法（可以重载）
• 子类重载父类方法时， 参数范围不能缩小， 返回值应更严格。（前置条件宽松， 后置条件严格）

依赖倒置原则

高层次不应依赖低层次， 他们都应依赖抽象。

抽象不应依赖具体， 具体依赖与抽象。

不难发现， 以下代码实例也符合开闭原则

public interface ICar
{
    void Run();
    void Turn();
    void Stop();
}
public class BmwCar:ICar
{
    public void Run()
    {
        Console.WriteLine("宝马开始启动了");
    }
    public void Turn()
    {
        Console.WriteLine("宝马开始转弯了");
    }
    public void Stop()
    {
        Console.WriteLine("宝马开始停车了");
    }
}
public class FordCar:ICar
{
    publicvoidRun()
    {
        Console.WriteLine("福特开始启动了");
    }
    public void Turn()
    {
        Console.WriteLine("福特开始转弯了");
    }
    public void Stop()
    {
        Console.WriteLine("福特开始停车了");
    }
}
public class HondaCar:ICar
{
    publicvoidRun()
    {
        Console.WriteLine("本田开始启动了");
    }
    public void Turn()
    {
        Console.WriteLine("本田开始转弯了");
    }
    public void Stop()
    {
        Console.WriteLine("本田开始停车了");
    }
}
public class AutoSystem
{
    private ICar icar;
    public AutoSystem(ICar icar)
    {
        this.icar=icar;
    }
    private void RunCar()
    {
        icar.Run();
    }
    private void TurnCar()
    {
        icar.Turn();
    }
    private void StopCar()
    {
        icar.Stop();
    }
}

参考资料