??写在前面
- 这里是温文艾尔的学习之路
- 👍如果对你有帮助，给博主一个免费的点赞以示鼓励把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.合成复用原则
合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现
通常类的复用分为继承复用和合成复用两种
继承复用虽然简单，但是也存在缺点
- 继承破坏了类的封装性。因为继承会将父类的实现细节暴露给子类
- 子类和父类耦合度高，子类的实现任何改变都会导致子类的实现发生变化，不利于类的扩展和维护
- 它限制了复用的灵活性，从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不肯能发生变化
采用组合或聚合复用时，将已有对象纳入新对象，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点
- 它维持了类的封装性，因为成分对象的内部细节，新对象看不见，所以这种复用称为“黑箱”复用
- 对象间耦合度低，可以在类的成员位置声明抽象
- 复用灵活性高，可以在运行时动态进行，新对象动态引用与侧好难过分对象类型相同的对象
我们举个例子
【汽车分类管理程序】
汽车按“动力源”划分为汽油汽车，电动汽车等，按颜色分为白色汽车，红色汽车和黑色汽车，如果同时考虑这两种分类，组合就会很多，下图为继承复用
从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有了新的动力源或者新的颜色的话，就需要再定义新的类，我们将继承复用改为聚合复用
