6大设计原则

一、单一职责

定义：应该有且仅有一个原因引起类的变更。

优点：
1、类的复杂性降低，实现什么职责都有清晰明确的定义
2、可读性提高，可维护性提高，变更引起的风险降低。

一个好的单一职责做的好，一个接口变更只对响应的实现类有影响。

举例：一个用户信息实体类，里面的方法，设置用户名称，设置用户密码，获取用户名称
，获取密码，改变用户密码等。

根据单一指责定义，不该讲上面的所有方法都放在用户实体中。

应该分成：
1、BO （Bussiness Objcect） 业务对象
2、Biz （Bussiness Logic） 业务逻辑

也就是说，改变用户密码属于业务逻辑，不属于用户属性里面的。

优化：

1、创建IUserBO(维护用户基本属性)

void serUserID(String userid);
String getUserID（）；
void setUserPass（）；
String getUserPass（）；

2、IUserBiz（负责用户行为）

boolean chagePassword（）；
boolean deleteUser（String userid）；

二、里氏替换原则

问题：主要是处理继承关系，具体逻辑没有仔细看，需要后期补充。

定义：所有引用基类的地方必须能透明的使用其子类对象。

通俗解释：只要父类能出现的地方子类就可以出现，而且替换子类也不会产生任何错误
或者异常，使用者根本不需要知道是父类还是子类，但是反过来就不行了，有子类出现的地方， 父类未必就能适应。

三、依赖倒置

定义：

1、高层模块不应该依赖底层模块，两者都应该依赖其抽象
2、抽象不应该依赖细节
3、细节应该依赖抽象

优点：采用依赖倒置原则可以减少类间的耦合性，提高系统稳定性，降低并行开发引起
的风险，提高代码可读性和可维护性。

在Java中的具体表现

1、模块之间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖
关系是通过接口或者抽象类产生的。
2、接口或者抽象类不依赖于实现类
3、实现类依赖接口或者抽象类。

更加简洁的说：就是面向接口编程（OOD）

举例：

汽车和司机之间的关系。
反面设计：

//司机类
public class Driver
{
//司机的主要职责，开车（传入奔驰汽车，让其驾驶）
public void diver(Benz benz)
{
benz.run();
}
}
//奔驰汽车
public class Benz
{
public void run()
{
println("奔驰汽车开始运行“);
}
}

上面设计程序的问题，如果换成驾驶宝马汽车，则需要修改
司机的类，因为司机类中仅仅定义了奔驰车的构造方法，引起了不必要的变化。

优化：

//司机接口
public interface IDriver
{
public void driver(ICar icar);
}

//司机实现类
public class Driver implements IDriver
{
//无论传入什么样的汽车，司机只需要开就可以了
public void driver（ICar icar）
{
icar.run();
}
}

//汽车接口
public interface ICAR
{
public void run（）;
}

//奔驰实现类
public class Benz implements ICar
{
public void run（）
{
system.out.println("奔驰汽车开始运行");
}
}

//宝马实现类
public class Benz implements ICar
{
public void run（）
{
system.out.println("宝马汽车开始运行");
}
}

//业务场景

public class client
{
public static void main(String[] args)
{
IDriver zhangsan=new Driver();
ICar benz=new Benz();
zhangsan.run();
}
}