目录
开闭原则
关于开闭原则,是面向对象设计中所有原则(包括设计模式)的基础,强调的就是用抽象构建框架,用实现扩展细节。所以也可以说是面向抽象编程,让类依赖抽象,这样扩展起来,不需要修改老代码,也就是说如类、模块、方法应该对扩展开放,对修改关闭。提高软件的稳定性。
优点:提高软件系统的可复用性和可维护性。
举例:
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就是一对一的组合复用关系,更加灵活了。