浅谈java设计模式七大设计原则

设计模式七大设计原则

单一职责原则

• 降低类的复杂度，一个类只负责一个职责
• 提高类的可读性，可维护性
• 降低变更引起的风险
• 可以选择在代码量小的情况下 可在方法上体现单一原则

接口隔离原则

基本介绍

客户端不停该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
简单来说，就是将一个大的接口拆成若干个小的接口，让他们实现若干个小的接口

里氏替换原则

实际开发存在的问题

实际开发中，我们经常重写，父类的方法，这样写起来虽然简单，但是整个继承体系的复用性会比较差，特别是运行多态比较频繁的时候
通常的做法是：原来的父类和子类都继承一个更基础的基类

举例

//**传统代码**
class A{
    public int func1(int a,int b){
        return a-b;
    }
}

class B extends A{
    //这里重写了方法
    public int func1(int a,int b){
        return a+b;
    }

    public int func2(int a,int b){
        return func1(a,b)+9;//这里不满足里氏替换
    }
}


-------------------------------------------------------------------------------------
//**符合里氏替换原则的代码**
class Base{
	public int func1(int a,int b){
        return a-b;
    }
}

class A1 extends Base{

}

class B1 extends  Base{
    private A1 a1=new A1();

    public int func1(int a,int b){
        return a+b;
    }

    public int func2(int a,int b){
        return a1.func1(a,b)+9;
    }
}

依赖倒转原则

高层模块不应该依赖底层模块，二者都应该依赖其抽象
抽象不应该依赖细节，细节应该依赖抽象
依赖倒置的中心思想就是面向接口编程
理念：相对于细节的多变性，抽象的东西要相对稳定。以抽象为基础搭建的框架比以细节为基础的框架要稳定。
抽象—抽象类、接口 ; 制定规范，设计模式。不涉及具体的操作
细节—实现类

实现人接收信息问题

传统代码

//一个Person接收消息的类
//方式以分析
//1.简单，比较容易想到
//2.如果我们从其他地方获取消息就需要新加类
//3.解决思路：引入一个抽象的接口IReceive，表示接收者，这样Person类与接口发生依赖
class Person{
    public void receive(Email email){//依赖这个类
        System.out.println(email.getInfo());
    }
}
//发邮件的方式一
class Email{
    public String getInfo(){
        return "电子邮件信息：hello world";
    }
}
//调试
public class DependencyInversion1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
    }
}

显然上述的代码,可维护性不高.如果再新加其他的接收信息的方式,代码可读性会极差

接口(依赖倒转)

//定义一个接收信息的接口
interface  IReceiver{
    public String getInfo();
}

//接收信息途径一
class Email implements IReceiver{
    public String getInfo(){
        return "电子邮件信息：hello world";
    }
}
//接收信息途径二
class WeiXin implements IReceiver{

    @Override
    public String getInfo() { return "微信消息：hello ok";}
}
class Person{
    public void receive(IReceiver receiver){//依赖接口
        System.out.println(receiver.getInfo());
    }
}
//调试
public class DependencyInversion1 {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeiXin());

    }
}

实现依赖的方式

方式一：通过接口传递实现依赖

//方式一：通过接口传递实现依赖
//开关接口
interface IOpenAndClose{
    public void open(ITV tv);//抽象方法，接收接口
}

interface ITV{//ITV接口
    public void play();
}

class OpenAndClose implements IOpenAndClose{

    @Override
    public void open(ITV tv) {
        tv.play();
    }
}

class Changhong implements ITV{

    @Override
    public void play() {
        System.out.println("长虹电视");
    }
}

 @Test
   public void test1(){
        Changhong changhong = new Changhong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.open(changhong);
    }

方式二：通过构造器实现依赖

//方式2：通过构造方法依赖传递
interface IOpenAndClose{
    public void open();//抽象方法
}
interface ITV{//ITV接口
    public void play();
}

class OpenAndClose implements IOpenAndClose{
    public ITV tv;//成员

    public OpenAndClose(ITV tv) {
        this.tv = tv;
    }

    @Override
    public void open() {
        tv.play();
    }
}

class Changhong implements ITV{
    @Override
    public void play() {
        System.out.println("长虹电视");
    }
}

@Test
  public void test2(){
      Changhong changhong = new Changhong();
      OpenAndClose openAndClose = new OpenAndClose(changhong);

  }

方式三：通过setter方法

//方法3：通过setter方法传递
interface IOpenAndClose{
    public void open();//抽象方法
    public void setTv(ITV tv);
}
interface  ITV{//ITV接口
    public void play();
}

class OpenAndClose implements  IOpenAndClose{
    private ITV tv;

    @Override
    public void open() {
        this.tv.play();
    }

    public void setTv(ITV tv){
        this.tv=tv;
    }
}



class Changhong implements ITV{
    @Override
    public void play() {
        System.out.println("长虹电视");
    }
}
@Test
    public void test3(){
        Changhong changhong = new Changhong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTv(changhong);
        openAndClose.open();
    }

总结

底层模块尽量都用抽象类或接口
变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象之间，就存在一个缓冲层，利于程序扩展和优化
继承时遵循里氏替换原则

开闭原则

1.开闭原则是编程做基础、最重要的原则
2.一个软件实体，模块和函数应该对扩展开放、对修改关闭。用抽象构建框架，用实现扩展细节
3.当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码实现
4.使用设计模式的目的就是遵循开闭原则

合成复用原则

该原则是尽量使用合成/聚合的方式，而不是使用继承

迪米特法则

• 一个对象应该对其他对象保持最少的了解
• 类与类关系越密切,耦合度越大
• 迪米特法则又叫最少知道原则,即一个类对自己依赖的类知道的越少越好,也就是说.对于被依赖的类不管多么复杂,都尽量将逻辑封装再类的内部.对外处理提供public方法,不对外泄露任何信息
• 迪米特法则还有个简单的定义:只与直接的朋友通信
• 直接的朋友:只要两个对象之间又耦合关系,我们就说这两个对象之间是朋友关系.耦合的方式很多,依赖 关联 组合 聚合… 其中,我们成出现成员变量,方法参数,方法返回值中的类为直接的朋友,二出现再局部变量中的类不是直接的朋友.也就是说,陌生的类最好不要以局部变量的形式出现在类的内部

设计原理的核心

找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在与一起
针对接口编程，而不是针对实现编程
为了交互对象之间的松耦合设计而努力