工厂模式

工厂模式

工厂模式包括：
1.简单工厂模式
2.工厂方法模式
3.抽象工厂模式
简单工厂模式
一个抽象产品类，派生出多个具体产品类
一个工厂类，通过逻辑判断，实例化所需的产品类
具体的描述
(1) 抽象产品类：为各种具体产品声明抽象类或者接口
(2) 具体产品类：抽象产品的具体实现，对应具体的产品
(3) 工厂类：用户只关注产品，无需关注具体实现，生产出具体的产品

代码实现：
抽象产品类：

public abstract class Fruits {
	
	public abstract void print();
}

具体产品类：

// 苹果
public class Apple extends Fruits {

	@Override
	public void print() {
		System.out.println("This is a Apple");
		
	}
}
//橙子
public class Orange extends Fruits {

	@Override
	public void print() {
		// TODO Auto-generated method stub
		System.out.println("This is a Orange");
	}
}

工厂类

public class FruitsFactory {
	
	public Fruits getFruit(String name) {
		Fruits fruit = null;
		if(""==name||name == null) {
			return fruit;
		}
		switch (name) {
		case "Apple":
			fruit = new Apple();
			break;

		case "Orange":
			fruit = new Orange();
			break;
		}
		return fruit;
	}
}

工厂方法模式
一个抽象产品类，派生出多个具体产品类
一个抽象工厂类，派生出多个具体工厂类
每个具体工厂类只能生产出一个具体的产品类
具体的描述
(1) 抽象产品类：为各种具体产品声明抽象类或者接口
(2) 具体产品类：抽象产品的具体实现
(3) 抽象工厂类：声明了一个方法，只对应一种产品
(4) 具体工厂类：抽象工厂的实现，生成一个具体产品 (一组产品)

代码实现：

抽象产品类

public abstract class Operation {
	
	public int A;
	public int B;
	
	public int getA() {
		return A;
	}

	public void setA(int a) {
		A = a;
	}

	public int getB() {
		return B;
	}

	public void setB(int b) {
		B = b;
	}
	
	public abstract void getResult() ;
	
}

具体产品类

//加法
public class OperationAdd extends Operation{
	
	public int a;
	public int b;
	
	public OperationAdd() {
	
	}
	
	@Override
	public void getResult() {
		
		System.out.println("a+b="+(super.A+super.B));
	}
}
// 减法
public class OperationSub extends Operation{
	
	public int a;
	public int b;
	
	@Override
	public void getResult() {
		// TODO Auto-generated method stub
		System.out.println("a-b="+(super.A - super.B));
	}
}

抽象工厂类和具体工厂
public interface IFactory {

Operation createOperation();

}

class AddFactory implements IFactory{

@Override
public Operation createOperation() {
	// TODO Auto-generated method stub
	return new OperationAdd();
}

}

class SubFactory implements IFactory{

@Override
public Operation createOperation() {
	// TODO Auto-generated method stub
	return new OperationSub();
}

}
抽象工厂模式
多个抽象产品类，每个抽象产品类都可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类都能生成出多个具体产品类 （后续都有相应代码，看了就会懂）
具体的描述
(1) 抽象产品类：为各种具体产品声明抽象类或者接口
(2) 具体产品类：抽象产品的具体实现
(3) 抽象工厂类：声明了一组方法，每个方法对应一种类型产品
(4) 具体工厂类：抽象工厂的实现，生成一组具体产品 (一组产品)
代码实现
抽象产品类
//座椅
public interface Chair {

public void getChair();

}

//发动机
public interface Engine {

public void getEngine ();

}
具体产品类
/座椅/

//京东买的
public class JD_Chair implements Chair{

@Override
public void getChair() {
	// TODO Auto-generated method stub
	System.out.println("从京东购买的座椅....");
}

}
//淘宝买的
public class TB_Chair implements Chair {

@Override
public void getChair() {
	// TODO Auto-generated method stub
	System.out.println("从淘宝买的座椅.....");
}

}
/发动机/

//进口的
public class Import_Engine implements Engine{

@Override
public void getEngine() {
	// TODO Auto-generated method stub
	System.out.println("使用进口发动机....");
}

}

//本地的
public class Local_Engine implements Engine{

@Override
public void getEngine() {
	// TODO Auto-generated method stub
	System.out.println("使用本地发动机....");
}

}
抽象工厂
public interface CarFactory {

//一组方法 对应 一组产品 上面有讲过
public Chair getChair();
public Engine getEngine();

}
具体工厂
//生产A型号的汽车
public class AcarFactory implements CarFactory{

@Override
public Chair getChair() {
	// TODO Auto-generated method stub
	return new JD_Chair();
}

@Override
public Engine getEngine() {
	// TODO Auto-generated method stub
	return new Local_Engine();
}

}
//生产B型号的汽车
public class BcarFactory implements CarFactory{

@Override
public Chair getChair() {
	// TODO Auto-generated method stub
	return new TB_Chair();
}

@Override
public Engine getEngine() {
	// TODO Auto-generated method stub
	return new Import_Engine();
}

}