Go语言视频零基础入门到精通

javalearner

第一步：
/*******************新建一个Apple类**********/
public class Apple {
   // 采集
    public void get() {
      System.out.println("采集苹果"); }}
                                                                                            
/******************新建一个Banana类**********/
public class Banana implements Fruit {
    /* 采集 */
    public void get() {
       System.out.println("采集香蕉"); }}

/***************再新建一个MainClass主类*********/
public class MainClass {
    public static void main(String[] args) {
      Apple apple = new Apple();
      Banana banana = new Banana();
      apple.get(); banana.get(); }}  
  
  
  
/*
* 输出
* 采集苹果
* 采集香蕉
*/
//由此可以看出Apple,Banana这两个类可以抽象出一个方法,他们都是水果,他们都有一个get()这个方法
                        [/code] 第二步：
//抽取一个接口
public interface Fruit {
        /**
         * 采集
         */
        public void get();
}

//Apple去实现Fruit这个接口
public class Apple implements Fruit{
        /**
         * 采集
         */
        public void get() {
                System.out.println("采集苹果");
        }
}

//Banana也去实现Fruit这个接口
public class Banana implements Fruit {
        /**
         * 采集
         */
        public void get() {
                System.out.println("采集香蕉");
        }
}

//这么做的好处是什么呢?我们用了多态,这是我们要去new Apple,Banana的话,我们可以用接口来做
public class MainClass {
        public static void main(String[] args) {
                Fruit apple = new Apple();
                Fruit banana = new Banana();
                apple.get();
                banana.get();
        }
}
/*
* 输出
* 采集苹果
* 采集香蕉
*/
                        [/code] 回归概念：简单工厂模式
简单工厂模式属于类的创建模式,又叫做静态工厂方法模式.通过专门定义一个类来负责创建其他类的实例,
被创建的实例通常都具有共同的父类.
第三步：
//根据以上定义来定义一个工厂
public class FrutiFactory {
        /**
         * 获得Apple实例
         */
        public static Fruit getApple() {
                return new Apple();
        }
        /**
         * 获得Banana实例
         */
        public static Fruit getBanana() {
                return new Banana();
        }
}

//这是的MainClass
public class MainClass {
        public static void main(String[] args) {
                // 实例化一个Apple
                Fruit apple = FrutiFactory.getApple();
                // 实例化一个Banana
                Fruit banana = FrutiFactory.getBanana();
                apple.get();
                banana.get();
        }
}
/*
* 输出
* 采集苹果
* 采集香蕉
*/

//这就是静态工厂的实现
/**
* 1,工厂角色(FrutiFactory)
*   简单工厂模式的核心,它负责实现所有实例的内部逻辑.
*   工厂类可以被外界直接调用,创建所需的产品对象
* 2,抽象角色(Fruit)
*   简单工厂模式所创建的所有对象的父类,他负责描述所有实例所共有的公共接口
* 3,具体产品角色(apple.get(),banana.get())
*   简单工厂模式所创建的具体实例的对象
*/
                        [/code]
第四步：
//来改进FrutiFactory
public class FrutiFactory {
        /**
         * get方法,获得所有产品对象
         *
         * @throws IllegalAccessException
         * @throws InstantiationException
         */
        public static Fruit getFruit(String type) throws InstantiationException,
                        IllegalAccessException {
                if (type.equalsIgnoreCase("apple")) {
                        return Apple.class.newInstance();
                } else if (type.equalsIgnoreCase("banana")) {
                        return Banana.class.newInstance();
                } else {
                        System.out.println("找不到相应的实例化类");
                        return null;
                }
        }
}
//MainClass运行
        public static void main(String[] args) throws InstantiationException,
                        IllegalAccessException {
                Fruit apple = FrutiFactory.getFruit("apple");
                Fruit banana = FrutiFactory.getFruit("banana");
                apple.get();
                banana.get();
        }
                        [/code]
第五步：
//继续改进FrutiFactory
public class FrutiFactory {
        /**
         * get方法,获得所有产品对象
         *
         * @throws ClassNotFoundException
         * @throws IllegalAccessException
         * @throws InstantiationException
         *
         * @throws IllegalAccessException
         * @throws InstantiationException
         */
        public static Fruit getFruit(String type) throws ClassNotFoundException, InstantiationException,
IllegalAccessException {
                Class<?> fruit = Class.forName(type);
                return (Fruit) fruit.newInstance();
        }
}
//MainClass运行
public class MainClass {
        public static void main(String[] args) throws InstantiationException,
                        IllegalAccessException, ClassNotFoundException {
                Fruit apple = FrutiFactory.getFruit("cobra.simpleFactory.Apple");
                Fruit banana = FrutiFactory.getFruit("cobra.simpleFactory.Banana");
                apple.get();
                banana.get();
        }
}
                        [/code]
总结：
工厂类是整个模式的关键所在,它包含了必要的判断逻辑,能够根据外界给定的信息,决定究竟创建哪个具体类的对象.
在使用时可以直接根据工厂类去创建所需实例,而无需了解这些对象是如何创建的.有利于整个软件体系的结构优化
缺点就是：高类聚做的不够好,另外,当系统中的具体产品类不断增多时,可能会出现要求工厂类的修改,扩展性不好.