设计模式2，设计原则

最新推荐文章于 2023-12-05 22:50:29 发布
最新推荐文章于 2023-12-05 22:50:29 发布
阅读量152 收藏
点赞数 1
分类专栏： 设计模式 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haozi_rou/article/details/103774970
版权

目录

开闭原则

依赖倒置原则

单一职责原则

接口隔离原则

迪米特法则（最少知道原则）

里氏替换原则

合成/复用原则（组合/复用原则）

开闭原则

关于开闭原则，是面向对象设计中所有原则（包括设计模式）的基础，强调的就是用抽象构建框架，用实现扩展细节。所以也可以说是面向抽象编程，让类依赖抽象，这样扩展起来，不需要修改老代码，也就是说如类、模块、方法应该对扩展开放，对修改关闭。提高软件的稳定性。

优点：提高软件系统的可复用性和可维护性。

举例：

public interface Person {
    String getName();
    Integer getAge();
    Double getWeight();
}
public class Haozi implements Person{

    String name;
    Integer age;
    Double weight;

    public Haozi(String name, Integer age, Double weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
    }

    @Override
    public String getName() {
        return name;
    }

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

    @Override
    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public Double getWeight() {
        return weight;
    }

    public void setWeight(Double weight) {
        this.weight = weight;
    }
}
public class Test {
    public static void main(String[] args) {
        Person haozi = new Haozi("耗子" , 18 , 60.0);
        System.out.println("person:[haozi,name-" + haozi.getName()
            + ",age-" + haozi.getAge() + ",weight-" + haozi.getWeight() + "]");
    }
}

 

结构图：

 这样是一个很基础的结构，现在有一个新需求，我想改名，在名称的前后都加个“【】”符号，简单粗暴的方式有几种：在实现类的set里加，但是如果有多个实现类，这样就太麻烦，而且没法看原来的名字。在接口里加方法，但是这样接口就起不到约定的作用了，而且每个实现类都要实现，更麻烦，于是，遵循开闭原则，新建一个类继承需要改名的类

public class NewHaozi extends Haozi{
    public NewHaozi(String name, Integer age, Double weight) {
        super(name, age, weight);
    }

    @Override
    public String getName(){
        return super.getName();
    }

    public String getNewName(){
        return "【" + super.getName() + "】";
    }
}
public class Test {
    public static void main(String[] args) {
        Person haozi = new NewHaozi("耗子" , 18 , 60.0);
        System.out.println("person:[haozi,name-" + haozi.getName()
                + ",age-" + haozi.getAge() + ",weight-" + haozi.getWeight() + "],newName-"
                + ((NewHaozi) haozi).getNewName());
    }
}

引用用的时候，就不引用原本的Haozi，而是用新的NewHaozi，这样，不仅可以使用到新的名字，还可以查到原来的名字。

这样，接口也没有变，原实现类也没有变，所以也没有破坏原本的结构，提高了复用性和可维护性，所以开闭原则非常重要。结构图就议案成了：

依赖倒置原则

高层模块不应该依赖底层模块，二者都应该依赖他们的抽象。抽象不应该依赖细节，细节应该依赖抽象。针对接口编程，不要针对实现编程。

简单地说，就是尽量使处理类尽量不要直接和实现类直接产生关系，而是通过其继承的接口，在使用的时候具体传入实现类。

优点：可以减少类之间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。

首先先举一个简单的例子：

public class Haozi {
    public void playPCGame(){
        System.out.println("耗子正在玩电脑游戏");
    }

    public void playPS4Game(){
        System.out.println("耗子正在玩PS4游戏");
    }
}
public class Test {
    public static void main(String[] args) {
        Haozi haozi = new Haozi();
        haozi.playPCGame();
        haozi.playPS4Game();
    }
}

现在我又想玩NS了，以现在的情况，只能是在Haozi里面加一个方法，但是如果需求越来越多，那么对Haozi的改动也是越来越大的，这样的做法就是面向实现编程，Haozi就是一个实现类，属于底层模块，Test是高层模块，高层模块直接依赖底层模块的具体实现，所以这也不符合依赖倒置原则。

接下来用依赖倒置原则写一下：

public interface Game {
    void playGame(String name);
}
public class PCGame implements Game{
    @Override
    public void playGame(String name) {
        System.out.println(name + "正在玩电脑游戏");
    }
}
public class PS4Game implements Game {
    @Override
    public void playGame(String name) {
        System.out.println(name + "正在玩PS4游戏");
    }
}
public class Haozi {
    public void playGames(Game game){
        game.playGame("耗子");
    }
}
public class Test {
    public static void main(String[] args) {
        Haozi haozi = new Haozi();
        haozi.playGames(new PCGame());
        haozi.playGames(new PS4Game());
    }
}

看一下类图：

这样，Test就不直接依赖具体实现类了，而是通过Haozi，这样，再想加玩NS游戏，我只要再写一个类实现Game接口，其他的都不需要动了，我需要实现什么，通过高层模块决定就好了，这样，Haozi和Test也解耦了。

代码再进一步优化，用set的方式

public class Haozi {

    private Game game;

    public void setGame(Game game) {
        this.game = game;
    }

    public void playGames(){
        game.playGame("耗子");
    }
}
public class Test {
    public static void main(String[] args) {
        Haozi haozi = new Haozi();
        haozi.setGame(new PCGame());
        haozi.playGames();
        
        haozi.setGame(new PS4Game());
        haozi.playGames();
    }
}

 再看一下类图：

具体玩什么，都不会动Haozi，只需要动应用层Test，添加只需要添加Game即可。这样的结构，也比依赖具体的稳定的多。

单一职责原则

不要存在多余一个导致类变更的愿意，举例：假如在一个类中，有职责1和职责2，在修改职责1的时候，会影响职责2，这就是没有实现单一职责原则。所以一个类/接口/方法只负责一项职责。

优点：降低类的复杂度、提高类的可读性，提高系统的可维护性、降低变更引起的风险。举个例子：

类上的单一职责：

public class Haozi {
    public void wearClothes(String weather){
        System.out.println("耗子" + weather+ "穿棉袄");
    }
}
public class Test {
    public static void main(String[] args) {
        Haozi haozi = new Haozi();
        haozi.wearClothes("下雪");
    }
}

 但如果我传入“天热”，就变成了天热穿棉袄，正常来说肯定是不对的，所以还需要扩展：

public class Haozi {
    public void wearClothes(String weather){
        if("下雪".equals(weather)){
            System.out.println("耗子" + weather + "穿棉袄");
        }else if ("天热".equals(weather)){
            System.out.println("耗子" + weather + "穿短袖");
        }
    }
}

这样虽然解决了问题，但是如果我还有别的天气呢？这就需要不停地扩展Haozi ，违背了单一职责。遵循单一职责原则，我们把穿衣这个类拆分成天冷和天热两种：

public class HotWeather {
    public void wearClothes(String weather) {
        System.out.println("耗子" + weather + "穿单衣");
    }
}
public class ColdWeather {
    public void wearClothes(String weather) {
        System.out.println("耗子" + weather + "穿棉袄");
    }
}

再看类图 

接口上的职责单一：

public interface Game {
    //获取游戏信息
    String getGameName();
    Float getPlayTime();
    //游戏相关操作
    void playGame();
    void refundGame();
}

这样一个接口有两个职责，获取游戏信息和对游戏的相关操作，玩游戏的话，可以获取到游戏时间，但是如果把游戏推掉了，那就不能获取游戏时间了，所以这两个职责互相影响，不符合单一职责原则。

把这个接口拆分：

public interface GameContent {
    String getGameName();
    Float getPlayTime();
}
public interface GameManager {
    void playGame();
    void refundGame();
}
public class GameImpl implements GameContent , GameManager{
    @Override
    public String getGameName() {
        return null;
    }

    @Override
    public Float getPlayTime() {
        return null;
    }

    @Override
    public void playGame() {

    }

    @Override
    public void refundGame() {

    }
}

这样，一个接口的修改只对实现类有影响，对于其他接口没有影响。

类图：

方法上的单一职责：

public class Person {
    public Haozi updateHaozi(Haozi haozi){
        haozi.setName("耗子");
        haozi.setAddress("123");
        return haozi;
    }

    class Haozi{
        private String name;
        private String address;

        public String getName() {
            return name;
        }

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

        public String getAddress() {
            return address;
        }

        public void setAddress(String address) {
            this.address = address;
        }
    }
}

这样的话，updateHaozi这个方法就有了两个职责，一个设置名字，一个设置地址，一般来说遵照单一原则，会拆分成两个方法：

public Haozi updateName(Haozi haozi){
        haozi.setName("耗子");
        return haozi;
    }

    public Haozi updateAddr(Haozi haozi){
        haozi.setAddress("123");
        return haozi;
    }

在实际使用的过程中，接口和方法的单一职责比较好遵循，对于类如果一味地追求单一职责，类的数量可能非常多，所以对于类的单一职责，在实际场景中灵活使用就好。 

接口隔离原则

一个类对一个类的依赖应该建立在最小的接口上，假如有一个接口里面有很多方法，那么如果一个类（或接口）实现这个接口，那里面的方法都要实现（这里不说default），所以我们要建立单一的接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少，当然，一定要根据实际情况适度。

优点：符合我们常说的高内聚低耦合的设计思想，从而使类具有很好的可读性、可扩展性、可维护性。

举例：

public interface AnimalAction {
    public void eat();
    public void fly();
    public void swim();
}
public class Dog implements AnimalAction{
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swim() {

    }
}
public class Bird implements AnimalAction {
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swim() {

    }
}

类图：

对于动物的行为，狗会吃和游泳，但不会飞，对于鸟来说，会吃，有些鸟会飞有些不会，所以对于这种情况，实现了动物行为的接口，那么有些接口就是空实现了。

根据接口隔离原则优化一下：

public interface AllAnimalAction {
    public void eat();
}
public interface FlyAnimalAction {
    public void fly();
}
public interface SwimAnimalAction {
    public void swim();
}
public class Dog implements AllAnimalAction , SwimAnimalAction{
    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }
}
public class Bird implements AllAnimalAction , FlyAnimalAction {
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }
}

 再看类图：

这样就解决了有些方法空实现的问题，细粒度是可以合并的，但是粗粒度是不可以拆分的。当然在实际工作过程中还是要根据实际情况来使用。

迪米特法则（最少知道原则）

一个对象应该对其他对象保持最少的了解。强调指和朋友交流，不和陌生人说话（朋友是指出现在成员变量、方法的出入参中的类成为成员朋友类，出现在方法体内部的类不属于朋友类）

优点：降低类之间的耦合

举例：

public class Boss {
    public void checkNumber(Worker worker){
        List<Goods> goodsList = new ArrayList<>();
        for(int i = 0 ; i < 20 ; i ++){
            goodsList.add(new Goods());
        }
        worker.checkNumberGoods(goodsList);
    }
}
public class Worker {
    public void checkNumberGoods(List<Goods> goodsLists){
        System.out.println("一共有" + goodsLists.size() + "件商品");
    }
}

依照上面的定义，对于Boss而言，worker是他的朋友类，但是方法体中的Goods并不是，所以按照迪米特法则，boos并不是直接创建Goods的，所以Goods不要出现在方法体中。

调整一下：

public class Boss {
    public void checkNumber(Worker worker){
        worker.checkNumberGoods();
    }
}
public class Worker {
    public void checkNumberGoods(){
        List<Goods> goodsList = new ArrayList<>();
        for(int i = 0 ; i < 20 ; i ++){
            goodsList.add(new Goods());
        }
        System.out.println("一共有" + goodsList.size() + "件商品");
    }
}

类图：

这样就清爽多了

里氏替换原则

如果程序中，一个类型为A的对象a，还有一个类型为B的对象b，当我们把a对象都替换成b对象，对于系统没有变化的时候，那么a就是b的父类。也就是说只有当子类可以替换父类，并且软件功能不受影响的时候，父类才是真正的被复用了。

对于定义的扩展：一个软件实体如果使用一个父类的话，那么一定适用于其子类，所有引用父类的地方必须能透明地使用其子类对象，子类对象能够替换父类对象，而程序逻辑不变。

引申意义：子类可以扩展父类的功能，但不能改变父类原有的功能。

1.子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

2.子类中可以增加自己特有的方法。

3.当子类的方法重载父类的方法时，方法的前置条件（即入参）要比父类方法的入参更宽松。

4.当子类的方法实现父类的方法时（重写/重载/实现抽象方法），方法的后置条件（即出参）要比父类的更严格或相等。

优点：约束继承泛滥，开闭原则的一种体现。加强程序的健壮性，同时变更的时候也可以做到非常好的兼容性，提高程序的维护性和扩展性，降低需求变更时引入的风险。

举个例子

public class Rectangle {
    private long length;
    private long width;

    public long getLength() {
        return length;
    }

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

    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }
}
public class Square extends Rectangle{
    private long sideLength;

    public long getSideLength() {
        return sideLength;
    }

    public void setSideLength(long sideLength) {
        this.sideLength = sideLength;
    }

    @Override
    public long getLength() {
        return getSideLength();
    }

    @Override
    public void setLength(long length) {
        setSideLength(length);
    }

    @Override
    public long getWidth() {
        return getSideLength();
    }

    @Override
    public void setWidth(long width) {
        setSideLength(width);
    }
}
public class Test {
    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() <= rectangle.getLength()){
            rectangle.setWidth(rectangle.getWidth() + 1);
            System.out.println("width:" + rectangle.getWidth()
                    + ",length:" + rectangle.getLength());
        }
        System.out.println("end");
    }

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

运行结果：

如果main方法换成正方形呢？

public static void main(String[] args) {
        Square square = new Square();
        square.setLength(10);
        resize(square);
    }

由于while条件一直满足，所以会无限执行下去，这就跟我们预期的不一样了，所以有时候子类父类的关系需要多注意。

新建一个四边形接口

public interface Quadrangle {
    long getLength();
    long getWidth();
}

 调整一下

public class Rectangle implements Quadrangle{
    private long length;
    private long width;

    @Override
    public long getLength() {
        return length;
    }

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

    @Override
    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }
}
public class Square implements Quadrangle{
    private long sideLength;

    public void setSideLength(long sideLength) {
        this.sideLength = sideLength;
    }

    @Override
    public long getLength() {
        return sideLength;
    }

    @Override
    public long getWidth() {
        return sideLength;
    }
}

 这样，在main方法中resize就不能使用正方形了，这样也就防止了继承泛滥，父类和子类不一致的情况。

合成（组合）/聚合复用原则

尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的。组合：contains-A，聚合：has-A，继承：is-A

优点：可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响较少。

对于继承关系，父类的实现细节都会暴露给子类，而对于组合来说，A里面有个B类，对于B类的具体实现细节A是看不到的。

组合：A类中创建了B类对象，当A类消失的时候，B类这个引用也就消失了。

聚合：A类中创建了B类对象，这个对象还被C类引用，当A类消失的时候，B类不会消失。

举个例子：

public class DBConnection {
    public String getConnection(){
        return "mysql";
    }
}
public class ProductDao extends DBConnection {
    public void addProduce(){
        String conn = super.getConnection();
        System.out.println("使用" + conn + "数据连接");
    }
}
public class Test {
    public static void main(String[] args) {
        ProductDao productDao = new ProductDao();
        productDao.addProduce();
    }
}

类图：

这是一个继承关系，如果我还需要一个Oracle连接，以现有的情况，我们可以在DBConnection 中再加一个，但这样就违反了开闭原则。

调整一下：

public abstract class DBConnection {
    public abstract String getConnection();
}
public class MysqlConnection extends DBConnection {
    @Override
    public String getConnection() {
        return "Mysql";
    }
}
public class ProductDao{

    private DBConnection dbConnection;

    public void setDbConnection(DBConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void addProduce(){
        String conn = dbConnection.getConnection();
        System.out.println("使用" + conn + "数据连接");
    }
}
public class Test {
    public static void main(String[] args) {
        ProductDao productDao = new ProductDao();
        productDao.setDbConnection(new MysqlConnection());
        productDao.addProduce();
    }
}

 类图：

这样一来，ProductDao和DBConnection就是一对一的组合复用关系，更加灵活了。 

耗子肉
关注
专栏目录
JavaOOP 实现接口案列
qq_36074134的博客
04-02 380
package hello3; public class CommonHandSet extends HandSet implements PlayWriting{ public CommonHandSet(String string, String string2) { super(string,string2); } public void play(String inco
定义商品类goods包含单价unitprice_MyBatis+Spring技术整合实现商品模块CRUD操作
weixin_31100895的博客
01-04 1192
业务描述基于Spring,MyBatis,SpringBoot,Thymeleaf技术实现商品模块的增删改查操作。项目环境初始化准备工作1. MySQL(5.7)2. JDK (1.8)3. Maven (3.6.3)4. STS(4.7.1)数据库初始化打开mysql控制台,然后按如下步骤执行goods.sql文件。第一步:登录mysql。mysql–uroot –proot第二步:设置控制台...
2.设计模式的六大原则
dezhiduxia38224的博客
02-03 103
1、开闭原则（Open Close Principle） 开闭原则的意思是：对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。简言之，是为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。 2、里氏代换原则（Liskov Substitution Principle） 里氏代...
10.接口
wu_intellect的博客
09-01 155
接口 1.定义 接口是一种能力,在接口中对方法做具体的定义,但是不去做具体的实现,通过子类实现接口的抽象方法做具体的实现,优势:扩展性更强 接口是抽象类实体,因为类是单继承关系,所以可以通过多实现接口拥有更多的父类. 接口和抽象类的区别: 抽象类中可以有属性,可以有抽象方法,构造方法,普通方法, 接口中没有属性,都是public static final修饰的常量,都是public abstract修饰的抽象方法 抽象类和接口都不能被实例化 类可以单独继承类.也可以单独实现接
Java复习知识点梳理之接口
Toddr的博客
09-07 761
Java复习知识点梳理——第三天接口 抽象类 1.1 接口概述 接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。 Java中的接口更多的体现在对行为的抽象 1.2 接口特点 .接口用关键字interface修饰 Public interface 接口名 {} 类实现接口用implement表示 Public class 类名 implement 接口名{} 接口不能实例化 需要参照多态的方式，通过实现类对象实例化，这叫接口多态 多态的形式：具体类多态、抽象类多态、接口多态
设计模式23模式介绍
学Java，找哪吒
01-18 13万+
设计模式精品专栏。
设计模式——七大设计原则
weixin_43412762的博客
12-05 3024
设计模式的七大原则：开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、合成复用原则、迪米特法则
Java中23种设计模式
呜呜老司机的博客家园
10-10 8万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
Java设计模式之七大设计原则
qq_49529322的博客
04-28 1万+
Java设计模式之七大设计原则 本文对Java设计模式中的七大设计原则进行汇总介绍，提炼最核心的概念。 设计模式总结笔记 一、设计模式七大原则 设计模式的目的： 代码可重用性：相同功能的代码，不用多次编写。 可读性：编程规范性，便于其他程序员的阅读和理解。 可扩展性：当需要增加新的功能的时候，非常方便，称为可扩展性。 可靠性：当我们新增功能后，对原来的功能没有影响。 使程序呈现高内聚、低耦合特性。 1.1、单一职责原则 不遵守单一职责原则： 对类来说的，就是一个类应该只负责一项职责。 比如：Us
JAVA 24种设计模式介绍与6大设计原则.pdf
04-12
JAVA的六大设计原则是对设计模式应用的指导，是使软件更加灵活、易于维护和复用的基础。这六大设计原则包括： 1. 单一职责原则（Single Responsibility Principle, SRP）：一个类应该只有一个引起它变化的原因，即...
设计模式之六大原则详解，Markdown笔记
11-18
详细介绍了设计模式六大原则，配有示例代码和图片，有开闭原则，单一职责原则，里氏替换原则，依赖倒置原则，接口隔离原则，迪米特法则等等。
设计原则与设计模式
09-18
面向对象设计原则：面向对象设计原则、开闭原则、里氏替换原则、里氏替换原则、里氏替换原则
24种设计模式介绍与6大设计原则-PDF版 查阅方便
12-22
这个PDF文档“24种设计模式介绍与6大设计原则”旨在帮助开发者理解和应用这些模式，提高代码的可维护性和可扩展性。以下是其中的主要内容： 一、设计原则 1. 单一职责原则：一个类或模块应只有一个引起其变化的原因...
OBS-Studio-30.2.3-Windows.zip
最新发布
09-23
OBS-Studio-30.2.3-Windows.zip
ChanjeeDlnaTool-v1.0 推送电脑上的文件到安卓电视大屏，实现音视频播放和apk安装
09-23
详情参考：https://blog.csdn.net/title71/article/details/142462255?spm=1001.2014.3001.5501 文件里面含有视频使用教程 一.windows+Android大屏 使用投送教程： 准备 0.电视机和电脑要在同一网络下面 1.使用u盘安装chanjeeDlnaTool.apk到电视机 2.将Windows软件拷贝到合适目录，将.mp4 /.flac /.jpg ...文件拷贝到软件目录的www/files文件夹下面 投送 1.打开Android电视机大屏的刚安装的软件，找到左上角显示的电视机的ip地址 2.双击打开Windows软件的ChanjeeDlnaTool.exe文件，有弹窗提示防火墙网络，请点击允许 3.在Windows软件的ip地址栏输入Android电视机大屏上面的ip地址，并在Windows软件点击认证 4.认证完成后Windows软件下方蓝字会提示Binging successful 就说明绑定成功，此时就可以在Windows软件选择本地文件向Android大屏投送文件了
CODESYS是PLC软件编程工具.docx
09-23
CODESYS是一款功能强大的PLC（可编程逻辑控制器）软件编程工具，广泛应用于工业自动化领域。以下是对CODESYS的详细介绍： 一、基本概述 定义：CODESYS是Controlled Development System的缩写，是可编程逻辑控制PLC的完整开发环境。 开发商：CODESYS软件商是德国Smart software solution GmbH，该公司位于德国巴伐利亚州肯普腾市。 最新版本：CODESYS V3（国内PLC用户使用的版本多为CODESYS V2.3）。V3版本在软件架构上有了很大的改善，朝安全软件的方向发展，正在申请TUV关于EN 61508的SIL认证。 二、主要特点 开放性：CODESYS是一个开放的软件平台，允许第三方开发者在其上开发定制化的解决方案，适应不同厂商的PLC设备，具有很高的灵活性和扩展性。 跨平台：CODESYS可以运行在多种不同的操作系统上，包括Windows、Linux和嵌入式系统（RTOS），提高了开发效率和可移植性。 多语言支持：支持IEC61131-3标准下的IL、ST、FBD、LD、CFC、SFC六种PLC编程语言，用
设计模式六大原则详解
"设计模式六大原则是软件设计中的一些核心准则，它们有助于创建可维护、可扩展和高质量的代码。这些原则包括单一职责原则、里氏替换原则、依赖倒置原则、接口隔离原则、迪米特法则和开闭原则。" 在设计模式六大原则...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值