乐趣区

关于android:Java-23种设计模式之工厂模式

jiezi

Java 23 种设计模式之工厂模式

一：定义
工厂模式 ：定义一个创立产品对象的工厂接口，将产品产品对象的理论创立工作推延到具体子工厂类当中。这满足创立型模式中要求的“创立与应用相拆散”的特点
按理论业务划分：简略工厂模式 ， 工厂办法模式 和形象工厂模式
咱们把创立的对象称为“产品”，把创立产品的对象称为“工厂”，如果要创立的产品不多，只有一个工厂类就能够实现，这种模式叫“简略工厂模式”
在简略工厂模式中创立实例的办法通常为动态（static）办法，因而简略工厂模式（Simple Factory Pattern）又叫作动态工厂办法模式（Static Factory Method Pattern）
简略工厂模式 每减少一个产品就要减少一个具体产品类和一个对应的具体工厂类，减少了零碎的复杂度，违反了“开闭准则”
工厂办法模式 是对简略工厂模式的进一步抽象化，其益处是能够使零碎在不批改原来代码的状况下引进新的产品，即满足开闭准则。
二：简略工厂模式（Simple Factory Pattern）
模式构造
简略工厂模式的次要角色如下：
简略工厂（SimpleFactory）: 是简略工厂模式的外围，负责实现创立所有实例的外部逻辑。工厂类的创立产品类的办法能够被外界间接调用，创立所须要的产品对象
形象产品（Product）: 是简略工厂创立的所有对象的父类，负责形容所有实例共有的公共接口
具体产品（ConcreteProduct）：是简略工厂模式的创立指标

代码实现：

// 形象产品接口
public interface Car {
    
    // 生成小汽车
    void productCar();}


// 具体产品：奔驰车
public class BenChiCar implements Car{
    @Override
    public void productCar() {System.out.println("我来具体生成奔驰车");

    }
}


// 具体产品宝马车
public class BaoMaCar  implements Car{
    @Override
    public void productCar() {System.out.println("我来具体生成宝马车");
    }
}

// 工厂类生成产品的
public  class SimpleCarFactory {public  Car getCar(int a) {switch (a){
            case 0:
                return new BenChiCar();
            case 1:
                return new BaoMaCar();
            default:
               return null;
        }

    }
}

// 应用

   try {Car car= new SimpleCarFactory().getCar(0);// 拿到产品对象
           car.productCar();// 调用办法} catch (Exception e) {e.printStackTrace();
        }

// 后果
System.out: 我来具体生成奔驰车

二：工厂办法模式
工厂办法模式 Factory Method，又称多态性工厂模式。在工厂办法模式中，外围的工厂类不再负责所有的产品的创立，而是将具体创立的工作交给子类去做。该外围类成为一个形象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类该当被实例化这种细节。
模式的构造
工厂办法模式的次要角色如下。
1. 形象工厂（Abstract Factory）：提供了创立产品的接口，调用者通过它拜访具体工厂的工厂办法 newProduct() 来创立产品。
2. 具体工厂（ConcreteFactory）：次要是实现形象工厂中的形象办法，实现具体产品的创立。
3. 形象产品（Product）：定义了产品的标准，形容了产品的次要个性和性能。
4. 具体产品（ConcreteProduct）：实现了形象产品角色所定义的接口，由具体工厂来创立，它同具体工厂之间一一对应。

代码实现

// 形象产品接口
public interface Car {
    
    // 生成小汽车
    void productCar();}


// 具体产品：奔驰车
public class BenChiCar implements Car{
    @Override
    public void productCar() {System.out.println("我来具体生成奔驰车");

    }
}


// 具体产品宝马车
public class BaoMaCar  implements Car{
    @Override
    public void productCar() {System.out.println("我来具体生成宝马车");
    }
}

// 形象工厂

public interface AbstractFactory {
    // 生产产品的办法
    public Car createCar();}

// 具体工厂的实现：宝马工厂
public class BaoMaFactory implements AbstractFactory {
    @Override
    public Car createCar() {System.out.println("我是来宝马工厂创立宝马产品的");
        return new BaoMaCar();}
}

// 具体工厂：飞驰工厂
public class BenChiFactory implements AbstractFactory {
    @Override
    public Car createCar() {System.out.println("我是飞驰工厂创立飞驰产品的");
        return new BenChiCar();}
}

// 调用
Car benCar= new BenChiFactory().createCar();
        benCar.productCar();
        Car baoCar= new BaoMaFactory().createCar();
        baoCar.productCar();
        
 // 后果
 System.out: 我是飞驰工厂创立飞驰产品的
System.out: 我来具体生成奔驰车
System.out: 我是来宝马工厂创立宝马产品的
System.out: 我来具体生成宝马车

三：形象工厂模式
形象工厂（AbstractFactory）模式的定义：是一种为拜访类提供一个创立一组相干或相互依赖对象的接口，且拜访类毋庸指定所要产品的具体类就能失去同族的不同等级的产品的模式构造。
形象工厂模式是工厂办法模式的降级版本，工厂办法模式只生产一个等级的产品，而形象工厂模式可生产多个等级的产品。
应用形象工厂模式个别要满足以下条件。
零碎中有多个产品族，每个具体工厂创立同一族但属于不同等级构造的产品。
零碎一次只可能生产其中某一族产品，即同族的产品一起应用。
模式的构造
形象工厂模式的次要角色如下。
1. 形象工厂（Abstract Factory）：提供了创立产品的接口，它蕴含多个创立产品的办法 newProduct()，能够创立多个不同等级的产品。
2. 具体工厂（Concrete Factory）：次要是实现形象工厂中的多个形象办法，实现具体产品的创立。
3. 形象产品（Product）：定义了产品的标准，形容了产品的次要个性和性能，形象工厂模式有多个形象产品。
4. 具体产品（ConcreteProduct）：实现了形象产品角色所定义的接口，由具体工厂来创立，它同具体工厂之间是多对一的关系。

代码实现

// 形象电视产品接口
public interface Tv {
    // 生成电视
    void productTv();}

// 具体产品：飞驰电视
public class BenChiTv implements Tv{
    @Override
    public void productTv() {System.out.println("具体生产飞驰牌电视");
    }
}

// 具体产品：宝马电视
public class BaomaTv  implements Tv{
    @Override
    public void productTv() {System.out.println("具体生产宝马牌电视");
    }
}

// 形象汽车产品接口
public interface Car {
    
    // 生成小汽车
    void productCar();}


// 具体产品：奔驰车
public class BenChiCar implements Car{
    @Override
    public void productCar() {System.out.println("我来具体生成奔驰车");

    }
}


// 具体产品宝马车
public class BaoMaCar  implements Car{
    @Override
    public void productCar() {System.out.println("我来具体生成宝马车");
    }
}

// 形象工厂，外面有生成汽车产品，有生成电视产品的办法
public interface AbstractFactory {
    // 生产产品的办法
    public Car createCar();
    // 生产产品电视的办法
    public Tv createTv();}

// 具体工厂：飞驰工厂
public class BenChiFactory implements AbstractFactory {
    @Override
    public Car createCar() {return new BenChiCar();
    }

    @Override
    public Tv createTv() {return new BenChiTv();
    }
}

// 具体工厂的实现：宝马工厂
public class BaoMaFactory implements AbstractFactory {
    @Override
    public Car createCar() {return new BaoMaCar();
    }

    @Override
    public Tv createTv() {return new BaomaTv();
    }
}


// 应用
  Car benCar= new BenChiFactory().createCar();
        benCar.productCar();
        Tv benTv= new BenChiFactory().createTv();
        benTv.productTv();
        Car baoCar= new BaoMaFactory().createCar();
        baoCar.productCar();
        Tv baoTv= new BaoMaFactory().createTv();
        baoTv.productTv();
        
  // 后果
System.out: 我来具体生成奔驰车
System.out: 具体生产飞驰牌电视
System.out: 我来具体生成宝马车
System.out: 具体生产宝马牌电视


工厂模式个别联合动静代理和单例应用

END: 奋斗是自有人类以来就生生不息的

退出移动版