设计模式

创建型模式【工厂方法(FactoryMethod )、 抽象工厂(AbstractFactory )、 建造者模式(Builder)、 单态模式(Singleton)、 原型模式(Prototype)】

结构型模式【适配器模式(adapter)、 桥接模式(bridging)、组合模式(Composite)、 装饰模式、 外观模式、 享元模式、代理模式】

行为型模式【 责任链模式、 命令模式(Command)、 解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、 状态模式、策略模式、模板方法、访问者模式(Visitor) 】

1、工厂方法(FactoryMethod )

使用场合：当一个类不知道它所必须创建对象的类或一个类希望由子类来指定它所创建的对象时，可以使用工厂方法。

public interface Work {
 void doWork();
}

public interface IWorkFactory{
 Work getWork();
}

public class StudentWork implements Work {

 @Override
 public void doWork() {
  System.out.println("学生写作业");
 }}

public class StudentWorkFactory implements IWorkFactory { @Override
 public Work getWork() {
  return new StudentWork();
 }}

public class TeacherWork implements Work { @Override
 public void doWork() {
  System.out.println("老师审批作业");
 }}

public class TeacherWorkFactory implements IWorkFactory { @Override
 public Work getWork() {
  return new TeacherWork();
 }

public class Test { /**
  * @param args
  */
 public static void main(String[] args) {
  IWorkFactory studentWorkFactory = new StudentWorkFactory();
  studentWorkFactory.getWork().doWork();  IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
  teacherWorkFactory.getWork().doWork(); }}

2、抽象工厂(AbstractFactory )

适用范围：

1.一个系统要独立于它的产品的创建、组合和表示时

2.一个系统要由多个产品系列中的一个来配置时.

3.当你要强调一系列相关的产品对象的设计以便进行联合使用时.

4.当你提供一个产品类库，而只想显示它们的接口而不是实现时

public abstract interface AbstractFactory {
 
 public abstract Television getTelevisionProduct();

 public abstract Airconditioning getAirconditioningProduct();
 
}

public abstract interface Television {
 void product();
}

public abstract interface Airconditioning {
 void product();
}

public class HairFactory implements AbstractFactory {

 @Override
 public Television getTelevisionProduct() {
  return new HairTelevision();
 }

 @Override
 public Airconditioning getAirconditioningProduct() {
  return new HairAirconditioning();
 }

}

public class HairTelevision implements Television {

 @Override
 public void product() {
  System.out.println("生产海尔电视机");
 }

}

public class HairAirconditioning implements Airconditioning {

 @Override
 public void product() {
  System.out.println("生产海尔空调");
 }

}

public class TclFactory implements AbstractFactory {

 @Override
 public Television getTelevisionProduct() {
  return new TclTelevision();
 }

 @Override
 public Airconditioning getAirconditioningProduct() {
  return new TclAirconditioning();
 }

}

public class TclTelevision implements Television {

 @Override
 public void product() {
  System.out.println("生产TCL电视机");
 }

}

public class TclAirconditioning implements Airconditioning {

 @Override
 public void product() {
  System.out.println("生产TCL空调");
 }

}

public class Test {

 /**
  * @param args
  */
 public static void main(String[] args) {
  AbstractFactory hairFactory = new HairFactory();
  hairFactory.getTelevisionProduct().product();
  hairFactory.getAirconditioningProduct().product();
  AbstractFactory tclFactory = new TclFactory();
  tclFactory.getTelevisionProduct().product();
  tclFactory.getAirconditioningProduct().product();
 }

}

 3、建造者模式(Builder)(这个模式有不太明白，过两天再想)

使用场景：

1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

2、当构造过程必须允许被构造的对象有不同的表示时。

4、单态模式(Singleton)

使用场景：

1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时

2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

/* 线程安全  并且效率高  能有多个线程访问*/
public class Singleton {
 private static Singleton instance;

 private Singleton() {
 }

 public static Singleton getInstance() {
  if (instance == null) {
   synchronized (Singleton.class) {
    if (instance == null) {
     instance = new Singleton();
    }
   }
  }
  return instance;
 }

}

/*
 线程安全 但效率比较低  一开始就要加载类new一个 对象
 这是饿汉方式的单例模式
 */
public class Singleton1 {
 private Singleton1() {
 }

 private static final Singleton1 instance = new Singleton1();

 public static Singleton1 getInstancei() {
  return instance;
 }

}

//饱汉方式的单例模式 但是有多个线程访问时就不是安全的 返回的不是同一个对象
public class Singleton2 {
 private Singleton2() {
 }

 private static Singleton2 instance;

 public static Singleton2 getInstance() {
  if (instance == null)
   instance = new Singleton2();
  return instance;
 }

}

//虽然是安全的 但是效率非常低在一个时候只有一个线程能访问  同时返回一个对象
public class Singleton3 {
 private Singleton3() {
 }

 private static Singleton3 instance;

 public static synchronized Singleton3 getInstance() {
  if (instance == null)
   instance = new Singleton3();
  return instance;
 }

}

public class Test {
 public static void main(String[] args) {
  Singleton singleton1 = Singleton.getInstance();
  Singleton singleton2 = Singleton.getInstance();

  System.out.println(singleton1);
  System.out.println(singleton2);

 }

}

5、 原型模式(Prototype)

用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.

Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

public abstract class Prototype implements Cloneable {
 private String name;
 public void setName(String name) {
  this.name = name;
 }
 public String getName() {
  return this.name;
 }
 public Object clone() {
  try {
   return super.clone();
  } catch (Exception e) {
   e.printStackTrace();
   return null;
  }
 }
}

public class ConcretePrototype extends Prototype {
 public ConcretePrototype(String name) {
  setName(name);
 }
}

public class Test {
 public static void main(String[] args) {
  Prototype pro = new ConcretePrototype("prototype");
  Prototype pro2 = (Prototype) pro.clone();
  System.out.println(pro.getName());
  System.out.println(pro2.getName());
 }
}

6、适配器模式(Adapter )

共有两类适配器模式： 对象适配器模式

　　-- 在这种适配器模式中，适配器容纳一个它我包裹的类的实例。在这种情况下，适配器调用被包裹对象的物理实体。

类适配器模式

　　-- 这种适配器模式下，适配器继承自已实现的类（一般多重继承）。

 

public interface Target {
 void adapteeMethod();   
    void adapterMethod();
}

 

public class Adapter implements Target {
 private Adaptee adaptee;

 public Adapter(Adaptee adaptee) {
  this.adaptee = adaptee;
 }

 public void adapteeMethod() {
  adaptee.adapteeMethod();
 }

 @Override
 public void adapterMethod() {
  System.out.println("Adapter method!");
 }

}

public class Adaptee {
 public void adapteeMethod() {
  System.out.println("Adaptee method!");
 }
}

public class Test {
 public static void main(String[] args) {
  Target target = new Adapter(new Adaptee());
  target.adapteeMethod();
  target.adapterMethod();
 }
}

 7、桥接模式(bridging)