// 第一步创建Calendar对象 
Calendar calendar = Calendar.getInstance();

// 第二步调用getInstance()方法（抽象类Calendar）
public static Calendar getInstance(){
    return createCalendar(
        TimeZone.getDefault(), 
        Locale.getDefault(Locale.Category.FORMAT));
}

// 第三步创建对象
private static Calendar createCalendar(TimeZone zone,Locale aLocale){
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
}

//定义一个接口规范
public interface Sender {
  public void Send();
}

//建造一个实现类，并且实现定义的接口
public class MailSender implements Sender{
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

//建造一个实现类，并且实现定义的接口
public class SmsSender implements Sender {
    public void Send() {
        System.out.println("this is sms sender!");
    }
} 

//建工厂类
public class SendFactory {
    public Sender produce(String type){
        if("mail".equals(type)){
            return new MailSender();
        }else if("sms".equals(type)){
            return new SmsSender();
        }else{
            System.out.println("请输入正确的类型!");
            return null;
        }
    }
    
}

//进行测试
public class FactoryTest {

        public static void main(String[] args) {
            //创建工厂类对象
            SendFactory factory = new SendFactory();

            //通过工厂类来创建SmsSender对象，
            //SmsSender smsSender = factory.produce("sms");
            Sender sender = factory.produce("sms");

            //smsSender.Send();
            sender.Send();
        }
}

//创建一个工厂类
public class SendFactory {  
      
    public static Sender produceMail(){  
        return new MailSender();  
    }  

    public static Sender produceSms(){  
        return new SmsSender();  
    }  
}  


public class FactoryTest {  
  
    public static void main(String[] args) {
        
        Sender sender = SendFactory.produceMail(); 
        
        sender.Send();  
    }  
}

//  1. 创建抽象工厂类
abstract class Factory{
    public abstract Product Manufacture();
}

// 2. 创建抽象产品类
abstract class Product{
    public abstract void Show();
}

// 3. 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；
//具体产品A类
class  ProductA extends  Product{
    @Override
    public void Show() {
        System.out.println("生产出了产品A");
    }
}
 
//具体产品B类
class  ProductB extends  Product{
 
    @Override
    public void Show() {
        System.out.println("生产出了产品B");
    }
}
// 4. 创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
//工厂A类 - 生产A类产品
class  FactoryA extends Factory{
    @Override
    public Product Manufactu re() {
        return new ProductA();
    }
}
 
//工厂B类 - 生产B类产品
class  FactoryB extends Factory{
    @Override
    public Product Manufacture() {
        return new ProductB();
    }
}

// 5. 外界通过调用具体工厂类的方法，从而创建不同具体产品类的实
//生产工作流程
public class FactoryPattern {
    public static void main(String[] args){
        //客户要产品A
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.Manufacture().Show();
 
        //客户要产品B
        FactoryB mFactoryB = new FactoryB();
        mFactoryB.Manufacture().Show();
    }
}

/**
 *制作水果汁接口
 */
public interface JuiceProduct {
    void make();
}

/**
*制作蛋糕的接口
*/
public interface CakeProduct {
	void cooking();
}


/**
 * 制作苹果汁
 */
public class AppleJuiceProduct implements JuiceProduct {
    @Override
    public void make() {
        System.out.println("正在制作苹果汁>>>");
    }
}
/**
 * 制作梨汁
 */
public class PearJuiceProduct implements JuiceProduct {
    @Override
    public void make() {
        System.out.println("正在制作梨汁>>>");
    }
}

/**
 * 制作香蕉汁
 */
public class BananaJuiceProduct implements JuiceProduct {
    @Override
    public void make() {
        System.out.println("正在制作香蕉汁>>>");
    }
}

public class CheeseCakeProduct implements CakeProduct {
    @Override
    public void cooking() {
        System.out.println("正在烹饪芝士蛋糕>>>");
    }
}

/**
 * 制作套餐工厂
 */
public interface SetMealFactory {

    //生产蛋糕
    CakeProduct productCake();

    //生产果汁
    JuiceProduct productJuice();

}

/**
 * A套餐生产工厂
 */
public class ASetMealFactory implements SetMealFactory{

    //生产芝士蛋糕
    @Override
    public CakeProduct productCake() {
        return new CheeseCakeProduct();
    }

    //生产苹果汁
    @Override
    public JuiceProduct productJuice() {
        return new AppleJuiceProduct();
    }
}