今天花了很多时间把工厂模式又整理了一下,发现以前都没怎么弄懂。。
工厂模式分为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个抽象工厂,这一点应该能注意到,以上就是工厂模式我目前接触到的全部内容,正在学习中。。。还是没有睡意。。。。。。。。