设计模式----七大原则和UML类图

大忽悠爱学习

发布于 2021-11-15 15:21:32

31100

代码可运行

文章被收录于专栏：c++与qt学习c++与qt学习

运行总次数：0

代码可运行

设计模式

设计模式常用七大原则

单一职责原则

单一职责原则的注意事项和细节

接口隔离原则

问题:

不符合接口隔离原则，解决方法如下

依赖倒转原则

支付案例演示:

//支付案例演示依赖倒转原则
interface  payWay
{
    public String payBy();
}
//微信
class WeiXin implements payWay{

    @Override
    public String payBy() {
        return "微信支付";
    }
}
//支付宝
class ZhiFuBao implements payWay{

    @Override
    public String payBy() {
        return "支付宝支付";
    }
}
//测试
public class test
{
    public String payByWhat(payWay pay)
    {
             return pay.payBy();
    }
    @Test
    public void test()
    {
        System.out.println(payByWhat(new ZhiFuBao()));
        System.out.println("==================");
        System.out.println(  payByWhat(new WeiXin()));
    }
}

通过接口实现依赖传递

//Tv接口
interface Tv{
    public void play();
}
//开关tv的接口
interface OpenAndClose{
    public void open(Tv tv);//抽象方法，接收接口
}
//实现接口
class OpenClose implements OpenAndClose
{
    @Override
    public void open(Tv tv) {
        tv.play();
    }
}

通过构造方法依赖传递

//Tv接口
interface Tv{
    public void play();
}
//开关tv的接口
interface OpenAndClose{
    public void open();
}
//实现接口
class OpenClose implements OpenAndClose
{
   private Tv tv;
   OpenClose(Tv tv)//构造器传递
   {
       this.tv=tv;
   }
    @Override
    public void open() {
       this.tv.play();
    }
}

通过setter方法实现

//Tv接口
interface Tv{
    public void play();
}
//开关tv的接口
interface OpenAndClose{
    public void open();
}
//实现接口
class OpenClose implements OpenAndClose
{
   private Tv tv;

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

注意事项和细节

里氏替换原则

class A{
    public int fun1(int a,int b)
    {
        return a-b;
    }
}

class B extends  A
{
    //无意中重写了A的fun1方法，但是使用的时候，依然认为fun1是继承自A的方法
    public int fun1(int a,int b)
    {
        return a+b;
    } 
}

解决方法:

//基类解耦合
class base
{
    
}
class A extends  base{
    public int fun1(int a,int b)
    {
        return a-b;
    }
}

class B extends  base
{
    //采用组合方式
    private A aa=new A();
    public int fun1(int a,int b)
    {
        return aa.fun1(a,b);
    }
}

开闭原则

当我们给类增加新功能的时候，尽可能不修改之前的代码，或者少修改之前的代码

//支付案例演示依赖倒转原则
interface  payWay
{
    public String payBy();
}
//微信
class WeiXin implements payWay{

    @Override
    public String payBy() {
        return "微信支付";
    }
}
//支付宝
class ZhiFuBao implements payWay{

    @Override
    public String payBy() {
        return "支付宝支付";
    }
}
//测试
public class test
{
    public String payByWhat(payWay pay)
    {
        return pay.payBy();
    }
    @Test
    public void test()
    {
        System.out.println(payByWhat(new ZhiFuBao()));
        System.out.println("==================");
        System.out.println(  payByWhat(new WeiXin()));
    }
}

之前的支付案例，就是满足开闭原则的一个经典案例，当我们需要增加新的支付方式时，只需要增添一个接口的实现类即可，其余地方代码不需要做改动

主要还是通过一个抽象层或者接口层实现

迪米特法则

没有遵守迪米特法则:

class Stu
{
    String name;
    Stu(String name)
    {
        this.name=name;
    }
    Stu(){}
 //获取所有学生
    public Stream<Stu> getStus()
 {
     List<Stu> list = new ArrayList<>();
     list.add(new Stu("1"));
     list.add(new Stu("2"));
     list.add(new Stu("3"));
     return list.stream();
 }

    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Print
{
    //打印所有学生
    static public void printStu()
    {
        //陌生类作为局部变量
        //输出所有学生的相关信息，这部分功能应该交给学生类来完成，而不是输出类来完成
        Stu stu=new Stu();
         stu.getStus().forEach(s-> System.out.println(s));
    }
}
public class test
{
    @Test
    public void test()
    {
        Print.printStu();
    }
}

遵守迪米特法则:

class Stu
{
    String name;
    Stu(String name)
    {
        this.name=name;
    }
    Stu(){}
 //获取所有学生
    public Stream<Stu> getStus()
 {
     List<Stu> list = new ArrayList<>();
     list.add(new Stu("1"));
     list.add(new Stu("2"));
     list.add(new Stu("3"));
     return list.stream();
 }
 //输出所有学生相关的信息
    public void printStu()
    {
        getStus().forEach(s-> System.out.println(s));
    }
    @Override
    public String toString() {
        return "Stu{" +
                "name='" + name + '\'' +
                '}';
    }
}
class Print
{
   static private Stu s=new Stu();
    //打印所有学生
    static public void print()
    {
        s.printStu();
    }
}
public class test
{
    @Test
    public void test()
    {
        Print.print();
    }
}