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

Posted 大忽悠爱忽悠

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了设计模式----七大原则和UML类图相关的知识,希望对你有一定的参考价值。

设计模式常用七大原则


单一职责原则



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


接口隔离原则


问题:


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


依赖倒转原则


支付案例演示:

//支付案例演示依赖倒转原则
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();
    }
}


注意事项


合成复用原则



设计原则核心思想


UML类图


分类和说明


UML类图


IDEA的UML类图使用方法

教程


类图六大关系总结

依赖关系

泛化关系

实现关系

关联关系

聚合关系

组合关系



以上是关于设计模式----七大原则和UML类图的主要内容,如果未能解决你的问题,请参考以下文章

Java设计模式-创建型设计模式-原型模式

设计模式第一篇:概述耦合UML七大原则,详细分析总结(基于Java)

设计模式概论与原则 & UML类图

设计模式概述

大话设计模式——设计原则单例模式(UML类图)

面向对象编程原则(02)——UML与类图