[color=red]工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。[/color]
示例1:
示例2:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。[/color]
示例1:
package hello;
/**
* 抽象工厂简单示例
* @author HZ20232
*
*/
public class FactoryMethodPattern{
public static void main(String args[]){
Factory longFactory = new LongWeaponFactory();
Gun longGun = longFactory.createGun();
Connon longConnon = longFactory.createConnon();
longGun.Beng();
longConnon.Beng();
Factory shorFactory = new ShortWeaponFactory();
Gun shorGun = shorFactory.createGun();
Connon shortConnon = shorFactory.createConnon();
shorGun.Beng();
shortConnon.Beng();
}
}
interface Gun{
void Beng();
}
interface Connon{
void Beng();
}
class LongGun implements Gun{
public void Beng(){
System.out.println("Big Gun Beng!");
}
}
class ShortGun implements Gun{
public void Beng(){
System.out.println("Little Gun Beng!");
}
}
class LongConnon implements Connon{
public void Beng(){
System.out.println("Big Connon Beng!");
}
}
class ShortConnon implements Connon{
public void Beng(){
System.out.println("Little Connon Beng!");
}
}
interface Factory{
Gun createGun();
Connon createConnon();
}
class LongWeaponFactory implements Factory{
public Gun createGun(){
return new LongGun();
}
public Connon createConnon(){
return new LongConnon();
}
}
class ShortWeaponFactory implements Factory{
public Gun createGun(){
return new ShortGun();
}
public Connon createConnon(){
return new ShortConnon();
}
}
示例2:
package hello;
import java.io.*;
/**
* 简单工厂简单示例
* @author HZ20232
*
*/
public class FactoryMethodPattern{
public static void main(String args[]){
try {
System.out.println("请输入数字1:");
String strA = new BufferedReader(new InputStreamReader(System.in))
.readLine();
System.out.println("请输入运算符:");
String stroperate = new BufferedReader(new InputStreamReader(
System.in)).readLine();
System.out.println("请输入数字2:");
String strB = new BufferedReader(new InputStreamReader(System.in))
.readLine();
Operation oper;
OperationFactory factory = new OperationFactory();
oper=factory.getOperation(stroperate);
oper.setA(Integer.parseInt(strA));
oper.setB(Integer.parseInt(strB));
int result = oper.operator();
System.out.println(result);
} catch (Exception e) {
}
}
}
abstract class Operation{
int operandA;
int operandB;
public Operation(){
this.setA(0);
this.setB(0);
}
public Operation(int a,int b){
this.setA(a);
this.setB(b);
}
public void setA(int numA){
this.operandA = numA;
}
public int getA(){
return this.operandA;
}
public void setB(int numB){
this.operandB = numB;
}
public int getB(){
return this.operandB;
}
public abstract int operator();
}
class AddOperation extends Operation{
public int operator(){
return this.operandA+this.operandB;
}
}
class MulOperation extends Operation{
public int operator(){
return this.operandA*this.operandB;
}
}
interface Factory{
Operation getOperation(String a);
}
class OperationFactory implements Factory{
public Operation getOperation(String operator){
Operation operation = null;
if("+".equalsIgnoreCase(operator))
operation = new AddOperation();
else if("*".equalsIgnoreCase(operator))
operation = new MulOperation();
return operation;
}
}