面试高频Java设计原则总结

Posted 2022-11-28 温文艾尔

⭐️写在前面

---

• 这里是温文艾尔的学习之路
• 👍如果对你有帮助，给博主一个免费的点赞以示鼓励把QAQ
• 👋博客主页🎉 温文艾尔的学习小屋
• ⭐️更多文章👨‍🎓请关注温文艾尔主页📝
• 🍅文章发布日期：2022.03.28
• 👋java学习之路！
• 欢迎各位🔎点赞👍评论收藏⭐️
• 🎄冲冲冲🎄
• ⭐️上一篇内容：HashMap夺命14问，你能坚持到第几问？

---

文章目录

• 1.1开闭原则
• 1.1抽象类（AbstractSkin）
• 1.2默认皮肤（DefaultSpecificSkin）
• 1.3自定义皮肤（WqlSpecificSkin）
• 1.4聚合类（SougouInput）
• 1.5测试
• 2.里氏替换原则
• 2.1长方形类（Rectangle）
• 2.2正方形类（Square）
• 2.3测试类
• 3.依赖倒转原则
• Cpu接口
• IntelCpu
• Memory接口
• KingstonMemory
• Disk接口
• XiJieHardDisk
• 电脑类
• 测试
• 4.接口隔离原则
• 5.迪米特原则
• 明星类
• 粉丝类
• 公司类
• 经纪人类
• 测试类
• 6.合成复用原则

设计原则一共有6条

• 开闭原则
• 里氏替换原则
• 依赖倒转原则
• 接口隔离原则
• 迪米特原则
• 合成复用原则

遵循设计原则的目的是提高软件系统的可维护性和可复用性，增加软件的可扩展性和灵活性，提升软件开发效率，节约软件开发成本和维护成本

1.1开闭原则

对扩展开放，对修改关闭。在程序进行扩展的时候，不能去修改原有的代码，要实现一个热拔插的效果，类似于我们的U盘，不同种类的U盘都可以和我们的电脑进行联系。

想要达到这样的效果，我们需要使用接口和抽象类

我们以搜狗输入法为例介绍开闭原则的应用

分析：搜狗输入法的皮肤是输入法背景图片，窗口颜色和声音的组合，用户可以根据自己的喜爱更换输入法的皮肤，也可以从网上下载新的皮肤，这些皮肤属于同一种东西，所以可以为其定义一个抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin）和（WqlSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主体，而不需要修改源代码，所以他是满足开闭原则的

1.1抽象类（AbstractSkin）

public abstract class AbstractSkin 
    public abstract  void display();

1.2默认皮肤（DefaultSpecificSkin）

public class DefaultSpecificSkin extends  AbstractSkin
    @Override
    public void display() 
        System.out.println("默认皮肤");
    

1.3自定义皮肤（WqlSpecificSkin）

public class WqlSpecificSkin extends AbstractSkin 
    @Override
    public void display() 
        System.out.println("自定义皮肤");
    

1.4聚合类（SougouInput）

public class SougouInput 
    AbstractSkin skin;

    public void setSkin(AbstractSkin skin) 
        this.skin = skin;
    

    public void display()
        skin.display();
    

1.5测试

public class Test 
    public static void main(String[] args) 
        DefaultSpecificSkin defaultSpecificSkin = new DefaultSpecificSkin();
        WqlSpecificSkin wqlSpecificSkin = new WqlSpecificSkin();
        SougouInput sougouInput = new SougouInput();
        sougouInput.setSkin(defaultSpecificSkin);
        sougouInput.display();
        sougouInput.setSkin(wqlSpecificSkin);
        sougouInput.display();
    

默认皮肤
自定义皮肤

2.里氏替换原则

通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。子类继承父类时，除添加新的方法完成新增功能外
，尽量不要重写父类的方法

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，因为这样父类定义的方法没有任何意义了，我们想要调用父类的方法时会因为多态而调用子类的方法，造成错误

下面看一个里氏替换原则中经典的例子

在数学领域里，正方形毫无疑问是长方形，它是一个长宽相等的长方形。所以，我们开发的一个与几何图形相关的软件系统，就可以让正方形继承自长方形

我们让正方形类重写长方形类的设置长和宽的方法，看看破坏里氏替换原则后会有什么结果

2.1长方形类（Rectangle）

public class Rectangle 
    private double length;
    private double width;

    public double getLength() 
        return length;
    

    public void setLength(double length) 
        this.length = length;
    

    public double getWidth() 
        return width;
    

    public void setWidth(double width) 
        this.width = width;
    

2.2正方形类（Square）

public class Square extends Rectangle 

    @Override
    public void setLength(double length) 
        super.setLength(length);
        super.setWidth(length);
    

    @Override
    public void setWidth(double width) 
        super.setWidth(width);
        super.setLength(width);
    

2.3测试类

public class RectangleDemo 
    public static void main(String[] args) 
        //以下操作证明如果破坏里氏替换原则的后果
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        resize(rectangle);
        printLengthAndWidth(rectangle);
//        Rectangle square = new Square();
//        square.setLength(20);
    

    //扩宽方法，当长方形款<长时，进行扩宽
    public static void resize(Rectangle rectangle)
        while (rectangle.getWidth()<=rectangle.getLength())
            rectangle.setWidth(rectangle.getWidth()+1);
        
    

    //打印长和款
    public static void printLengthAndWidth(Rectangle rectangle)
        System.out.println(rectangle.getLength());
        System.out.println(rectangle.getWidth());
    

对长方形进行扩宽

20.0
21.0

正常，但是对正方形进行扩宽

    public static void main(String[] args) 
        //以下操作证明如果破坏里氏替换原则的后果
        Rectangle square = new Square();
        square.setLength(20);
        resize(square);
        printLengthAndWidth(square);
    

进入死循环，这是因为我们破坏了里氏替换原则，程序进入了死循环

所以说为了遵循里氏替换原则，子类尽量不要重写父类已经定义好的方法，而是在父类的基础上进行新的扩展

3.依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象，抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行变成，不要对实现进行编程，这样就降低了客户与实现模块间的耦合，可以理解我们的Dao，DaoImpl，Service之间的关系

下面看一个例子来理解依赖倒转原则

【组装电脑】

现在要组装一台电脑，需要配件cpu，硬盘，内存条。只有这些配置都有了，计算机才能正常的运行。cpu有很多选择，如Intel，AMD等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。

Cpu接口

public interface Cpu 
    void run();

IntelCpu

public class IntelCpu implements Cpu 

    public void run()
        System.out.println("使用Intel处理器");
    

Memory接口

public interface Memory 
    void save();

KingstonMemory

public class KingstonMemory implements Memory 
    public void save()
        System.out.println("使用金士顿内存条存储数据");
    

Disk接口

public interface HardDisk 

    public void save(String data);

    public String get();

XiJieHardDisk

public class XiJieHardDisk implements HardDisk 
    public void save(String data)
        System.out.println("使用希捷硬盘存储数据为："+data);
    

    public String get()
        System.out.println("使用希捷硬盘取数据");
        return "数据";
    

电脑类

public class Computer 
    private HardDisk xiJieHardDisk;
    private Cpu cpu;
    private Memory kingstonMemory;

    public HardDisk getXiJieHardDisk() 
        return xiJieHardDisk;
    

    public void setXiJieHardDisk(HardDisk xiJieHardDisk) 
        this.xiJieHardDisk = xiJieHardDisk;
    

    public Cpu getCpu() 
        return cpu;
    

    public void setCpu(Cpu cpu) 
        this.cpu = cpu;
    

    public Memory getKingstonMemory() 
        return kingstonMemory;
    

    public void setKingstonMemory(Memory kingstonMemory) 
        this.kingstonMemory = kingstonMemory;
    

    public void setKingstonMemory(KingstonMemory kingstonMemory) 
        this.kingstonMemory = kingstonMemory;
    

    public void run()
        System.out.println("运行计算机");
        String data = xiJieHardDisk.get();
        System.out.println("从硬盘上获取的数据是："+data);
        cpu.run();
        kingstonMemory.save();
    

测试

public class ComputerDemo 
    public static void main(String[] args) 
        //创建组件
        HardDisk hardDisk = new XiJieHardDisk();
        Cpu cpu = new IntelCpu();
        Memory memory = new KingstonMemory();
        Computer computer = new Computer();
        computer.setXiJieHardDisk(hardDisk);
        computer.setCpu(cpu);
        computer.setKingstonMemory(memory);
        computer.run();
    

运行计算机
使用希捷硬盘取数据
从硬盘上获取的数据是：数据
使用Intel处理器
使用金士顿内存条存储数据

4.接口隔离原则

客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上

假如有一个A类，A类中有方法1和方法2，B类需要A类中的方法1，此时不应该让B类继承A类，虽然继承之后B类拥有了方法1，但是B类也多出了不需要的方法2，所以我们应该让A类变为两个接口，两个接口分别拥有方法1和方法2，这样，B类实现接口1即可

5.迪米特原则

又称最少知识原则

如果两个软件实体无需直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用，其目的是降低类之间的耦合度，提高模块的相对独立性，也就是和你的直接朋友交谈，不跟陌生人说话

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法

比如我们举一个例子

【明星与经纪人的关系实例】

明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，比如和粉丝的见面会，公司业务处理等，这里的经纪人是明星的朋友，而粉丝是陌生人，所以适合使用迪米特原则

明星类

public class Star 
    private String name;

    public Star(String name)
        this.name = name;
    

    public String getName() 
        return name;
    

粉丝类

public class Fans 

    private String name;

    public Fans(String name) 
        this.name = name;
    

    public String getName() 
        return name;
    

公司类

public class Company 
    private String name;

    public Company(String name) 
        this.name = name;
    

    public String getName() 
        return name;
    

经纪人类

public class Agent 
    private Star star;
    private Fans fans;
    private Company company;

    public void setStar(Star star) 
        this.star = star;
    

    public void setFans(Fans fans) 
        this.fans = fans;
    

    public void setCompany(Company company) 
        this.company = company;
    

    //和粉丝见面的方法
    public void meeting()
        System.out.println(star.getName()+"和粉丝"+fans.getName()+"进行见面");
    

    //和媒体洽谈的方法
    public void business()
        System.out.println(star.getName()+"和公司"+company.getName()+"进行洽谈");
    

测试类

public class Test 
    public static void main(String[] args) 
        Star star = new Star("明星1");
        Fans fans = new Fans("粉丝1");
        Company company = new Company("公司1");
        Agent agent = new Agent();
        agent.setCompany(company);
        agent.setFans(fans);
        agent.setStar(star);
        agent.meeting();
        agent.business();
    

明星1和粉丝粉丝1进行见面
明星1和公司公司1进行洽谈

6.合成复用原则

合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现

通常类的复用分为继承复用和合成复用两种

继承复用虽然简单，但是也存在缺点

• 继承破坏了类的封装性。因为继承会将父类的实现细节暴露给子类
• 子类和父类耦合度高，子类的实现任何改变都会导致子类的实现发生变化，不利于类的扩展和维护
• 它限制了复用的灵活性，从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不肯能发生变化

采用组合或聚合复用时，将已有对象纳入新对象，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点

• 它维持了类的封装性，因为成分对象的内部细节，新对象看不见，所以这种复用称为“黑箱”复用
• 对象间耦合度低，可以在类的成员位置声明抽象
• 复用灵活性高，可以在运行时动态进行，新对象动态引用与侧好难过分对象类型相同的对象

我们举个例子

【汽车分类管理程序】

汽车按“动力源”划分为汽油汽车，电动汽车等，按颜色分为白色汽车，红色汽车和黑色汽车，如果同时考虑这两种分类，组合就会很多，下图为继承复用

从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有了新的动力源或者新的颜色的话，就需要再定义新的类，我们将继承复用改为聚合复用