目录
开闭原则
关于开闭原则，是面向对象设计中所有原则（包括设计模式）的基础，强调的就是用抽象构建框架，用实现扩展细节。所以也可以说是面向抽象编程，让类依赖抽象，这样扩展起来，不需要修改老代码，也就是说如类、模块、方法应该对扩展开放，对修改关闭。提高软件的稳定性。
优点：提高软件系统的可复用性和可维护性。
举例：
public interface Person {
String getName();
Integer getAge();
Double getWeight();
}public class Haozi implements Person{
String name;
Integer age;
Double weight;
public Haozi(String name, Integer age, Double weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
@Override
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public Double getWeight() {
return weight;
}
public void setWeight(Double weight) {
this.weight = weight;
}
}public class Test {
public static void main(String[] args) {
Person haozi = new Haozi("耗子" , 18 , 60.0);
System.out.println("person:[haozi,name-" + haozi.getName()
+ ",age-" + haozi.getAge() + ",weight-" + haozi.getWeight() + "]");
}
}
结构图：
这样是一个很基础的结构，现在有一个新需求，我想改名，在名称的前后都加个“【】”符号，简单粗暴的方式有几种：在实现类的set里加，但是如果有多个实现类，这样就太麻烦，而且没法看原来的名字。在接口里加方法，但是这样接口就起不到约定的作用了，而且每个实现类都要实现，更麻烦，于是，遵循开闭原则，新建一个类继承需要改名的类
public class NewHaozi extends Haozi{
public NewHaozi(String name, Integer age, Double weight) {
super(name, age, weight);
}
@Override
public String getName(){
return super.getName();
}
public String getNewName(){
return "【" + super.getName() + "】";
}
}public class Test {
public static void main(String[] args) {
Person haozi = new NewHaozi("耗子" , 18 , 60.0);
System.out.println("person:[haozi,name-" + haozi.getName()
+ ",age-" + haozi.getAge() + ",weight-" + haozi.getWeight() + "],newName-"
+ ((NewHaozi) haozi).getNewName());
}
}引用用的时候，就不引用原本的Haozi，而是用新的NewHaozi，这样，不仅可以使用到新的名字，还可以查到原来的名字。
这样，接口也没有变，原实现类也没有变，所以也没有破坏原本的结构，提高了复用性和可维护性，所以开闭原则非常重要。结构图就议案成了：
依赖倒置原则
高层模块不应该依赖底层模块，二者都应该依赖他们的抽象。抽象不应该依赖细节，细节应该依赖抽象。针对接口编程，不要针对实现编程。
简单地说，就是尽量使处理类尽量不要直接和实现类直接产生关系，而是通过其继承的接口，在使用的时候具体传入实现类。
优点：可以减少类之间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。
首先先举一个简单的例子：
public class Haozi {
public void playPCGame(){
System.out.println("耗子正在玩电脑游戏");
}
public void playPS4Game(){
System.out.println("耗子正在玩PS4游戏");
}
}public class Test {
public static void main(String[] args) {
Haozi haozi = new Haozi();
haozi.playPCGame();
haozi.playPS4Game();
}
}现在我又想玩NS了，以现在的情况，只能是在Haozi里面加一个方法，但是如果需求越来越多，那么对Haozi的改动也是越来越大的，这样的做法就是面向实现编程，Haozi就是一个实现类，属于底层模块，Test是高层模块，高层模块直接依赖底层模块的具体实现，所以这也不符合依赖倒置原则。
接下来用依赖倒置原则写一下：
public interface Game {
void playGame(String name);
}public class PCGame implements Game{
@Override
public void playGame(String name) {
System.out.println(name + "正在玩电脑游戏");
}
}public class PS4Game implements Game {
@Override
public void playGame(String name) {
System.out.println(name + "正在玩PS4游戏");
}
}public class Haozi {
public void playGames(Game game){
game.playGame("耗子");
}
}public class Test {
public static void main(String[] args) {
Haozi haozi = new Haozi();
haozi.playGames(new PCGame());
haozi.playGames(new PS4Game());
}
}看一下类图：
这样，Test就不直接依赖具体实现类了，而是通过Haozi，这样，再想加玩NS游戏，我只要再写一个类实现Game接口，其他的都不需要动了，我需要实现什么，通过高层模块决定就好了，这样，Haozi和Test也解耦了。
代码再进一步优化，用set的方式
public class Haozi {
private Game game;
public void setGame(Game game) {
this.game = game;
}
public void playGames(){
game.playGame("耗子");
}
}public class Test {
public static void main(String[] args) {
Haozi haozi = new Haozi();
haozi.setGame(new PCGame());
haozi.playGames();
haozi.setGame(new PS4Game());
haozi.playGames();
}
}再看一下类图：
具体玩什么，都不会动Haozi，只需要动应用层Test，添加只需要添加Game即可。这样的结构，也比依赖具体的稳定的多。
单一职责原则
不要存在多余一个导致类变更的愿意，举例：假如在一个类中，有职责1和职责2，在修改职责1的时候，会影响职责2，这就是没有实现单一职责原则。所以一个类/接口/方法只负责一项职责。
优点：降低类的复杂度、提高类的可读性，提高系统的可维护性、降低变更引起的风险。举个例子：
类上的单一职责：
public class Haozi {
public void wearClothes(String weather){
System.out.println("耗子" + weather+ "穿棉袄");
}
}public class Test {
public static void main(String[] args) {
Haozi haozi = new Haozi();
haozi.wearClothes("下雪");
}
}但如果我传入“天热”，就变成了天热穿棉袄，正常来说肯定是不对的，所以还需要扩展：
public class Haozi {
public void wearClothes(String weather){
if("下雪".equals(weather)){
System.out.println("耗子" + weather + "穿棉袄");
}else if ("天热".equals(weather)){
System.out.println("耗子" + weather + "穿短袖");
}
}
}这样虽然解决了问题，但是如果我还有别的天气呢？这就需要不停地扩展Haozi ，违背了单一职责。遵循单一职责原则，我们把穿衣这个类拆分成天冷和天热两种：
public class HotWeather {
public void wearClothes(String weather) {
System.out.println("耗子" + weather + "穿单衣");
}
}public class ColdWeather {
public void wearClothes(String weather) {
System.out.println("耗子" + weather + "穿棉袄");
}
}再看类图
接口上的职责单一：
public interface Game {
//获取游戏信息
String getGameName();
Float getPlayTime();
//游戏相关操作
void playGame();
void refundGame();
}这样一个接口有两个职责，获取游戏信息和对游戏的相关操作，玩游戏的话，可以获取到游戏时间，但是如果把游戏推掉了，那就不能获取游戏时间了，所以这两个职责互相影响，不符合单一职责原则。
把这个接口拆分：
public interface GameContent {
String getGameName();
Float getPlayTime();
}public interface GameManager {
void playGame();
void refundGame();
}public class GameImpl implements GameContent , GameManager{
@Override
public String getGameName() {
return null;
}
@Override
public Float getPlayTime() {
return null;
}
@Override
public void playGame() {
}
@Override
public void refundGame() {
}
}这样，一个接口的修改只对实现类有影响，对于其他接口没有影响。
类图：
方法上的单一职责：
public class Person {
public Haozi updateHaozi(Haozi haozi){
haozi.setName("耗子");
haozi.setAddress("123");
return haozi;
}
class Haozi{
private String name;
private String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
}这样的话，updateHaozi这个方法就有了两个职责，一个设置名字，一个设置地址，一般来说遵照单一原则，会拆分成两个方法：
public Haozi updateName(Haozi haozi){
haozi.setName("耗子");
return haozi;
}
public Haozi updateAddr(Haozi haozi){
haozi.setAddress("123");
return haozi;
}在实际使用的过程中，接口和方法的单一职责比较好遵循，对于类如果一味地追求单一职责，类的数量可能非常多，所以对于类的单一职责，在实际场景中灵活使用就好。
接口隔离原则
一个类对一个类的依赖应该建立在最小的接口上，假如有一个接口里面有很多方法，那么如果一个类（或接口）实现这个接口，那里面的方法都要实现（这里不说default），所以我们要建立单一的接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少，当然，一定要根据实际情况适度。
优点：符合我们常说的高内聚低耦合的设计思想，从而使类具有很好的可读性、可扩展性、可维护性。
举例：
public interface AnimalAction {
public void eat();
public void fly();
public void swim();
}public class Dog implements AnimalAction{
@Override
public void eat() {
}
@Override
public void fly() {
}
@Override
public void swim() {
}
}public class Bird implements AnimalAction {
@Override
public void eat() {
}
@Override
public void fly() {
}
@Override
public void swim() {
}
}类图：
对于动物的行为，狗会吃和游泳，但不会飞，对于鸟来说，会吃，有些鸟会飞有些不会，所以对于这种情况，实现了动物行为的接口，那么有些接口就是空实现了。
根据接口隔离原则优化一下：
public interface AllAnimalAction {
public void eat();
}public interface FlyAnimalAction {
public void fly();
}public interface SwimAnimalAction {
public void swim();
}public class Dog implements AllAnimalAction , SwimAnimalAction{
@Override
public void eat() {
}
@Override
public void swim() {
}
}public class Bird implements AllAnimalAction , FlyAnimalAction {
@Override
public void eat() {
}
@Override
public void fly() {
}
}再看类图：
这样就解决了有些方法空实现的问题，细粒度是可以合并的，但是粗粒度是不可以拆分的。当然在实际工作过程中还是要根据实际情况来使用。
迪米特法则（最少知道原则）
一个对象应该对其他对象保持最少的了解。强调指和朋友交流，不和陌生人说话（朋友是指出现在成员变量、方法的出入参中的类成为成员朋友类，出现在方法体内部的类不属于朋友类）
优点：降低类之间的耦合
举例：
public class Boss {
public void checkNumber(Worker worker){
List<Goods> goodsList = new ArrayList<>();
for(int i = 0 ; i < 20 ; i ++){
goodsList.add(new Goods());
}
worker.checkNumberGoods(goodsList);
}
}public class Worker {
public void checkNumberGoods(List<Goods> goodsLists){
System.out.println("一共有" + goodsLists.size() + "件商品");
}
}
依照上面的定义，对于Boss而言，worker是他的朋友类，但是方法体中的Goods并不是，所以按照迪米特法则，boos并不是直接创建Goods的，所以Goods不要出现在方法体中。
调整一下：
public class Boss {
public void checkNumber(Worker worker){
worker.checkNumberGoods();
}
}public class Worker {
public void checkNumberGoods(){
List<Goods> goodsList = new ArrayList<>();
for(int i = 0 ; i < 20 ; i ++){
goodsList.add(new Goods());
}
System.out.println("一共有" + goodsList.size() + "件商品");
}
}类图：
这样就清爽多了
里氏替换原则
如果程序中，一个类型为A的对象a，还有一个类型为B的对象b，当我们把a对象都替换成b对象，对于系统没有变化的时候，那么a就是b的父类。也就是说只有当子类可以替换父类，并且软件功能不受影响的时候，父类才是真正的被复用了。
对于定义的扩展：一个软件实体如果使用一个父类的话，那么一定适用于其子类，所有引用父类的地方必须能透明地使用其子类对象，子类对象能够替换父类对象，而程序逻辑不变。
引申意义：子类可以扩展父类的功能，但不能改变父类原有的功能。
1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
2.子类中可以增加自己特有的方法。
3.当子类的方法重载父类的方法时，方法的前置条件（即入参）要比父类方法的入参更宽松。
4.当子类的方法实现父类的方法时（重写/重载/实现抽象方法），方法的后置条件（即出参）要比父类的更严格或相等。
优点：约束继承泛滥，开闭原则的一种体现。加强程序的健壮性，同时变更的时候也可以做到非常好的兼容性，提高程序的维护性和扩展性，降低需求变更时引入的风险。
举个例子
public class Rectangle {
private long length;
private long width;
public long getLength() {
return length;
}
public void setLength(long length) {
this.length = length;
}
public long getWidth() {
return width;
}
public void setWidth(long width) {
this.width = width;
}
}public class Square extends Rectangle{
private long sideLength;
public long getSideLength() {
return sideLength;
}
public void setSideLength(long sideLength) {
this.sideLength = sideLength;
}
@Override
public long getLength() {
return getSideLength();
}
@Override
public void setLength(long length) {
setSideLength(length);
}
@Override
public long getWidth() {
return getSideLength();
}
@Override
public void setWidth(long width) {
setSideLength(width);
}
}public class Test {
public static void resize(Rectangle rectangle){
while (rectangle.getWidth() <= rectangle.getLength()){
rectangle.setWidth(rectangle.getWidth() + 1);
System.out.println("width:" + rectangle.getWidth()
+ ",length:" + rectangle.getLength());
}
System.out.println("end");
}
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.setWidth(10);
rectangle.setLength(20);
resize(rectangle);
}
}运行结果：
如果main方法换成正方形呢？
public static void main(String[] args) {
Square square = new Square();
square.setLength(10);
resize(square);
}由于while条件一直满足，所以会无限执行下去，这就跟我们预期的不一样了，所以有时候子类父类的关系需要多注意。
新建一个四边形接口
public interface Quadrangle {
long getLength();
long getWidth();
}调整一下
public class Rectangle implements Quadrangle{
private long length;
private long width;
@Override
public long getLength() {
return length;
}
public void setLength(long length) {
this.length = length;
}
@Override
public long getWidth() {
return width;
}
public void setWidth(long width) {
this.width = width;
}
}public class Square implements Quadrangle{
private long sideLength;
public void setSideLength(long sideLength) {
this.sideLength = sideLength;
}
@Override
public long getLength() {
return sideLength;
}
@Override
public long getWidth() {
return sideLength;
}
}这样，在main方法中resize就不能使用正方形了，这样也就防止了继承泛滥，父类和子类不一致的情况。
合成（组合）/聚合复用原则
尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的。组合：contains-A，聚合：has-A，继承：is-A
优点：可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响较少。
对于继承关系，父类的实现细节都会暴露给子类，而对于组合来说，A里面有个B类，对于B类的具体实现细节A是看不到的。
组合：A类中创建了B类对象，当A类消失的时候，B类这个引用也就消失了。
聚合：A类中创建了B类对象，这个对象还被C类引用，当A类消失的时候，B类不会消失。
举个例子：
public class DBConnection {
public String getConnection(){
return "mysql";
}
}public class ProductDao extends DBConnection {
public void addProduce(){
String conn = super.getConnection();
System.out.println("使用" + conn + "数据连接");
}
}public class Test {
public static void main(String[] args) {
ProductDao productDao = new ProductDao();
productDao.addProduce();
}
}类图：
这是一个继承关系，如果我还需要一个Oracle连接，以现有的情况，我们可以在DBConnection 中再加一个，但这样就违反了开闭原则。
调整一下：
public abstract class DBConnection {
public abstract String getConnection();
}public class MysqlConnection extends DBConnection {
@Override
public String getConnection() {
return "Mysql";
}
}public class ProductDao{
private DBConnection dbConnection;
public void setDbConnection(DBConnection dbConnection) {
this.dbConnection = dbConnection;
}
public void addProduce(){
String conn = dbConnection.getConnection();
System.out.println("使用" + conn + "数据连接");
}
}public class Test {
public static void main(String[] args) {
ProductDao productDao = new ProductDao();
productDao.setDbConnection(new MysqlConnection());
productDao.addProduce();
}
}类图：
这样一来，ProductDao和DBConnection就是一对一的组合复用关系，更加灵活了。
扫一扫
386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
