⭐️写在前面
- 这里是温文艾尔的学习之路
- 👍如果对你有帮助，给博主一个免费的点赞以示鼓励把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();
}
public class DefaultSpecificSkin extends AbstractSkin{
@Override
public void display() {
System.out.println("默认皮肤");
}
}
public class WqlSpecificSkin extends AbstractSkin {
@Override
public void display() {
System.out.println("自定义皮肤");
}
}
public class SougouInput {
AbstractSkin skin;
public void setSkin(AbstractSkin skin) {
this.skin = skin;
}
public void display(){
skin.display();
}
}
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.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;
}
}
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);
}
}
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等，硬盘可以选择希捷，西数等，内存条可以选择金士顿，海盗船等。
public interface Cpu {
void run();
}
public class IntelCpu implements Cpu {
public void run(){
System.out.println("使用Intel处理器");
}
}
public interface Memory {
void save();
}
public class KingstonMemory implements Memory {
public void save(){
System.out.println("使用金士顿内存条存储数据");
}
}
public interface HardDisk {
public void save(String data);
public String get();
}
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处理器
使用金士顿内存条存储数据
客户端不应该被迫依赖于它不使用的方法；一个类对另一个类的依赖应该建立在最小的接口上
假如有一个A类，A类中有方法1和方法2，B类需要A类中的方法1，此时不应该让B类继承A类，虽然继承之后B类拥有了方法1，但是B类也多出了不需要的方法2，所以我们应该让A类变为两个接口，两个接口分别拥有方法1和方法2，这样，B类实现接口1即可
又称最少知识原则
如果两个软件实体无需直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用，其目的是降低类之间的耦合度，提高模块的相对独立性，也就是和你的直接朋友交谈，不跟陌生人说话
迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法
比如我们举一个例子
【明星与经纪人的关系实例】
明星由于全身心投入艺术，所以许多日常事务由经纪人负责处理，比如和粉丝的见面会，公司业务处理等，这里的经纪人是明星的朋友，而粉丝是陌生人，所以适合使用迪米特原则
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进行洽谈
合成复用原则是指：尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现
通常类的复用分为继承复用和合成复用两种
继承复用虽然简单，但是也存在缺点
- 继承破坏了类的封装性。因为继承会将父类的实现细节暴露给子类
- 子类和父类耦合度高，子类的实现任何改变都会导致子类的实现发生变化，不利于类的扩展和维护
- 它限制了复用的灵活性，从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不肯能发生变化
采用组合或聚合复用时，将已有对象纳入新对象，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点
- 它维持了类的封装性，因为成分对象的内部细节，新对象看不见，所以这种复用称为“黑箱”复用
- 对象间耦合度低，可以在类的成员位置声明抽象
- 复用灵活性高，可以在运行时动态进行，新对象动态引用与侧好难过分对象类型相同的对象
我们举个例子
【汽车分类管理程序】
汽车按“动力源”划分为汽油汽车，电动汽车等，按颜色分为白色汽车，红色汽车和黑色汽车，如果同时考虑这两种分类，组合就会很多，下图为继承复用
从上面类图我们可以看到使用继承复用产生了很多子类，如果现在又有了新的动力源或者新的颜色的话，就需要再定义新的类，我们将继承复用改为聚合复用
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）