工厂模式

最新推荐文章于 2021-01-06 18:39:26 发布

HaleyLiu123

最新推荐文章于 2021-01-06 18:39:26 发布

阅读量300

点赞数

分类专栏： # 【设计模式】文章标签：工厂模式

本文链接：https://blog.csdn.net/HaleyLiu123/article/details/72807137

版权

【设计模式】专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一·.简单工厂模式（静态工厂模式）

1、简单说明工厂模式：现在所谓的个性化定制就是一个很好的列子，比如你想买一辆与众不同的汽车，你就去汽车生产厂家说你要什么样的汽车，之后他就会按你的要求给你生产你的车，而你无需关心这个生产过程，这就是工厂模式；

2、简单工厂模式中只有三个角色：工厂，产品抽象，具体产品类；具体产品实现抽象产品，工厂按照传入的产品类名称生产具体实例；工厂中使用Java反射进行动态生产对象

3、简单工厂模式中如果不使用java的反射动态生产对象，则你如果要生产另一种汽车，就要修改工厂，而如果使用java的反射动态生成，则你只需要添加具体产品类就可以而不用在修改工厂。

4、简单工厂模式适合于生产产品比较少的 。

(1)产品抽象

package com.lrq.dao;

public interface Hero {
	public void attack();
}

(2)具体产品类

package com.lrq.dao.impl;

import com.lrq.dao.Hero;

public class ADC implements Hero{
	@Override
	public void attack() {
		System.out.println("adc对敌人造成1200点物理伤害");
	}

}

package com.lrq.dao.impl;

import com.lrq.dao.Hero;

public class AP implements Hero{

	@Override
	public void attack() {
		System.out.println("ap对敌人造成2000点魔法伤害");

	}

}

package com.lrq.dao.impl;

import com.lrq.dao.Hero;

public class Surpport implements Hero{

	@Override
	public void attack() {
		System.out.println("辅助给队友们加了1000点血量");
		
	}

}

package com.lrq.dao.impl;

import com.lrq.dao.Hero;

public class Tank implements Hero{

	@Override
	public void attack() {
		System.out.println("坦克为队友抵挡了1200点伤害");
	
	}

}

（3）反射的方式构建静态 产品工厂

package com.lrq.factory;

import com.lrq.dao.Hero;

public class ProductFactory {
	public static Hero getHero(String name) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
		Hero hero=(Hero) Class.forName(name).newInstance();
		return hero;	
	}
}

（4）测试类

package com.lrq.test;

import com.lrq.dao.Hero;
import com.lrq.dao.impl.ADC;
import com.lrq.dao.impl.AP;
import com.lrq.factory.ProductFactory;

public class StaticFactory {
	public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
		ADC adc=(ADC) ProductFactory.getHero("com.lrq.dao.impl.ADC");
		AP ap=(AP) ProductFactory.getHero("com.lrq.dao.impl.AP");
		adc.attack();
		ap.attack();
	}
}

结果：

二.工厂方法模式-----静态工厂拓展版

通过工厂方法模式的类图可以看到，工厂方法模式有四个要素：

工厂接口。工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。在实际编程中，有时候也会使用一个抽象类来作为与调用者交互的接口，其本质上是一样的。
工厂实现。在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。
产品接口。产品接口的主要目的是定义产品的规范，所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的，产品接口定义的优劣直接决定了调用者代码的稳定性。同样，产品接口也可以用抽象类来代替，但要注意最好不要违反里氏替换原则。
产品实现。实现产品接口的具体类，决定了产品在客户端中的具体行为。

前文提到的简单工厂模式跟工厂方法模式极为相似，区别是：简单工厂只有三个要素，他没有工厂接口，并且得到产品的方法一般是静态的。因为没有工厂接口，所以在工厂实现的扩展性方面稍弱，可以算所工厂方法模式的简化版。

(1)接口类

产品接口

package com.lrq.dao;

public interface Hero {
	public void attack();
}

工厂接口

package com.lrq.dao;

public interface HeroFactory {
	
	public Hero  getHero();

}

(2)产品实现类

package com.lrq.dao.impl;

import com.lrq.dao.Hero;

public class ADC implements Hero{
	@Override
	public void attack() {
		System.out.println("adc对敌人造成1200点物理伤害");
	}

}

package com.lrq.dao.impl;

import com.lrq.dao.Hero;

public class AP implements Hero{

	@Override
	public void attack() {
		System.out.println("ap对敌人造成2000点魔法伤害");

	}

}

（3）工厂实现类

package com.lrq.factory;

import com.lrq.dao.Hero;
import com.lrq.dao.HeroFactory;
import com.lrq.dao.impl.ADC;

public class ADCFactory implements HeroFactory{

	@Override
	public Hero getHero() {
		return new ADC();
	}

}

package com.lrq.factory;

import com.lrq.dao.Hero;
import com.lrq.dao.HeroFactory;
import com.lrq.dao.impl.AP;

public class APFactory implements HeroFactory{

	@Override
	public Hero getHero() {
		// TODO Auto-generated method stub
		return new AP();
	}

}

（4）测试类

package com.lrq.test;

import com.lrq.dao.Hero;
import com.lrq.dao.impl.ADC;
import com.lrq.dao.impl.AP;
import com.lrq.factory.ADCFactory;
import com.lrq.factory.APFactory;
import com.lrq.factory.HeroFactory;

public class TestFactory {
	public static void  main(String[] args) {	
	     ADCFactory adcFactory=new ADCFactory();
             ADC adc=(ADC) adcFactory.getHero();
	     adc.attack();
		
	
	    APFactory apFactory=new APFactory();
	    AP ap=(AP) apFactory.getHero();
	    ap.attack();
				
	}
}

结果：

三、抽象工厂模式

1、抽象工厂模式是对工厂方法模式的再次扩展这里涉及到的角色有：抽象工厂角色，具体工厂角色，产品抽象角色（接口），产品抽象角色（抽象类），产品具体类，这里的产品想比上面多了一层是因为这里涉及到了一个叫产品族的概念；

2、抽象工厂中定义了一个获取具体产品的抽象方法，而具体工厂实现这个方法获取具体的产品；

3、产品抽象，就是一类产品的抽象，而多余的这个抽象类就是实现这个接口，在使用具体类来描述具体的产品信息，就是这里多的这个抽象类实现了产品族！！

（1）抽象工厂角色

package com.lrq.dao;

import com.lrq.entity.AP;
import com.lrq.entity.ADC;

public interface Factoty {
	ADC getADC();
	AP getAP();
}

（2）具体工厂角色

package com.lrq.factory;

import com.lrq.dao.Factoty;
import com.lrq.entity.AP;
import com.lrq.entity.ADC;
import com.lrq.entity.Vayne;
import com.lrq.entity.Ziggs;

public class RedFactory implements Factoty {

	@Override
	public ADC getADC() {
		// TODO Auto-generated method stub
		return new Vayne();
	}

	@Override
	public AP getAP() {
		// TODO Auto-generated method stub
		return new Ziggs();
	}

}

（3）产品抽象角色（接口）

package com.lrq.dao;

public interface Hero {
	public void attack();
}

（4）产品抽象角色（抽象类）

package com.lrq.entity;

import com.lrq.dao.Hero;

public abstract class ADC implements Hero {
	public abstract void attack();
	
}

package com.lrq.entity;

import com.lrq.dao.Hero;

public abstract class AP implements Hero{
	public abstract void attack();
}

（5）产品具体类

/**
 * 
 */
package com.lrq.entity;

/**
 * @author Administrator
 *
 */
public class Vayne extends ADC{

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("暗夜猎手薇恩用弩对对方造成1000点真实伤害");
	}
	

}

package com.lrq.entity;
/**
 * 吉格斯
 * @author HaleLiu
 *
 */
public class Ziggs extends AP{

	@Override
	public void attack() {
		// TODO Auto-generated method stub
		System.out.println("吉格斯对敌方造成1000点魔法伤害");
	}
	

}

（6）测试类

package com.lrq.test;
import com.lrq.entity.Vayne;
import com.lrq.entity.Ziggs;
import com.lrq.factory.RedFactory;

public class TestNewFactory {
	public static void main(String[] args){
		RedFactory redFactory=new RedFactory();
		Vayne vayne=(Vayne) redFactory.getADC();
		vayne.attack();
		
		Ziggs ziggs=(Ziggs) redFactory.getAP();
		ziggs.attack();
		
	}
}

结果：