Java中对单一职责思想的理解

最新推荐文章于 2022-01-19 21:54:45 发布
最新推荐文章于 2022-01-19 21:54:45 发布
阅读量221 收藏
点赞数
分类专栏： 单一职责思想 面向对象 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JayAbcab/article/details/108437999
版权

Java中对单一职责思想的理解

在Java中最主要的思想是面向对象，而面向对象相对于以往面向过程的思维方式有着明显的优势，
因为面向对象可以做到明确的职责划分，让每个对象各司其职，这样不仅让代码结构更加的清晰，而且对后期的维护和修改有很大的帮助，下面我以一个简易的ATM系统来介绍一下使用单一职责带来的优势~

本次设计的ATM系统的主要结构如下：

  1. 账户类
  2. 窗口类（登录、菜单、查询、改密、存款、取款、转账）
  3. 接口
  4. 接口的实现方法
    如下为实现步骤：

首先，我们创建一个用户类，其属性包括账户名，密码，以及余额，并赋予其相应的get，set方法
账户类主要用于实现账户对象的创建，使每一个用户拥有相同的属性和方法

public class CodeBean {
	private String code;
	private String pwd;
	private int money;
	
	
	public CodeBean(String code, String pwd, int money) {
		super();
		this.code = code;
		this.pwd = pwd;
		this.money = money;
	}

	public CodeBean() {
		super();
	}

	public String getCode() {
		return code;
	}

	public void setCode(String code) {
		this.code = code;
	}

	public String getPwd() {
		return pwd;
	}

	public void setPwd(String pwd) {
		this.pwd = pwd;
	}

	public int getMoney() {
		return money;

接下来根据业务需求，我们创建一个接口，来定义我们的业务需求：

public interface ICodeService {
	
	/**
	 * 登录方法
	 * @param code
	 * @param pwd
	 * @return登录是否成功
	 */
	public  boolean login(String code,String pwd);
	
	
	/**
	 * 查询
	 * @author Administrator
	 *得到登录帐号的余额
	 */
	public int getCodeMoney(); 
	
	
	/**
	 * 存款
	 * @param sm 存款金额
	 */
	public void saveMoney(int sm);

完成了接口的创建之后，我们就需要对接口中的方法进行具体的实现**，需要注意的是：我们的接口实现类这里是独立于接口之外的，也就是说，当我们的实现方法需要作出相应的调整时候，只需要重新编写一个实现类，而不需要再改变其余的代码，这样，提高了代码的灵活性，也让代码的维护变得简单**

public class CodeServiceImpl implements ICodeService{
	/**
	 * 帐号数组
	 */
	private static CodeBean[]  codeArray = {
			new CodeBean("001","111",5000),
			new CodeBean("002","222",8000),
			new CodeBean("003","333",4000)
	};
	/**
	 * 登录帐号
	 */
	private static CodeBean loginCode;
	
	@Override
	public boolean login(String code, String pwd) {
		for(int i = 0 ;i<codeArray.length;i++) {
			if(codeArray[i].getCode().equals(code)
					&& codeArray[i].getPwd().equals(pwd)) {
				loginCode = codeArray[i];
				return true;
			}
		}
		
		return false;
	}

	@Override
	public int getCodeMoney() {
		return loginCode.getMoney();
	}

	@Override
	public void saveMoney(int sm) {
		loginCode.setMoney(loginCode.getMoney() + sm);
	}

	@Override
	public boolean sellMoney(int gm) {
		if(gm > loginCode.getMoney()) {
			
		return false;	
		}
		loginCode.setMoney(loginCode.getMoney() - gm);
		return true;
	}

	@Override
	public String updatePwd(String oldPwd, String newPwd, String rePwd) {
		String info = "";
		if((oldPwd.equals(loginCode.getPwd()) == false)) {
			info += "原密码错误\n";
		}
		if(newPwd.equals(rePwd) == false) {
			info += "两次密码不一致\n";
		}
		if(info.length() != 0) {
			return info;
		}
		loginCode.setPwd(newPwd);
		return null;
	}

	@Override
	public String transMoney(String tranCode, int money) {
		String info ="";
		CodeBean transCode = checkCode(tranCode);
		if(checkCode(tranCode) == null) {
			info += "转账账号不存在\n";
		}
		if(money > loginCode.getMoney()) {
			info += "余额不足\n";
		}
		if(info.length() != 0) {
			return info;
		}
		loginCode.setMoney(loginCode.getMoney() - money);
		transCode.setMoney(transCode.getMoney() + money);
		return null;
	} 
	
	/**
	 * 验证帐号是否存在
	 * @param code 帐号
	 * @return 是否存在
	 */
	private CodeBean checkCode(String code) {
		for(int i = 0;i<codeArray.length;i++) {
			if(code.equals(codeArray[i].getCode())) {
				return codeArray[i];
			}
		}
		return null;
	}
	
	

}

在完成对接口方法的实现之后，我们需要将这些方法定义在不同的GUI窗口中，这里我们将不同的窗口单独划分，并在相应的窗口中调用需要的实现类对象，来实现窗口功能的赋予，当我们重新创建一个接口的实现类来调整实现方法时，我们只需要更新窗口中调用的实现类对象就可以完成对方法的切换，这样使代码变得更加的灵活，具有很高的可调整性

**登录窗口**
public class LoginFrame extends JFrame{
	private MyTxt loginTxt = new MyTxt("帐号：",100,100,this);
	private MyTxt pwdTxt = new MyTxt("密码：",100,200,this);
	

	public LoginFrame() {
		this.setLayout(null);
		
		init();
		this.setTitle("登录窗口");
		this.setVisible(true);
		this.setSize(500, 500);
		this.setDefaultCloseOperation(3);
		this.setLocationRelativeTo(null);
	}
	
	
	

	private void init() {
		MyButton loginButton = new MyButton("登录",100,300,this);
		loginButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				login();
				
			}
		});
	}
	
	public void login() {
		String code = loginTxt.getText();
		String pwd = pwdTxt.getText();
		
		if(new CodeServiceImpl().login(code, pwd) == true) {
			this.dispose();
			new MainFrame();
			JOptionPane.showConfirmDialog(null, "登录成功");
		}else {
			JOptionPane.showConfirmDialog(null, "帐号密码错误");
		}
		
	}




	public static void main(String[] args) {
		new LoginFrame();
	}

}


**取款窗口**

public class GetFrame extends JFrame{
	
	public GetFrame(){
		this.setLayout(null);
	
		this.setTitle("取款窗口");
		this.setSize(600,400);
		this.setVisible(true);
		this.setDefaultCloseOperation(3);
		this.setLocationRelativeTo(null);
		init();
		
		
	}

	private void init() {
		MyTxt getTxt = new MyTxt("取款金额：",100,100,this);
		MyButton sureButton = new MyButton("确定",100,150,this);
		MyButton backButton= new MyButton("返回",230,150,this);
		
		backButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				GetFrame.this.dispose();
				new FindFrame();
			}
		});
		
		sureButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				if(new CodeServiceImpl().sellMoney(Integer.parseInt(getTxt.getText())) == true) {
					
					JOptionPane.showConfirmDialog(null, "取款成功");
					GetFrame.this.dispose();
					new FindFrame();
				}else {
					JOptionPane.showConfirmDialog(null, "余额不足");
				}
			}
		});
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new GetFrame();
	}

}



**转账窗口**

public class TransFrame extends JFrame {
	
	public TransFrame(){
		this.setLayout(null);
		this.setTitle("取款窗口");
		this.setSize(600,400);
		this.setVisible(true);
		this.setDefaultCloseOperation(3);
		this.setLocationRelativeTo(null);
		init();
		
		
	}

	private void init() {
		MyTxt transCodeTxt = new MyTxt("转账帐号：",100,100,this);
		MyTxt transMoneyTxt = new MyTxt("转账金额：",100,150,this);
		MyButton sureButton = new MyButton("确定",100,230,this);
		MyButton backButton= new MyButton("返回",300,230,this);
		
		backButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				TransFrame.this.dispose();
				new FindFrame();
			}
		});
		
		sureButton.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
					String info = new CodeServiceImpl().transMoney(transCodeTxt.getText(),Integer.parseInt(transMoneyTxt.getText()) );
					if(info == null) {
					JOptionPane.showConfirmDialog(null, "转账成功");
					TransFrame.this.dispose();
					new FindFrame();
				}else {
					JOptionPane.showConfirmDialog(null, info);
				}
			}
		});
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new TransFrame();
	}

}

在窗口类中，我们只需要定义相应的按钮和按钮关联即可，其余方法都调用实现类即可

结束语：使用单一职责划分的思想，可以让代码更加有层次感和灵活性，每个类各司其职，当我们需要调整时，只需要对相应的类中的代码和它们的连接关系作出调整即可。
而如果将方法和窗口代码写在一起，容易让代码内容复杂，修改起来也比较容易出问题，使用单一职责思想，只需要点对点作出调整即可完成，且出错率较低，思维清晰。
当我们需要调整窗口，就对窗口类进行改变，而其中不会涉及到具体的实现，我们将具体的实现已经封装在实现类中。
单一职责划分可以让我们的代码结构和思路清晰，可调整性高，后期维护方便，是一种非常好的编程思路，希望大家看完本文章对Java编程有更多的理解和思考，以后我还会分享更多相关的编程技术和思考方式，欢迎大家一起交流和探讨~

JayAbcab
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试被问到如何理解单一职责原则
斯巴达人的博客
10-25 278
前言 面试官在进行了redis和mysql连环问后，自我感觉答的还可以，正洋洋得意，但是面试官随口又问怎么理解单一职责原则，本人心想，不就是功能单一，职责单一吗，心里还在想这么基础的问题带一嘴就行了，谁成想，面试官接着问，单一职责是如何指导开发的？开发的过程会考虑设计原则吗，都应用过什么设计原则和设计模式，你是如何写出高性能代码的，你是如何给别人review代码的（我前面有提过自己山擅长写高性能代码，负责组织团队内代码review），场面一度尴尬。 因此我决心把这一部分变为自己的长处，而不是短板，也想让自己
对单一职责的理解
qq_37924275的博客
09-06 443
对单一职责的理解 ​ 按字面意思理解，单一职责就是自己只负责自己的事，不需要去关心别人的事。对于一个类来说，一个类承担一个职责就是，引起它变化的原因有且仅有一个。如果用大白话来讲，每个人都负责自己的事情，不要一揽子都弄到自己身上，到时候出问题了都得找你，你忙不过来。 ​ 在面对对象编程中，每个对象只负责自己的任务，比如该提供数据的就只是提供数据，该负责提供服务的就只提供服务，这样的开发方式代码耦合较低，较灵活，易扩展。好比对象承担的职责越多，它被复用的可能性就越小，而且一个对象承担的
java设计模式：单一职责原则理解
u011220266的博客
06-03 178
首先声明仅仅是个人理解，可能有不对的地方，谢谢指正！ 1，起源： 为了解决问题：如果因需求变更，对类中的某个方法（职责）做了修改，影响了类中其他方法（职责）的使用，因为这个方法的修改，需要代码更新，重新部署项目。这个类其他方法暂时也不能用了。 2，定义： 一个类如果只是有且仅有一个因素来引起他的变化，（应用于模块、类）。拿个类举例子:类中应该只有一个方法，完成一项职责。唯一能够引起这个类变化的因素只有这项方法（职责）发生了变化。 3，优缺点： 优点：降低了类中方法的耦合性，缺点：一个类只有一个方
单一职责原则-快速理解
BREATH57的博客
09-01 356
定义 不要存在多余一个导致类变更的原因 一个类/接口/方法只负责一项职责 怎么理解？ 尽量降低类间，方法间，接口间的耦合。 假设场景：（注意：这里说的任务是，独立开来是没有任何联系的）把多个任务 压到一个人身上，那样他会很累，而且，一个人，只能在同一时刻，做一件事，如果其中一件事没做好，就会影响没做完的事情的进度，或者因为心情不好，做后面的事情就变慢了，或者不想做了。（这么说，多个任务给一个...
简单讲解Java设计模式编程中的单一职责原则
09-02
Java设计模式中的单一职责原则（Single Responsibility Principle，SRP）是面向对象设计的基本原则之一，它的核心思想是：一个类或者一个模块应该只有一个引起它变化的原因。这意味着一个类应该只负责一项职责，使得...
Java程序的设计思想
12-22
Java程序设计思想是软件开发中的核心指导原则，它关乎到代码的可维护性、扩展性和重用性。这里提到的SOLID+2原则是面向对象设计的基石，它们分别是： 1. 开-闭原则（Open-Closed Principle, OCP）： 开-闭原则指出...
Java中的四个核心技术思想Java中的四个核心技术思想
06-04
API的设计和使用遵循一定的设计模式和原则，如单一职责原则、开闭原则等，这些都是面向对象设计的核心思想。 理解并熟练掌握这四个核心技术思想，不仅能够帮助开发者编写高效、可维护的Java代码，还能深入理解Java...
java基础编程思想
03-10
通过深入学习《Java编程思想（中文第三版）》，你将对Java语言有全面的理解，为进阶开发打下坚实的基础。同时，实践是检验理论的最好方式，所以不仅要阅读理论知识，更要动手编写代码，以加深理解和记忆。
Java单一职责原则
慕白博客
08-22 684
单一职责原则（SRP：Single responsibility principle）又称单一功能原 则，面向对象五个基本原则（SOLID： SRP 单一责任原则、OCP 开放封闭原 则、LSP 里氏替换原则、DIP 依赖倒置原则、ISP 接口分离原则）之一。它规 定一个类应该只有一个发生变化的原因。该原则由罗伯特·C·马丁（Robert C. Martin）于《敏捷软件开发：原则、模式和实践》一...
对单一职责原则的理解
wujiang88的博客
01-20 839
单一职责原则就是说在一个类、接口，甚至是方法功能上的职责上要单一，不能混杂其他的职责，因为当我们混杂了其他的职责，那么这个时候当我们修改代码中的一个职责或者方法的时候就会影响到另一个职责的功能，这个时候给项目维护带来不必要的风险。 当然职责这个东西在不同的项目中定义不同，要根据自己的具体情况来分析。 接口上的职责一定要单一，这个是为了便于后期的维护，一个接口一个实现，这样的话是非常的单一的，我
【设计原则和思想---单一职责（Single Responsibility Principle ）】
浩海烟云的博客
01-19 294
经典的设计原则 SOLID、KISS、YAGNI、DRY、LOD 很多人因为对这些原则理解的不够透彻，导致在使用的时候过于教条主义，拿原则当真理，生搬硬套，反而适得其反； SOLID原则并非单纯的1个原则，而是由5个设计原则组成的，它们分别是：单一职责原则、开闭原则、里式替换原则、接口隔离原则和依赖反转原则，依次对应SOLID中的S、O、L、I、D这5个英文字母。 单一职责 1.如何理解单一职责原则（SRP）？ 一个类只负责完成一个职责或者功能。不要...
单一职责原则的思考
hai330的博客
12-10 300
单一职责原则的思考  Posted on 2018-11-15 |  Edited on 2019-01-09 |  Comments: 2 |  Views: 5 单一职责原则是软件开发过程中经常被用到的一个原则，易于理解，且十分受用。 什么是单一职责原则 单一职责原则，是面向对象设计的基本原则之一，易于理解，且十分受用。官方对此理解为：一个类应该有且只有一个变化的原因。当有多个原因导致...
理解微服务的单一职责原则的优缺点
snowglede的专栏
08-21 3613
近来看到好多有关微服务的文章提到，“单一职责”原则是微服务的基本原则之一。 “单一职责”原则其实本就是面向对象设计与编程的基本原则之一。 我们先看看面向对象原则中对SRP原则的权威解释： 单一职责原则(single responsibility principle )       There should never be more than one reason for a clas
如何理解单一职责原则？
睡猫的博客
02-06 4740
“一个类仅有一个职责”或者“引起类变化的只有一个原因”，这就是单一职责原理。 类只因一个原因而变化，这仿佛是一种新的类定义方式。当接触面向对象编程时，试图把一个类对比为一个事物，事物具备的功能都是这个类的操作。比如，一根尺子，既可以用来打学生手板，也可以用来丈量布匹。而在单一职责原理下，尺子的两个功能就是引起这个类变化的两个原因，就应该写成两个类。 如果混在一起写，在修改一个职
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值