j2ee常用设计模式之工厂模式

 

      今天花了很多时间把工厂模式又整理了一下，发现以前都没怎么弄懂。。

 

      工厂模式分为3种：简单工厂模式，工厂方法模式和抽象工厂模式。

 

1.简单工厂模式：

      其实这个概念我还真没怎么看懂，难道是我的智商有问题？既然概念没看懂就不说了，说说我知道的吧。

      简单工厂模式由三部分组成：工厂，抽象产品，具体产品。

      刚才看见别人写的一个女娲造人的例子，一看就懂了，女娲就是工厂，脑海里的人就是抽象产品，捏出来的人就是具体产品。

      下面看个例子加深认识吧：

 

抽象产品：人

public interface Person {
	public void run();//人跑步的方法
	public void eat();//人吃饭的方法
	public void sleep();//人睡觉的方法
}

 

具体产品：学生

public class Student implements Person{
	public void run() {
		System.out.println("学生跑步");
	}
	public void eat() {
		System.out.println("学生吃饭");
	}
	public void sleep() {
		System.out.println("学生睡觉");
	}
}

 具体产品：老师

public class Teacher implements Person{
	public void run() {
		System.out.println("老师跑步");
	}
	public void eat() {
		System.out.println("老师吃饭");
	}
	public void sleep() {
		System.out.println("老师睡觉");
	}
}

 

工厂：学校

public class School {
	public static Person getPerson(String type){
		Person person = null;
		if(type.equals("student")){//如果要学生就造个学生
			person = new Student();
		}
		if(type.equals("teacher")){//如果要老师就造个老师
			person = new Teacher();
		}
		return person;
	}
}

 

测试类：

public class Test {
	public static void main(String [] args){
		Person person = School.getPerson("student");
		person.run();
		person.eat();
		person.sleep();
		person = School.getPerson("teacher");
		person.run();
		person.eat();
		person.sleep();
	}
}

 

      很显然都知道结果是什么。刚开始创建了学生对象，后面创建了老师对象。看上去好像很不错，但其实也存在问题：如果我要加个具体校长类呢？那不是又要修改工厂方法吗？下面就引出了工厂方法模式。

 

2.工厂方法模式：

      工厂方法模式由四部分组成：抽象工厂，具体工厂，抽象产品，具体产品。

      下面看看对上面的例子进行改进，在不修改工厂方法的基础上加个校长：

 

      抽象产品中人类，学生类，老师类我就不写了，再加个校长类：

 

抽象产品：校长

public class Principal implements Person{
	public void run() {
		System.out.println("校长跑步");
	}
	public void eat() {
		System.out.println("校长吃饭");
	}
	public void sleep() {
		System.out.println("校长睡觉");
	}
}

 

和简单工厂模式不同

 

抽象工厂：

public interface School {
	public Person getPerson();
}

具体工厂：生产学生

public class School_student implements School{
	public Person getPerson() {
		return new Student();
	}
}

 

具体工厂：生产老师

public class School_teacher implements School{
	public Person getPerson() {
		return new Teacher();
	}
}

 

具体方法：生产校长

public class School_principal implements School{
	public Person getPerson() {
		return new Principal();
	}
}

 

测试类：

public class Test {
	public static void main(String [] args){
		Person person;
		School school = new School_student();//创建生产学生的学校
		person = school.getPerson();//创建学生
		person.run();
		person.eat();
		person.sleep();
		school = new School_teacher();//创建生产老师的学校
		person = school.getPerson();//生产老师
		person.run();
		person.eat();
		person.sleep();
		school = new School_principal();//创建生产校长的学校
		person = school.getPerson();//生产校长
		person.run();
		person.eat();
		person.sleep();
	}
}

 

      由上面的例子我们发现，将工厂抽象，然后我们需要什么样的人，就实现生产什么人的什么工厂，然后由工厂生产具体的人，是不是一下子就很清晰了，如果还要加辅导员，只要创建一个辅导员类实现Person类，然后创建生产辅导员的学校实例化School，根本不用改其他的类。如果我们接触的不是一个产品，而是一簇多类甚至几簇产品呢，这又怎么办？这就引入了抽象工厂模式。

 

3.抽象工厂模式：

      下面介绍一簇多类的例子，通过例子可能会更容易弄明白

 

 抽象产品：学生

public interface Student {
	public void study();//学生学习方法
	public void rest();//学生休息方法
}

 

具体产品：A级本科生

public class UndergraduateA implements Student{
	public void study() {
		System.out.println("本科生AAAAA学习方法");
	}
	public void rest() {
		System.out.println("本科生AAAAA休息方法");
	}
}

 

具体产品：B级本科生

public class UndergraduateB implements Student{
	public void study() {
		System.out.println("本科生BBBBB学习方法");
	}
	public void rest() {
		System.out.println("本科生BBBBB休息方法");
	}
}

 

具体产品：A级研究生

public class GraduateA implements Student{
	public void study() {
		System.out.println("研究生AAAAA学习方法");
	}
	public void rest() {
		System.out.println("研究生AAAAA休息方法");
	}
}

 

具体产品：B级研究生

public class GraduateB implements Student{
	public void study() {
		System.out.println("研究生BBBBB学习方法");
	}
	public void rest() {
		System.out.println("研究生BBBBB学习方法");
	}
}

 

抽象工厂：学校

public interface School {
	public Student getUndergraduate();//生产本科生
	public Student getGraduate();//生产研究生
}

 

具体工厂：生产A级学生的学校

public class School_A implements School{//生产A级学生
	public Student getUndergraduate() {
		return new UndergraduateA();
	}
	public Student getGraduate() {
		return new GraduateA();
	}
}

 

具体工厂：生产B级学生的学校

public class School_B implements School{//生产B级学生
	public Student getUndergraduate() {
		return new UndergraduateB();
	}
	public Student getGraduate() {
		return new GraduateB();
	}
}

 

测试类：

public class Test {

	public static void main(String[] args) {
		School school = new School_A();//创建A级学校
		Student undergraduate = school.getUndergraduate();//创建本科生
		Student graduate = school.getGraduate();//创建研究生
		undergraduate.study();
		undergraduate.rest();
		graduate.study();
		graduate.rest();
		school = new School_B();//创建B级学校
		undergraduate = school.getUndergraduate();//创建本科生
		graduate = school.getGraduate();//创建研究生
		undergraduate.study();
		undergraduate.rest();
		graduate.study();
		graduate.rest();
	}
}

 

      这里是一簇多类，所以只要一个抽象产品多个抽象工厂，一簇产品那就学生，但是有几类，A级和B级，然后就有一个抽象的工厂来生产他们，当我们要A级学生的时候就用一个A级学校实现这个工厂，需要本科生就生产本科生要研究生就生产研究生，要B级的也是一样，如果以后还要一个C级的，那么只要用C级学生实现Student，用C级学校实现School，就可以了，完全不用改动原来的代码。是不是很爽啊！

 

      下面再来看看多簇的例子。这里就以两簇为例吧：

 

抽象产品：衣服

public interface Clothes {
	public void getColor();//衣服的颜色
	public void getSize();//衣服的大小
}

 

抽象产品：裤子

public interface Trousers {
	public void getColor();//裤子的颜色
	public void getlength();//裤子的长短
}

 

具体产品：白色衣服

public class Clothes_white implements Clothes{
	public void getColor() {
		System.out.println("白色的衣服");
	}
	public void getSize() {
		System.out.println("170大小");
	}
}

 

具体产品：黑色衣服

public class Clothes_black implements Clothes{
	public void getColor() {
		System.out.println("黑色的衣服");
	}
	public void getSize() {
		System.out.println("180大小");
	}
}

 

具体产品：白色裤子

public class Trousers_white implements Trousers{
	public void getColor() {
		System.out.println("白色的裤子");
	}
	public void getlength() {
		System.out.println("170长短");
	}
}

 

具体产品：黑色裤子

public class Trousers_black implements Trousers{
	public void getColor() {
		System.out.println("黑色的裤子");
	}
	public void getlength() {
		System.out.println("180长短");
	}
}

 

抽象工厂：服装厂

public interface Clothing {
	public Clothes createClothes();//生产衣服的方法
	public Trousers createTrousers();//生产裤子的方法
}

 

具体工厂：白色服装厂

public class Clothing_white implements Clothing{//生产白色的服装
	public Clothes createClothes() {//生产白色衣服
		return new Clothes_white();
	}
	public Trousers createTrousers() {//生产白色裤子
		return new Trousers_white();
	}
}

 

具体工厂：黑色服装厂

public class Clothing_black implements Clothing{//生产黑色的服装
	public Clothes createClothes() {//生产黑色衣服
		return new Clothes_black();
	}
	public Trousers createTrousers() {//生产黑色裤子
		return new Trousers_black();
	}
}

 

测试类：

public class Test {
	public static void main(String [] args){
		Clothing clothing = new Clothing_white();//创建白色服装厂
		Clothes clothes = clothing.createClothes();//生产白色衣服
		Trousers trousers = clothing.createTrousers();//生产白色裤子
		clothes.getColor();
		clothes.getSize();
		trousers.getColor();
		trousers.getlength();
		clothing = new Clothing_black();//创建黑色服装厂
		clothes = clothing.createClothes();//生产黑色衣服
		trousers = clothing.createTrousers();//生产黑色裤子
		clothes.getColor();
		clothes.getSize();
		trousers.getColor();
		trousers.getlength();
	}
}

 

      这里是两簇的例子，如果是N簇M类，那么就要N个抽象产品，M个抽象工厂，这一点应该能注意到，以上就是工厂模式我目前接触到的全部内容，正在学习中。。。还是没有睡意。。。。。。。。