java回调机制

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量128 收藏
点赞数
分类专栏： java 文章标签： java 回调
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cmzglj/article/details/90441834
版权

最简单的回调机制如下：

public class CallbackDemo {
	public static void main(String[] args) {
		new A().aa();
	}
}

class A{

	public void aa(){

		new B().b();
		System.out.println("This is aa!");
	}

	public void ab(){
		System.out.println("This is ab!");
	}
}

class B{

	public void b(){
		new A().ab();
		System.out.println("This is b!");
	}
}

执行的结果如下：

This is ab!
This is b!
This is aa!

上面的例子看上去没有什么实际的应用，现在我们想象这样的一个场景：每个人参加工作之后都会面临交税的事，但是除了税务财务人员，其他人并不关心具体的算法，他们只关心交了多少税（2019年的税法复杂了点，采用）；

1.应纳税所得额 = 税前工资收入金额 - 五险一金（个人缴纳部分） -费用减除额

2.应纳税额 = 应纳税所得额 x 税率 - 速算扣除数

级数全年应纳税所得额税率（%）速算扣除数

1

不超过36000元的

3

0

2

超过36000元至144000元的部分

10

2520

3

超过144000元至300000元的部分

20

16920

4

超过300000元至420000元的部分

25

31920

5

超过420000元至660000元的部分

30

52920

6

超过660000元至960000元的部分

35

85920

7

超过960000元的部分

45

181920

最原始的代码：

public class CallbackDemo2 {
	public static void main(String[] args) {

		Student xiaomiStudent = new Student("小米", 200000, 6000, 5000);
		xiaomiStudent.say();
	}
}

class Student{

	private String name;

	private int wages;
	private int five;
	private int jian;

	Student(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	// 应纳税所得额 = 税前工资收入金额 - 五险一金（个人缴纳部分） -费用减除额
	// 应纳税额 = 应纳税所得额 x 税率 - 速算扣除数
	public int getTax(int wages,int five,int jian){

		int cost;

		int level = wages<36000?1:wages<144000?2:wages<300000?3:wages<420000?4:wages<660000?5:wages<960000?6:7;

		switch(level){
			case 1:
				cost= (wages-five-jian)*3/100;
				break;
			case 2:
				cost= (wages-five-jian)*10/100-2520;
				break;
			case 3:
				cost= (wages-five-jian)*20/100-16920;
				break;
			case 4:
				cost= (wages-five-jian)*25/100-31920;
				break;
			case 5:
				cost= (wages-five-jian)*30/100-52920;
				break;
			case 6:
				cost= (wages-five-jian)*35/100-85920;
				break;
			case 7:
				cost= (wages-five-jian)*45/100-181920;
				break;
			default:
				cost = 0;


		}

		return cost;

	}


	public void say() {

		System.out.println(this.name + ":需要交税：" + getTax(this.wages,this.five,this.jian));
	}

}

运行结果：

小米:需要交税：20880

现在有一个老师需要完成交税的任务，将上面的类在写一遍？如果又有销售需要交税。。。现在我们将公共的方法提取出来。

public class CallbackDemo2 {
	public static void main(String[] args) {

		Student xiaomiStudent = new Student("小米同学", 200000, 6000, 5000);
		xiaomiStudent.say();
		Tercher laoshiTercher = new Tercher("大米老师", 400000, 8000, 8000);
		laoshiTercher.say();
	}
}

class Student{

	private String name;

	private int wages;
	private int five;
	private int jian;

	Student(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	

	public void say() {

		System.out.println(this.name + ":需要交税：" + new Common().getTax(this.wages,this.five,this.jian));
	}

}


class Common{
	
	// 应纳税所得额 = 税前工资收入金额 - 五险一金（个人缴纳部分） -费用减除额
		// 应纳税额 = 应纳税所得额 x 税率 - 速算扣除数
		public int getTax(int wages,int five,int jian){

			int cost;

			int level = wages<36000?1:wages<144000?2:wages<300000?3:wages<420000?4:wages<660000?5:wages<960000?6:7;

			switch(level){
				case 1:
					cost= (wages-five-jian)*3/100;
					break;
				case 2:
					cost= (wages-five-jian)*10/100-2520;
					break;
				case 3:
					cost= (wages-five-jian)*20/100-16920;
					break;
				case 4:
					cost= (wages-five-jian)*25/100-31920;
					break;
				case 5:
					cost= (wages-five-jian)*30/100-52920;
					break;
				case 6:
					cost= (wages-five-jian)*35/100-85920;
					break;
				case 7:
					cost= (wages-five-jian)*45/100-181920;
					break;
				default:
					cost = 0;


			}

			return cost;

		}

}

class Tercher{

	private String name;

	private int wages;
	private int five;
	private int jian;

	Tercher(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	public void say() {

		System.out.println(this.name + ":需要交税：" + new Common().getTax(this.wages,this.five,this.jian));
	}

}

运行结果：

小米同学:需要交税：20880
大米老师:需要交税：64080

    这里我们调用了一个公共类替我们完成了税的计算，但是与回调显然是有区别的。想想这样的一个场景，现在公司要求统计每个人全年的交税金额，财务方面更希望是能得到银行给的数据，也就是说员工查询后，公共类将结果也返回了财务部门；使用回调功能需要将自身的一部分方法暴露出来；

public class CallbackDemo2 {
	public static void main(String[] args) {

		Student xiaomiStudent = new Student("小米同学", 200000, 6000, 5000);
		xiaomiStudent.say();
		Tercher laoshiTercher = new Tercher("大米老师", 400000, 8000, 8000);
		laoshiTercher.say();
	}
}

class Student  implements People{

	private String name;

	private int wages;
	private int five;
	private int jian;

	Student(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	public int getTax(int wages, int five, int jian) {
		System.out.println(name + "询问银行交的税");

		return new Common().getTax(wages, five, jian);
	}


	public void say() {
		new Bank().say(wages, five, jian,name,this);
	}

}

interface People{

	public int getTax(int wages,int five,int jian);
}

class Bank{

	public void say(int wages, int five, int jian,String name, People people){
		System.out.println("银行说:"+name+"交税："+ people.getTax(wages, five, jian));
	}
}

class Common{

	// 应纳税所得额 = 税前工资收入金额 - 五险一金（个人缴纳部分） -费用减除额
		// 应纳税额 = 应纳税所得额 x 税率 - 速算扣除数
		public int getTax(int wages,int five,int jian){

			int cost;

			int level = wages<36000?1:wages<144000?2:wages<300000?3:wages<420000?4:wages<660000?5:wages<960000?6:7;

			switch(level){
				case 1:
					cost= (wages-five-jian)*3/100;
					break;
				case 2:
					cost= (wages-five-jian)*10/100-2520;
					break;
				case 3:
					cost= (wages-five-jian)*20/100-16920;
					break;
				case 4:
					cost= (wages-five-jian)*25/100-31920;
					break;
				case 5:
					cost= (wages-five-jian)*30/100-52920;
					break;
				case 6:
					cost= (wages-five-jian)*35/100-85920;
					break;
				case 7:
					cost= (wages-five-jian)*45/100-181920;
					break;
				default:
					cost = 0;


			}

			return cost;

		}

}

class Tercher  implements People{

	private String name;

	private int wages;
	private int five;
	private int jian;

	Tercher(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	public int getTax(int wages, int five, int jian) {
		System.out.println(name + "询问银行交的税");

		return new Common().getTax(wages, five, jian);
	}


	public void say() {
		new Bank().say(wages, five, jian,name,this);
	}

}

运行结果：

小米同学询问银行交的税
银行说:小米同学交税：20880
大米老师询问银行交的税
银行说:大米老师交税：64080

这里的方法：

	public int getTax(int wages, int five, int jian) {
		System.out.println(name + "询问银行交的税");

		return new Common().getTax(wages, five, jian);
	}

      就是一个回调方法，显然代码看上去有点傻傻的，因为看上去多此一举，为什么要借助Bank类，这是因为我们这里使用的是同步回调，面对一些复杂的业务我们想得到这样的结果：

小米同学询问银行交的税
大米老师询问银行交的税
银行说:小米同学交税：20880
银行说:大米老师交税：64080
public class CallbackDemo2 {
	public static void main(String[] args) {

		Student xiaomiStudent = new Student("小米同学", 200000, 6000, 5000);
		Tercher laoshiTercher = new Tercher("大米老师", 400000, 8000, 8000);
		new Thread(xiaomiStudent).start();
		new Thread(laoshiTercher).start();
	}
}

class Student  implements People,Runnable {

	private String name;

	private int wages;
	private int five;
	private int jian;

	Student(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	public int getTax(int wages, int five, int jian) {
		System.out.println(name + "询问银行交的税");

		return new Common().getTax(wages, five, jian);
	}


	public void say() {
		new Bank().say(wages, five, jian,name,this);
	}

	@Override
	public void run() {
		say();

	}

}

interface People{

	public int getTax(int wages,int five,int jian);
}

class Bank{

	public void say(int wages, int five, int jian,String name, People people){
		int shui = people.getTax(wages, five, jian);
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("银行说:"+name+"交税："+ shui);
	}
}

class Common{

	// 应纳税所得额 = 税前工资收入金额 - 五险一金（个人缴纳部分） -费用减除额
		// 应纳税额 = 应纳税所得额 x 税率 - 速算扣除数
		public int getTax(int wages,int five,int jian){

			int cost;

			int level = wages<36000?1:wages<144000?2:wages<300000?3:wages<420000?4:wages<660000?5:wages<960000?6:7;

			switch(level){
				case 1:
					cost= (wages-five-jian)*3/100;
					break;
				case 2:
					cost= (wages-five-jian)*10/100-2520;
					break;
				case 3:
					cost= (wages-five-jian)*20/100-16920;
					break;
				case 4:
					cost= (wages-five-jian)*25/100-31920;
					break;
				case 5:
					cost= (wages-five-jian)*30/100-52920;
					break;
				case 6:
					cost= (wages-five-jian)*35/100-85920;
					break;
				case 7:
					cost= (wages-five-jian)*45/100-181920;
					break;
				default:
					cost = 0;


			}

			return cost;

		}

}

class Tercher  implements People,Runnable{

	private String name;

	private int wages;
	private int five;
	private int jian;

	Tercher(String name,int wages,int five,int jian){
		this.name = name;
		this.wages = wages;
		this.five = five;
		this.jian = jian;
	}

	public int getWages() {
		return wages;
	}

	public void setWages(int wages) {
		this.wages = wages;
	}

	public int getFive() {
		return five;
	}

	public void setFive(int five) {
		this.five = five;
	}

	public int getJian() {
		return jian;
	}

	public void setJian(int jian) {
		this.jian = jian;
	}

	public String getName() {
		return name;
	}

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

	public int getTax(int wages, int five, int jian) {
		System.out.println(name + "询问银行交的税");

		return new Common().getTax(wages, five, jian);
	}


	public void say() {
		new Bank().say(wages, five, jian,name,this);
	}

	@Override
	public void run() {
		say();

	}

}

执行结果：

小米同学询问银行交的税
大米老师询问银行交的税
银行说:大米老师交税：64080
银行说:小米同学交税：20880

这里采用了多线程，实际上本质是采用了阻塞，异步阻塞。小米同学在询问银行后，她的线程是在阻塞中的，直到银行处理完成后，她的线程才继续执行。关于异步与同步，阻塞与非阻塞的内容 会在另外的博文介绍。

 

 

cmzglj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java回调机制
keeper42的博客
02-03 575
一、Java回调机制是什么意思 Java中的回调机制是什么意思呢?所谓回调：就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法。百度百科中对Java回调机制是这样解释的： 软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。 回调是一种特殊的调用，至于三种方式也有点不同。 1、同步回调，即阻塞，单向。 2、回调，即双向(类似自行车的两个齿轮)。 3、异步调用，即通过异步消息进行通知。 二、Java回调机制案
java回调是什么意思_Java回调机制是什么意思？
weixin_36035466的博客
02-12 907
原标题：Java回调机制是什么意思？一、Java回调机制是什么意思Java中的回调机制是什么意思呢?所谓回调：就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法。百度百科中对Java回调机制是这样解释的： 软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。回调是一种特殊的调用，至于三种方式也有点不同。1、同步回调...
JAVA回调机制
weixin_43195281的博客
05-24 4824
本人学生期间代码接触的都是C++与Matlab，在工作之后由于从事android开发需要接触java开发，于是边学边用，其中踩了不少坑，记录下来大家一起阅读。 1.定义 什么是回调函数？是一个通过函数指针调用的函数。英文为CALLBACK，call then back，回调函数不是由该函数的实现方法直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件进行响应。在JAVA中可以特定理解为：通过函数参数传递到其他代码的，某一块可执行代码的引用。 2.分类 一般将回调函数分为两类：同步回
JAVA回调机制(CallBack)详解
weiweiqiao的专栏
05-31 1601
但是有些函数却要求应用先传给它一个函数，好在合适的时候调用，以完成目标任务。这个被传入的、后又被调用的函数就称为回调函数（callback function）。一般情况下，应用程序（application program）会时常通过API调用库里所预先备好的函数。
java回调函数举例,详解Java回调机制 (Callback) 讲解+实例
weixin_39949297的博客
03-11 740
详解Java回调机制 (Callback) 讲解+实例Java中的回调(callback)是很重要的一个概念，spring整合hibernate大量使用了这种技术。究竟怎样才是回调呢？这是网上最多见到的说明：1.class A,class B2.class A实现接口callback3.class B拥有一个参数为callback接口类型的函数4.class A运行时调用c...
Java回调机制研究
张亚运的专栏
06-04 1867
1. 什么是回调函数 回调函数，顾名思义，用于回调的函数。回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。回调函数是一个工作流的一部分，由工作流来决定函数的调用（回调）时机。回调函数包含下面几个特性：   (1)属于工作流的一个部分；   (2)必须按照工作流指定的调用约定来申明（定义）；     (3)他的调用时机由工作流决定，回调函数的实现者不能直接调用回调函数来
Java 回调机制
xiangxiongfly
07-17 2581
Java回调机制概述
理解Java回调机制
LaterEqualsNever
03-03 4346
其实对于回调机制，在实际使用中还是经常用到的。但好笑的是，一直没能对所谓的回调的概念有一个很清晰的理解。 最近抽空看一些书的时候，老是时不时的提到回调的概念。那好吧，正好抽空来简单总结总结，加深一下印象和理解~ 网上的百科之类的资料中，看到的对于回调比较书面和规范的解释是： 在计算机程序设计中，回调函数，是指通过函数参数传递到其它代码的，某一块可执行代码的引用。这一设计允许了底层
java回调机制实现
一点点
07-14 6081
java回调机制实现
Java回调机制解读
08-31
Java回调机制是编程中一种非常重要的设计模式，它允许一个对象在另一个对象执行特定操作后得到通知或执行相应的处理。这种机制在Java中通常通过接口实现，使得被调用的对象能够在适当的时候调用回调方法来传递结果...
java回调机制1
08-08
Java回调机制是一种编程模式，它允许一个对象在特定事件发生时调用另一个对象的方法。在上述例子中，回调机制的概念逐渐展开，通过一个简单的幼儿园加法故事进行解释。 首先，我们有`Student`类，它有一个`fill...
通过简易例子讲解Java回调机制
08-25
Java回调机制是一种设计模式，它允许一个对象在完成特定任务时通知另一个对象。这种机制使得代码更加灵活，因为被调用者可以在适当的时候主动调用调用者的某个方法，而不仅仅是被动地接收返回值。回调在多线程、事件...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1097
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java-Lambda
lizhiwei21的博客
07-21 411
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 745
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 72
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 308
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
Java接口与回调机制解析
"接口和回调在Java编程中的应用，主要涉及Java接口的概念、使用以及回调机制的解释。接口是Java中定义行为规范的关键工具，它包含抽象方法的声明，不包含实现。回调则是通过传递对象及其方法引用来指定特定事件发生...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值