设计模式（一）工厂模式（创建型）

 简单工厂模式

     一个抽象产品类，可以派生出多个具体产品类；

     一个具体工厂类，可以创建多个具体产品的实例。

 

       抽象产品类定义

public abstract class Sender {
    
    void send(){
        
    };

}

      具体产品类定义

    邮件产品类

public class MailSender extends Sender{
    
    public void send(){
      System.out.println("Mail Sender!");    
    }
}

 

    短信产品类

public class SmsSender extends Sender{
    
    public void send(){
          System.out.println("Sms Sender!");    
    }

}

 

   简单工厂类

public class SimpleFactory {
    
    public static MailSender createMailSender(){
        return new MailSender();
    }
    
    public static SmsSender createSmsSender(){
        return new SmsSender();
    }

}

 

        测试类

public class SimpleFactoryTest {

    public static void main(String[] args) {
        Sender mailSender = SimpleFactory.createMailSender();
        mailSender.send();
        
        Sender smsSender = SimpleFactory.createSmsSender();
        smsSender.send();
    }

}

     工厂方法模式

         一个抽象产品类，可以派生出多个具体产品类；

         一个抽象工厂类，可以派生出多个具体工厂类；

         每个具体工厂类只能创建一个具体产品类的实例。

         抽象产品类定义

public abstract class Fruit {
    
    void print(){
        
    };

}

       具体产品类定义

public class Apple extends Fruit{
    
    public void print(){
        System.out.println("apple");
    }

}
public class Pear extends Fruit{
    
    public void print(){
        System.out.println("pear");
    }

}

    工厂方法抽象类定义

public abstract class Factory {
    
    abstract Fruit create();

}

 

    工厂方法具体工厂类定义：

public class AppleFactory extends Factory{
    
    public Fruit create(){
        return new Apple();
    }

}
public class PearFactory extends Factory{
    
    public Fruit create(){
        return new Pear();
    }

}

      测试类

public class MethodFactoryTest {
    
    public static void main(String[] args) {
        Factory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.create();
        apple.print();
        
        Factory pearFactory = new PearFactory();
        Fruit pear = pearFactory.create();
        pear.print();
    }

}

     抽象工厂模式

       多个抽象产品类，每个抽象产品类可以派生出多个具体的产品类；

       一个抽象工厂类，可以派生出多个具体工厂类；

       每个具体工厂类可以创建多个具体产品类的实例。

     抽象产品类定义

public abstract class Fruit {
    
    void print(){
        
    };

}
public abstract class Car {

    void print(){
        
    };
    
}

     具体产品类定义

public class Apple extends Fruit{
    
    public void print(){
        System.out.println("apple");
    }

}
public class Pear  extends Fruit{
    
    public void print(){
        System.out.println("pear");
    }

}
public class Bmw extends Car{
    
    public void print(){
        System.out.println("bmw");
    }

}
public class Buick extends Car{
    
    public void print(){
        System.out.println("buick");
    }

}

 

     抽象工厂抽象类定义

public abstract class AbstractFactory {
    
    abstract Fruit createFruit();
    
    abstract Car createCar();

}

    抽象工厂具体工厂类定义

public class BmwAppleFactory extends AbstractFactory{
    
    public Fruit createFruit(){
        return new Apple();
    }
    
    public Car createCar(){
        return new Bmw();
    }

}
public class BuickPearFactory extends AbstractFactory{
    
    public Fruit createFruit(){
        return new Pear();
    }
    
    public Car createCar(){
        return new Buick();
    }

}

     测试类

public class AbstractFactoryTest {
    
    public static void main(String[] args) {
        AbstractFactory bmwAppleFactory = new BmwAppleFactory();
        Car car1 = bmwAppleFactory.createCar();
        Fruit fruit1 = bmwAppleFactory.createFruit();
        car1.print();
        fruit1.print();
        
        AbstractFactory buickPearFactory = new BuickPearFactory();
        Car car2 = buickPearFactory.createCar();
        Fruit fruit2 = buickPearFactory.createFruit();
        car2.print();
        fruit2.print();
    }

}

 

      工厂方法和抽象工厂的区别：

         工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

         工厂方法模式的具体工厂类只能创建一个具体产品的实例，而抽象工厂模式可以创建多个。