De nombreux objets avec l'état global et local

Question

Je cherche la meilleure conception pour la situation suivante.

Nous avons de nombreux objets forment une classe, par exemple un cadre photo. Maintenant, chacun des cadres d'image peut afficher 3 types d'image. 1) une face 2) une capture d'écran 3) vide

Cest facile:

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.
    }
}

Nous pouvons maintenant créer des cadres d'image avec des images différentes et facilement changer le mode pour chacun.

Maintenant, je veux ajouter un setter global pour tous les cadres d'image. Ensuite, chaque nouvelle PictureFrame devrait prendre le paramètre global que celui par défaut. Il peut ensuite être réglé à un autre par.

Voici ma solution, mais je veux discuter s'il y a une meilleure.

J'ai ajouté un champ statique PictureFrame.Instances à la classe PictureFrame où tous les cadres d'image sont accessibles. Maintenant, je peux itérer sur tous les CadreImage pour appliquer le nouveau mode global à toutes les images.

En outre, j'ai une deuxième PictureFrame.GlobalImageMode de champ statique où je mis le mode global si je change sur tous les cadres et lu dans le constructeur de la PictureFrame. Le compositeur pour le GlobalImageMode peut être statique dans la classe PictureFrame aussi.

Answer 1

Juste coup sauvage ici ...: Pourquoi ne pas vous utilisez toujours getter pour le mode image en cours avec une condition dans ce:

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

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

Answer 2

Si je comprends bien l'énoncé du problème correctement, je pense que cela est semblable à ce que vous avez besoin:

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);
    }
  }
}

Vous utilisez via:

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();

Sinon, si vous ne voulez pas étendre l'image ou vous voulez avoir plusieurs modes, vous pouvez créer un objet décorateur pour envelopper l'image et dire quel mode il est.