Wie ich in der Standardimplementierung der MVC weiß, übergeben wir Controller und Model an die View

Aber ich bin ein bisschen anderer Meinung als diese Idee. Ich möchte nicht, dass meine Ansicht sowohl über den Controller als auch über das Modell informiert wird (oh nein. Vielleicht benötigt die Ansicht manchmal ein Modell, aber ich bin mir sicher, dass er ohne Controller-Kenntnisse leben kann).

Meiner Meinung nach sollte der Controller Ansicht und Modell verwalten, und Model muss nicht über Controller und Ansicht Bescheid wissen. Die Ansicht muss den Controller nicht kennen (ich schließe das Modell nicht aus, da einige Implementierungen von Ansichten das Modell kennen müssen, um Änderungen im Modell zu überwachen). Das ist meine IdeeAnsicht muss nicht über Controller wissen.

1. Hier ist ein Beispiel:

public class MyView implements ButtonClickListener {

    private Controller myController;
    private Button myButton;

    // I commented out the model because we dont need it now 
    // we are talking about using controller in the view

    public MyView(Controller c/*, Model m*/) {
        myController  = c;
        myButton      = new Button(); // lets say that it is "register" button
        myButton.setOnButtonClickListener(this);
    }

    public void setRegisterButtonText(String text) {
        myButton.setText(text);
    }

    @Override
    public void onClick() {
        myController.tellToModelToDoSomething();
    }

}

Und Controller:

public MyController implements Controller {

     private Model model;
     private View view;

     public MyController(Model model) {

          this.model = model;
          this.view  = new MyView(this);

     }

     public void tellToModelToDoSomething() {
          model.doSomeActions();
     }


}

2. Und jetzt, wie sehe ich diese Implementierung, ohne den Controller zu übergeben:

Meine Sicht:

public class MyView {

    private Button myButton;

    public MyView() {
        myButton = new Button();
    }

    public void setRegisterButtonText(String text) {
        myButton.setText(text);
    }

    public void setOnRegisterButtonClick(final Command command) {
        myButton.setOnButtonClickListener(new ButtonClickListener() {
                            @Override
                            public void onClick() {
                                command.execute();
                            }
                         });
    }

}

"Command" -Schnittstelle:

public interface Command {

     void execute(/*also can handle extra params*/);

}

Und Controller:

public MyController implements Controller {

 private Model model;
 private View view;

 public MyController(Model model) {

      this.model = model;
      this.view  = new MyView();

      view.setOnRegisterButtonClick(command);

 }

 public void tellToModelToDoSomething() {
      model.doSomeActions();
 }

 private Command command = new Command() {

     public void execute() {
          tellToModelToDoSomething();
     }

 };

}

Also, warum denke ich, dass mit Controller in der AnsichtIST NICHT GUT:

Wir mischen Controller- und View-Implementierungen und machen neue Abhängigkeiten.

Außerdem denke ich, dass View nur VIEWS und Operationen mit ihnen enthalten sollte (und die Verwendung des Controllers und einiger seiner Methoden sieht bereits nach Logik aus).

In der ersten Beispielansicht wird dem Controller mitgeteilt, was zu tun ist. Sind Sie damit einverstanden? Es sieht aus wie Ansicht steuert den Controller!

Im zweiten Beispiel steuert der Controller, was zu tun ist, und sagt der Ansicht lediglich, was zu tun ist, wenn auf eine Schaltfläche (nur die Ansicht weiß, welche Schaltfläche angeklickt wird) geklickt wird

Ich habe immer das zweite Schema verwendet, aber nachdem ich ein neues Buch über MVC gelesen habe, in dem steht, dass wir den Controller an die Ansicht übergeben müssen, bin ich ein bisschen verwirrt.

Können Sie mir bitte helfen, zu verstehen, warum ich mich irre, und mir einige Beispiele zeigen?