一,单列模式

这种模式属于创建型模式。在该模式下只能创建单个的实列，创建的实列是该类的实列，这个类提供了唯一的访问对象的方式，不需要去实列化对象。

注意点：

  1. 只能创建一个实列
  2. 单列类创建的实列必须是由自己完成
  3. 单列类必须给所有对象提供单列实列

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。

1.懒汉式单列模式

  1. package singleMode;
  3. /**
  4.  * 懒汉式单列模式
  5.  */
  6. public class LazySingleMode {
  7.     //定义一个静态属性，但是类不加载它
  8.     private static LazySingleMode lsm=null;
  9.     //构造器私有化
  10.     private LazySingleMode(){
  11.         //加这段代码防止反射破解单列
  12.         if(lsm!=null){
  13.             throw new RuntimeException();
  14.         }
  16.     }
  17.     //得到实例的方法需要同步
  18.     public static synchronized LazySingleMode getInstance(){
  19.         if(lsm==null){
  20.             lsm=new LazySingleMode();
  21.         }
  22.         return lsm;
  23.     }
  24. }

2.饿汉式单列模式

  1. package singleMode;
  3. /**
  4.  * 饿汉单列模式
  5.  */
  6. public class HungrySingleMode {
  7.     //设置静态属性
  8.     private static HungrySingleMode hsm=new HungrySingleMode();
  9.     //把构造器私有化
  10.     private HungrySingleMode(){
  12.     }
  13.     public static HungrySingleMode getInstance(){
  14.         return hsm;
  15.     }
  16. }

3.双重检测单列模式

  1. package singleMode;
  3. /**
  4.  * 双重检测锁单列模式
  5.  */
  6. public class DoubleDetectionLockSingleMode {
  7.     private static volatile DoubleDetectionLockSingleMode ddlsm=null;
  9.     private DoubleDetectionLockSingleMode(){
  10.     }
  12.     public static DoubleDetectionLockSingleMode getInstance(){
  13.         if(ddlsm==null){
  14.             synchronized (DoubleDetectionLockSingleMode.class){
  15.               if(ddlsm==null){
  16.                   ddlsm=new DoubleDetectionLockSingleMode();
  17.               }
  18.             }
  19.         }
  20.         return  ddlsm;
  21.     }
  23. }

4.静态内部类

  1. package singleMode;
  3. public class StaticInternalClass {
  4.     private static class Intertance{
  5.         private static final StaticInternalClass sic=new StaticInternalClass();
  6.     }
  7.     public static StaticInternalClass getInstance(){
  9.         return Intertance.sic;
  10.     }
  11.     private StaticInternalClass(){
  13.     }
  15. }

5.枚举单列模式

  1. package singleMode;
  3. public enum  EnumSingleton {
  4.     //定义一个枚举元素，它就代表一个singleton实例
  5.     INSTANCE;
  6.     //单列可以有自己的操作
  7.     public void singletonOperation(){
  8.         //操作
  9.     }
  10. }

二,工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不同条件下创建不同实例时。
如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
关键代码：创建过程在其子类执行。
应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。
注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

简单工厂

  1. package factoryMode.simpleFactory;
  3. public interface Car {
  4.     public void run();
  5. }
  8. package factoryMode.simpleFactory;
  10. public class Byd implements Car {
  11.     @Override
  12.     public void run() {
  13.         System.out.println("比亚迪在奔跑");
  14.     }
  15. }
  17. package factoryMode.simpleFactory;
  19. public class Audi implements Car {
  20.     @Override
  21.     public void run() {
  22.         System.out.println("奥迪在奔跑");
  23.     }
  24. }
  27. ackage factoryMode.simpleFactory;
  29. public class CarFactory {
  30.     //private static Car car;
  31.     public static Car MakeCar(String type) {
  32.         if ("奥迪".equals(type)) {
  33.             return new Audi();
  34.         } else if ("比亚迪".equals(type)) {
  35.             return new Byd();
  36.         } else {
  37.             System.out.println("请输入正确的选择");
  38.             return null;
  39.         }
  40.     }
  41. }
  44. package factoryMode.simpleFactory.test;
  46. import factoryMode.simpleFactory.Car;
  47. import factoryMode.simpleFactory.CarFactory;
  49. public class TestSimpleFactory {
  50.     public static void main(String[] args) {
  51.         Car c1= CarFactory.MakeCar("奥迪");
  52.         Car c2= CarFactory.MakeCar("比亚迪");
  53.         c1.run();
  54.         c2.run();
  55.     }
  57. }

工厂方法

  1. package factoryMode.FactoryMethod;
  3. public interface Car {
  4.     public void run();
  5. }
  8. package factoryMode.FactoryMethod;
  10. public interface CarFactory {
  11.     Car carFactory();
  12. }
  14. package factoryMode.FactoryMethod;
  16. public class BydFactory implements CarFactory {
  17.     @Override
  18.     public Car carFactory() {
  19.         return new Byd();
  20.     }
  21. }
  23. package factoryMode.FactoryMethod;
  25. public class AudiFactory implements CarFactory {
  26.     @Override
  27.     public Car carFactory() {
  28.         return new Audi();
  29.     }
  30. }
  32. package factoryMode.FactoryMethod;
  34. public class Audi implements Car {
  35.     public void run() {
  36.         System.out.println("奥迪在奔跑");
  37.     }
  38. }
  40. package factoryMode.FactoryMethod.test;
  42. import factoryMode.FactoryMethod.AudiFactory;
  43. import factoryMode.FactoryMethod.BydFactory;
  44. import factoryMode.FactoryMethod.Car;
  46. public class TestManyFactoryMethod {
  47.     public static void main(String[] args) {
  48.         Car c1= new BydFactory().carFactory();
  49.         Car c2=new AudiFactory().carFactory();
  50.         c1.run();
  51.         c2.run();
  53.     }
  54. }

三,抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

介绍

意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
主要解决：主要解决接口选择的问题。
何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
如何解决：在一个产品族里面，定义多个产品。
关键代码：在一个工厂里聚合多个同类产品。
应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。
优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。
注意事项：产品族难扩展，产品等级易扩展。

  1. package factoryMode.abstractFactory;
  3. public interface CarFactory {
  4.    Engine makeEgine();
  5.    Seat makeSeat();
  6.    Tyre makeTyre();
  7. }
  9. package factoryMode.abstractFactory;
  11. public interface Engine {
  12.     void run();
  13.     void start();
  14. }
  16. package factoryMode.abstractFactory;
  18. public interface Seat {
  19.     void makeSeat();
  20. }
  22. package factoryMode.abstractFactory;
  24. public interface Tyre {
  25.     void makeType();
  26. }
  27. package factoryMode.abstractFactory;
  29. package factoryMode.abstractFactory;
  31. public class LowCarFactory implements CarFactory {
  32.     @Override
  33.     public Engine makeEgine() {
  34.         return new LowEngine();
  35.     }
  37.     @Override
  38.     public Seat makeSeat() {
  39.         return new LowSeat();
  40.     }
  42.     @Override
  43.     public Tyre makeTyre() {
  44.         return new LowTyre();
  45.     }
  46. }
  48. package factoryMode.abstractFactory;
  50. public class LowEngine implements Engine {
  51.     @Override
  52.     public void run() {
  53.         System.out.println("汽车跑得慢");
  54.     }
  56.     @Override
  57.     public void start() {
  58.         System.out.println("汽车不能自动启动停止");
  59.     }
  60. }
  62. package factoryMode.abstractFactory;
  64. public class LowSeat implements Seat {
  65.     @Override
  66.     public void makeSeat() {
  67.         System.out.println("不能按摩");
  68.     }
  69. }
  71. package factoryMode.abstractFactory;
  73. public class LowTyre implements Tyre {
  74.     @Override
  75.     public void makeType() {
  76.         System.out.println("不能自动充气");
  77.     }
  78. }
  80. package factoryMode.abstractFactory;
  82. public class HighEngine implements Engine {
  83.     @Override
  84.     public void run() {
  85.         System.out.println("汽车跑得快");
  86.     }
  88.     @Override
  89.     public void start() {
  90.         System.out.println("汽车自动启动停止");
  91.     }
  92. }
  94. package factoryMode.abstractFactory;
  96. public class HighSeat implements Seat {
  97.     @Override
  98.     public void makeSeat() {
  99.         System.out.println("能按摩");
  100.     }
  101. }
  103. package factoryMode.abstractFactory;
  106. public class HighTyre implements Tyre {
  107.     @Override
  108.     public void makeType() {
  109.         System.out.println("能自动充气");
  110.     }
  111. }
  113. package factoryMode.abstractFactory;
  115. public class HignCarFactory implements  CarFactory{
  116.     @Override
  117.     public Engine makeEgine() {
  118.         return new HighEngine();
  119.     }
  121.     @Override
  122.     public Seat makeSeat() {
  123.         return new HighSeat();
  124.     }
  126.     @Override
  127.     public Tyre makeTyre() {
  128.         return new HighTyre();
  129.     }
  130. }
  133. package factoryMode.abstractFactory.test;
  135. import factoryMode.abstractFactory.Engine;
  136. import factoryMode.abstractFactory.HignCarFactory;
  138. public class TestAbstractFactory {
  139.     public static void main(String[] args) {
  140.         HignCarFactory factory=new HignCarFactory();
  141.         Engine engine=factory.makeEgine();
  142.         engine.run();
  143.         engine.start();
  144.     }
  145. }

四,建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决：主要解决在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
何时使用：一些基本部件不会变，而其组合经常变化的时候。
如何解决：将变与不变分离开。
关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的”套餐”。 2、JAVA 中的 StringBuilder。
优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

  1. package builderMode;
  3. public interface PhoneBuilder {
  4.     CPU buildCpu();
  5.     Screen screenBuild();
  6.     Battery buildBattery();
  7. }
  9. package builderMode;
  11. public interface PhoneDirector {
  12.     Phone directPhone();
  13. }
  15. ackage builderMode;
  17. public class Screen {//屏幕
  18.     private String screen;
  20.     public Screen(String screen) {
  21.         this.screen = screen;
  22.     }
  24.     public String getScreen() {
  25.         return screen;
  26.     }
  28.     public void setScreen(String screen) {
  29.         this.screen = screen;
  30.     }
  31. }
  33. package builderMode;
  35. public class Battery {//电池
  36.     private String Battery;
  38.     public String getBattery() {
  39.         return Battery;
  40.     }
  42.     public void setBattery(String battery) {
  43.         Battery = battery;
  44.     }
  46.     public Battery(String battery) {
  47.         Battery = battery;
  48.     }
  49. }
  51. package builderMode;
  53. public class CPU {
  54.     private String cpu;
  56.     public String getCpu() {
  57.         return cpu;
  58.     }
  60.     public void setCpu(String cpu) {
  61.         this.cpu = cpu;
  62.     }
  64.     public CPU(String cpu) {
  65.         this.cpu = cpu;
  66.     }
  67. }
  69. package builderMode;
  71. public class Phone {
  72.     private CPU cpu;
  73.     private Screen screen;
  74.     private Battery battery;
  76.     public Phone(CPU cpu, Screen screen, Battery battery) {
  77.         this.cpu = cpu;
  78.         this.screen = screen;
  79.         this.battery = battery;
  80.     }
  82.     public Phone() {
  83.     }
  85.     public CPU getCpu() {
  86.         return cpu;
  87.     }
  89.     public void setCpu(CPU cpu) {
  90.         this.cpu = cpu;
  91.     }
  93.     public Screen getScreen() {
  94.         return screen;
  95.     }
  97.     public void setScreen(Screen screen) {
  98.         this.screen = screen;
  99.     }
  101.     public Battery getBattery() {
  102.         return battery;
  103.     }
  105.     public void setBattery(Battery battery) {
  106.         this.battery = battery;
  107.     }
  108. }
  110. package builderMode;
  112. public class VivoPhoneBuilder implements PhoneBuilder {
  113.     @Override
  114.     public CPU buildCpu() {
  115.         System.out.println("构建处理器");
  116.         return new CPU("晓龙865");
  117.     }
  119.     @Override
  120.     public Screen screenBuild() {
  121.         System.out.println("构建屏幕");
  122.         return new Screen("AMOLED");
  123.     }
  125.     @Override
  126.     public Battery buildBattery() {
  127.         System.out.println("构建锂电池");
  128.         return new Battery("锂电池");
  129.     }
  130. }
  132. public class VivoPhoneDirector implements PhoneDirector{
  134.     private PhoneBuilder builder;
  136.     public VivoPhoneDirector(PhoneBuilder builder) {
  137.         this.builder = builder;
  138.     }
  140.     @Override
  141.     public Phone directPhone() {
  142.         CPU cpu = builder.buildCpu();
  143.         Battery battery = builder.buildBattery();
  144.         Screen screen = builder.screenBuild();
  145.         Phone phone=new Phone(cpu,screen,battery);
  146.         return phone;
  147.     }
  148. }
  150. ppackage builderMode.test;
  152. import builderMode.Phone;
  153. import builderMode.VivoPhoneBuilder;
  154. import builderMode.VivoPhoneDirector;
  156. public class TestBuilderMode {
  157.     public static void main(String[] args) {
  158.         VivoPhoneDirector vivoPhoneDirector=new VivoPhoneDirector(new VivoPhoneBuilder());
  159.         Phone phone = vivoPhoneDirector.directPhone();
  160.         System.out.println(phone.getCpu());
  161.         System.out.println(phone.getBattery());
  162.         System.out.println(phone.getScreen().getScreen());
  163.     }
  164. }

五,原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

介绍

意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
主要解决：在运行期建立和删除原型。
何时使用： 1、当一个系统应该独立于它的产品创建，构成和表示时。 2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。 3、为了避免创建一个与产品类层次平行的工厂类层次时。 4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。
如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。
关键代码： 1、实现克隆操作，在 JAVA 继承 Cloneable，重写 clone()，在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。 2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些”易变类”拥有稳定的接口。
应用实例： 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。
优点： 1、性能提高。 2、逃避构造函数的约束。
缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。
使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

  1. package prototype;
  3. import java.util.Date;
  5. public class Sheep2 implements Cloneable {
  6.     private String sName;
  7.     private Date birthday;
  9.     @Override
  10.     public Object clone() throws CloneNotSupportedException {
  11.         Object obj =super.clone();
  12.         //加以下代码实现深复制
  13.         Sheep2 s2=(Sheep2)obj;
  14.         s2.birthday=(Date) this.birthday.clone();//把属性也克隆
  15.         return obj;
  16.     }
  18.     public Sheep2() {
  19.     }
  21.     public Sheep2(String sName, Date birthday) {
  22.         this.sName = sName;
  23.         this.birthday = birthday;
  24.     }
  26.     public String getsName() {
  27.         return sName;
  28.     }
  30.     public void setsName(String sName) {
  31.         this.sName = sName;
  32.     }
  34.     public Date getBirthday() {
  35.         return birthday;
  36.     }
  38.     public void setBirthday(Date birthday) {
  39.         this.birthday = birthday;
  40.     }
  41. }
  44. package prototype.test;
  45. /**
  46.  * 实现深复制
  47.  */
  48.  import prototype.Sheep2;
  50. import java.util.Date;
  52. public class Client2 {
  53.     public static void main(String[] args) throws Exception{
  54.         Date date=new Date(151515151515L);
  55.         Sheep2 s2=new Sheep2("少利",date);
  56.         Sheep2 s3 = (Sheep2)s2.clone();
  57.         s3.setsName("多利");
  58.         date.setTime(252525252525L);
  59.         System.out.println(s2.getsName());
  60.         System.out.println(s2.getBirthday());
  61.         System.out.println(s3.getsName());
  62.         System.out.println(s3.getBirthday());
  63.     }
  64. }

序列化和反序列进行克隆

  1. package prototype;
  3. import java.io.Serializable;
  4. import java.util.Date;
  6. public class Sheep3 implements Cloneable, Serializable {
  7.     private String sName;
  8.     private Date birthday;
  10.     @Override
  11.     public Object clone() throws CloneNotSupportedException {
  12.         Object obj =super.clone();
  13.         return obj;
  14.     }
  16.     public Sheep3() {
  17.     }
  19.     public Sheep3(String sName, Date birthday) {
  20.         this.sName = sName;
  21.         this.birthday = birthday;
  22.     }
  24.     public String getsName() {
  25.         return sName;
  26.     }
  28.     public void setsName(String sName) {
  29.         this.sName = sName;
  30.     }
  32.     public Date getBirthday() {
  33.         return birthday;
  34.     }
  36.     public void setBirthday(Date birthday) {
  37.         this.birthday = birthday;
  38.     }
  39. }
  41. package prototype.test;
  43. import prototype.Sheep3;
  45. import java.io.ByteArrayInputStream;
  46. import java.io.ByteArrayOutputStream;
  47. import java.io.ObjectInputStream;
  48. import java.io.ObjectOutputStream;
  49. import java.util.Date;
  51. /**
  52.  * 序列化和反序列化实现深克隆
  53.  */
  54. public class Client4 {
  55.     public static void main(String[] args) throws Exception{
  56.         Date date=new Date(151515151515L);
  58.         Sheep3 s3=new Sheep3("少利",date);
  59.         //序列化
  60.         ByteArrayOutputStream bos=new ByteArrayOutputStream();
  61.         ObjectOutputStream oos=new ObjectOutputStream(bos);
  62.         oos.writeObject(s3);
  63.         byte[] bytes=bos.toByteArray();
  64.         //反序列化
  65.         ByteArrayInputStream bais=new ByteArrayInputStream(bytes);
  66.         ObjectInputStream ois=new ObjectInputStream(bais);
  67.         Sheep3 s33= (Sheep3) ois.readObject();
  68.         s33.setsName("多利");
  69.         date.setTime(252525252525L);
  70.         System.out.println(s3.getsName());
  71.         System.out.println(s3.getBirthday());
  72.         System.out.println(s33.getsName());
  73.         System.out.println(s33.getBirthday());
  77.     }
  78. }

六,适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。
这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。
我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。

介绍

意图：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
主要解决：主要解决在软件系统中，常常要将一些”现存的对象”放到新的环境中，而新环境要求的接口是现对象不能满足的。
何时使用： 1、系统需要使用现有的类，而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。 3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）
如何解决：继承或依赖（推荐）。
关键代码：适配器继承或依赖已有的对象，实现想要的目标接口。
应用实例： 1、美国电器 110V，中国 220V，就要有一个适配器将 110V 转化为 220V。 2、JAVA JDK 1.1 提供了 Enumeration 接口，而在 1.2 中提供了 Iterator 接口，想要使用 1.2 的 JDK，则要将以前系统的 Enumeration 接口转化为 Iterator 接口，这时就需要适配器模式。 3、在 LINUX 上运行 WINDOWS 程序。 4、JAVA 中的 jdbc。
优点： 1、可以让任何两个没有关联的类一起运行。 2、提高了类的复用。 3、增加了类的透明度。 4、灵活性好。
缺点： 1、过多地使用适配器，会让系统非常零乱，不易整体进行把握。比如，明明看到调用的是 A 接口，其实内部被适配成了 B 接口的实现，一个系统如果太多出现这种情况，无异于一场灾难。因此如果不是很有必要，可以不使用适配器，而是直接对系统进行重构。 2.由于 JAVA 至多继承一个类，所以至多只能适配一个适配者类，而且目标类必须是抽象类。
使用场景：有动机地修改一个正常运行的系统的接口，这时应该考虑使用适配器模式。
注意事项：适配器不是在详细设计时添加的，而是解决正在服役的项目的问题。

  1. package adapter;
  3. public interface Target {
  4.     public void HandelReq();
  5. }
  7. package adapter;
  9. public class KeyBoard {
  10.     public void request(){
  11.         System.out.println("能完成电脑所需要的功能");
  12.     }
  13. }
  15. package adapter;
  17. public class Computer {
  18.     public void test(Target t){
  19.         t.HandelReq();
  20.     }
  21.     public static void main(String[] args) {
  22.        Computer computer=new Computer();
  23.        Adapter a=new Adapter(new KeyBoard());
  24.        computer.test(a);
  25.     }
  26. }
  28. package adapter;
  30. public class Adapter implements Target {
  31.     private KeyBoard keyBoard;
  33.     public Adapter(KeyBoard keyBoard) {
  34.         this.keyBoard = keyBoard;
  35.     }
  36.     @Override
  37.     public void HandelReq() {
  38.         keyBoard.request();
  39.     }
  40. }

七,桥接模式

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。
这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。
我们通过下面的实例来演示桥接模式（Bridge Pattern）的用法。其中，可以使用相同的抽象类方法但是不同的桥接实现类，来画出不同颜色的圆。

介绍

意图：将抽象部分与实现部分分离，使它们都可以独立的变化。
主要解决：在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活。
何时使用：实现系统可能有多个角度分类，每一种角度都可能变化。
如何解决：把这种多角度分类分离出来，让它们独立变化，减少它们之间耦合。
关键代码：抽象类依赖实现类。
应用实例： 1、猪八戒从天蓬元帅转世投胎到猪，转世投胎的机制将尘世划分为两个等级，即：灵魂和肉体，前者相当于抽象化，后者相当于实现化。生灵通过功能的委派，调用肉体对象的功能，使得生灵可以动态地选择。 2、墙上的开关，可以看到的开关是抽象的，不用管里面具体怎么实现的。
优点： 1、抽象和实现的分离。 2、优秀的扩展能力。 3、实现细节对客户透明。
缺点：桥接模式的引入会增加系统的理解与设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设计与编程。
使用场景： 1、如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的继承联系，通过桥接模式可以使它们在抽象层建立一个关联关系。 2、对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用。 3、一个类存在两个独立变化的维度，且这两个维度都需要进行扩展。
注意事项：对于两个独立变化的维度，使用桥接模式再适合不过了。

  1. public interface DrawAPI {
  2.    public void drawCircle(int radius, int x, int y);
  3. }
  5. public class RedCircle implements DrawAPI {
  6.    @Override
  7.    public void drawCircle(int radius, int x, int y) {
  8.       System.out.println("Drawing Circle[ color: red, radius: "
  9.          + radius +", x: " +x+", "+ y +"]");
  10.    }
  11. }
  13. public class GreenCircle implements DrawAPI {
  14.    @Override
  15.    public void drawCircle(int radius, int x, int y) {
  16.       System.out.println("Drawing Circle[ color: green, radius: "
  17.          + radius +", x: " +x+", "+ y +"]");
  18.    }
  19. }
  21. public abstract class Shape {
  22.    protected DrawAPI drawAPI;
  23.    protected Shape(DrawAPI drawAPI){
  24.       this.drawAPI = drawAPI;
  25.    }
  26.    public abstract void draw();  
  27. }
  29. public class Circle extends Shape {
  30.    private int x, y, radius;
  32.    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
  33.       super(drawAPI);
  34.       this.x = x;  
  35.       this.y = y;  
  36.       this.radius = radius;
  37.    }
  39.    public void draw() {
  40.       drawAPI.drawCircle(radius,x,y);
  41.    }
  42. }
  44. public class BridgePatternDemo {
  45.    public static void main(String[] args) {
  46.       Shape redCircle = new Circle(100,100, 10, new RedCircle());
  47.       Shape greenCircle = new Circle(100,100, 10, new GreenCircle());
  49.       redCircle.draw();
  50.       greenCircle.draw();
  51.    }
  52. }

八,过滤器模式

过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。

  1. package criteriaPattern;
  2. import java.util.List;
  3. public interface Criteria {
  4.     public List<Person> meetCriteria(List<Person> persons);
  6. }
  8. package criteriaPattern;
  10. import java.util.ArrayList;
  11. import java.util.List;
  12. /*
  13. 根据女性进行过滤
  14.  */
  15. public class CriteriaFamale implements Criteria {
  16.     @Override
  17.     public List<Person> meetCriteria(List<Person> persons) {
  18.         List<Person> famaleCriterial =new ArrayList<>();
  19.         for(Person person:persons){
  20.             if(person.getGender().equalsIgnoreCase("Famale")){
  21.                 famaleCriterial.add(person);
  22.             }
  23.         }
  24.         return famaleCriterial;
  25.     }
  26. }
  28. package criteriaPattern;
  29. /*
  30. 和标准
  31.  */
  32. import java.util.ArrayList;
  33. import java.util.List;
  35. public class AndCriteria implements Criteria {
  36.     private Criteria criteria;
  37.     private Criteria otherCriteria;
  39.     public AndCriteria(Criteria criteria, Criteria otherCriteria) {
  40.         this.criteria = criteria;
  41.         this.otherCriteria = otherCriteria;
  42.     }
  44.     @Override
  45.     public List<Person> meetCriteria(List<Person> persons) {
  46.         List<Person> firstCriteriaPerson=criteria.meetCriteria(persons);//先过滤第一标准要求
  47.         List<Person> otherCriteriaPerson=otherCriteria.meetCriteria(firstCriteriaPerson);//过滤第二标准要求
  48.         return otherCriteriaPerson;
  49.     }
  50. }
  52. package criteriaPattern;
  54. import java.util.ArrayList;
  55. import java.util.List;
  57. public class SingleCriteria implements Criteria {
  58.     @Override
  59.     public List<Person> meetCriteria(List<Person> persons) {
  60.         List<Person> singleCriteria=new ArrayList<>();
  61.         for(Person person:persons){
  62.             if(person.getMaritalStatus().equalsIgnoreCase("single")){
  63.                 singleCriteria.add(person);
  64.             }
  65.         }
  66.         return singleCriteria ;
  67.     }
  68. }
  70. package criteriaPattern;
  72. import java.util.ArrayList;
  73. import java.util.List;
  75. public class CriteriaPatternDemo {
  76.     public static void main(String[] args) {
  77.         List<Person> persons=new ArrayList<>();
  78.         persons.add(new Person("小明","male","single"));
  79.         persons.add(new Person("小红","famale","marry"));
  80.         persons.add(new Person("小张","famale","single"));
  81.         persons.add(new Person("小明","male","marry"));
  82.         persons.add(new Person("小天","famale","marry"));
  83.         List<Person> male=new CriteriaMale().meetCriteria(persons);
  84.         Criteria famale=new CriteriaFamale();
  85.         Criteria single=new SingleCriteria();
  86.         List<Person> andCriteria=new AndCriteria(famale,single).meetCriteria(persons);
  87.         printPeron(andCriteria);
  91.     }
  92.     private static void printPeron(List<Person> persons){
  93.         for(Person person:persons){
  94.             System.out.println(person.getName()+" "+person.getGender()+" "+person.getMaritalStatus());
  95.         }
  97.     }
  98. }

九,组合模式

组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。
我们通过下面的实例来演示组合模式的用法。实例演示了一个组织中员工的层次结构。

介绍

意图：将对象组合成树形结构以表示”部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
主要解决：它在我们树型结构的问题中，模糊了简单元素和复杂元素的概念，客户程序可以像处理简单元素一样来处理复杂元素，从而使得客户程序与复杂元素的内部结构解耦。
何时使用： 1、您想表示对象的部分-整体层次结构（树形结构）。 2、您希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。
如何解决：树枝和叶子实现统一接口，树枝内部组合该接口。
关键代码：树枝内部组合该接口，并且含有内部属性 List，里面放 Component。
应用实例： 1、算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作符也可以是操作数、操作符和另一个操作数。 2、在 JAVA AWT 和 SWING 中，对于 Button 和 Checkbox 是树叶，Container 是树枝。
优点： 1、高层模块调用简单。 2、节点自由增加。
缺点：在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。
使用场景：部分、整体场景，如树形菜单，文件、文件夹的管理。
注意事项：定义时为具体类。

  1. package compositePattern;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. public class Employee {
  7.     private String name;
  8.     private String dept;
  9.     private int salary;
  10.     protected List<Employee> nextSubEmployee;
  12.     public Employee(String name, String dept, int salary) {
  13.         this.name = name;
  14.         this.dept = dept;
  15.         this.salary = salary;
  16.         nextSubEmployee=new ArrayList<>();
  17.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  23.     public void setName(String name) {
  24.         this.name = name;
  25.     }
  27.     public String getDept() {
  28.         return dept;
  29.     }
  31.     public void setDept(String dept) {
  32.         this.dept = dept;
  33.     }
  35.     public int getSalary() {
  36.         return salary;
  37.     }
  39.     public void setSalary(int salary) {
  40.         this.salary = salary;
  41.     }
  43.     public List<Employee> getNextSubEmployee() {
  44.         return nextSubEmployee;
  45.     }
  47.     public void setNextSubEmployee(List<Employee> nextSubEmployee) {
  48.         this.nextSubEmployee = nextSubEmployee;
  49.     }
  51.     public void add(Employee employee){
  52.         nextSubEmployee.add(employee);
  53.     }
  55.     @Override
  56.     public String toString() {
  57.         return "Employee{" +
  58.                 "name='" + name + '\'' +
  59.                 ", dept='" + dept + '\'' +
  60.                 ", salary=" + salary +
  61.                 '}';
  62.     }
  63. }
  65. package compositePattern;
  67. import java.util.List;
  69. /*
  70. 组合模式测试
  71.  */
  72. public class CompositePatternDemo {
  73.     public static void main(String[] args) {
  74.         Employee CEO=new Employee("jack","001",30000);
  75.         Employee employee1=new Employee("moli","002",20000);
  76.         Employee employee2=new Employee("yali","003",20000);
  77.         Employee employee3=new Employee("zoli","005",2000);
  78.         Employee employee4=new Employee("uoli","008",2000);
  79.         Employee employee5=new Employee("loli","068",4000);
  80.         Employee employee6=new Employee("toli","004",8000);
  81.         CEO.add(employee1);
  82.         CEO.add(employee2);
  83.         employee1.add(employee3);
  84.         employee1.add(employee4);
  85.         employee2.add(employee5);
  86.         employee2.add(employee6);
  87.         printEmployee(CEO.getNextSubEmployee());
  88.     }
  89.     private static void printEmployee(List<Employee> employees){
  90.         for(Employee employee:employees){
  91.             System.out.println(employee);
  92.             for(Employee temp:employee.getNextSubEmployee()){
  93.                 System.out.println(temp);
  94.             }
  95.         }
  96.     }
  99. }

十,装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。

介绍

意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
何时使用：在不想增加很多子类的情况下扩展类。
如何解决：将具体功能职责划分，同时继承装饰者模式。
关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。
应用实例： 1、孙悟空有 72 变，当他变成”庙宇”后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。
优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
缺点：多层装饰比较复杂。
使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。
注意事项：可代替继承。

  1. package decoratorPattern;
  3. public interface Noodle {
  4.     public void cook();
  5. }
  7. package decoratorPattern;
  9. public class RiceNoodle implements Noodle {
  10.     @Override
  11.     public void cook() {
  12.         System.out.println("RiceNoodle");
  13.     }
  14. }
  16. package decoratorPattern;
  18. public class DecoratorPatternDemo {
  19.     public static void main(String[] args) {
  20.         Noodle noodle=new RiceNoodle();
  21.         BeefNoodleDecorator beefNoodle=new BeefNoodleDecorator(noodle);
  22.         beefNoodle.cook();
  23.     }
  24. }
  26. package decoratorPattern;
  27. abstract class DecorateNoodle implements Noodle  {
  28.     protected Noodle noodle;
  29.     public DecorateNoodle(Noodle noodle){
  30.         this.noodle=noodle;
  31.     }
  32.     public void cook() {
  33.         noodle.cook();
  34.     }
  35. }
  37. package decoratorPattern;
  39. public class BeefNoodleDecorator extends DecorateNoodle {
  40.     public BeefNoodleDecorator(Noodle noodle){
  41.         super(noodle);
  42.     }
  43.     @Override
  44.     public void cook(){
  45.         noodle.cook();
  46.         System.out.println("add beef");
  47.     }
  48. }

十一,外观模式

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。
这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

介绍

意图：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端与之的接口。
何时使用： 1、客户端不需要知道系统内部的复杂联系，整个系统只需提供一个”接待员”即可。 2、定义系统的入口。
如何解决：客户端不与系统耦合，外观类与系统耦合。
关键代码：在客户端和复杂系统之间再加一层，这一层将调用顺序、依赖关系等处理好。
应用实例： 1、去医院看病，可能要去挂号、门诊、划价、取药，让患者或患者家属觉得很复杂，如果有提供接待人员，只让接待人员来处理，就很方便。 2、JAVA 的三层开发模式。
优点： 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。
缺点：不符合开闭原则，如果要改东西很麻烦，继承重写都不合适。
使用场景： 1、为复杂的模块或子系统提供外界访问的模块。 2、子系统相对独立。 3、预防低水平人员带来的风险。
注意事项：在层次化结构中，可以使用外观模式定义系统中每一层的入口。

  1. package facadePattern;
  3. public interface Shape {
  4.     public void draw();
  5. }
  7. package facadePattern;
  9. public class Rectangle implements Shape{
  10.     @Override
  11.     public void draw(){
  12.         System.out.println("Rectangle: draw");
  13.     }
  14. }
  16. package facadePattern;
  18. public class FacedePatternDemo {
  19.     public static void main(String[] args) {
  20.         ShapeMake shapeMake=new ShapeMake();
  21.        shapeMake.drawCircle();
  22.        shapeMake.drawRectangle();
  24.     }
  25. }
  27. package facadePattern;
  29. public class Circle implements Shape {
  30.     @Override
  31.     public void draw(){
  32.         System.out.println("Circle");
  33.     }
  35. }
  37. package facadePattern;
  39. public class ShapeMake {
  40.     private Shape circle;
  41.     private Shape rectangle;
  42.     public ShapeMake(){
  43.         circle=new Circle();
  44.         rectangle=new Rectangle();
  45.     }
  46.     public void drawCircle(){
  47.         circle.draw();
  48.     }
  49.     public void drawRectangle(){
  50.         rectangle.draw();
  51.      }
  52. }

十二,享元模式

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。
享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。我们将通过创建 5 个对象来画出 20 个分布于不同位置的圆来演示这种模式。由于只有 5 种可用的颜色，所以 color 属性被用来检查现有的 Circle 对象。

介绍

意图：运用共享技术有效地支持大量细粒度的对象。
主要解决：在有大量对象时，有可能会造成内存溢出，我们把其中共同的部分抽象出来，如果有相同的业务请求，直接返回在内存中已有的对象，避免重新创建。
何时使用： 1、系统中有大量对象。 2、这些对象消耗大量内存。 3、这些对象的状态大部分可以外部化。 4、这些对象可以按照内蕴状态分为很多组，当把外蕴对象从对象中剔除出来时，每一组对象都可以用一个对象来代替。 5、系统不依赖于这些对象身份，这些对象是不可分辨的。
如何解决：用唯一标识码判断，如果在内存中有，则返回这个唯一标识码所标识的对象。
关键代码：用 HashMap 存储这些对象。
应用实例： 1、JAVA 中的 String，如果有则返回，如果没有则创建一个字符串保存在字符串缓存池里面。 2、数据库的数据池。
优点：大大减少对象的创建，降低系统的内存，使效率提高。
缺点：提高了系统的复杂度，需要分离出外部状态和内部状态，而且外部状态具有固有化的性质，不应该随着内部状态的变化而变化，否则会造成系统的混乱。
使用场景： 1、系统有大量相似对象。 2、需要缓冲池的场景。
注意事项： 1、注意划分外部状态和内部状态，否则可能会引起线程安全问题。 2、这些类必须有一个工厂对象加以控制。

  1. package flyweightPattern;
  3. public interface Shape {
  4.     public void draw();
  5. }
  7. package flyweightPattern;
  9. public class Circle implements Shape {
  10.     private int x;
  11.     private int y;
  12.     private int radius;
  13.     private String color;
  14.     public Circle(String color){
  15.         this.color=color;
  16.     }
  18.     public int getX() {
  19.         return x;
  20.     }
  22.     public void setX(int x) {
  23.         this.x = x;
  24.     }
  26.     public int getY() {
  27.         return y;
  28.     }
  30.     public void setY(int y) {
  31.         this.y = y;
  32.     }
  34.     public int getRadius() {
  35.         return radius;
  36.     }
  38.     public void setRadius(int radius) {
  39.         this.radius = radius;
  40.     }
  42.     @Override
  43.     public void draw() {
  44.         System.out.println("circle："+"x:"+this.x+"y:"+this.y+"radius:"+this.radius);
  45.     }
  46. }
  48. package flyweightPattern;
  50. import java.util.HashMap;
  52. public class ShapeFactory {
  53.     private static final HashMap<String,Shape> hashMap=new HashMap<>();
  54.     public static Shape getCircle(String color){
  55.         Circle circle=(Circle) hashMap.get(color);
  56.         if(circle==null){
  57.             circle=new Circle(color);
  58.             hashMap.put(color,circle);
  59.         }
  60.         return circle;
  61.     }
  63. }
  65. package flyweightPattern;
  67. public class FlyweightPatternDemo {
  68.     public static final String colors[]={"red","green","black","blue","white"};
  69.     public static void main(String[] args) {
  70.         for(int i=0;i<20;i++) {
  71.             Circle circle = (Circle) ShapeFactory.getCircle(getColor());
  72. //            circle.setRadius(100);
  73. //            circle.setX(getRandomX());
  74. //            circle.setY(getRandomY());
  75. //            circle.draw();
  76.             setCircleX(circle);
  77.             setCircleY(circle);
  78.             circle.draw();
  79.         }
  80.     }
  81.     public static String getColor(){
  82.         return colors[(int)(Math.random()*colors.length)];
  83.     }
  84.     public static void setCircleX(Circle circle){
  85.         circle.setX((int)(Math.random()*100));
  86.     }
  87.     public static void setCircleY(Circle circle){
  88.         circle.setY((int)(Math.random()*100));
  89.     }
  90.     public static int getRandomX(){
  91.       return (int)(Math.random()*100);
  92.     }
  93.     public static int getRandomY(){
  94.         return (int)(Math.random()*100);
  95.     }
  97. }