精华内容
下载资源
问答
  • 耦合java
    2021-02-12 19:01:53

    耦合是指另一个对象对一个对象的使用。也可以称为协作。一个对象与另一个对象之间的依赖关系可以完成一些任务,可以分为以下两种类型:紧密耦合-当对象创建要使用的对象时,则为紧密耦合情况。由于主要对象创建了对象本身,因此无法从外部将其更改为易于将其标记为紧密耦合的对象。

    松散耦合-当对象从外部获取要使用的对象时,则为松散耦合情况。由于主要对象仅是使用对象,因此可以从外部轻松更改该对象,将其标记为松散耦合的对象。

    示例-紧耦合

    测试器

    public class Tester {

    public static void main(String args[]) {

    A a = new A();

    //a.display()将打印A和B-

    //此实现不能动态更改

    //紧密耦合

    a.display();

    }

    }

    class A {

    B b;

    public A() {

    //b与A紧密耦合

    b = new B();

    }

    public void display() {

    System.out.println("A");

    b.display();

    }

    }

    class B {

    public B(){}

    public void display() {

    System.out.println("B");

    }

    }

    这将产生以下结果-

    输出结果A

    B

    示例-松耦合

    测试器import java.io.IOException;

    public class Tester {

    public static void main(String args[]) throws IOException {

    Show b = new B();

    Show c = new C();

    A a = new A(b);

    //a.display()将打印A和B-

    a.display();

    A a1 = new A(c);

    //a.display()将打印A和C-

    a1.display();

    }

    }

    interface Show {

    public void display();

    }

    class A {

    Show s;

    public A(Show s) {

    //s与A松散耦合

    this.s = s;

    }

    public void display() {

    System.out.println("A");

    s.display();

    }

    }

    class B implements Show {

    public B(){}

    public void display() {

    System.out.println("B");

    }

    }

    class C implements Show {

    public C(){}

    public void display() {

    System.out.println("C");

    }

    }

    这将产生以下结果-

    输出结果A

    B

    A

    C

    使用接口,我们通过注入依赖关系来实现松散耦合。

    更多相关内容
  • 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的作用?
      消除计算机程序对象的耦合
    展开全文
  • 程序间耦合是指程序之间的依赖关系。我们开发的程序如果耦合度太高就会导致独立性太差,所以软件开发应该遵循高内聚,低耦合的设计标准。依赖一般分为类之间的依赖和方法之间的依赖。那么如何降低程序间的依赖呢?在...

    程序间耦合是指程序之间的依赖关系。我们开发的程序如果耦合度太高就会导致独立性太差,所以软件开发应该遵循高内聚,低耦合的设计标准。依赖一般分为类之间的依赖和方法之间的依赖。那么如何降低程序间的依赖呢?在开发中,应该做到程序在编译的时候不依赖,在运行的时候才依赖,我们可以通过两个步骤来分析实现,第一:使用反射来创建对象,避免使用new关键字创建;第二:通过配置文件来获取要创建对象的全限定类名。通过以上两步即可做到完美解耦。

    案例:

    我们做一个模拟保存用户的例子,在有解耦意识之前,我们的代码是这样的:

    package cn.com.gjw.dao;
    
    //用户持久层接口
    public interface UserDao {
    	void saveUser();
    }
    
    package cn.com.gjw.dao.impl;
    
    import cn.com.gjw.dao.UserDao;
    //用户持久层接口实现类
    public class UserDaoImpl implements UserDao {
    
    	@Override
    	public void saveUser() {
    		System.out.println("模拟保存用户信息。。。");
    	}
    
    }
    
    package cn.com.gjw.service;
    //用户业务层接口
    public interface UserService {
    
    	void saveUser();
    }
    
    package cn.com.gjw.service.impl;
    
    import cn.com.gjw.dao.UserDao;
    import cn.com.gjw.dao.impl.UserDaoImpl;
    import cn.com.gjw.service.UserService;
    
    public class UserServiceImpl implements UserService {
    
    	private UserDao dao = new UserDaoImpl();
    	@Override
    	public void saveUser() {
    		dao.saveUser();
    	}
    
    }
    
    package cn.com.gjw.test;
    
    import cn.com.gjw.service.UserService;
    import cn.com.gjw.service.impl.UserServiceImpl;
    
    public class Test2 {
    
    	public static void main(String[] args) {
    		UserService service = new UserServiceImpl();
    		service.saveUser();
    	}
    }
    

    main函数依赖UserServiceImpl类才能编译成功,同样,UserServiceImplement类依赖UserDaoImpl才能编译成功,足以看出耦合度很高。

    那么接下来我们通过解耦来提高程序的独立性:

    首先创建一个属性文件(beans.properties),以键值对的形式存放以下内容:

    userService=cn.com.gjw.service.impl.UserServiceImpl
    userDao=cn.com.gjw.dao.impl.UserDaoImpl

    其次再创建一个Bean工厂,由工厂代替new关键字为我们创建对象: 

    package cn.com.gjw.factory;
    //bean工厂
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
    
    public class BeanFactory {
    
    	private static Properties props;
    	//静态代码块,只在程序启动时执行一次
    	static {
    		try {
    			props = new Properties();
    			//通过流的方式加载属性文件
    			InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("beans.properties");
    			props.load(in);
    			
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	//通过bean的名称获取对象
    	public static Object getBean(String beanName) {
    		//bean的全限定类名
    		String beanPath = props.getProperty(beanName);
    		Object bean = null;
    		try {
    			bean = Class.forName(beanPath).newInstance();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return bean;
    	}
    }
    

    此时,我们创建对象时,只需要调用BeanFactory类的getBean()方法即可。同时,我们对依赖的类也要做调整:

    package cn.com.gjw.test;
    
    import cn.com.gjw.factory.BeanFactory;
    import cn.com.gjw.service.UserService;
    
    public class Test2 {
    
    	public static void main(String[] args) {
    		//UserService service = new UserServiceImpl();
    		UserService service = (UserService) BeanFactory.getBean("userService");
    		service.saveUser();
    	}
    }
    
    package cn.com.gjw.service.impl;
    
    import cn.com.gjw.dao.UserDao;
    import cn.com.gjw.factory.BeanFactory;
    import cn.com.gjw.service.UserService;
    
    public class UserServiceImpl implements UserService {
    
    	//private UserDao dao = new UserDaoImpl();
    	private UserDao dao = (UserDao) BeanFactory.getBean("userDao");
    	
    	@Override
    	public void saveUser() {
    		dao.saveUser(); 
    	}
    
    }
    

    至此,我们已完成程序间解耦,此时,不管程序中缺少UserServiceImpl类还是缺少UserDaoImpl类,程序都能编译通过。但是我们的Bean现在是多例模式,例如:

    	public static void main(String[] args) {
    		//UserService service = new UserServiceImpl();
    		for(int i = 0; i < 5; i++) {
    			UserService service = (UserService) BeanFactory.getBean("userService");
    			System.out.println(service);
    		}
    		//service.saveUser();
    	}

    打印结果为:

    从打印结果可以看出,我们循环了5次,创建了5次service对象,这会影响我们程序的性能,最好使用单例模式,同样也要注意单例模式带来的多线程问题,因此在使用单例模式时,我们尽量把普通变量定义到方法内部,形成局部变量,对工厂类进行改进:

    package cn.com.gjw.factory;
    //bean工厂
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Enumeration;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Properties;
    
    public class BeanFactory {
    
    	private static Properties props;
    	
    	//程序启动时,将所有的对象创建好,并存入map集合中,使用的时候直接从集合中拿,不需要再创建
    	private static Map<String, Object> beans = new HashMap<String, Object>();
    	
    	//静态代码块,只在程序启动时执行一次
    	static {
    		try {
    			props = new Properties();
    			//通过流的方式加载属性文件
    			InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("beans.properties");
    			props.load(in);
    			//从属性对象props中获取所有的键,是一个枚举类型的集合
    			Enumeration<Object> keys = props.keys();
    			//遍历
    			while(keys.hasMoreElements()) {
    				String key = keys.nextElement().toString();
    				String pathName = props.getProperty(key);
    				try {
    					Object value = Class.forName(pathName).newInstance();
    					beans.put(key, value);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    			}
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public static Object getBean(String beanName) {
    		return beans.get(beanName);
    	}
    	//通过bean的名称获取对象
    /*	public static Object getBean(String beanName) {
    		//bean的全限定类名
    		String beanPath = props.getProperty(beanName);
    		Object bean = null;
    		try {
    			bean = Class.forName(beanPath).newInstance();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return bean;
    	}*/
    }
    

    打印结果为:

    此刻,已实现单例模式,并且成功完成解耦。

    展开全文
  • Java 高内聚,低耦合

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

    一、定义

    1. 内聚

    1.1. 内聚,一个模块内各元素间,结合的紧密程度。

    2. 耦合

    2.1. 耦合,各个代码块间联系紧密程度的度量(模块之间联系越紧密,其耦合性就越强,模块的独立性则越差。模块间耦合的高低取决于模块间接口的复杂性,调用的方式以及传递的信息。)

    2.2. 耦合度,对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高,维护成本越高,因此软件设计时,应注意降低耦合度。

    3. 高内聚

    3.1. 高内聚,一个软件模块是由相关性很强的代码组成,只负责一项任务,也就是常说的单一责任原则。

    4. 低耦合

    4.1. 解耦,也成为降低耦合度,解除耦合关系。模块间有依赖关系就必然存在耦合,理论上的绝对零耦合是做不到的,但可以通过一些现有的方法将耦合度降至最低。

    4.2. 低耦合,一个完整的系统,模块与模块之间,尽可能的使其独立存在。即,让每个模块,尽可能的独立完成某个特定的子功能。模块与模块之间的接口,尽量的少而简单。

    二、实现“高内聚、低耦合”

    接口、继承是解耦合的一种好方法。

    1、核心思想,尽可能减少代码耦合,如果发现代码耦合,就要采取解耦技术。让数据模型,业务逻辑和视图显示三层之间彼此降低耦合,把关联依赖降到最低,而不至于 “牵一发而动全身”。
    2、原则,A功能的代码不要写在B的功能代码中,如果两者之间需要交互,可以通过接口,通过消息,甚至可以引入框架,但就是不要直接交叉写。

    3、观察者模式,观察者模式存在的意义就是「解耦」,它使观察者和被观察者的逻辑不再搅在一起。
    3.1. 观察者模式的事例
    网易新闻的夜间模式,当用户切换成夜间模式之后,被观察者会通知所有的观察者【设置改变了,大家快蒙上遮罩吧】。
    QQ消息推送,消息推送来了之后,既要在通知栏上弹个推送,又要在桌面上标个小红点,也是观察者与被观察者的巧妙配合。

    三、高内聚、低耦合的好处

    1、短期,并没有很明显的好处,甚至短期内会影响系统的开发进度。因为高内聚,低耦合的系统对开发设计人员提出了更高的要求。
    2、长期来看,低耦合的模块便于进行单元测试,且便于维护。
    3、代码关系过于紧密,往往改一小段代码,需要整个项目做很大的改动。所以在实际开发中应该尽量避免过高的耦合。

    四、事例

    在java中,程序需要调用类A,如果直接在程序中 new A(),这样就写死了。如果下次业务逻辑有变化,就必须重新修改 类A的代码。在这种情况下,如果 类A被其他程序调用,你修改了 类A的代码,可能会对其他程序造成影响。
    但是如果在配置文件里配置你要用到的类的相关属性,通过程序动态获取,则只需要修改这个配置文件,把它指向另一个 类B就行了。用B替代A。这就是低耦合,也是java的面向增加开放,面向修改关闭的原则。

    展开全文
  • Java项目,庞大的对象依赖关系将一直紧密耦合引起对象难以管理或修改。在这种情况下,可以使用Spring框架作为一个核心模块轻松高效地管理所有的对象依赖。本文章向大家介绍Spring松耦合的实例,需要的朋友可以参考...
  • Java/Android 常见的设计模式总结,提高代码重用性和扩展下 概念 耦合性(英语:Coupling,dependency,或称耦合力或耦合度)是指一程序中,模块及模块之间信息或参数依赖的程度。 内聚性是一个和耦合性相.....
  • 什么是耦合、解耦

    千次阅读 2021-02-13 00:34:19
    什么是耦合、解耦一、耦合1、耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。2、在软件工程中,对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高,维护成本越高...
  • 展开全部耦合性是编程中的一个判断代码模块构成质量的属性,不影响已有功能,但影响未来62616964757a686964616fe78988e69d8331333365633838拓展,与之对应的是内聚性。耦合性:也称块间联系。指软件系统结构中各模块...
  • 我对java中的松散耦合和紧密耦合有一些困惑。因为我知道松散耦合意味着彼此之间的信息最少,而紧密耦合意味着依赖关系。因为我们知道松散耦合可以通过接口实现和继承实现紧密耦合。例如:1)A(接口)2)C(班级)假设这四...
  • 什么是Java程序的耦合

    千次阅读 2021-03-09 04:24:42
    耦合耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系...
  • 展开全部耦合性62616964757a686964616fe59b9ee7ad9431333365643662是编程中的一个判断代码模块构成质量的属性,不影响已有功能,但影响未来拓展,与之对应的是内聚性。耦合性:也称块间联系。指软件系统结构中各模块...
  • 什么是耦合耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。...我们可以利用Java的反射技术,通过类定名,来进行反射创建对象,这个时候我们可以成功的避免编译时异常,并且保证了项
  • 在程序设计时,为了避免程序的冗杂,减少各个类之间的依耐性,经常使用低耦合和高内聚的设计理念。 为了达到这个目的,我们采取以下措施: ①降低耦合:我们常用封装来降低耦合。例如,假如现在又A、B两个类,为降低...
  • java 里面耦合和解耦

    万次阅读 2019-11-10 18:33:18
      耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 解耦就是用数学方法将两种运动分离开来处理问题。 这是形象搞笑的比喻:   完全可以这么想像嘛,有一对热恋中的...
  • 耦合耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。 在软件工程中,对象之间的耦合度就是对象之间的依赖性。对象之间的耦合越高,维护成本越高,因此对象的设计应使...
  • Java耦合的理解

    千次阅读 2020-05-26 23:12:43
    java讲究高内聚,低耦合。今天我们就先来说一下什么是耦合,如何才能低耦合。 1.耦合定义:耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。也就是两者存在着强关联。 ...
  • java接口如和解耦合? package 接口解耦合; /** * @program: 设计模式的学习 * @description: 一个解释java接口如何解耦合的例子 * @author: chenzou * @create: 2021-10-24 10:28 **/ public class test { ...
  • 耦合度就是某模块(类)与其它模块(类)之间的关联、感知和依赖的程度,是衡量代码独立性的一个指标,也是软件工程设计及编码质量评价的一个标准
  • 动力节点的Java课程适合绝对零基础的观看,教程中讲解了Java开发环境搭建、Java的基础语法、Java的面向对象。每一个知识点都讲解的非常细腻,由浅入深。适合非计算机专业,想转行做Java开发的朋友,或者想让Java基础...
  • 一、什么是耦合耦合度就是某模块(类)与其它模块(类)之间的关联、感知和依赖的程度,是衡量代码独立性的一个指标,也是软件工程设计及编码质量评价的一个标准。耦合的强度依赖于以下几个因素:(1)一个模块对另一个...
  • Java中的耦合和解耦

    千次阅读 2020-05-22 20:19:32
    Java耦合: 例如在web开发中,表现层需要持有业务层的对象,业务层中需要持有持久层的对象,这种关系是很强的依赖关系。 代码如下: 业务层:(在包service下) package top.radish.service public class Account...
  • java耦合与解耦

    2019-08-27 19:36:23
    https://blog.csdn.net/qq_38788128/article/details/81187763
  • 什么是程序的耦合耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系,包括控制关系...
  • 几年来经历了很多项目,对代码之间的强耦合及书写不规范,维护性差等问题深恶痛绝。在这里,通过仔细分析后,结合自己的编码习惯总结了一套适用于javaweb项目的前端书写规范,与大家分享一下
  • 自己封装的java类,高内聚低耦合的工具类,帮助类,ui组件类 sql 数据库静态操作类,免实例化操作数据库,支持事务,支持多线程,连接池。实现了增删改查,查询后返回与数据库数据类型匹配的对象数组列表。 ...
  • Java】浅谈关于代码的耦合性前言一、需求二、简单的实现1.资源代码(项目提供)2.对需求的普通实现三、利用业务与逻辑分离的方式实现改进四、对需求改进后的同步项目改进(优点)总结 前言 前几天一个在公司里的...
  • 如何降低耦合

    2021-02-26 16:46:32
    一、什么是耦合耦合度就是某模块(类)与其它模块(类)之间的关联、感知和依赖的程度,是衡量代码独立性的一个指标,也是软件工程设计及编码质量评价的一个标准。耦合的强度依赖于以下几个因素:(1)一个模块对另一个...
  • Java 】什么叫耦合,什么叫解耦

    千次阅读 2019-02-12 21:36:44
    耦合: 有一对热恋中的男女,水深火热的,谁离开谁都不行了,离开就得死,要是对方有一点风吹草动,这一方就得地动山摇。可以按照琼瑶阿姨的路子继续想象,想成什么样都不过分,他们之间的这种状态就应该叫做“耦合...
  • 高内聚低耦合的理解

    2021-03-15 15:21:48
    以下转自百度百科内聚与耦合耦合:是对模块间关联程度的度量。耦合的强弱取决与模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。 模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、...
  • 用于 Java 的信号和插槽 介绍 Java 的信号和槽。 信号和槽提供了一种机制来松散用于通知的类的耦合。 这些课程相互联系,彼此不了解。 连接是类型化的,不需要任何接口实现。当前模式分析Java 知道两种基本的通知...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 284,458
精华内容 113,783
关键字:

耦合java