设计模式之享元模式

享元模式

享元模式就像共享单车。

众所周知共享单车存在外部资源和内部资源，

外部你使用可以调整座位高矮。内部信息是该共享单车存在一个特有的id或其他信息，这些信息外部无法改变和直接使用。

例如数据库连接池，我们的connection实例一开始就创建。当你使用就拿来使用，使用完继续放回数据库连接池，

其中你可以使用不同的sql语句就是外部资源信息、内部资源就是其中连接实例的账号、密码、url.

package com.wei.model8;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;

public class Test {
  public static void main(String[] args) {
    test();
  }
  public static void  test(){
    ObjectPool<Person> pool = new ObjectPool();
    //个体对象池添加实例
    pool.addInstance(new Person(1));
    pool.addInstance(new Person(2));

    //从对象池去除对象
    Person person = pool.GetInstance();
    person.print();

    Person person2 = pool.GetInstance();
    person2.print();
    //使用完毕回收
    person2.Back();

    Person person3 = pool.GetInstance();
    person3.print();
  }
  public static void getData(){
    Date date = new Date();
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("ss:SS");
    System.out.println(simpleDateFormat.format(date));
  }
}

//对象池

class ObjectPool<T> {
  private List<T> list=new LinkedList<>();
  public void setList(List<T> list){
    this.list=list;
  }
  public void addInstance(Inside t){
    if(t != null){
        list.add((T)t);
    }
  }
  //取对象
  public T GetInstance(){
    for (T _t : list) {
      Inside t=(Inside)_t;
      if(!t.isActive()){
        t.Use();
        return (T)t;
      }
    }
    return null;
  }
}


//共享对象抽象类

abstract class Inside{
  public boolean isActive() {
    return isActive;
  }
  //是否处于使用状态
  private boolean isActive;
  public void Use(){
    isActive=true;
    init();
  }
  public void Back(){
    close();
    isActive=false;
  }
  protected abstract Inside CreateInstance(Object[] arms);
  //关闭时回调的方法
  protected void close(){};
  //关闭时开启的方法
  protected void init(){};
}

//共享实体类

class Person extends Inside{
  int id;
  @Override
  protected Inside CreateInstance(Object[] arms) {
    return new Person((int)arms[0]);
  }
  @Override
  protected void close() {
//    System.out.println("收尾");
  }
  @Override
  protected void init() {
//    System.out.println("初始化");
  }
  public void print(){
    System.out.print("");
  }
  public Person(int id) {
    this.id = id;
  }
}

上面我写了一个泛型对象池，主要类继承了抽象类 Inside就可以被放进对象池。

不过后来我发现这样对象就无法继承其他父类了，这样会使类变得没有了扩展性，所以还是把Inside写成接口会比较好。

//共享对象接口
interface Inside{
  public boolean isActive() ;
  public void Use();
  public void Back();
}
//共享对象
class Person implements Inside{
  private boolean isatcive;
  int id;
  public void print(){
    System.out.print("");
  }
  public Person(int id) {
    this.id = id;
  }
  @Override
  public boolean isActive() {
    return isatcive;
  }
  @Override
  public void Use() {
  }
  @Override
  public void Back() {
  }
}