面试高频Java设计原则总结

Posted 温文艾尔

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面试高频Java设计原则总结相关的知识,希望对你有一定的参考价值。

⭐️写在前面


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

文章目录

设计原则一共有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.合成复用原则

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

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

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

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

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

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

我们举个例子

【汽车分类管理程序】

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


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

以上是关于面试高频Java设计原则总结的主要内容,如果未能解决你的问题,请参考以下文章

大厂Mysql高频面试题!让人抓狂的Nginx性能调优,面试总结

Java开发基础面试题,java研发工程师年终总结

总结近期 BATJ 大厂 Java 岗高频面试题,提问率高达 98%

2021年全网最全Java面试总结及答案建议收藏

Java核心面试宝典Day15“Java容器”高频面试题总结!✊✊✊

Java核心面试宝典Day15“Java容器”高频面试题总结!✊✊✊