一.简单工厂设计模式(SimpleFactory):
工厂模式是我们使用最多的一种模式,可以说是随处可见.
我们在创建对象时将会遇到这种情况:就是当一个对象的构造器需要传入的参数过多时,
就很容易出现错误,这样也有背于于Java面向对象的原则,代码也变得很难看了.
在设计程序时应该尽量将长的代码分派“切割”成每段，
将每段再“封装”起来(减少段和段之间偶合联系性)，
这样，就会将风险分散，以后如果需要修改，
只要更改每段，不会再发生牵一动百的事情。
利用一个工厂类,将实例化对象将对象在内部进行初始化并返回,
这样可以做到封装的效果,避免了错误的出现几率
public class Demo4
{
public static void main(String[] args)
{
Sample sampleA=new SampleA();
Sample sampleB=new SampleB();
//利用工厂代替上边的实例化过程,减少参数传递时所发生的错误几率
Sample sampleA1=Factory.creator(1);
Sample sampleB1=Factory.creator(2);
}
}
interface Sample
{
public void method();
}
class SampleA implements Sample
{
public void method()
{
System.out.println("SampleA");
}
}
class SampleB implements Sample
{
public void method()
{
System.out.println("SampleB");
}
}
class Factory//建立工厂
{
public static Sample creator(int which)
{
if (which==1)
return new SampleA();
else
return new SampleB();
}
}
使用工厂方法要注意几个角色，首先你要定义产品接口，如Sample.
产品接口下有Sample接口的实现类,如SampleA,SampleB
其次要有一个factory类，用来生成产品Sample，他就是生成类的工厂.
但是这个工厂有弊端,如果子类增加了,则要修改工厂.
利用反射,可以不需要考虑类名.
public class Demo4
{
public static void main(String[] args)throws Exception
{
Sample f1=Factory.creator("SampleB");
f1.method();
}
}
interface Sample
{
public void method();
}
class SampleA implements Sample
{
public void method ()
{
System.out.println("SampleA");
}
}
class SampleB implements Sample
{
public void method ()
{
System.out.println("SampleB");
}
}
class Factory//建立工厂
{
public static Sample creator(String type)throws Exception
{
InputStream is=new FileInputStream("bin/demo/path.properties");
Properties p=new Properties();
p.load(is);
is.close();
return (Sample)Class.forName(p.getProperty(type)).newInstance();
}
}
工厂模式(Factory):
如果添加新的类,就需要修改工厂,简单工厂不符合开放.封闭的原则.所以应需要使用工厂模式:
意义是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中,
核心工厂类不再负责产品的创建,这样核心类成为一个抽象工厂角色,
仅负责具体工厂子类必须实现的接口,
这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品.
将简单工厂进行修改后的抽象工厂源代码如下:
public class Demo4
{
public static void main(String[] args)throws Exception
{
Factory sa=new SampleAFactory();//利用多态获取不同的具体工厂
Sample saa=sa.getSample();//利用多态获取具体工厂返回的具体角色来实例化抽象角色
saa.method();//调用方法
Factory sb=new SampleBFactory();
Sample sbb=sb.getSample();
sbb.method();
}
}
interface Sample
{
public void method();
}
class SampleA implements Sample
{
public void method ()
{
System.out.println("SampleA");
}
}
class SampleB implements Sample
{
public void method ()
{
System.out.println("SampleB");
}
}
interface Factory//建立工厂
{
public Sample getSample();
}
class SampleAFactory implements Factory//工厂的实现类: 通过调用不同的抽象工厂子类可以获得不同的实例对象
{
public Sample getSample()
{
return new SampleA();
}
}
class SampleBFactory implements Factory//工厂的实现类.
{
public Sample getSample()
{
return new SampleB();
}
}
如果后期添加新的Sample子类,则只需要创建类并且实现Factory,
利用接口定义的getSample函数返回Sample的子类实例对象即可,增强了扩展性.
抽象工厂的四大角色:
1.抽象工厂角色:
工厂方法模式的核心.任何工厂类都必须实现这个接口
2.具体工厂角色:
具体工厂类是抽象工厂的一个实现,负责实例化产品对象.
3.抽象角色:
工厂方法模式所创建的所有对象的父类,他负责实例化产品对象.
4.具体产品角色:
工厂方法模式锁创建的具体实例对象
总结与三大工厂的优缺点:
工厂方法模式与简单方法模式在结构上的不同不是很明显.
工厂方法模式的核心是一个抽象的工厂类,而简单工厂模式把核心放在一个具体的类上.
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口,或者有共同的抽象父类.
当系统扩展需要添加新的产品对象时,仅仅需要添加一个具体对象以及一个具体工厂对象,
原有工厂对象不需要进行任何的修改,也不需要修改客户端,很好的复合了"开放-封闭"原则.
而简单工厂模式在添加新产品对象后不得不去修改工厂方法,扩展性不好.
本人的学习笔记,不是抄的... |
收藏
淘帖
踩
