学习日记-设计模式(软件设计原则)

已于 2024-02-17 13:39:00 修改
阅读量552 收藏 12
点赞数 23
分类专栏： 学习日记 文章标签： 学习 设计模式
于 2024-02-17 13:29:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60875928/article/details/136134258
版权

开闭原则

对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。

案例:  搜狗输入法 的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤，也可以从网上下载新的皮肤。这些皮肤有共同的特点，可以为其定义一个抽象类（AbstractSkin），而每个具体的皮肤（DefaultSpecificSkin和HeimaSpecificSkin）是其子类。用户窗体可以根据需要选择或者增加新的主题，而不需要修改原代码，所以它是满足开闭原则的。

package com.itheima.principles.demo1;

/**
 * @author Vincent.wang
 * @description  抽象的皮肤类
 * @date 2024/2/12 15:53
 */
public abstract class AbstractSkin {

    public  abstract  void display(); //显示皮肤

}

package com.itheima.principles.demo1;

/**
 * @author Vincent.wang
 * @description  默认皮肤类
 * @date 2024/2/12 15:54
 */
public class DefaultSkin extends AbstractSkin {
    @Override
    public void display() {
        System.out.println("默认皮肤");
    }
}

package com.itheima.principles.demo1;

/**
 * @author Vincent.wang
 * @description 黑色皮肤
 * @date 2024/2/12 15:55
 */
public class HeimaSkin extends AbstractSkin{
    @Override
    public void display() {
        System.out.println("黑色皮肤");
    }
}

package com.itheima.principles.demo1;

/**
 * @author Vincent.wang
 * @description 输入法类
 * @date 2024/2/17 01:18
 */
public class SougouInput  {
    private AbstractSkin skin;

    public void setSkin(AbstractSkin skin) {
        this.skin = skin;
    }
    public void display(){
        skin.display();
    }
}

package com.itheima.principles.demo1;

/**
 * @author Vincent.wang
 * @description 开闭原则demo 在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果
 * @date 2024/2/12 16:03
 */
public class Client {
    public static void main(String[] args) {
        //1.创建搜狗输入法
        SougouInput sougouInput = new SougouInput();
        //2.创建默认皮肤
        DefaultSkin defaultSkin = new DefaultSkin();
        //3.创建黑色皮肤
        HeimaSkin heimaSkin = new HeimaSkin();
        //4.设置默认皮肤
        sougouInput.setSkin(defaultSkin);
        sougouInput.display();
        //5.设置黑色皮肤
        sougouInput.setSkin(heimaSkin);
        sougouInput.display();
    }
}

里氏代换原则

里氏代换原则是面向对象设计的基本原则之一。

里氏代换原则：任何基类可以出现的地方，子类一定可以出现。通俗理解：子类可以扩展父类的功能，但不能改变父类原有的功能。换句话说，子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大。

例 正方形不是长方形。

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

 修改前

package com.itheima.principles.demo2.before;

/**
 * @author Vincent.wang
 * @description 长方形类
 * @date 2024/2/12 16:08
 */
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;
    }
}


package com.itheima.principles.demo2.before;

/**
 * @author Vincent.wang
 * @description 正方形类
 * @date 2024/2/12 16:09
 */
public class Square extends Rectangle {

    public void setWidth(double width) {
        super.setLength(width);
        super.setWidth(width);
    }

    public void setLength(double length) {
        super.setLength(length);
        super.setWidth(length);
    }
}

package com.itheima.principles.demo2.before;

/**
 * @author Vincent.wang
 * @description 里氏代换原则demo 子类可以扩展父类的功能，但不能改变父类原有的功能
 * @date 2024/2/12 16:09
 */
public class RectangleDemo {

    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());
    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setLength(20);
        rectangle.setWidth(10);
        resize(rectangle);
        printLengthAndWidth(rectangle);

        System.out.println("============");

        Rectangle rectangle1 = new Square();
        rectangle1.setLength(10);
        resize(rectangle1);
        printLengthAndWidth(rectangle1);
    }
}

运行一下这段代码就会发现，假如我们把一个普通长方形作为参数传入resize方法，就会看到长方形宽度逐渐增长的效果，当宽度大于长度,代码就会停止，这种行为的结果符合我们的预期；假如我们再把一个正方形作为参数传入resize方法后，就会看到正方形的宽度和长度都在不断增长，代码会一直运行下去，直至系统产生溢出错误。所以，普通的长方形是适合这段代码的，正方形不适合。 我们得出结论：在resize方法中，Rectangle类型的参数是不能被Square类型的参数所代替，如果进行了替换就得不到预期结果。因此，Square类和Rectangle类之间的继承关系违反了里氏代换原则，它们之间的继承关系不成立，正方形不是长方形。

修改后

package com.itheima.principles.demo2.after;

/**
 * @author Vincent.wang
 * @description  四边形接口
 * @date 2024/2/12 16:23
 */
public interface Quadrilateral {

    //获取长
    double getLength();

    //获取宽
    double getWidth();

}

package com.itheima.principles.demo2.after;

/**
 * @author Vincent.wang
 * @description  长方形类
 * @date 2024/2/12 16:26
 */
public class Rectangle implements Quadrilateral{

    private double length;
    private double width;

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

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

    @Override
    public double getLength() {
        return this.length;
    }

    @Override
    public double getWidth() {
        return this.width;
    }
}

package com.itheima.principles.demo2.after;

/**
 * @author Vincent.wang
 * @description 正方形类
 * @date 2024/2/12 16:24
 */
public class Square implements Quadrilateral{

    private double side;

    @Override
    public double getLength() {
        return side;
    }

    @Override
    public double getWidth() {
        return side;
    }

    public double getSide() {
        return side;
    }

    public void setSide(double side) {
        this.side = side;
    }
}

package com.itheima.principles.demo2.after;

/**
 * 使用接口的方式 限制入参的类型
 * 就可以避免继承的方式 修改了父类的信息
 */
public class RectangleDemo {
    public static void main(String[] args) {
       //创建长方形对象
        Rectangle r=new Rectangle();
        r.setLength(20);
        r.setWidth(10);
        //调用方法
        resize(r);
        printLengthAndWidth(r);

    }

    //括宽的方法
    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());
    }

}

两个分别独立实现 互不干扰 解决问题

依赖倒转原则

高层模块不应该依赖低层模块，两者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

【例】组装电脑

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

 修改前

package com.itheima.principles.demo3.before;

/**
 * @author Vincent.wang
 * @description 计算机类
 * @date 2024/2/12 16:58
 */
public class Computer {

    private XiJieHardDisk hardDisk;
    private IntelCpu cpu;
    private KingstonMemory memory;

    public IntelCpu getCpu() {
        return cpu;
    }

    public void setCpu(IntelCpu cpu) {
        this.cpu = cpu;
    }

    public KingstonMemory getMemory() {
        return memory;
    }

    public void setMemory(KingstonMemory memory) {
        this.memory = memory;
    }

    public XiJieHardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(XiJieHardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public void run() {
        System.out.println("计算机工作");
        cpu.run();
        memory.save();
        String data = hardDisk.get();
        System.out.println("从硬盘中获取的数据为：" + data);
    }
}

package com.itheima.principles.demo3.before;

/**
 * @author Vincent.wang
 * @description Intel处理器
 * @date 2024/2/12 16:56
 */
public class IntelCpu  {

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

package com.itheima.principles.demo3.before;

/**
 * @author Vincent.wang
 * @description 金士顿内存条类
 * @date 2024/2/12 16:57
 */
public class KingstonMemory  {

    public void save() {
        System.out.println("使用金士顿作为内存条");
    }
}

package com.itheima.principles.demo3.before;

/**
 * @author Vincent.wang
 * @description 希捷硬盘类
 * @date 2024/2/12 16:55
 */
public class XiJieHardDisk  {

    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据" + data);
    }

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

package com.itheima.principles.demo3.before;

/**
 * @author Vincent.wang
 * @description 依赖倒转原则 要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。
 * @date 2024/2/12 17:00
 */
public class TestComputer {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setHardDisk(new XiJieHardDisk());
        computer.setCpu(new IntelCpu());
        computer.setMemory(new KingstonMemory());
        computer.run();
    }
}

上面代码可以看到已经组装了一台电脑，但是似乎组装的电脑的cpu只能是Intel的，内存条只能是金士顿的，硬盘只能是希捷的，这对用户肯定是不友好的，用户有了机箱肯定是想按照自己的喜好，选择自己喜欢的配件。

修改后

代码我们只需要修改Computer类，让Computer类依赖抽象（各个配件的接口），而不是依赖于各个组件具体的实现类。

package com.itheima.principles.demo3.after;

/**
 * @author Vincent.wang
 * @description cpu接口
 * @date 2024/2/12 17:10
 */
public interface Cpu {
    //运行cpu
    public void run();
}


package com.itheima.principles.demo3.after;

/**
 * @author Vincent.wang
 * @description 内存条接口
 * @date 2024/2/12 17:11
 */
public interface Memory {

    //保存数据
    public void save();

}

package com.itheima.principles.demo3.after;

/**
 * @author Vincent.wang
 * @description 硬盘接口
 * @date 2024/2/12 17:09
 */
public interface HardDisk {

    //储存数据
    public void save(String data);

    //获取数据
    public String get();
}

package com.itheima.principles.demo3.after;

/**
 * @author Vincent.wang
 * @description Intel处理器
 * @date 2024/2/12 16:56
 */
public class IntelCpu implements Cpu  {

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

package com.itheima.principles.demo3.after;

/**
 * @author Vincent.wang
 * @description 金士顿内存条类
 * @date 2024/2/12 16:57
 */
public class KingstonMemory implements Memory {

    public void save() {
        System.out.println("使用金士顿作为内存条");
    }
}

package com.itheima.principles.demo3.after;

/**
 * @author Vincent.wang
 * @description 希捷硬盘类
 * @date 2024/2/12 16:55
 */
public class XiJieHardDisk implements HardDisk {

    public void save(String data) {
        System.out.println("使用希捷硬盘存储数据" + data);
    }

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

package com.itheima.principles.demo3.after;


public class Computer {

    private Memory memory;

    private HardDisk hardDisk;

    private Cpu cpu;

    public Memory getMemory() {
        return memory;
    }

    public void setMemory(Memory memory) {
        this.memory = memory;
    }

    public HardDisk getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(HardDisk hardDisk) {
        this.hardDisk = hardDisk;
    }

    public Cpu getCpu() {
        return cpu;
    }

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

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

package com.itheima.principles.demo3.after;

public class ComputerDemo {
    public static void main(String[] args) {
        //创建计算机对象
        Computer computer = new Computer();
        //创建组件对象
        HardDisk hardDisk = new XiJieHardDisk();
        Cpu cpu = new IntelCpu();
        Memory memory = new KingstonMemory();
        //组装计算机
        computer.setCpu(cpu);
        computer.setHardDisk(hardDisk);
        computer.setMemory(memory);
        //运行计算机
        computer.run();
    }
}

接口隔离原则

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

下面看一个例子来理解接口隔离原则

【例】安全门案例

我们需要创建一个其他品牌的安全门，该安全门具有防火、防水、防盗的功能。可以将防火，防水，防盗功能提取成一个接口，形成一套规范。类图如下：

修改前 

package com.itheima.principles.demo4.before;

/**
 * @author Vincent.wang
 * @description 安全门接口
 * @date 2024/2/12 17:27
 */
public interface SafetyDoor {

    //防水
    void waterproof();

    //防火
    void fireproof();

    //防盗
    void antiTheft();

}

package com.itheima.principles.demo4.before;

/**
 * @author Vincent.wang
 * @description 幸福品牌安全门
 * @date 2024/2/12 17:29
 */
public class HeimaSafetyDoor implements SafetyDoor{
    @Override
    public void waterproof() {
        System.out.println("防水功能");
    }

    @Override
    public void fireproof() {
        System.out.println("防火功能");
    }

    @Override
    public void antiTheft() {
        System.out.println("防盗功能");
    }
}


package com.itheima.principles.demo4.before;

/**
 * @author Vincent.wang
 * @description  接口隔离原则 客户端不应该被迫依赖于它不使用的方法 也就是说 不需要的方法不应该强加
 * @date 2024/2/12 17:30
 */
public class Client {
    public static void main(String[] args) {
        HeimaSafetyDoor safetyDoor = new HeimaSafetyDoor();
        safetyDoor.antiTheft();
        safetyDoor.fireproof();
        safetyDoor.waterproof();
    }
}

上面的设计我们发现了它存在的问题，幸福品牌的安全门具有防盗，防水，防火的功能。现在如果我们还需要再创建一个品牌的安全门，而该安全门只具有防盗、防水功能呢？很显然如果实现SafetyDoor接口就违背了接口隔离原则，那么我们如何进行修改呢？看如下类图： 

修改后 

package com.itheima.principles.demo4.after;

/**
 * @author Vincent.wang
 * @description  防盗接口
 * @date 2024/2/12 17:31
 */
public interface AntiTheft {
    void antiTheft();
}

package com.itheima.principles.demo4.after;

/**
 * @author Vincent.wang
 * @description 防火接口
 * @date 2024/2/12 17:32
 */
public interface Fireproof {
    void fireproof();
}

package com.itheima.principles.demo4.after;

/**
 * @author Vincent.wang
 * @description 防水接口
 * @date 2024/2/12 17:32
 */
public interface Waterproof {
    void waterproof();
}

package com.itheima.principles.demo4.after;

/**
 * @author Vincent.wang
 * @description 幸福安全门
 * @date 2024/2/12 17:32
 */
public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof {
    public void antiTheft() {
        System.out.println("防盗");
    }

    public void fireproof() {
        System.out.println("防火");
    }


    public void waterproof() {
        System.out.println("防水");
    }
}

package com.itheima.principles.demo4.after;

/**
 * @author Vincent.wang
 * @description 传统安全门
 * @date 2024/2/12 17:36
 */
public class ItcastSafetyDoor implements AntiTheft,Fireproof {
    public void antiTheft() {
        System.out.println("防盗");
    }

    public void fireproof() {
        System.out.println("防火");
    }
}

package com.itheima.principles.demo4.after;

public class Client {
    public static void main(String[] args) {
        HeiMaSafetyDoor safetyDoor = new HeiMaSafetyDoor();
        safetyDoor.antiTheft();
        safetyDoor.fireproof();
        safetyDoor.waterproof();

        System.out.println("-------------");

        ItcastSafetyDoor itcastSafetyDoor = new ItcastSafetyDoor();
        itcastSafetyDoor.antiTheft();
        itcastSafetyDoor.fireproof();

    }
}

迪米特法则

迪米特法则又叫最少知识原则。

只和你的直接朋友交谈，不跟“陌生人”说话（Talk only to your immediate friends and not to strangers）。

其含义是：如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

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

下面看一个例子来理解迪米特法则

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

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

package com.itheima.principles.demo5;

/**
 * @author Vincent.wang
 * @description 媒体公司类
 * @date 2024/2/12 19:30
 */
public class Company {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.itheima.principles.demo5;

/**
 * @author Vincent.wang
 * @description 粉丝类
 * @date 2024/2/12 19:26
 */
public class Fans {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package com.itheima.principles.demo5;

/**
 * @author Vincent.wang
 * @description 明星类
 * @date 2024/2/12 19:25
 */
public class Star {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


package com.itheima.principles.demo5;

/**
 * @author Vincent.wang
 * @description 经纪人类
 * @date 2024/2/12 19:30
 */
public class Agent {
    //明星
    private  Star star;

    //粉丝
    private Fans fans;

    //公司
    private Company company;


    public Star getStar() {
        return star;
    }

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

    public Fans getFans() {
        return fans;
    }

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

    public Company getCompany() {
        return company;
    }

    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()+"洽谈");
    }
}

package com.itheima.principles.demo5;

/**
 * @author Vincent.wang
 * @description 迪米特法则 如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。
 * @date 2024/2/12 19:36
 */
public class Client {
    public static void main(String[] args) {

        //创建明星对象
        Star star = new Star();
        star.setName("刘德华");
        //创建粉丝对象
        Fans fans = new Fans();
        fans.setName("张三");
        //创建经纪公司
        Company company = new Company();
        company.setName("华谊兄弟");

        //创建经纪人类
        Agent agent = new Agent();
        agent.setStar(star);
        agent.setFans(fans);
        agent.setCompany(company);
        agent.meeting(); //和粉丝见面
        agent.business(); //洽谈业务
    }
}

合成复用原则

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

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

继承复用虽然有简单和易实现的优点，但它也存在以下缺点：

  1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。

  2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。

  3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

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

  1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。

  2. 对象间的耦合度低。可以在类的成员位置声明抽象。

  3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

下面看一个例子来理解合成复用原则

【例】汽车分类管理程序

汽车按“动力源”划分可分为汽油汽车、电动汽车等；按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类，其组合就很多。类图如下：

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

package com.itheima.principles.demo6.two;

// 颜色接口
interface Color {
    String getColor();
}


package com.itheima.principles.demo6.two;

// 动力源接口
interface PowerSource {
    String getPowerSource();
}

package com.itheima.principles.demo6.two;

// 黑色实现
class BlackColor implements Color {
    @Override
    public String getColor() {
        return "黑色";
    }
}

package com.itheima.principles.demo6.two;

// 红色实现
class RedColor implements Color {
    @Override
    public String getColor() {
        return "红色";
    }
}

package com.itheima.principles.demo6.two;

// 白色实现
class WhiteColor implements Color {
    @Override
    public String getColor() {
        return "白色";
    }
}

package com.itheima.principles.demo6.two;

// 电动力实现
class ElectricPower implements PowerSource {
    @Override
    public String getPowerSource() {
        return "电动力";
    }
}

package com.itheima.principles.demo6.two;

// 汽油动力实现
class GasolinePower implements PowerSource {
    @Override
    public String getPowerSource() {
        return "汽油动力";
    }
}

package com.itheima.principles.demo6.two;

// 汽车类
class Car {
    private PowerSource powerSource; // 动力源
    private Color color; // 颜色

    // 构造方法，注入动力源和颜色
    public Car(PowerSource powerSource, Color color) {
        this.powerSource = powerSource;
        this.color = color;
    }

    // 展示汽车信息
    public void displayInfo() {
        System.out.println("这是一辆" + color.getColor() + "的，采用" + powerSource.getPowerSource() + "。");
    }
}

LogicLuminary
关注
  • 23
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
计算机毕业设计-个人日记本系统
02-21
内容概要：该项目为个人日记本系统，主要编程语言为java。 适用人群：已工作或未工作的软件开发人员。 使用场景及目标：适合研究学习使用，以及项目初期快速搭建脚手架。 其他说明：暂无
Javaweb期末设计项目-日记管理系统
01-05
使用场景及目标：这份资源适用于Javaweb期末设计作业，也适合用于练习适用ssm项目和vue+elementui开发的模式，从而更好的入门Javaweb这门课程，为后续学习Java或者前端做好准备。 其他说明：资源中包括：Java代码，...
学习日记-设计模式(行为型模式)
qq_60875928的博客
02-18 1067
先看下面的图片，我们去旅游选择出行模式有很多种，可以骑自行车、可以坐汽车、可以坐火车、可以坐飞机。定义该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。结构策略模式的主要角色如下：1.抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
学习日记-设计模式(结构型模式)
qq_60875928的博客
02-17 1459
由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成，而动态代理代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。如果去欧洲国家去旅游的话，他们的插座如下图最左边，是欧洲标准。而我们使用的插头如下图最右边的。因此我们的笔记本电脑，手机在当地不能直接充电。
学习日记-设计模式(创建者模式)
qq_60875928的博客
02-17 753
用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。结构原型模式包含如下角色：1.抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。2.具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。3.访问类：使用具体原型类中的 clone() 方法来复制新的对象。实现原型模式的克隆分为浅克隆和深克隆。浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
架构师日记-深入理解软件设计模式
京东科技开发者
05-05 166
一、设计模式与编程语言1.1 什么是设计模式设计模式（Design pattern）：由软件开发人员在软件开发中面临常见问题的解决方案，是经过长时间的试验积累总结出来的，它使设计更加灵活和优雅，复用性更好。从实用的角度来看，它代表了某一类问题的最佳实践。设计模式到底解决了开发过程中的哪些难题呢，它又是如何来解决的呢？其核心是：复用和解耦。使不稳定依赖于稳定、具体依赖于抽象，以此增强软件设计适应变化...
android源码设计模式学习笔记（一）
qq_42447739的博客
08-09 2213
设计模式的学习
【学习日记】设计模式学习过程思路疑问记录
云吞煲仔牛腩河的博客
09-25 144
工厂模式： 好处： 如果多处php文件调用了该类，如果该类名字或参数需要修改，则只改此处，或者根据业务需求，传入不同的参数，调用不同的类（原理其实也就是给这种情景的类做一个入口，统一管理）；例如，就像下面例子中的工厂模式下的普通调用模式改为单例模式： 普通调用-----》 工厂模式调用-----》 单例模式： 原理：静态方法创建的元素也是静态元素， 通过静态方法创建静态对象 将__co...
《C++20设计模式》学习笔记——第1章引论
qq_41668147的博客
02-02 784
本文是《C++20设计模式——可复用的面向对象设计方法》一书第一章的学习笔记，主要介绍一些在C++世界里很重要的概念，并且这些概念会在后续的模块章节中反复出现，值得进行熟悉。
架构师日记-深入理解软件设计模式 | 京东云技术团队
JDDTechTalk的博客
05-05 822
本文从设计模式与编程语言的关系，设计模式与架构模式的区别，设计原则和设计模式的关系等几个维度进行了分析和解答。关于设计模式应该如何学习和应用的问题，给出了学习意见和实践心得。
备战面试日记（3.1） - （设计模式.七大原则）
weixin_44414492的博客
01-05 186
本人本科毕业，21届毕业生，一年工作经验，简历专业技能如下，现根据简历，并根据所学知识复习准备面试。 记录日期：2022.1.4 大部分知识点只做大致介绍，具体内容根据推荐博文链接进行详细复习。 文章目录设计模式 - 七大原则前言学习方法文章内容学习好处设计模式七大原则单一职责原则举例说明优点开闭原则为什么要使用开闭原则（优点）最基础的设计原则提高复用性提高维护性面向对象开发的要求如何使用开闭原则抽象约束元数据(metadata)控件模块行为制定项目章程封装变化举例说明里氏替换原则举例说明总结依赖倒转原
行业教育软件-学习软件-松鼠日记PPT课件 免费版.zip
08-03
行业教育软件-学习软件-松鼠日记PPT课件 免费版.zip
基于Android的安卓日记本设计源码
04-17
本项目是基于Android开发的安卓日记本设计源码，主要使用Java进行开发。项目共包含73个文件，其中XML配置文件xml 21个，PNG图片文件png 17个，Java源代码文件java 11个，WebP图片文件webp 10个，Git忽略配置文件...
行业文档-设计装置-内置笔日记本.zip
08-25
行业文档-设计装置-内置笔日记本.zip
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 195
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1096
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
微信小程序学习（第八章作业）
weixin_74181724的博客
05-13 575
留言板是一款能实现浏览留言、发表留言、删除留言和编辑留言的小程序，用户能够浏览当前的已留言内容，并且能按照时间的升序来查看最新的留言内容;能够发表自己的留言内容，在留言发表页填写相关项后即可发表，并能查看到新留言内容;能够删除不需要的留言;能够修改留言内容。因此，简单留言板的功能主要为显示留言、发表留言删除留言和编辑留言。
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 670
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
安卓多功能日记本E-R图设计
06-12
针对安卓多功能日记本E-R图的设计，可以按照以下步骤进行： 1. 确定实体：首先需要确定在日记本中需要用到的实体，例如日记、用户、标签等。 2. 确定实体之间的关系：在确定实体之后，需要确定实体之间的关系，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值