Java学习之路3--用建造者模式模拟给工人发工资

题目：模拟给工人发工资

题目要求

普通工人的工资与经理的工资发放方式不一样，要求用建造者模式实现工资的发放并统计发放工资总金额。

具体实现

1.运用建造者模式实现发放工资

什么是建造者模式

好比如我们要生产一台电脑，我们要先生产他的部件如：cpu，gpu，散热器。然后再把这些部件组装起来，就生产成了一台电脑。 建造者模式：就是把生产电脑拆分成部件的生产与部件的组装两部分。生产完部件后，模式中的指引者（Director）会“指引”部件进行组装，最终生成一个完整的产品。

建造模式是将复杂的内部创建封装在内部，对于外部调用的人来说，只需要传入建造者和建造工具，对于内部是如何建造成成品的，调用者无需关心。

建造者模式由4部分组成

建造者模式由Director,Product,Builder,ConBuilder4部分组成。

Product: 表示被构造的复杂对象,其中包含需要构建的部件属性。
Builder: 创建一个产品对象的各个部件指定抽象接口。
ConBuilder： 实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示。
Director：调用具体建造者角色以创建产品对象。

代码如下（示例）：

Product：

package java3;

public class Product {
		private int Emoney;
		private int Mmoney;
		
		public Product() {
			Emoney=0;
			Mmoney=0;
		}
		
		public int getemoney() {
			return Emoney;
		}
		public int getmmoney() {
			return Mmoney;
		}
		public int getmoney() {
			return Mmoney+Emoney;
		}
		public void toemoney(int money) {
			Emoney+=money;
		}
		public void tommoney(int money) {
			Mmoney+=money;
		}
}

Bulider

package java3;

public interface Builder {
		int Esalary(int money);
		int Msalary(int money);
}

ConBuilder

package java3;

public class SalaryBuilder implements Builder{
		
	@Override
	public int Esalary(int money) {
		int allmoney=0;
		Factory fac=new Factory();
		Staff staff= fac.factory("Employee");
		for(int i=0;i<=2;i++)
		{
			staff.toaccount(i, money);
			allmoney+=money;
		}
		return allmoney;
	}
	
	@Override
	public int Msalary(int money) {
		int allmoney=0;
		money=money*2;
		Factory fac=new Factory();
		Staff staff=fac.factory("Manage");
		for(int i=0;i<=2;i++)
		{
			staff.toaccount(i, money);
			allmoney+=money;
		}
		return allmoney;
	}
	
}

Director：

package java3;

public class Director {
		
		SalaryBuilder mybuild=new SalaryBuilder();
		public Director(SalaryBuilder mybuild) {
			this.mybuild=mybuild;
		}
		
		public Product buildpro(int money) {
			Product pro=new Product();
			pro.toemoney(mybuild.Esalary(money));//给员工发工资
			pro.tommoney(mybuild.Msalary(money));//给经理发工资
			return pro;
		}
}

Client：

package java3;

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Product pro=new Product();
		int money=2000;
		SalaryBuilder sal=new SalaryBuilder();
		
		Director dir=new Director(sal);
		pro=dir.buildpro(money);//发放工资完毕
		
		System.out.println("总发放工资金额:"+pro.getmoney());
		System.out.println(s);
	}

}

---

2.运用工厂模式，创建所需的不同对象

代码如下：

Manage:

package java3;

public class Manage extends Staff{
		private static String[] name;
		private static int[] account;
		
		public Manage() {
			account=new int[5];
			name =new String[5];
			

			name[0]="刘星";
			name[1]="刘国栋";
			name[2]="郭美美";
		}
		
		public static int getaccount(int num) {
			return account[num];
		}
		public static String getname(int num) {
			return name[num];
		}
		public void toaccount(int num,int money) {
			account[num]+=money;
		}
		public void toname(int num,String na) {
			name[num]=na;
		}
}

Employee:

package java3;

public  class Employee extends Staff{
		private static int[] account;
		private static String[] name;
	
		public  Employee(){
			account=new int[5];
			name =new String[5];
			

			name[0]="罗宇轩";
			name[1]="李明";
			name[2]="吴本伟";
		}
			public static int  getaccount (int num) {
				return account[num];
			}
			public static String getname(int num) {
				return name[num];
			}
			public void toaccount(int num,int money) {
				account[num]+=money;
			}
			public void toname(int num,String na) {
				name[num]=na;
			}
		
}

用static标识变量name,account和方法getname/getaccount，使其不随对象的改变而改变其中的值，直接保存在类里面，同时需要的时候直接调用类来get即可。

Factor:

package java3;

public class Factory {
	
		public Staff factory(String type) {
			if(type.equals("Employee"))
					{
						Staff a=new Employee();
						return a;
					}
			
			if(type.equals("Manage"))
			{
				Staff a=new Manage();
				return a;
			}
			return null;
		}
}

Staff:

package java3;

public abstract class Staff {
		public abstract void toaccount(int num,int money);
		public abstract void toname(int num,String na);
}

总结

应该在Employee和Manage类的变量使加上static的关键字，使得该变量属于类而不是属于对象，创建对象只对这些变量进行修改而不会每次创建对象后都重新执行构造函数。
对于全局都要保存使用的量，我们要用static关键字来进行描述。