工厂-
1.单例--------------------使一个类Car只能有一个实例(即不能new出多个类Car的对象)
??class Car {
???//私有静态变量,为Car类的实例a
???private static Car car = new Car();
???//私有private构造函数,不能直接使用new来创建新对象
???private Car(){
???
???}
???//通过静态方法getInstance来获得静态私有变量类Car的对象car
???public static Car getInstance(){
????//注意:在getInstance方法中可以加权限/条件判断等--->保护对象任意被获得
????return car;
???}
??}
------->即:任何一个客户端或想创建多个类Car的对象的地方都不能使用new来创建Car类的对象
???? 且只能使用getInstance静态方法来获得Car类中的私有静态变量car
(注意:getInstance---->实质是静态工厂模式---->一般任何用来控制实例创建的情况都涉及到工厂模式)?
(***多例--->private static List<Car> cars = new ArrayList<Car>();---->连接池使用多例....********)???
2.工厂方法factory method
----------------------------------任意定制交通工具并控制生产过程
类结构:
Movable接口<----Car类?????
???? <----Plane类???
????
VehicleFactory交通工具抽象类<-----CarFactory汽车工厂类??
???????<-----PlaneFactory飞机工厂类
Interface Movable{
?void run();
}????
class Car implements Movable{
?public void run(){
??System.out.println("汽车跑啊跑...");
?}
}
class Plane implements Movable{
?public void run(){
??System.out.println("飞机飞呀飞...");
?}
}
----->首先由上我们可以任意定制交通公具---即:
?? Movable m = new Car();
????? m.run();
?? 这样不管new 什么交通公具,都将由接口Movable引用,并调用m.run()会根据不同的交通公具调用其自己的run方法
------------工厂??
abstract class VehicleFactory{
?abstract Movable create();
}??
class CarFactory extends VehicleFactory{
?public Movable create(){
??return new Car();
?}?
}
class PlaneFactory extends VehicleFactory{
?public Movable create(){
??return new Plane();
?}
}
------>这样我们可以控制交通工具的生产:
??? //获得生产汽车的工厂
??? VehicleFactory factory = new CarFactory();
??? //生产出来的即为汽车
??? Movable m = factory.create();
??? //生产飞机的工厂
??? VehicleFactory factory = new PlaneFactory();
??? //生产出来的即为飞机
??? Movable m = factory.create();
----->这样带来的扩展性----->假如我们现在又添加了另一交通工具---火车train,则:
?? ---->新建一火车类Train继承Movable接口,再新建一火车工厂TrainFactory继承自VehicleFactory
????? class Train implements Movable{
??? public void run(){
???? System.out.println("火车呜呜的跑...");
??? }
?? }
?? class TrainFactory extends VehicleFactory(){
??? public Movable create(){
???? return new Train();
??? }
?? }
?? ---->这样直接获得生产火车的工厂让其生产火车
?? Movable m = TrainFactory.create();
?? m.run();
------------------------------------------------------
3.抽象工厂------
----"系列产品"---->比如阿迪达斯--->生产adidas鞋子,adidas裤子,adidas外套--->这就是一系列产品
??????? 耐克------->生产nike鞋子,? nike裤子,? nike外套----->又是一系列产品
----假如我们的程序中需要获取这一系列的产品--鞋子,裤子,外套(如同客户要买一系列的鞋子/裤子/外套产品,生产场商一定要生产出这一系列的产品来)???????
---->此时有两套系列的产品,而且这两套系列的产品都有共同点--->每个系列都分为鞋子/裤子/外套(只是品牌不同,生产场商不同)
---->在这种情况下一般使用"抽象工厂"--->即程序中的实体可以分为多个系列,而且各个系列的实体都有类似的地方,这样我们分析各系列实体的类似点,
? 抽象化产品/实体,并且抽象化生产各系列产品/实体的工厂---->我们会获得更有扩展性,更建壮的程序
----就拿以上例子来讲:?
---->首先抽象产品--->
public abstract class Shoe{
?public abstract void IAmShoe();
}
public abstract class Trousers{
?public abstract void IAmTrousers();
}
public abstract class Coat{
?public abstract void IAmCoat();
}
--->具体产品
public class AdidasShoe extends Shoe{
?public void IAmShoe{
??System.out.println("I am Adidas shoe!");
?}
}
public class AdidasTrousers extends Trousers{
?public void IAmTrousers{
??System.out.println("I am Adidas trousers!");
?}
}
public class AdidasCoat extends Coat{
?public void IAmCoat{
??System.out.println("I am Adidas coat!");
?}
}
public class NikeShoe extends Shoe{
?public void IAmShoe{
??System.out.println("I am Nike shoe!");
?}
}
public class NikeTrousers extends Trousers{
?public void IAmTrousers{
??System.out.println("I am Nike trousers!");
?}
}
public class NikeCoat extends Coat{
?public void IAmCoat{
??System.out.println("I am Nike coat!");
?}
}
--------------->首先把产品抽象化了--->产品方面已经有很好的扩展性了--->父类引用指向子类对象--->比如:Shoe shoe = new NikeShoe();(任何鞋类的对象都能赋予Shoe的引用都)
------->工厂的抽象(根据实际程序中的需求和分析的各系列产品的共同特性来设计--抽象工厂--->如该例中Adidas,Nike两个生产商都会生产鞋子/裤子/外套)
------->以下这个抽象工厂负则创建一系列产品--->就像Adidas,Nike两个生产商的抽象化(虽然这个抽象类什么都不能做,只是定义,或者说规定工厂生产什么)
??(我们也会注意到----将产品抽象化的好处----不管你生产Adidas还是Nike的鞋子,都可以使用createShoe方法返回一个抽象的鞋子类型Shoe的引用上)
public abstract AbstractFactory{
?public abstract Shoe createShoe();
?public abstract Trousers createTrousers();
?public abstract Coat createCoat();
}
---->以下是生产各系列具体产品的生产商(工厂)---如Adidas生产商(工厂)都干嘛...以下就是
public class AdidasFactory extends AbstractFactory{
?public Shoe createShoe(){
??return new AdidasShoe();
?}
?public Trousers createAdidasTrousers(){
??return new AdidasTrousers();
?}
?public Coat createAdidasCoat(){
??return new AdidasCoat();
?}
}
public class NikeFactory extends AbstractFactory{
?public Shoe createShoe(){
??return new NikeShoe();
?}
?public Trousers createAdidasTrousers(){
??return new NikeTrousers();
?}
?public Coat createAdidasCoat(){
??return new NikeCoat();
?}
}
-------------------->抽象工作完成,看看客户端
public class Client{
?public static void main(String[] args){
??//客户需要Adidas的一系列产品(假如客户自己要量身定作一套Adidas系列的鞋子,裤子,外套)--->首先搞一个Adidas的工厂
??AbstractFactory factory = new AdidasFactory();
??Shoe shoe = factory.createShoe();
??Shoe trousers = factory.createTrousers();
??Shoe coat = factory.createCoat();
??shoe.IAmShoe();
??trousers.IAmTrousers();
??coat.IAmCoat();
?}
}
--------->OK-->一系列Adidas的鞋子裤子外套产生好了--->什么?要Nike的,只需要把第一句--建工厂的语句改为....new NikeFactory()
------->下面的全都不需要变,一系列的Nike的鞋子,裤子,外套就生产了
(将建立哪个工厂写在配置文件中,O了,想建哪个系列,程序都不需要改动,只要改一下配置文件....)
--------->想要匡威的鞋子,裤子,外套?????没问题
先把产品规格定义好:
public class ConverseShoe extends Shoe{
?public void IAmShoe(){
??System.out.println("I aam Converse Shoe!!");
?}
}
public class ConverseTrousers extends Trousers{
?public void IAmTrousers(){
??System.out.println("I am Converse Trousers");
?}
}
public class ConverseCoat extends Coat{
?public void IAmCoat(){
??Systme.out.println("I am Converse Coat!!");
?}
}
----->定制产品后,建行生产匡威这一系列鞋子,裤子,外套的工厂吧--->
public class ConverseFactory extends AbstractFactory{
?public Shoe createShoe(){
??return new ConverseShoe();
?}
?public Trousers createTrousers(){
??return new ConverseTrousers();
?}
?public Coat createCoat(){
??return new ConverseCoat();
?}
}
---------->O了,在客户端,将工厂改成这个生产匡威系列产品的工厂ConverseFactory,其余的不用改,就会生成一系列匡威的鞋子,裤子,外套了!!!
4.工厂方法----抽象工厂---区别:
----工厂方法--->便于在"产品"这个维度上扩展(比如新增一个产品---只要定义该产品类,继承自抽象产品;再定义生产该产品的工厂类,继承自"抽象化过"的工厂即可)
----抽象工厂--->利于在"产品系列"这个维度上扩展(比如新增一个产品系列--只要定义新的一系列产品,分别继承自各产品的抽象产品;再....如上述)
(缺点:工厂方法---扩展几个新的产品还是不错的,但是如果扩展一大批一系列的产品,那么会建一大批类和其对应的一大批工厂--->结果工厂泛滥了...)
(缺点:抽象工厂---扩展新的一系列产品很方便,但是如果使用抽象工厂-->去新增一个产品....会很麻烦)
两个工厂模式,综合运用--->牛X
5.工厂之四----模拟spring的BEAN工厂
?1>.Spring配置文件-------applicationContext.xml
?<?xml version="1.0" encoding="UTF-8">
?<beans xmls="XXXXX">
??<bean id="xx" class="xxx.xxx.具体产品对应的类名">
??</bean>
?</beans>
?2>.建立BEAN工厂
?BeanFactory bf = new ClassPathXmlApplicationContext("applicationContext.xml");
?Object o = bf.getBean("配置文件中的id");
?------>可以使用BEAN工厂BeanFactory的getBean方法,获得配置文件中配置的各个id代表的产品
?(面向抽象/接口编程,具体的东西写在配置文件中!!)
?-------------------------------------------抽象类作为子类的工厂(抽象产品角色-工厂角色合并)
抽象类java.text.DateFormat的getDateInstance静态方法返回子类SimpleDateFormat的实例(DateFormat类型)
?
?
?
