gof设计模式之工厂模式大致分为3中方式:
A 简单工厂模式
B 工厂方法模式
C 抽象工厂模式
A 简单工厂模式:整个模式以工厂类为核心,由工厂类实现指定类型的对象的创建.
方便之处见图:
代码实现:
//水果
interface Friut{
public Friut get();
}
//苹果
class Apple implements Friut{
public Friut get(){
return new Apple();
}
}
//橘子
class Orange implements Friut{
public Friut get(){
return new Orange();
}
}
//香蕉
class Banana implements Friut{
public Friut get(){
return new Banana();
}
}
//水果厂
class FriutFactory{
public static Friut make(Friut friut){
return friut.get();
}
}
//水果店
class FriutShop{
public static Friut take(String name){
if("apple".equals(name)){
return FriutFactory.make(new Apple());
}else if("orange".equals(name)){
return FriutFactory.make(new Orange());
}else if("banana".equals(name)){
return FriutFactory.make(new Banana());
}else{
System.out.println("暂时没该水果供售");
return null;
}
}
public static void main(String[] args){
System.out.println("进入商店买水果:");
take("apple");
take("banana");
take("orange");
}
}
B 工厂方法模式
从上面的简单工厂可以看出,如果只是简单的几种类别需要产出,那还是很方便的,要是水果店要卖个1000中水果,那工厂里面可是一大堆的逻辑判断了..由此引出工厂方法模式
工厂方法模式:核心工厂类不再负责对象的创建,将创建具体的对象延迟到具体的工厂类中,核心工厂类只负责子工厂类必须实现的接口,而屏蔽创建的细节.
这样就是水果点业务扩大,品种齐全了,实行专一生产.看着比简单工厂就是正规点
代码实现:
interface Friut{
public Friut get();
}
class Apple implements Friut{
public Friut get(){
return new Apple();
}
}
class Orange implements Friut{
public Friut get(){
return new Orange();
}
}
class Banana implements Friut{
public Friut get(){
return new Banana();
}
}
interface FriutFactory{
public Friut makeFriut();
}
class AppleFactory implements FriutFactory{
@Override
public Friut makeFriut() {
return new Apple();
}
}
class OrangeFactory implements FriutFactory{
@Override
public Friut makeFriut(){
return new Orange();
}
}
class BananaFactory implements FriutFactory{
@Override
public Friut makeFriut() {
return new Banana();
}
}
class FriutShop{
public static Friut take(FriutFactory factory){
return factory.makeFriut();
}
public static void main(String[] args){
System.out.println("进入商店买水果:");
take(new AppleFactory());
take(new BananaFactory());
take(new OrangeFactory());
}
}
C 抽象工厂方法
工厂方法已经很专一了,为什么还要抽象工厂呢?
原来水果店规模以后,已经不单单只卖某一种水果了,现在要产品成套销售(苹果+香蕉=》天天美容装)
从现在看,每个工厂都生产不同种类的产品(这里可能区分不是很明显,只是用苹果和苹果汁带表示,you can understand ?)
这是工厂方法和抽象工厂的差别,从单一对象的创建扩展了.
代码实现:
interface Friut{
public Friut get();
}
interface Drink{
public Drink get();
}
class AppleCider implements Drink{
@Override
public Drink get() {
return new AppleCider();
}
}
class Apple implements Friut{
public Friut get(){
return new Apple();
}
}
class Orange implements Friut{
public Friut get(){
return new Orange();
}
}
class OrangeCider implements Drink{
@Override
public Drink get() {
return new OrangeCider();
}
}
class BananaCider implements Drink{
@Override
public Drink get() {
return new BananaCider();
}
}
class Banana implements Friut{
public Friut get(){
return new Banana();
}
}
interface ShopFactory{
public Friut makeFriut();
public Drink makeDrink();
}
class AppleFactory implements ShopFactory{
@Override
public Friut makeFriut() {
return new Apple();
}
@Override
public Drink makeDrink() {
return new AppleCider();
}
}
class OrangeFactory implements ShopFactory{
@Override
public Friut makeFriut(){
return new Orange();
}
@Override
public Drink makeDrink() {
return new OrangeCider();
}
}
class BananaFactory implements ShopFactory{
@Override
public Friut makeFriut() {
return new Banana();
}
@Override
public Drink makeDrink() {
return new BananaCider();
}
}
class FriutShop{
public static String take(ShopFactory factory){
System.out.println("要是有个有个名字该多好啊.一定记住是一族产品");
return factory.makeFriut().toString() + factory.makeDrink().toString();
}
public static void main(String[] args){
System.out.println("进入商店买水果:");
take(new AppleFactory());
take(new BananaFactory());
take(new OrangeFactory());
}
}
就假设果汁和对应的水果做组合套吧..
这是我的一些理解..要是有问题的话请you 指出啊.