1)系统需要使用现有的类,而此类的接口不符合系统的需要.

2)想要建立一个可以重复使用的类,用于与一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作.这些原类不一定有很复杂的接口.

3)(对对象的适配器模式)在设计里,需要改变多个已有的子类的接口,如果使用类的适配器模式,就要针对每一个子类做一个适配器类,而这不太实际.

下面通过一个实际的问题来理解适配器模式.

问题:请做一个Kittie具体类,并实现miao(),catchRat(),run(),sleep()方法,再做一个Puppie的接口,要求有wao(),fetchBall(),run(),sleep()方法.

假设现在客户需要一只Puppie,可是只找到一只Kittie,所以需要适配器Jalion把Kittie适配成Puppie.

代码如下:

===============================================================================

类Kittie

public class Kittie {
 public void miao()
 {
  
 }
 public void run()
 {
  
 }
 public void sleep()
 {
  
 }
}

接口Puppie

public interface Puppie {
 public void wao();
 public void fetchBall();
 public void run();
 public void sleep();
}

适配器Jalion

public class Jalion extends Kittie implements Puppie {

 public void fetchBall() {
  
  
 }

 public void wao() {
  
  
 }
 public void run()
 {
  super.run();
 }
 public void sleep()
 {
  super.sleep();
 }

}

================================================================================

在本例中,系统需要的是一个Puppie类,但现在只找到一个Kittie类,通过一个适配器,把功能和Puppie相近的类转换成了符合要求的Puppie类.

&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

适配器模式之缺省适配器模式
当一个接口定义了n个方法

public interface interfaceA {
 public void method1();
 public void method2();
 public void method3();
 public void method4();
 public void method5();
 public void method6();
 public void method7();
}

当一个类需要实现这个接口时,必须实现所有的方法,即使是你不需要的恶方法也得默认空实现.造成了浪费和麻烦.

使用适配器模式可以解决此问题

定义一个抽象类,实现接口interfaceA

public  abstract class AbstractA implements interfaceA {

 public void method1() {}
 public void method2() {}
 public void method3() {}
 public void method4() {}
 public void method5() {}
 public void method6() {}
 public void method7() {}
}

然后让实体类继承抽象类

public class ClassA extends AbstractA {
 public void method1()
 {
  
 }
 public void method7()
 {
  
 }
}
这样就可以在类中添加感兴趣的方法了.在awt事件监听器中,许多都是用了缺省适配器模式.

合成模式即是来描述整体和部分关系的模式。使得客户端把一个个单独的成分对象和由他们复合成的对象同等对待。根据实现细节不同，分为两种方式：安全方式和透明方式。下面以一个几何图形的例子来了解下这2种方式.

一个简单的几何图形是有圆,直线,矩形组成.其中几何图形就是由一个或多个单独的直线,圆,矩形对象组成的符合对象.

所以本例一共有4个类,一个接口.Graphics 接口,line类,rectangle类,circle类,Picture类.根据两个UML注意区别安全方式和透明方式的实现细节.

1)安全方式

=====================================================================================

接口 Graphics

public interface Graphics {
 public void draw();
}

类Line

public class Line  implements Graphics  {
 public void draw()
 {
  System.out.println("画一条直线");
 }

}

类Circle

public class Circle implements Graphics {

 public void draw() {
  System.out.println("画一个圆");
 }
 
}

类Rectangle

public class Rectangle implements Graphics{
 public void draw()
 {
  System.out.println("画一个矩形");
 }
}

类Picture

import java.util.*;

public class Picture implements Graphics {
 private List list=new ArrayList();
 
 public void draw()
 {
  for(int i=0;i<list.size();i++)
  {
   Graphics g=(Graphics)list.get(i);
   g.draw();
  }
 }
 public void add(Graphics g)
 {
  list.add(g);
 }
 public void remove(Graphics g)
 {
  list.remove(g);
 }
 public Graphics getGraphics(int i)
 {
  return (Graphics)list.get(i);
 }
 
}

=========================================================================================

2)透明方式

=====================================================================================

接口 Graphics

 public interface Graphics {
 public void draw();
 public void add(Graphics g);
 public void remove(Graphics g);
 public Graphics getGraphics(int i);
}

类Line

public class Line implements Graphics{

 public void add(Graphics g) { 
 }

 public void draw() {
  System.out.println("画一条直线");
  
 }

 public Graphics getGraphics(int i) {
  return null;
 }

 public void remove(Graphics g) {
 }

}

类Circle

public class Circle implements Graphics{

 public void add(Graphics g) {
 }

 public void draw() {
  System.out.println("画一个圆");
  
 }

 public Graphics getGraphics(int i) {
  return null;
 }

 public void remove(Graphics g) {
 }

}

类Rectangle

public class Rectangle implements Graphics {

 public void add(Graphics g) {
 }

 public void draw() {
  System.out.println("画一个矩形");
  
 }

 public Graphics getGraphics(int i) {
  return null;
 }

 public void remove(Graphics g) {
  
 }

}

类Picture

 public class Picture implements Graphics {
 private List list=new ArrayList();
 
 public void draw()
 {
  for(int i=0;i<list.size();i++)
  {
   Graphics g=(Graphics)list.get(i);
   g.draw();
  }
 }
 public void add(Graphics g)
 {
  list.add(g);
 }
 public void remove(Graphics g)
 {
  list.remove(g);
 }
 public Graphics getGraphics(int i)
 {
  return (Graphics)list.get(i);
 }
 
}

=========================================================================================

在安全方式和透明方式中,不同之处是实现对子类的管理方法:add(),remove(),getGraphics()的位置不同,是在Graphics接口中实现,还是在复合类Picture中实现.

在安全方式中,管理方法在复合类Picture中实现,如果客户端在对Line()等单独的成分对象发送add()等消息时,无法编译通过.

在透明方式中,将管理方法在接口中定义,所有单独成分对象(如:Line()等)由于实现了Graphics接口,必须实现add()等管理方法,即使是方法中不需要任何操作,当客户端在对单独成分对象发送add()等消息时,编译通过,但在程序运行时,则可能会抛出异常.这样做的好处是都有相同的接口,客户端可以同等的对待对象.

适合使用合成模式的条件:

1)需要描述对象的部分和整体的等级结构

2)客户端需要忽略掉整体构件和个体构件的区别

合成模式的优点:

1.可以很容易的增加新种类的构件

2.使用合成模式可以使客户端变得很容易设计,因为客户端不需要知道构件是个体构件还是整体构件

缺点:

1.控制整体构件的类型比较困难

2.用继承方法增加新的行为很困难.

单例模式的写法：

第一种

public class EagerSingle {
 private static final EagerSingle s=new EagerSingle();
 private EagerSingle()
 {
 }
 public static EagerSingle getInstance()
 {
  return s;
 }

}

第二种：
public class LazySingle {
private static LazySingle ls=null;
 private LazySingle()
 {
  }
synchronized static LazySingle getIntance()
{
 if(ls==null)
 {
  ls=new LazySingle();
 }
 return ls;
}
}

两种写法的比较：

第一种在加载时就将自己实例化，资源利用率低，效率和反应速度高。

第二种在首次用到类的时候实例化，效率和反映率相对低，但有效的利用资源。

单例模式的扩展：

 不完全单例模式：构造子为public

 多例模式

在上图中，假设农场现在可以生产水果和蔬菜，从地域上划分，又分为南方和北方。所以产品等级图分为：南方水果，南方蔬菜，北方水果，北方蔬菜；抽象工厂模式与工厂方法模式最大的区别在于：工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。

  有多少个产品等级结构，就会在工厂角色中发现多少个工厂方法。 每个产品等级结构中有多少具体产品，就有多少个产品族，也就会在工厂等级结构中发现多少个具体工厂；例如在上图中，产品等级结构：蔬菜（vegetable）和水果(Fruit），相应的工厂角色中就有public Fruit createFruit()和public Vegetable CreateVegetable()方法。有2个产品族：North和South，对应两个具体工厂，NorthFactory和SouthFactory;
关于抽象模式和开闭原则：

当增加产品等级结构时，即当我们增加一个新产品：花卉时，需要修改工厂角色的工厂方法，这显然是不支持开闭原则的；

当增加产品族时，即添加了新的产品角色，这时，只需添加新的工厂角色就可以了，符合开闭原则；

工厂模式的变通：工厂的工厂

可以把简单工厂模式应用到抽象工厂中，抽象工厂类可以配备静态方法，根据需要返回相应的工厂角色。返回值应该是抽象工厂类型，这样才能保证多态性。下面是一个按照此方法改进的 抽象工厂模式UML

接口Fruits的代码如下：

public interface Fruits {
 public void grow();
 public void harvest();
 public void plant();
 
}

类Apple的源代码

public class Apple implements Fruits {

 /*
  * 苹果的特有属性。苹果数的树龄
  */
 private int treeage;
 public int getTreeage() {
  return treeage;
 }

 public void setTreeage(int treeage) {
  this.treeage = treeage;
 }

 public void grow() {
  System.out.println("苹果的生长方法");

 }

 public void harvest() {
  System.out.println("苹果的收获方法");

 }

 public void plant() {
  System.out.println("苹果的种植方法");

 }

}

类Grape的源代码

public class Grape implements Fruits {

 /*
  * 葡萄的特有属性：有籽和无籽
  */
 private boolean seedless;
 public boolean isSeedless() {
  return seedless;
 }

 public void setSeedless(boolean seedless) {
  this.seedless = seedless;
 }

 public void grow() {
 System.out.println("葡萄的生长方法");

 }

 public void harvest() {
  System.out.println("葡萄的收获方法"); 

 }

 public void plant() {
  System.out.println("葡萄的种植方法");

 }

}

StrawBerry的源代码

public class StrawBerry implements Fruits {

 public void grow() {
  System.out.println("草莓的生长方法");
 }

 public void harvest() {
  System.out.println("草莓的收获方法");

 }

 public void plant() {
  System.out.println("草莓的种植方法");
 }

}
水果工厂的原代码

public class FruitsGrower {
 public static Fruits fruitFactory(String fruitType) throws BadFruitException
 {
  if(fruitType.equalsIgnoreCase("grape"))
  {
   return new Grape();
  }
  else if(fruitType.equalsIgnoreCase("apple"))
  {
   return new Apple();
  }
  else if(fruitType.equalsIgnoreCase("strawberry"))
  {
  return new StrawBerry(); 
  }
  else
  {
   throw new BadFruitException("这个水果工厂不能生产类型为"+fruitType+"的水果");
  }
 }
}

如果请求的类型错误，抛出BadFruitException异常

public class BadFruitException extends Exception {
 /**
  *
  */
 private static final long serialVersionUID = 4036317488144249503L;

 public BadFruitException(String msg) {
  super(msg);
 }
}

工厂方法的使用

 public static void main(String args[])
 {
  try {
   FruitsGrower.fruitFactory("grape");
  } catch (BadFruitException e) {
   // TODO 自动生成 catch 块
   e.printStackTrace();
  }
 }

====================================================================

以上代码演示了一个完整的简单工厂模式（SimpleFactory）,在实际应用中，可以省略产品的抽象,即Fruits接口，直接产生产品；也可以将工厂与抽象产品合并，即抽象产品也是也是生产子类的工厂；也可以将3个角色全部合并。

1。简单工厂模式的优点：

       模式的核心是工厂类，这个类含有必要的判断逻辑，可以决定在什么时候创建哪个产品的实例。而客户端可以免除直接创建产品对象的责任，而仅仅负责“消费”产品。实现了责任分隔。

2。缺点：

       上面的例子中，果农类无疑是整个模式的核心类，当他不能工作了，整个工厂就随之瘫痪。

        可扩展性：当需要添加新的产品时，就必须更改果农类的代码，增加必要的 判断逻辑。

        由于果农类使用了静态方法为工厂方法，而静态方法无法由子类继承，因此工厂角色无法形成基于继承的等级结构。

================================================================

简单工厂模式作为一个最基本的设计模式，在JDK的API中得到了很好的应用。、

DateFormat 类：

    一个日期和时间的格式化类， 查看代码可以发现：DateFormat类是一个抽象类，但DateFormat.getDateInstance()为什么又会得到一个实例呢？原来DateFormat.getDateInstance()并没有调用DateFormat()来构造自己的实例，而是使用了静态方法，经过逻辑判断生成了SimpleDateFormat实例。SimpleDateFormat则是DateFormat的一个子类。

下面是DateFormat的示意图：

继续水果为例：首先UML图如下：

源代码：

接口：FruitFactory

public interface FruitFactory {
 public Fruits factory();
}

接口：Fruits

public interface Fruits {
 public void grow();
 public void plant();
 public void harvest();
 
}

类：AppleFactory

public class AppleFactory implements FruitFactory {

 public Fruits factory() {
  
  return new Apple();
 }

}

类：GrapeFactory

public class GrapeFactory implements FruitFactory {

 public Fruits factory() {
  // TODO 自动生成方法存根
  return new Grape();
 }

}

类：Apple

public class Apple implements Fruits {

 /*
  * 苹果的特有属性。苹果数的树龄
  */
 private int treeage;
 public int getTreeage() {
  return treeage;
 }

 public void setTreeage(int treeage) {
  this.treeage = treeage;
 }

 public void grow() {
  System.out.println("苹果的生长方法");

 }

 public void harvest() {
  System.out.println("苹果的收获方法");

 }

 public void plant() {
  System.out.println("苹果的种植方法");

 }

}

类：Grape

public class Grape implements Fruits {

 public boolean seedless;
 public void grow() {
  System.out.println("葡萄的生长");

 }

 public void harvest() {
  System.out.println("葡萄的收获");

 }

 public void plant() {
  System.out.println("葡萄的种植");

 }

 public boolean isSeedless() {
  return seedless;
 }

 public void setSeedless(boolean seedless) {
  this.seedless = seedless;
 }

}

测试方法：Test.java

public static void main(String args[])
 {
  FruitFactory create; //声明工厂
  Fruits product; //声明产品
  create=new AppleFactory();
   product=create.factory();
    product.grow(); //调用产品的方法
 } 

 工厂方法返回的应该是抽象类型，而不是具体类型，只有这样，才能保证多态性。当需要一个新产品时，只要创建一个产品类，一个工厂类，并实现相应的接口就OK。

工厂方法模式在jDK API中的 应用：

 工厂方法模式在JDK中的应用到处可见，例如：Collection