接口设计模式-------工厂设计模式
工厂设计模式分为简单设计模式和工厂设计模式。
简单工厂模式
不想把new 放在主方法
专门定义一个类（第三方）用来创建其他类实例（解耦：抽取出来 ，将客户端创建对象的操作解耦到外部第三方类），被创建的实例通常具有共同的父类。
在我们之前的代码中，对象的实例化是在主方法中：
////传统在主方法中子类为接口实例化对象
interface IDrinkI
{
void drinkKind();
}
class CoffeeImpl implements IDrinkI
{
public void drinkKind()
{
System.out.println("煮咖啡");
}
}
class TeaImpl implements IDrinkI
{
public void drinkKind()
{
System.out.println("泡茶");
}
}
public class Factory1
{
public static void main(String[] args)
{
IDrinkI drink1=new CoffeeImpl();
drink1.drinkKind(); //子类为接口进行实例化处理
IDrinkI drink2=new TeaImpl();
drink2.drinkKind();
}
}
如果在主方法中new对象，如果之后饮料需要是奶茶，那就需要修改主方法（客户端），但这并不是我们希望看到的，所以需要定义一个工厂生产饮料（在工厂里new对象，客户端只需要告诉想要什么饮料）。
简单工厂模式：
/////简单工厂模式
interface IDrinkI
{
void drinkKind();
}
class Factory
{
//Factory是为了生产对象，没必要实例化一个工厂对象，所以声明为static，在外用类来调用该方法
public static IDrinkI getInfor(String drinkName)
{
System.out.println("请问您需要什么饮料");
System.out.println(drinkName);
if("coffee".equals(drinkName))
{
return new CoffeeImpl();
}
else if("tea".equals(drinkName))
{
return new TeaImpl();
}
return null;
}
//此时，根据用户需求只需要修改Factory这个工厂类即可
}
class CoffeeImpl implements IDrinkI
{
public void drinkKind()
{
System.out.println("煮咖啡");
}
}
class TeaImpl implements IDrinkI
{
public void drinkKind()
{
System.out.println("泡茶");
}
}
public class Factory1
{
public static void main(String[] args)
{
if(args.length==0)
{
System.out.println("没有命令行参数，程序退出");
System.exit(1) ; // 退出程序
}
IDrinkI drink1=Factory.getInfor(args[0]);
drink1.drinkKind();
}
}
定义工厂类后，根据客户需求修改Factory类。
简单工厂模式注组成：
- 一个抽象产品类
- N个具体产品类
- 一个工厂类（负责生产所有具体产品）
工厂方法模式：产品族（优点在于横向扩展）
定义一个用来创建对象的接口，让子类决定生产哪一个工厂，（每个工厂只生成同类产品，保护性）
工厂方法模式组成：
- 一个抽象产品类
- 多个具体产品类
- 一个抽象工厂
- 多个具体工厂（每个产品族对应一个具体工厂）
如下面的苹果生产工厂只生成和苹果手机，安卓生产工厂只生成安卓手机，就是每个工厂只生成一个产品族，代码如下：
////////////工厂方法模式
interface IPhone {
void buyPhone();
}
interface IFactory
{
IPhone createPhone(); //生产手机
}
class AppleImpl implements IPhone
{
public void buyPhone()
{
System.out.println("买一部苹果phone");
}
}
class AnirodImpl implements IPhone
{
public void buyPhone()
{
System.out.println("买一部安卓phone");
}
}
class AppleFactImpl implements IFactory //苹果工厂
{
public IPhone createPhone()
{
return new AppleImpl();
}
}
class AnirodFactImp implements IFactory //安卓工厂
{
public IPhone createPhone()
{
return new AnirodImpl();
}
}
public class Factory1
{
public static void main(String[] args)
{
IFactory factory1=new AppleFactImpl();
IPhone phone=factory1.createPhone();
phone.buyPhone();//买一部苹果phone
}
}
抽象工厂--------多个产品线混合
提供一个创建一系列相关或相互依赖对象的接口（抽象工厂，多条生产线），而无需指定他们具体的类。
比如说苹果工厂还生成macOs操作系统，安卓工厂还生产android操作系统，就是说一个抽象工厂生产相关产品。
工厂方法模式和抽象工厂模式基本类似，可以这样理解，当工厂生产一个产品族时，即方法工厂模式，而工厂生产2个或2个以上的产品族时是抽象工厂模式。
总结：
- 简单工厂模式最大的优点是工厂内有具体的逻辑去判断生产什么产品，将类的实例化将给工厂，这样当我们需要什么产品只需要修改工厂的调用而不需要去修改客户端，对客户端来说降低了与具体产品的依赖；
- 工厂方法模式是简单工厂的扩展，工厂方法模式把原来简单工厂中实现哪个具体类的逻辑交给了客户端，有多个工厂，每个工厂只生成同类产品，保护性如果像添加功能只需要修改客户和添加具体的功能，不用去修改之前的类；
- 抽象工厂模式进一步扩展了工厂方法模式，它把原来的工厂方法模式只生成一个产品族扩展成生成相关依赖产品，具有更多的生产线。
接口设计模式----代理模式
特点：两个子类共同实现一个接口，其中一个子类负责真是业务实现，另一个子类完成辅助真实业务主题的操作。
比如说代理买衣服，我们真实的业务是买一件风衣，至于生成风衣和风衣售后是代理操心，代理辅助我们买一件风衣：
/////代理模式
interface ICloths
{
void buyCloths(); //核心功能是买衣服
}
class RealClothsImpl implements ICloths //真实业务
{
public void buyCloths()
{
System.out.println("买一件风衣");
}
}
class ProClothsImpl implements ICloths //代理业务
{
private ICloths cloths;
public ProClothsImpl(ICloths cloths) //向上转型
{
this.cloths=cloths;
}
public void beforeBuy()
{
System.out.println("生产风衣");
}
public void afterBuy()
{
System.out.println("生产风衣售后团队");
}
public void buyCloths()
{
this.beforeBuy(); //业务办理前操作
this.cloths.buyCloths(); //调用真实业务办理
this.afterBuy(); //业务办理后操作
}
}
class Factory //工厂生产对象
{
public static ICloths getInfor()
{
return new ProClothsImpl(new RealClothsImpl()); //proClothsImpl辅助真实业务
}
}
public class Factory1
{
public static void main(String[] args)
{
ICloths cloths=Factory.getInfor();
cloths.buyCloths();
}
}
代理模式的本质：所有的真实业务操作都会有一个与之辅助的工具类（功能类）共同完成。