依赖和耦合

habren 发布于2019-08-16 18:24 / 1797人阅读

摘要：什么是依赖，什么是耦合现在来聊一聊我对于依赖和耦合的理解。现在又有一个需求小明想要去吃香蕉，想要去吃梨子。再加一个这个需求是一个合理的需求，但是因为我们这一段的代码是不合理的，产生了依赖和耦合。

我刚开始学习软件工程，学习设计模式，总是会聊到设计模式，总是会说高内聚，低耦合，还有依赖注入。什么是依赖，什么是耦合？现在来聊一聊我对于依赖和耦合的理解。

先看下面一段简单代码，

class Apple{
    private String name = "Apple";
}

class People{
    private List stomach = new ArrayList<>();
    
    public void eat(Apple apple){
        stomach.add(apple);
    }

}

class MainDemo {
    public static void main(String[] args) {    
        People xiaoming= new People();
        Apple apple = new Apple();
        xiaoming.eat(apple);
    }
}

一个人类，一个苹果类，代码的意思是小明吃苹果，保存在胃中。
现在又有一个需求：小明想要去吃香蕉，想要去吃梨子。用上面这一段的代码就不好改了。要完成需求就需要做大量的变化。再加一个 Banana stomach？
这个需求是一个合理的需求，但是因为我们这一段的代码是不合理的，产生了依赖和耦合。

如何减少依赖，就是使用面向接口的编程。依赖一个抽象而不是依赖一个实现。

interface Food{
    
}

class Banana implement Food{
    private String name = "Banana";
}

class Apple implement Food{
    private String name = "Apple";
}

class People{
    private List stomach = new ArrayList<>();
    
    public void eat(Food food){
        stomach.add(food);
    }
}

class MainDemo {
    public static void main(String[] args) {
        People xiaoming= new People();
        Food apple = new Apple();
        xiaoming.eat(apple);
        Food banana = new Banana();
        xiaoming.eat(banana);
    }
}

这样其实我的接口里面啥也没有，但是却将依赖转移到了抽象的接口。这样我每次添加都可以增加不同水果。其实我这个取名是Food，那么这个其实可以添加其他的种类食物。这也体现了开放-闭合原则。再看最后一个例子

import java.util.*;


interface Food{
    public String getName();    
}

abstract class Fruit implements Food {
    protected String type = "fruit";
    
    public abstract void fruitProperty();
}

class Banana extends Fruit {
    private String name = "Banana";
    
    public String getName(){
        return name;
    }
    
    public void fruitProperty(){}
}

class Apple extends Fruit {
    private String name = "Apple";
    
    public String getName(){
        return name;
    }
 
    public void fruitProperty(){}
    
}

abstract class Meat implements Food {
    protected String type = "meat";
            
    public abstract void meatProperty();
}

class Beef extends Meat {
    private String name = "Beef";
    
    public String getName(){
        return name;
    }
    
    public void meatProperty(){}
}

class Chicken extends Meat {
    private String name = "Chicken";
    
    public String getName(){
        return name;
    };
    
    public void meatProperty(){}
}

class People{
    private List stomach = new ArrayList<>();
    
    public void eat(Food food){
        stomach.add(food);
    }
    
    public void display(){
        for (Food f : stomach) {
            System.out.println("stomach have " + f.getName());
        }
    }
}


class MainDemo {
    public static void main(String[] args) 
    {
        People xiaoming= new People();
        Food apple = new Apple();
        xiaoming.eat(apple);
        Food banana = new Banana();
        xiaoming.eat(banana);
        Food beef = new Beef ();
        xiaoming.eat(beef);
        Food chicken = new Chicken ();
        xiaoming.eat(chicken);
        xiaoming.display();
    }
}

可以添加任何食物，西瓜，白菜，西兰花。并且他们之间的方法可以是共有的，也可以私有的。当出现几种大类相同的事务，添加一个蔬菜抽象类，这样简化代码。

GPU云服务器云服务器 DTS 解耦和耦合内容耦合松散耦合耦合性

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/75022.html

可靠React组件设计的7个准则之封装

摘要：组件可以处理其他组件的实例化为了避免破坏封装，请注意通过传递的内容。因此，将状态管理的父组件实例传递给子组件会破坏封装。让我们改进两个组件的结构和属性，以便恢复封装。组件的可重用性和可测试性显著增加。翻译：刘小夕原文链接：https://dmitripavlutin.com/7-... 原文的篇幅非常长，不过内容太过于吸引我，还是忍不住要翻译出来。此篇文章对编写可重用和可维护的Re...

yck 2019-08-26 10:40 评论0 收藏0
设计模式六大原则（PHP）

摘要：常用的六大设计模式有单一职责原则，里氏替换原则，依赖倒转原则，接口隔离原则，迪米特法则，开闭原则。这六大原则是最虚，最抽象的，很难理解。这就是接口隔离原则。当我们遵循前面介绍的五大原则，以及使用种设计模式的目的就是遵循开闭原则。　　设计模式的目的是为了更好的代码重用性，可读性，可靠性和可维护性。常用的六大设计模式有：单一职责原则（SRP），里氏替换原则（LSP），依赖倒转原则（DIP...

bluesky 2019-07-01 10:05 评论0 收藏0
深入理解JavaScript系列10:S.O.L.I.D五大原则之依赖倒置原则

摘要：前言本章我们要讲解的是五大原则语言实现的第篇，依赖倒置原则。当应用依赖倒置原则的时候，关系就反过来了。在当静态类型语言的上下文里讨论依赖倒置原则的时候，耦合的概念包括语义和物理两种。依赖倒置原则和依赖注入都是关注依赖，并且都是用于反转。前言本章我们要讲解的是S.O.L.I.D五大原则JavaScript语言实现的第5篇，依赖倒置原则LSP（The Dependency Invers...

chenjiang3 2019-08-19 17:22 评论0 收藏0
第6章：可维护性软件构建方法 6.1可维护性的度量和构造原则

摘要：设计方案的容易改变这就是所谓的软件构建的可维护性，可扩展性和灵活性。这也可能表明类型或方法可能难以维护。基于源代码中不同运算符和操作数的数量的合成度量。对修改的封闭这种模块的源代码是不可侵犯的。大纲软件维护和演变可维护性度量模块化设计和模块化原则OO设计原则：SOLIDOO设计原则：GRASP总结软件维护和演变什么是软件维护？软件工程中的软件维护是交付后修改软件产品以纠正故障...

chanjarster 2019-08-16 12:35 评论0 收藏0
Spring还可以这么学--IoC(控制反转) / DI(依赖注入)理解

摘要：对象之间耦合度过高的系统，必然会出现牵一发而动全身的情形。控制被反转之后，获得依赖对象的过程由自身管理变为了由容器主动注入。于是，他给控制反转取了一个更合适的名字叫做依赖注入。 Spring还可以这么学--IoC(控制反转) / DI(依赖注入)理解声明：文章的前三部分参考博文：https://www.cnblogs.com/Nouno...这篇文章首发是在我的个人微信订阅号每天学编...

atinosun 2019-08-15 15:55 评论0 收藏0