精华内容
下载资源
问答
  • Java耦合解耦

    2019-02-07 17:35:42
    一、耦合 耦合关系:某两个事物之间如果存在一种相互作用、相互影响的关系 耦合指的就是俩个类或者俩个对象之间联系的紧密程度 二、解耦 解除类之间的直接关系,将直接关系转换成间接关系,一般情况下发现耦合需要...

    一、耦合
    耦合关系:某两个事物之间如果存在一种相互作用、相互影响的关系
    耦合指的就是俩个类或者俩个对象之间联系的紧密程度
    二、解耦
    解除类之间的直接关系,将直接关系转换成间接关系,一般情况下发现耦合需要解耦,避免强耦合,这样的话一改则全部都要改,不利于程序进行

    展开全文
  • Java什么是耦合

    2020-09-08 08:58:25
    Java什么是耦合

    Java什么是耦合。


    持续更新,一起变强

    展开全文
  • Java耦合问题

    千次阅读 2020-07-10 12:45:01
    一、耦合问题 1、软件设计的耦合 耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。 软件工程中对象之间的耦合度就是指对象之间的...

    一、耦合问题

    1、软件设计的耦合

    耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。

    • 软件工程中对象之间的耦合度就是指对象之间的依赖性。
    • 对象之间的耦合越高,维护成本也就越高

    2、常见的耦合

    1. 内容耦合
      内容耦合是指一个模块与另一个模块的内部属性有关,不经调用直接使用另一个模块的程序代码或内部数据。
    2. 公共耦合
      公共耦合指通过一个公共数据环境相互作用的那些模块间的耦合,公共数据环境可以是全程变量或数据结构共享的通信,内存的公共覆盖区及任何存储介质上的文件。
      物理设备(也有将公共外部设备分类为外部耦合),由于两个模块都需引用同一个公共数据域,因此有较高的耦合度。
    3. 控制耦合/外部耦合
      一个模块通过接口向另一个模块传递一个控制信号,接收信号的模块根据信号值而进行适当的动作,这种耦合被称为控制耦合。
    4. 标记耦合
      若一个模块A通过接口向两个模块B和C传递一个公共参数,那么模块B和模块C之间存在一个标记耦合。
    5. 数据耦合
      模块之间通过参数来传递数据,那么被称为数据耦合。
      数据耦合是最低的一种耦合形式,系统中一般都存在这种类型的耦合,为了完成一些有意义的操作,往往需要将某些模块的输出数据作为另一些模块的输入数据
    6. 非直接耦合
      两个模块之间没有直接关系,他们之间的联系完全是通过主模块的控制和调用来实现的。

    3、耦合的解决方案

    • 耦合在一起的模块,如果一方发生了变化肯定会影响另一方,这样的话独立性降低危险度提高,维护成本自然就高了。
    • 如果必须用耦合的话,尽量使用数据耦合,少用控制耦合,限制公共耦合范围,避免内容耦合。
    • 高内聚低耦合是软件设计的最终解决思路,但高内聚意味着编码成本的增加,所以完美的高内聚是不存在的,所以适度设计即可。(内聚是指什么功能都由自己内部实现,不需要依靠外部任何资源)

    二、耦合的小例子

    1、最初版本

    • 实体类
    package com.gaj.entity;
    
    /**
     * Java实体类
     * @author Jan
     *
     */
    public class UserInfo {
    	private Integer id;
    	private String name;
    	
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	@Override
    	public String toString() {
    		return "UserInfo [id=" + id + ", name=" + name + "]";
    	}
    }
    
    
    • DAO层
    package com.gaj.dao;
    
    import com.gaj.entity.UserInfo;
    
    /**
     * 模拟获得对象及属性
     * @author Jan
     *
     */
    public class UserInfoDAO {
    	public UserInfo findUserById(Integer id){
    		// 创建方法返回值
    		UserInfo user = new UserInfo();
    		// 设置属性
    		user.setId(1);
    		user.setName("张三");
    		//返回
    		return user;
    	}
    }
    
    
    • Service层
    package com.gaj.service;
    
    import com.gaj.dao.UserInfoDAO;
    import com.gaj.entity.UserInfo;
    
    public class UserInfoService {
    	
    	private UserInfoDAO userDao = new UserInfoDAO();
    	
    	public UserInfo findUserById(Integer id){
    		return userDao.findUserById(id);
    	}
    	
    }
    
    
    • Test类
    package com.gaj.test;
    
    import org.junit.Test;
    
    import com.gaj.entity.UserInfo;
    import com.gaj.service.UserInfoService;
    
    public class MyTest {
    
    	@Test
    	public void findUserById(){
    		UserInfoService service = new UserInfoService();
    		UserInfo user = service.findUserById(1);
    		System.out.println(user);
    	}
    	
    }
    

    测试类是可以拿到结果的,但是类与类之间耦和度比较高。测试类依赖Service层的对象,Service层依赖DAO层的对象,DAO层依赖实体层的对象。
    在这里插入图片描述
    更改被引用类的类名,会直接影响到引用该类的类
    在这里插入图片描述

    2、引入接口降低耦合

    • DAO层接口
    package com.gaj.dao;
    
    import com.gaj.entity.UserInfo;
    
    
    public interface UserInfoDAO {
    	
    	public UserInfo findUserById(Integer id);
    	
    }
    
    
    • DAO层实现类
    package com.gaj.dao.Impl;
    
    import com.gaj.dao.UserInfoDAO;
    import com.gaj.entity.UserInfo;
    /**
     * 模拟获得对象及属性
     * @author Jan
     *
     */
    public class UserInfoDAOImplement implements UserInfoDAO{
    
    	@Override
    	public UserInfo findUserById(Integer id){
    		// 创建方法返回值
    		UserInfo user = new UserInfo();
    		// 设置属性
    		user.setId(1);
    		user.setName("张三");
    		//返回
    		return user;
    	}
    	
    }
    
    
    • Service层接口
    package com.gaj.service;
    
    import com.gaj.entity.UserInfo;
    
    public interface UserInfoService {
    
    	public UserInfo findUserById(Integer id);
    	
    }
    
    
    • Service层实现类
    package com.gaj.service.impl;
    
    import com.gaj.dao.UserInfoDAO;
    import com.gaj.dao.Impl.UserInfoDAOImplement;
    import com.gaj.entity.UserInfo;
    import com.gaj.service.UserInfoService;
    
    public class UserInfoServiceImplement implements UserInfoService {
    	
    	private UserInfoDAO userDao = new UserInfoDAOImplement();
    	
    	public UserInfo findUserById(Integer id){
    		return userDao.findUserById(id);
    	}
    	
    }
    
    
    • 测试类
    package com.gaj.test;
    
    import org.junit.Test;
    
    import com.gaj.entity.UserInfo;
    import com.gaj.service.UserInfoService;
    import com.gaj.service.impl.UserInfoServiceImplement;
    
    public class MyTest {
    
    	@Test
    	public void findUserById(){
    		UserInfoService service = new UserInfoServiceImplement();
    		UserInfo user = service.findUserById(1);
    		System.out.println(user);
    	}
    }
    
    

    耦合当然是存在的,但如果不new对象,就能减少耦合了。(将控制耦合转化为数据耦合)

    3、利用反射技术进一步降低耦合

    利用反射技术,将控制耦合转化为数据耦合。

    	@Test
    	public void findUserById2() throws Exception{
    		UserInfoService service = (UserInfoService) Class.forName("com.gaj.service.impl.UserInfoServiceImplement").newInstance();
    		UserInfo user = service.findUserById(1);
    		System.out.println(user);
    	}
    

    把本来的类与类之间的耦合降低为类与字符串之间的耦合,但要创建对象的类的权限定名写在了java文件里,也意味着如果修改这个创建对象的类名的话必须把当前这个java文件重新编译。

    4、将XML作为配置文件保存类全限定名

    因为XML是程序的元语言文件,XML是不需要任何编译器就能直接被计算机识别,HTML就是XML的一种高级应用,写HTML的时候只
    需要一个记事本,写完了无需编译直接扔到浏览器就能运行,所以可以利用XML的特性把要创建对象的类以某种自定义格式扔到XML中,然后用Java技术读取XML,读取到之后再反射生成对象。
    语法:

    头部标记 : 
    <?xml version="1.0" encoding="UTF-8"?>
    单标签 : 
    <标签名称 属性1="值1" 属性2="值2" .... 属性N="值N" />
    双标签 : 
    <标签名称 属性1="值1" 属性2="值2" .... 属性N="值N">标签之间的内容</标签名称>
    

    将需要创建对象的部分都放到XML文件中
    applicationContext.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <beans>
    	<bean id="userDao" class="com.gaj.dao.Impl.UserInfoDAOImplement" />
    	<bean id="service" class="com.gaj.service.impl.UserInfoServiceImplement" />
    </beans>
    

    5、dom4j工具解析XML文件

    dom4j是一个Java的XML API,是jdom的升级品,用来读写XML文件的。dom4j是一个十分优秀的JavaXML API,具有性能优异、功能强大和极其易使用的特点,它的性能超过sun公司官方的dom技术,同时它也是一个开放源代码的软件,可以在SourceForge上找到它。在IBM developerWorks上面还可以找到一篇文章,对主流的Java XML API进行的性能、功能和易用性的评测,因此可以知道dom4j无论在哪个方面都是非常出色的。如今可以看到越来越多的Java软件都在使用dom4j来读写XML,特别值得一提的是连Sun的JAXM也在用dom4j。这已经是必须使用的jar包,Hibernate也用它来读写配置文件。

    • 解析XML的dom4j的jar包:
      在这里插入图片描述
    • 测试dom4j
    	@Test
    	public void dom4jTest() throws DocumentException{
    		// 获取xml的位置
    		InputStream in = this.getClass().getClassLoader().getResourceAsStream("applicationContext.xml");
    		// 开始解析
    		// 1.将xml加载到内存中	相当于在内存中将字节流转化为XML文件
    		Document document = new SAXReader().read(in);
    		// 2.获取xml的beans根节点
    		Element beans = document.getRootElement();
    		// 3.获取根节点下的所有bean子节点 保存到List集合
    		List<Element> elements = beans.elements("bean");
    		// 4.解析id属性和class属性
    		for(Element e : elements){
    			// 获取id属性
    			String id = e.attributeValue("id");
    			// 获取class属性
    			String clazz = e.attributeValue("class");
    			// 输出
    			System.out.println(id + "\t\t" + clazz);
    		}
    	}
    }
    

    6、简单工厂模式

    拿类名创建对象,然后拿id值作为key,将这些创建的对象再保存到一个Map集合里去,程序用到的时候用map的key获取某个对象这样我们就不用new这个对象了,这个工具类可以通过读取XML的形式创建其他类的对象,也就是说创建所有类的对象都可以通过这一个类来创建,那么这个专门用来创建对象的类就是对象工厂类,而这种设计模式被叫做简单工厂设计模式。
    简单工厂模式获取目标对象有什么好处呢?使用工厂模式隐藏创建对象细节,这样可以统一对象管理,如果要修改某些实例对象只需要修改工厂方法即可,这样引用工厂的那些个类都不用修改。

    • 编写工厂类
      BeanFactory.java
    package com.gaj.utils;
    
    import java.io.InputStream;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    /**
     * 工厂类 读取xml文件通过bean标签的class属性值创建对象
     * 
     * @author Jan
     *
     */
    public class BeanFactory {
    
    	// 定义对象保存容器
    	private static Map<String, Object> objs = new HashMap<String, Object>();
    
    	static {
    		// 获取xml的位置
    		InputStream is = BeanFactory.class.getClassLoader().getResourceAsStream("applicationContext.xml");
    		// 1.将xml加载到内存中:字节流 -> xml文件
    		try {
    			Document document = new SAXReader().read(is);
    			// 2.获取xml的根节点 beans
    			Element beans = document.getRootElement();
    			// 3.获取根节点下的所有子节点 bean
    			List<Element> bean = beans.elements("bean");
    			// 4. 循环解析id属性和class属性
    			for (Element e : bean) {
    				String id = e.attributeValue("id");
    				String clazz = e.attributeValue("class");
    				// 通过类名创建对象
    				Object obj = Class.forName(clazz).newInstance();
    				// 保存到Map集合
    				objs.put(id, obj);
    			}
    		} catch (DocumentException e1) {
    			e1.printStackTrace();
    		} catch (InstantiationException e1) {
    			e1.printStackTrace();
    		} catch (IllegalAccessException e1) {
    			e1.printStackTrace();
    		} catch (ClassNotFoundException e1) {
    			e1.printStackTrace();
    		}
    
    	}
    
    	/**
    	 * 根据对象id获取对象
    	 * 
    	 * @param id
    	 * @return 返回该id的class类
    	 */
    	public static <T> T getBean(String id) {
    		Object obj = objs.get(id);
    		if (null != obj) {
    			return (T) obj;
    		} else {
    			return null;
    		}
    	}
    }
    
    
    • 修改Service实现类
    package com.gaj.service.impl;
    
    import com.gaj.dao.UserInfoDAO;
    import com.gaj.dao.Impl.UserInfoDAOImplement;
    import com.gaj.entity.UserInfo;
    import com.gaj.service.UserInfoService;
    import com.gaj.utils.BeanFactory;
    
    public class UserInfoServiceImplement implements UserInfoService {
    	
    	private UserInfoDAO userDao = BeanFactory.getBean("userDao");
    	
    	public UserInfo findUserById(Integer id){
    		return userDao.findUserById(id);
    	}
    	
    }
    
    
    • 修改测试类
    	@Test
    	public void findUserById(){
    		UserInfoService service = BeanFactory.getBean("service");
    		UserInfo user = service.findUserById(1);
    		System.out.println(user);
    	}
    

    7、自定义IOC

    IOC:(Inversion Of Control)控制反转,对象的创建权限由本类交给了工厂创建,对这种对象创建权限的移交叫控制反转。

    • IOC是什么?
      控制反转,把类创建自己对象的权利交给框架,让框架统一管理对象;
    • 为什么要用IOC创建对象呢?
      解耦和,IOC能把两个类的硬耦合(编程阶段耦合在了一起)编程两个类的软耦合(程序运行期间耦合在了一起),这样互不干扰,特别开心;
    • 在哪些地方使用IOC?
      框架应用中使用比较频繁
    • 怎么用IOC?
      1)定义对象容器
      2)工厂模式获取对象
    • IOC的作用?
      消除计算机程序对象的耦合
    展开全文
  • java 里面耦合和解耦

    万次阅读 2019-11-10 18:33:18
      耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 解耦就是用数学方法将两种运动分离开来处理问题。 这是形象搞笑的比喻:   完全可以这么想像嘛,有一对热恋中的...

    百度解释:

      耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。
    解耦就是用数学方法将两种运动分离开来处理问题。

    这是形象搞笑的比喻:

      完全可以这么想像嘛,有一对热恋中的男女,水深火热的,谁离开谁都不行了,离开就得死,要是对方有一点风吹草动,这一方就得地动山摇。
      可以按照琼瑶阿姨的路子继续想象,想成什么样都不过分,他们之间的这种状态就应该叫做“偶合”。

      他们这么下去,有人看不惯了,有一些掌握话语权的权利机构觉得有必要出面阻止了,这样下去不是个事吖,你得先爱祖国,爱社会,爱人民,爱这大好河山才行啊,
    于是棒打鸳鸯,让他们之间对对方的需要,抽象成一种生理需要,这就好办了,把她抽象成女人,他抽象成男人,当他需要女人时,就把她当做女人送来,反之亦然,
      看上去他们仍在一起,没什么变化,实质上呢,他们已经被成功的拆散了,当有一天他需要女人时,来了另外一个女人,嘿嘿 他不会反对的。对方怎么变他也不会关心了。这就是“解偶”。

      较为具体的说明就是有的时候程序需要修改,我只需要改正一部分,单是如果程序的耦合性很强的话就需要从头再写一遍很不划算,而正常的开发中都是改那部分,重写那部分,把配置文件一改就成了,java中通过接口(interface),spring技术中的ioc等实现的解耦合,重写覆盖父类的方法也是一种解耦行为

    展开全文
  • Java耦合的理解

    2020-05-26 23:12:43
    java讲究高内聚,低耦合。今天我们就先来说一下什么是耦合,如何才能低耦合。 1.耦合定义:耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。也就是两者存在着强关联。 ...
  • java耦合

    千次阅读 2019-02-20 16:09:23
    java耦合耦合度讲的是模块模块之间,代码代码之间的关联度,通过对系统的分析把他分解成一个一个子模块,子模块提供稳定的接口,达到降低系统耦合度的的目的,模块模块之间尽量使用模块接口访问,而不是随意...
  • java耦合度介绍

    千次阅读 2018-05-02 09:29:29
    java耦合度解释 我们写程序的目标就是 高内聚 低耦合! 那什么是耦合度呢? 程序的耦合度是 你的子程序之间的相关联性,也就是说你的多个类的联系 是否太紧密,耦合度 是松还是紧 就看你的 关联 是强还是弱,也...
  • Java/Android 常见的设计模式总结,提高代码重用性和扩展下 概念 耦合性(英语:Coupling,dependency,或称耦合力或耦合度)是指一程序中,模块及模块之间信息或参数依赖的程度。 内聚性是一个和耦合性相.....
  • 什么是耦合耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。...我们可以利用Java的反射技术,通过类定名,来进行反射创建对象,这个时候我们可以成功的避免编译时异常,并且保证了项
  • Java编程思想之低耦合

    2016-11-25 20:34:42
    1. 低耦合(Low Coupling) “低耦合”这个词相信大家已经耳熟能详,我们在看spring的书籍、MVC的数据、设计模 式的书籍,无处不提到“低耦合、高内聚”,它已经成为软件设计质量的标准之一。那么什么是低耦合?...
  • 请先看下这个关于松耦合的回答 举个简单的例子啦 有一百人分成10个团队做开发 你写了一个类A,供其他人调用,怎么办? 简单的方法就是把这个类打成jar包,然后给他们 他们就A a = new A(); 然后调用a的方法。 ...
  • java耦合与解耦

    千次阅读 2018-07-24 16:42:19
    java 里面耦合和解耦 百度解释: 耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 解耦就是用数学方法将两种运动分离开来处理问题。 这是形象搞笑的比喻: 完全...
  • 耦合性是用来描述模块之间的独立程度。这里讲模块之间的耦合程度分为六个程度R1.-R6(Ri >Rj, i > j)。分别是无耦合,数据耦合,标记耦合,控制耦合,共同耦合,内容耦合
  • Java中的耦合和解耦

    2020-05-22 20:19:32
    Java耦合: 例如在web开发中,表现层需要持有业务层的对象,业务层中需要持有持久层的对象,这种关系是很强的依赖关系。 代码如下: 业务层:(在包service下) package top.radish.service public class Account...
  • 一个是两个类两个类之间的耦合度问题,A类调用B类的一个操作b()和C类调用B类的一个操作b(xxx),是不是说C类相比于A类对B类的耦合度就更高,就因为C在和B发生关系的时候传递了参数,用于改变B内的变量这样?
  • 现在流行使用注解和Xml来达到松耦合的目的,但也大量使用了反射,这造成一定的资源消耗,而且维护起来比较繁琐,个人概念中,松耦合就是即插即用,为什么需要那么麻烦去配置XML,个人觉得看似更简单了,不过使用xml...
  • Java中的低耦合高内聚法则

    千次阅读 2017-12-18 20:21:14
    java框架模式_低耦合高内聚法则定义:一个对象应该对其他对象保持最少的了解。 问题由来:类与类之间的关系越来越密切,耦合度越来越大,当一个类发生改变时,对另外一个类的影响也越大. 解决方案:尽量降低类与类...
  • 对象之间的耦合越高,即代表对象之间的依赖性很强,维护成本越高,因此对象的设计应使类和构件之间的耦合最小(高内聚低耦合),耦合java中指的是,两个类之间的联系的紧密程度。 我们先来看一个例子: 这个例子...
  • 耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 解耦就是用数学方法将两种运动分离开来处理问题。 这是形象搞笑的比喻: 完全可以这么想像嘛,有一对热恋中的男女,...
  • JAVA之接口的解耦合

    2019-04-14 17:40:07
    学过java的人都知道,java是单继承的,也就是说一个class只能继承一个类。 例如我们想制作一台有播放器的手机,那么我们先得制作一个播放器吧,再把播放器放进手机里。在java会怎么实现呢?如果使用继承,我们会先...
  • 在程序设计时,为了避免程序的冗杂,减少各个类之间的依耐性,经常使用低耦合和高内聚的设计理念。 为了达到这个目的,我们采取以下措施: ①降低耦合:我们常用封装来降低耦合。例如,假如现在又A、B两个类,为降低...
  • Java框架与低耦合

    千次阅读 2015-10-03 13:06:57
    “低耦合”这个词相信大家已经耳熟能详,我们在看spring的书籍、MVC的数据、设计模 式的书籍,无处不提到“低耦合、高内聚”,它已经成为软件设计质量的标准之一。那么什么是低耦合耦合就是对某元素与其它元素之间...
  • Java学习记录:降低耦合

    千次阅读 2016-02-24 11:10:06
    降低耦合度 监听器设计
  • Java编程思想之高内聚低耦合

    千次阅读 2020-05-18 22:56:16
    文章目录1 前言2 低耦合耦合性定义耦合性分类3 高内聚高内聚定义耦合性分类4 示例5 总结 1 前言 编程的时候,经常要使得系统高内聚、低耦合,那么,我们口中的这些概念到底是什么?什么是高内聚低耦合呢? 2 低耦合 ...
  • Java 高内聚,低耦合

    2020-07-19 16:36:43
    2.1. 耦合,各个代码块间联系紧密程度的度量(模块之间联系越紧密,其耦合性就越强,模块的独立性则越差。模块间耦合的高低取决于模块间接口的复杂性,调用的方式以及传递的信息。) 2.2. 耦合度,对象之间的耦合度...
  • java耦合度,要高内聚,低耦合

    千次阅读 2017-03-16 14:01:26
    耦合度 是松还是紧 就看你的 关联 是强还是弱,也就是修改的代价,比如 你窗子是扣死在墙里的 那么你修改窗子 就必须修改墙 这就比较紧密了,但是如果你窗子是按照某种规格的 可以自由拆装的 那么修改的代价就小,...
  • Java中的耦合

    千次阅读 2011-12-15 19:41:12
    这就是紧耦合,他们的程序紧密地耦合着你的程序。 如果是松耦合的话,我想我可能会定义一个接口给他们,然后IOC的方式将实现类给他们,最好是远程的通过webservice的方式进行调用,这样我的A更新了,只需要切换掉...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 235,383
精华内容 94,153
关键字:

耦合java

java 订阅