Go语言视频零基础入门到精通

javalearner

所谓享元模式，说在一个系统中如果有多个相同的对象，那么只共享一份就可以了，不必每个都去实例化一个对象。在该模式中，包括抽象的享元，具体的享元，享元工厂以及客户端。其中抽象的享元为公共接口或抽象类，具体的享元实现抽象享元角色所规定的接口，享元工厂负责创建和管理享元角色。
     下面写了一个程序实现享元模式：包括抽象享元角色Person.java，两个具体享元角色OldFlyweight.java和YoungFlyweight.java，享元工厂FlyweightFactory.java,最后是一个客户端测试类ClientTest_Flyweight.java。

Person.java:
  package com.xpec.landon.trainjava.oop;
/**
  * 一个普通的抽象类，人
  * @author lvwenyong
  *
  */
public abstract class Person {
  /**
   * 为了享元模式中的方便一些，没有加入private修饰符
   * 另外为了另一个包下的使用，用protectd修饰
   */
   protected String personName;
   protected int personAge;
  
  //右键Source->Generate Getters and Setters
  public String getPersonName() {
   return personName;
  }  public void setPersonName(String personName) {
   this.personName = personName;
  }  public int getPersonAge() {
   return personAge;
  }  public void setPersonAge(int personAge) {
   this.personAge = personAge;
  }  /**
   * 抽象方法
   */
  public abstract void sayHello(); }
     
OldFlyweight.java:

  package com.xpec.landon.trainjava.designpattern; import com.xpec.landon.trainjava.oop.Person; /**
  * 具体的一个享元，继承自Person
  * @author lvwenyong
  *
  */
public class OldFlyweight extends Person{  public OldFlyweight(int age)
  {
   this.personAge = age;
  }
  public void sayHello()
  {
   System.out.println("Hello,I"m the young!");
  }
}
  
YoungFlyweight.java: package com.xpec.landon.trainjava.designpattern; import com.xpec.landon.trainjava.oop.Person; /**
  * 具体的一个享元，继承自Person
  * @author lvwenyong
  *
  */
public class YoungFlyweight extends Person{
  
  public YoungFlyweight(int age)
  {
   this.personAge = age;
  }
  
  public void sayHello()
  {
   System.out.println("Hello,I"m the old");
  }
}
  
FlyweightFactory.java:
  package com.xpec.landon.trainjava.designpattern;
import java.util.*; import com.xpec.landon.trainjava.oop.Person;
/**
  * 享元工厂
  * @author lvwenyong
  *
  */ public class FlyweightFactory {
  //这里用Hashtable，当然也可以用ArrayList等。
  private Hashtable agedPersons = new Hashtable();
  
  /**
   * 创建和管理享元
   * 如果没有创建具体享元，则创建。
   * 已创建，则直接获取
   * @param age 年龄
   * @return 抽象享元
   */
  public Person getFlyweight(int age)
  {
   Person person = (Person)agedPersons.get(age);
   
   if(person  != null)
   {
    if(age == person.getPersonAge())
    {
     //输出信息方便查看
     System.out.println("person-" + age + "被直接获取");
    }
   }
   
   if(person == null)
   {
    switch (age) {
    case 25:
     person = new YoungFlyweight(age);
     break;
    case 80:
     person = new OldFlyweight(age);
    default:
     break;
    }
   
    //输出信息方便查看
    System.out.println("person-" + age + "新被创建");
   
    agedPersons.put(age, person);
   }
   
   return person;
  } }
  
ClientTest_Flyweight.java:

  package com.xpec.landon.trainjava.designpattern; import com.xpec.landon.trainjava.oop.Person; /**
  * 享元模式中的客户端角色
  * @author lvwenyong
  *
  */
public class ClientTest_Flyweight {
  public static void main(String []args)
  {
   FlyweightFactory flyweightFactory = new FlyweightFactory();
   
   //第一次测试，应该是直接创建
   Person oldFlyweight1 = flyweightFactory.getFlyweight(80);
   Person youngFlyweight1 = flyweightFactory.getFlyweight(25);
   
   System.out.println(oldFlyweight1.getPersonAge());
   System.out.println(youngFlyweight1.getPersonAge());
   
   //第二次测试，应该是直接获取
   Person oldFlyweight2 = flyweightFactory.getFlyweight(80);
   Person youngFlyweight2 = flyweightFactory.getFlyweight(25);
   
   System.out.println(oldFlyweight2.getPersonAge());
   System.out.println(youngFlyweight2.getPersonAge());
   
  } }

     下面是程序运行截图：


     可以看到，第一次使用的时候是直接创建，以后再用到该对象的时候则是直接获取该对象。这就是享元模式的好处。