详细分类
一、简单工厂模式
二、工厂方法模式
三、抽象工厂模式
一、简单工厂模式
简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。不修改代码的话，是无法扩展的。
无工厂模式
package com.lgd.simplefactory;
public interface Car {
void run();
}
package com.lgd.simplefactory;
public class Byd implements Car {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("byd is runing");
}
}
package com.lgd.simplefactory;
public class Audi implements Car {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("audi is runing");
}
}client
package com.lgd.simplefactory;
/**
* 测试没有工厂模式的情况下
* @author Administrator
*
*/
public class Client01 {
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}简单工厂模式
package com.lgd.simplefactory;
public class CarFactory {
//方式1
public static Car createCar(String type)
{
if("audi".equals(type))
{
return new Audi();
}
else if("byd".equals(type)){
return new Byd();
}
else {
return null;
}
}
//方式2
/*public static Car createAudi()
{
return new Audi();
}
public static Car createByd()
{
return new Byd();
}*/
}package com.lgd.simplefactory;
/**
* 测试简单工厂模式的情况下
* @author Administrator
*
*/
public class Client02 {
public static void main(String[] args) {
Car c1 = CarFactory.createCar("audi");
Car c2 = CarFactory.createCar("byd");
c1.run();
c2.run();
}
}二、工厂方法模式
工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。
interface Car
class Audi implements Car
class Byd implements Car
package com.lgd.factorymethod;
public interface CarFactory {
Car createCar();
}
package com.lgd.factorymethod;
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {
// TODO Auto-generated method stub
return new Audi();
}
}
package com.lgd.factorymethod;
public class BydFactory implements CarFactory {
@Override
public Car createCar() {
// TODO Auto-generated method stub
return new Benz();
}
}
client
package com.lgd.factorymethod;
/**
* 工厂方法模式
* @author Administrator
*
*/
public class Client {
public static void main(String[] args) {
Car c1 = new AudiFactory().createCar();
Car c2 = new BydFactory().createCar();
c1.run();
c2.run();
//新增 不用改变原有类
Car c3 = new BenzFactory().createCar();
c3.run();
}
}
新增
package com.lgd.factorymethod;
public class Benz implements Car {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("benz is runing");
}
}
package com.lgd.factorymethod;
public class BenzFactory implements CarFactory {
@Override
public Car createCar() {
// TODO Auto-generated method stub
return new Byd();
}
}
三、抽象工厂模式
抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。
应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。
1、
interface Tyre
class LuxuryTyre implements Tyre
class LowTyre implements Tyre
interface Seat
class LuxurySeat implements Seat
class LowSeat implements Seat
interface Engine
class LuxuryEngine implements Engine
class LowEngine implements Engine
package com.lgd.abstractfactory;
public interface Tyre {
void revolve();
}
class LuxuryTyre implements Tyre
{
@Override
public void revolve() {
// TODO Auto-generated method stub
System.out.println("高：轮胎好");
}
}
class LowTyre implements Tyre{
@Override
public void revolve() {
// TODO Auto-generated method stub
System.out.println("低：轮胎差");
}
}package com.lgd.abstractfactory;
public interface Seat {
void massage();
}
class LuxurySeat implements Seat
{
@Override
public void massage() {
// TODO Auto-generated method stub
System.out.println("高，软");
}
}
class LowSeat implements Seat{
@Override
public void massage() {
// TODO Auto-generated method stub
System.out.println("低，硬");
}
}
package com.lgd.abstractfactory;
public interface Engine {
void run();
void start();
}
class LuxuryEngine implements Engine{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("快");
}
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("启动快");
}
}
class LowEngine implements Engine
{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("慢");
}
@Override
public void start() {
// TODO Auto-generated method stub
System.out.println("启动慢");
}
}2、
package com.lgd.abstractfactory;
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
package com.lgd.abstractfactory;
public class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
// TODO Auto-generated method stub
return new LowEngine();
}
@Override
public Seat createSeat() {
// TODO Auto-generated method stub
return new LowSeat();
}
@Override
public Tyre createTyre() {
// TODO Auto-generated method stub
return new LowTyre();
}
}
package com.lgd.abstractfactory;
public class LuxuryCarFactory implements CarFactory {
@Override
public Engine createEngine() {
// TODO Auto-generated method stub
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
// TODO Auto-generated method stub
return new LuxurySeat();
}
@Override
public Tyre createTyre() {
// TODO Auto-generated method stub
return new LuxuryTyre();
}
}
3、Client
package com.lgd.abstractfactory;
public class Client {
public static void main(String[] args) {
CarFactory factory = new LuxuryCarFactory();
Engine e = factory.createEngine();
e.run();
e.start();
}
}
小结
★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。
★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。
★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。
区别
简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）
工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
以上三种工厂 方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。
