MVC模式（上）--- Java

1.总结，实践

2.1 模式综合demo

  1 //java
  2 import java.util.*;
  3 
  4 //
  5 interface Observer{
  6     public void update(QuackObservable duck);
  7 }
  8 class Quackologist implements Observer{
  9     public void update(QuackObservable duck){
 10         System.out.println("Quackologist: " + duck + " quack");
 11     }
 12 }
 13 //6.observable 
 14 interface QuackObservable{
 15     public void registerObserver(Observer observer);
 16     public void notifyObservers();
 17 }
 18 class Observable implements QuackObservable{
 19     ArrayList<Observer> observers = new ArrayList<Observer>();
 20     QuackObservable duck;
 21     
 22     public Observable(QuackObservable duck){
 23         this.duck = duck;
 24     }
 25     public void registerObserver(Observer observer){
 26         observers.add(observer);
 27     }
 28     public void notifyObservers(){
 29         for(Observer c : observers)
 30             c.update(duck);
 31     }
 32 }
 33 //
 34 interface Quackable extends QuackObservable{
 35     public void quack();
 36 }
 37 class RedheadDuck implements Quackable{
 38     Observable observable;
 39     public RedheadDuck(){
 40         observable = new Observable(this);
 41     }
 42     public void quack(){
 43         System.out.println("redhead Quack");
 44         notifyObservers();
 45     }
 46     public void registerObserver(Observer observer){
 47         observable.registerObserver(observer);
 48     }
 49     public void notifyObservers(){
 50         observable.notifyObservers();
 51     }
 52 }
 53 class MallardDuck implements Quackable{
 54     Observable observable;
 55     public MallardDuck(){
 56         observable = new Observable(this);
 57     }
 58     public void quack(){
 59             System.out.println("mallard Quack");
 60             notifyObservers();
 61     }
 62     public void registerObserver(Observer observer){
 63         observable.registerObserver(observer);
 64 }
 65     public void notifyObservers(){
 66         observable.notifyObservers();
 67     }
 68     public String toString() {
 69         return "Mallard Duck";
 70     }
 71 }
 72 
 73 //4.combinate
 74 class Flock implements Quackable{
 75     ArrayList<Quackable> quackers = new ArrayList<Quackable>();
 76     public void add(Quackable quacker){
 77         quackers.add(quacker);
 78     }
 79     public void quack(){
 80         Iterator iterator = quackers.iterator();//5.Iterator
 81         while(iterator.hasNext()){
 82             Quackable quacker = (Quackable)iterator.next();
 83             quacker.quack();
 84         }
 85     }
 86     public void registerObserver(Observer observer){
 87     }
 88     public void notifyObservers(){
 89     }
 90 }
 91 
 92 //Goose
 93 class Goose{
 94     public void honk(){
 95         System.out.println("Honk");
 96     }
 97 }
 98 //1.GooseAdpter
 99 class GooseAdpter implements Quackable{
100     Goose goose;
101     public GooseAdpter(Goose goose){
102         this.goose = goose;
103     }
104     public void quack(){
105         goose.honk();
106     }
107     public void registerObserver(Observer observer){
108     }
109     public void notifyObservers(){
110     }
111 }
112 
113 //2.decorate
114 class QuackCounter implements Quackable{
115     Quackable duck;
116     static int numberOfQuacks;
117     public QuackCounter(Quackable duck){
118         this.duck = duck;
119     }
120     public void quack(){
121         duck.quack();
122         numberOfQuacks++;
123     }
124     public static int getQuacks(){
125         return numberOfQuacks;
126     }
127     public void registerObserver(Observer observer){
128         duck.registerObserver(observer);
129     }
130     public void notifyObservers(){
131         duck.notifyObservers();
132     }
133 }
134 
135 //3.factory
136 abstract class AbstractDuckFactory{
137     public abstract Quackable createMallardDuck();
138     public abstract Quackable createRedheadDuck();
139 } 
140 
141 class CountingDuckFactory extends AbstractDuckFactory{
142     public Quackable createMallardDuck(){
143         return new QuackCounter(new MallardDuck());
144     }
145     public Quackable createRedheadDuck(){
146         return new QuackCounter(new RedheadDuck());
147     }
148 }
149 //main
150 public class MvcDuck{
151     public static void main(String[] args){
152         MvcDuck mvcDuck = new MvcDuck();
153         AbstractDuckFactory duckFactory = new CountingDuckFactory();
154         mvcDuck.simulate(duckFactory);
155     }
156     void simulate(AbstractDuckFactory duckFactory){
157         Quackable redheadDuck = duckFactory.createRedheadDuck();
158         Quackable mallardDuck = duckFactory.createMallardDuck();
159         Quackable gooseDuck   = new GooseAdpter(new Goose());            //Adpter
160 
161         System.out.println("Duck Simulator");
162         
163         //test observer
164         Quackologist quackologist = new Quackologist();
165         mallardDuck.registerObserver(quackologist);
166 
167         //test combinate
168         Flock flockOfDucks = new Flock();
169         flockOfDucks.add(redheadDuck);
170         flockOfDucks.add(mallardDuck);
171         
172         //manage a group
173         simulate(flockOfDucks);
174         
175         //
176         simulate(gooseDuck);
177         
178         System.out.println("The duck quack number:" + QuackCounter.getQuacks());
179     }
180     void simulate(Quackable duck){
181         duck.quack();
182     }
183 }

2.2 MVC 有界面，运行，start,有声音，ProgressBar可跳动

  1 //beatModel java
  2 import java.awt.*;
  3 import java.awt.event.*;
  4 import javax.swing.*;
  5 import java.util.*;
  6 import javax.sound.midi.*;
  7 
  8 interface BeatObserver {
  9     void updateBeat();
 10 }
 11 interface BPMObserver {
 12     void updateBPM();
 13 }
 14 interface BeatModelInterface{
 15     void initialize();
 16     void on();
 17     void off();
 18     
 19     void setBPM(int bpm);
 20     int  getBPM();
 21     
 22     void registerObserver(BeatObserver o);
 23     void removeObserver  (BeatObserver o);
 24     
 25     void registerObserver(BPMObserver o);
 26     void removeObserver  (BPMObserver o);
 27 }
 28 interface ControllerInterface{
 29     void start();
 30     void stop();
 31     void increaseBPM();
 32     void decreaseBPM();
 33     void setBPM(int bpm);
 34 }
 35 class BeatModel implements BeatModelInterface,MetaEventListener{
 36     Sequencer sequencer;
 37     Sequence sequence;
 38     Track track;
 39     
 40     ArrayList<BeatObserver> beatObservers = new ArrayList<BeatObserver>();
 41     ArrayList<BPMObserver> bpmObservers = new ArrayList<BPMObserver>();
 42     int bpm = 90;
 43     
 44     public void initialize(){
 45         setUpMidi();
 46         buildTrackAndStart();
 47     }
 48     public void on(){
 49         System.out.println("Starting the sequencer");
 50         sequencer.start();
 51         setBPM(90);
 52     }
 53     public void off(){
 54         setBPM(0);
 55         sequencer.stop();
 56     }
 57     public void setBPM(int bpm){
 58         this.bpm = bpm;
 59         sequencer.setTempoInBPM(getBPM());
 60         notifyBPMObservers();
 61     }
 62     public int getBPM(){
 63         return bpm;
 64     }
 65 
 66     void beatEvent() {
 67         notifyBeatObservers();
 68     }
 69     public void registerObserver(BeatObserver o) {
 70         beatObservers.add(o);
 71     }
 72 
 73     public void notifyBeatObservers() {
 74         for(int i = 0; i < beatObservers.size(); i++) {
 75             BeatObserver observer = (BeatObserver)beatObservers.get(i);
 76             observer.updateBeat();
 77         }
 78     }
 79 
 80     public void registerObserver(BPMObserver o) {
 81         bpmObservers.add(o);
 82     }
 83 
 84     public void notifyBPMObservers() {
 85         for(int i = 0; i < bpmObservers.size(); i++) {
 86             BPMObserver observer = (BPMObserver)bpmObservers.get(i);
 87             observer.updateBPM();
 88         }
 89     }
 90     public void removeObserver(BPMObserver o){
 91         int i = bpmObservers.indexOf(o);
 92         if(i >= 0)
 93             bpmObservers.remove(i);
 94     }
 95     public void removeObserver(BeatObserver o) {
 96         int i = beatObservers.indexOf(o);
 97         if (i >= 0) {
 98             beatObservers.remove(i);
 99         }
100     }
101     
102     public void meta(MetaMessage message) {
103         
104         if (message.getType() == 47) {
105             beatEvent();
106             sequencer.setMicrosecondPosition(0);    //without it do not work
107             sequencer.start();
108             setBPM(getBPM());
109         }
110     }
111     
112     public void setUpMidi(){
113         try{
114             sequencer = MidiSystem.getSequencer();
115             sequencer.open();
116             sequencer.addMetaEventListener(this);
117             sequence = new Sequence(Sequence.PPQ,4);
118             track = sequence.createTrack();
119             sequencer.setTempoInBPM(getBPM());
120             //sequencer.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);//it continuous but not receive event
121         }catch(Exception e){
122             e.printStackTrace();
123         }
124     }
125     public void buildTrackAndStart() {
126         int[] trackList = {35, 0, 46, 0};
127 
128         sequence.deleteTrack(null);
129         track = sequence.createTrack();
130 
131         makeTracks(trackList);
132         track.add(makeEvent(192,9,1,0,4));      
133         try {
134             sequencer.setSequence(sequence);                    
135         } catch(Exception e) {
136             e.printStackTrace();
137         }
138     }
139     public void makeTracks(int[] list) {        
140 
141         for (int i = 0; i < list.length; i++) {
142             int key = list[i];
143 
144             if (key != 0) {
145                 track.add(makeEvent(144,9,key, 100, i));
146                 track.add(makeEvent(128,9,key, 100, i+1));
147             }
148         }
149     }
150     public  MidiEvent makeEvent(int comd, int chan, int one, int two, int tick) {
151         MidiEvent event = null;
152         try {
153             ShortMessage a = new ShortMessage();
154             a.setMessage(comd, chan, one, two);
155             event = new MidiEvent(a, tick);
156         } catch(Exception e) {
157             e.printStackTrace(); 
158         }
159         return event;
160     }
161 }
162 
163 class DJView implements ActionListener,BeatObserver,BPMObserver{
164     BeatModelInterface model;
165     ControllerInterface controller;
166     
167     JPanel viewPanel;
168     JPanel controlPanel;
169     
170     BeatBar beatBar;
171     JLabel bpmOutputLabel;
172     JLabel bpmLabel;
173     
174     JTextField bpmTextField;
175     JButton setBPMButton;
176     JButton increaseBPMButton;
177     JButton decreaseBPMButton;
178     JMenuBar menuBar;
179     JMenu menu;
180     JMenuItem startMenuItem;
181     JMenuItem stopMenuItem;
182     
183     JFrame controlFrame;
184     JFrame viewFrame;
185         
186     public DJView(ControllerInterface controller,BeatModelInterface model){
187         this.controller = controller;
188         this.model = model;
189         model.registerObserver((BeatObserver)this);
190         model.registerObserver((BPMObserver)this);
191     }
192     public void createControls(){
193         JFrame.setDefaultLookAndFeelDecorated(true);
194         controlFrame = new JFrame("Control");
195         controlFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
196         controlFrame.setSize(new Dimension(100,80));
197         
198         menuBar = new JMenuBar();
199         menu = new JMenu("DJ Control");
200         
201         startMenuItem = new JMenuItem("Start");
202         menu.add(startMenuItem);
203         startMenuItem.addActionListener(new ActionListener(){
204             public void actionPerformed(ActionEvent event){
205                 controller.start();
206             }
207         });
208         
209         stopMenuItem = new JMenuItem("Stop");
210         menu.add(stopMenuItem);
211         stopMenuItem.addActionListener(new ActionListener(){
212             public void actionPerformed(ActionEvent event){
213                 controller.stop();
214             }
215         });
216         
217         menuBar.add(menu);
218         controlFrame.setJMenuBar(menuBar);
219         
220         setBPMButton = new JButton("Set");
221         setBPMButton.setSize(new Dimension(10,40));
222         increaseBPMButton = new JButton(">>");
223         decreaseBPMButton = new JButton("<<");
224         setBPMButton.addActionListener(this);
225         increaseBPMButton.addActionListener(this);
226         decreaseBPMButton.addActionListener(this);
227         
228         JPanel buttonPanel = new JPanel(new GridLayout(1,2));
229         buttonPanel.add(decreaseBPMButton);
230         buttonPanel.add(increaseBPMButton);
231         
232         bpmTextField = new JTextField(2);
233         bpmLabel = new JLabel("Enter BPM:",SwingConstants.RIGHT);
234         JPanel enterPanel = new JPanel(new GridLayout(1, 2));
235         enterPanel.add(bpmLabel);
236         enterPanel.add(bpmTextField);
237         
238         JPanel insideControlPanel = new JPanel(new GridLayout(3, 1));
239         insideControlPanel.add(enterPanel);
240         insideControlPanel.add(setBPMButton);
241         insideControlPanel.add(buttonPanel);
242         
243         controlPanel = new JPanel(new GridLayout(1,2));
244         controlPanel.add(insideControlPanel);
245         
246         bpmLabel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
247         bpmOutputLabel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
248 
249         controlFrame.getRootPane().setDefaultButton(setBPMButton);
250         controlFrame.getContentPane().add(controlPanel, BorderLayout.CENTER);
251 
252         controlFrame.pack();
253         controlFrame.setVisible(true);
254     }
255     public void enableStopMenuItem(){
256         stopMenuItem.setEnabled(true);
257     }
258     public void disableStopMenuItem(){
259         stopMenuItem.setEnabled(false);
260     }
261     public void enableStartMenuItem(){
262         startMenuItem.setEnabled(true);
263     }
264     public void disableStartMenuItem(){
265         startMenuItem.setEnabled(false);
266     }
267     public void actionPerformed(ActionEvent event){
268         if(event.getSource() == setBPMButton){
269             int bpm = Integer.parseInt(bpmTextField.getText());
270             controller.setBPM(bpm);
271         }else if(event.getSource() == increaseBPMButton){
272             controller.increaseBPM();
273         }else if(event.getSource() == decreaseBPMButton){
274             controller.decreaseBPM();
275         }
276     }
277     public void createView(){
278         viewFrame = new JFrame("View");
279         viewFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
280         viewFrame.setSize(new Dimension(100,80));
281         
282         bpmOutputLabel = new JLabel("offline",SwingConstants.CENTER);
283         
284         beatBar = new BeatBar();
285         beatBar.setValue(60);
286         
287         JPanel bpmPanel = new JPanel(new GridLayout(2,1));
288         bpmPanel.add(beatBar);
289         bpmPanel.add(bpmOutputLabel);
290         
291         viewPanel = new JPanel(new GridLayout(1,2));
292         viewPanel.add(bpmPanel);
293         
294         viewFrame.getContentPane().add(viewPanel,BorderLayout.CENTER);
295         viewFrame.pack();
296         viewFrame.setVisible(true);
297     }
298     public void updateBPM(){
299         bpmOutputLabel.setText("Current BPM: " + model.getBPM());
300     }
301     public void updateBeat(){
302         beatBar.setValue(100);
303     }
304 }
305 
306 class BeatController implements ControllerInterface{
307     BeatModelInterface model;
308     DJView view;
309     public BeatController(BeatModelInterface model){
310         this.model = model;
311         view = new DJView(this,model);
312         view.createView();
313         view.createControls();
314         view.disableStopMenuItem();
315         view.enableStartMenuItem();
316         model.initialize();
317     }
318     public void start(){
319         model.on();
320         view.disableStartMenuItem();
321         view.enableStopMenuItem();
322     }
323     public void stop(){
324         model.off();
325         view.disableStopMenuItem();
326         view.enableStartMenuItem();
327     }
328     public void increaseBPM(){
329         model.setBPM(model.getBPM()+1);
330     }
331     public void decreaseBPM(){
332         model.setBPM(model.getBPM()-1);
333     }
334     public void setBPM(int bpm){
335         model.setBPM(bpm);
336     }
337 }
338 //BeatBar the code in the book may be not work,change a little above
339 class BeatBar extends JProgressBar implements Runnable{
340     private static final long serialVersionUID = 2L;
341     JProgressBar progressBar;
342     Thread thread;
343     public BeatBar(){
344         thread = new Thread(this);
345         setMaximum(100);
346         thread.start();
347     }
348     public void run(){
349         while(true){
350             int value = getValue();
351             value = (int)(value * 0.75);
352             setValue(value);
353             repaint();
354             try{
355                 Thread.sleep(50);
356             }catch(Exception e){
357                 e.printStackTrace();
358             }
359         }
360     }
361 }
362 
363 public class BeatModelTest{
364     public static void main(String[] args){
365         BeatModelInterface model = new BeatModel();
366         ControllerInterface controller = new BeatController(model);
367     }
368 }