I do not see a real problem with this style, assuming that the
assignment at hand was just to write such a simple dot paint program.
The inner classes can easily share a common model and identifier
scope, while at the same time there is some reasonable separation
between the different concerns of the inner classes.
Should it be required later to decouple one of these inner classes
more than now, this is also possible using a refactor that will make
it become an outer class or will introduce an observer relationship.
But should it not be required later, no time is wasted now to
implement a decoupling and separation not needed.
I sometimes strive to make nested classes static in order to facilitate
re-factoring, as suggested in the example below. Static also keeps me
honest on inadvertent coupling. I also use the somewhat dated Observer
and Observable classes to stress the observer pattern, even implementing
Observer despite leaking `this`.
Here's my understanding of the basic architecture:
<
http://stackoverflow.com/a/2687871/230513>
Here's a more elaborate example that mentions other ways to implement
the observer pattern:
<
http://stackoverflow.com/a/3072979/230513>
And I frequently refer to this article on Swing & MVC
<
http://java.sun.com/products/jfc/tsc/articles/architecture/>
import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class MVCMain {
public static void main(String args[]) {
new MVCMain().buildGui();
}
public void buildGui() {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
Model model = new Model();
View view = new View(model);
Control control = new Control(model, view);
JFrame f = new JFrame();
f.add(view);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
}
});
}
private static final class Model extends Observable {
private List<Point> points = new ArrayList<Point>();
public void next(Point p) {
points.add(p);
setChanged();
notifyObservers();
}
public List<Point> getPoints() {
return points;
}
}
private static final class View extends JPanel implements Observer {
private Model model;
public View(Model model) {
this.model = model;
this.model.addObserver(this);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
g.setColor(Color.blue);
for (Point p : model.getPoints()) {
g.fillRect(p.x, p.y, 8, 8);
}
}
@Override
public Dimension getPreferredSize() {
return new Dimension(300, 300);
}
@Override
public void update(Observable o, Object arg) {
repaint();
}
}
private static final class Control {
private Model model;
private View view;
public Control(final Model model, View view) {
this.model = model;
this.view = view;
this.view.addMouseListener(new MouseAdapter() {
@Override
public void mousePressed(MouseEvent e) {
model.next(e.getPoint());
}
});
}
}
}
