模式 工厂

 模式这个东西的重要性，想必不要我说，大家都觉得重要。
掌握了这个，做为程序员的你，就会达到手中无剑，心中有剑的境界
也就是说，这个东西让你眼光过远一点点。废话不说，进入正题。
先看看这三个的模糊定义：
简单工厂（Simple Factory）模式：又称静态工厂方法(Static Factory Method Pattern)
工厂方法(Factory Method)模式：又称多态性工厂(Polymorphic Factory)模式或者说是虚拟构造子（virtual Constructor）模式。
抽象工厂(Abstract Factory)模式：又称工箱具(Kit 或 Toolkit)模式。
这样看上去还是挻不了解的。
其实这些都是创建型模式，顾名思义，创建对象的。
上面三种是类模式，类模式处理类和子类之间的关系，这些关系通过继承建立，
是静态的，在编译时刻便确定下来了。而且这些都专门负责有大量共同接口的类，实例化。
这样说大家是不是有了一个抽象的了解。
从功能上说。Simple FactorySimple Factory:
结构：
结构说明：Simple Factory由三个角色构成：工厂角色，抽象产品角色，具体产品角色。
工厂角色：负责创建对象的逻辑。是个具体的类。
抽象产品角色：拥有共同接口的抽象类。
具体产品角色: 实现接口的具体的类。
问题描述：一个工厂生产苹果appale，葡萄grape两种水果。

代码清单：
furit水果接口：

public interface Fruit {
 /*
  *生长
  */
    public abstract void grow();
    /*
     * 收获
     */
    public abstract void harvest();
    /*
     * 种植
     */
    public abstract void plant();
}

 

apple 苹果

public class Apple implements Fruit {
 private int age;

 

 @Override
 public void grow() {
       log("Apple is harvesting");
 }

 @Override
 public void harvest() {
          log("Apple is harvesting");
 }

 @Override
 public void plant() {
          log("Apple is planting");
 }
 /*
  * 日志
  *
  */
 public static void log(String msg){
  System.out.println(msg);
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }
}

葡萄 grape
package simpleFactory.impl;

import simpleFactory.Fruit;

public class Grape implements Fruit {
    private boolean seedless;
 @Override
 public void grow() {
         log("Grape is growing");
 }

 @Override
 public void harvest() {

  log("Grape is harvesting");
 }

 @Override
 public void plant() {
       log("Grape is planting");
 }
 public static void log(String msg){
  System.out.println(msg);
 }
 

 public boolean isSeedless() {
  return seedless;
 }

 public void setSeedless(boolean seedless) {
  this.seedless = seedless;
 }
 
}

工厂

public class Factory {

                /*
                 * 静态工厂方法
                 */
      public static Fruit fruitFactory(String fruitname){
       if(fruitname.equalsIgnoreCase("apple")){
        return new Apple();
       }
       if(fruitname.equalsIgnoreCase("grape")){
        return new Grape();
       }
       return null;
      }
}
后面还有很多的模式都有用到简单工厂模式，简单工厂模式，多例模式，备忘录模式。这些模式，我以后研究。
但一个缺点就是，对“开-闭”原则支持不是很好，当这个工厂生产其他东西的时候。不得不改工厂这个类。

工厂方法模式很好解决这个问题，因为他把工厂也抽象了，这样你要扩展哪个产品，只要将这个产品继承这个工厂，
扩展一下下，就好了，和简单工厂相比，多了一个角色。抽象工厂角色。
抽象工厂角色：拥有共同接口的抽象类。
具体工厂角色：负责创建对象的逻辑。是个具体的类。
抽象产品角色：拥有共同接口的抽象类。
具体产品角色: 实现接口的具体的类。

 

代码清单：
furit水果接口：

public interface Fruit {
 
}

 

apple 苹果

public class Apple implements Fruit {
public Apple(){
  System.out.println("Apple is create!!!!!");
 }
}

葡萄 grape
package simpleFactory.impl;

import simpleFactory.Fruit;

public class Grape implements Fruit {
     public Grape(){
  System.out.println("Grape is create");
 } 
}

抽象工厂

public class Factory {

               public Furit factory();
}
具体工厂
public class AppleFactory implements Factory {

 @Override
 public Furit factory() {
  return new Apple();
 }

}
public class GrapeFactory implements Factory {

 @Override
 public Furit factory() {
  return new Grape();
 }

}

 

客户端
public class Client {

 
 public static Factory appleFactory,grapeFactory;
 public  static Furit apple,grape;
 
 
 public static void main(String[] args) {
         
    appleFactory=new AppleFactory();
    grapeFactory=new GrapeFactory();
   
    apple=appleFactory.factory();
    grape=grapeFactory.factory();
  
  
 }

}