Muchos objetos con el estado global y local

Question

Estoy buscando el mejor diseño para la siguiente situación.

Tenemos muchos objetos forman una clase, por ejemplo, un marco de imagen. Ahora cada uno de los marcos puede mostrar 3 tipos de imagen. 1) una cara 2) una captura de pantalla 3) vacío

Eso es fácil:

public enum PictureMode 
{
    Face,
    Screen,
    None
}

public class PictureFrame {
    private PictureMode mode;
    public PictureMode Mode 
    {
        get { retrun mode; }
        set { /* set currentPicture to the correct one */ }
    }

    private Image currentPicture;
    private Image face;
    private Image screen;
    private Image empty;

    public PictureFrame(Image face, Image screen) {
        this.face = face;
        this.screen = screen;

        mode = PictureMode.None; // Maybe this is our default.
    }
}

Ahora podemos crear algunos pictureframes con diferentes imágenes y fácilmente cambiar el modo para cada uno.

Ahora quiero añadir un regulador global para todos los pictureframes. A continuación, cada nueva PictureFrame debería tener la configuración global como el que viene por defecto. Más tarde se puede ajustar a una a través diferente.

Aquí está mi solución, pero quiero hablar de si hay una mejor.

He añadido PictureFrame.Instances campo estático de la clase PictureFrame donde todos pictureframes son accesibles. Ahora puedo iterar sobre todos los pictureframes para aplicar el nuevo modo global para todas las tramas.

Además tengo una segunda PictureFrame.GlobalImageMode campo estático donde hice el modo global si lo cambio en todos los marcos y lo leí en el constructor de la PictureFrame. El colocador para el GlobalImageMode puede ser estática en la clase PictureFrame, también.

Answer 1

Sólo tiro salvaje aquí ...: ¿Por qué no utilizar siempre captador para el modo de cuadro actual con una condición en la que:

class PictureFrame {
  private PictureMode instanceMode;
  private static PictureMode? globalMode;

  private PictureMode CurrentMode {
    get {
       return globalMode ?? instanceMode;
    }
  }
}

Answer 2

Si entiendo correctamente el enunciado del problema, creo que esto es similar a lo que necesita:

public class Face extends Image { }
public class Screen extends Image { }

public class PictureFrame {
  private Image picture = null;

  public PictureFrame(Image newPicture) {
    this.setPicture(newPicture);
  }

  public setPicture(Image newPicture) {
    this.picture = newPicture;
  }
}

public class PictureFactory {
  private static Image defaultPicture = null;

  public static void setDefaultPicture(Image newPicture) {
    PictureFactory.defaultPicture = newPicture;
  }

  public static Image getDefaultPicture() {
    return PictureFactory.defaultPicture;
  }

  public static PictureFrame getNewPictureFrame() {
    return new PictureFrame(PictureFactory.defaultPicture);
  }
}

public class PictureFrameManager {
  private static PictureManager INSTANCE = new PictureManager();
  private Vector<PictureFrame> frames = new Vector<PictureFrame>();

  public static PictureFrameManager getInstance() {
    return PictureManager.INSTANCE;
  }

  private PictureFrameManager() {}

  private void addPictureFrame(PictureFrame frame) {
    this.frames.add(frame);
  }

  private void setFramesToDefault() {
    Image defaultPicture = PictureFactory.getDefaultPicture();
    Enumeration<PictureFrame> iFrames = frames.elements();
    while(iFrames.hasMoreElements()) {
      iFrames.nextElement().setPicture(defaultPicture);
    }
  }
}

Se utiliza a través de:

Face face = new Face();
//...do something to load the face object here

PictureFactory.setDefaultPicture(face);
PictureFrame frame = PictureFactory.getNewPictureFrame();

PictureFrameManager manager = PictureFrameManager.getInstance();
manager.addPictureFrame(frame);

Screen screen = new Screen();
//...do something to load the screen object here

PictureFactory.setDefaultPicture(screen);
manager.setFramesToDefault();

Como alternativa, si no desea ampliar la imagen o que desea tener múltiples modos, se puede crear un objeto decorador para envolver la imagen en el modo y decir lo que es.