我得到了这套代码，需要提出一些方法来提高代码的内聚性和类的耦合性。但是我认为这些类之间已经很好地分离了，因为看起来它们在利用事件。就内聚而言，所有init（）调用都放在一起，对我来说一切似乎都还不错。
public class A
{
private C t;
private B g;
public static void main(String args[]) {
// Creates t and g.
t = new C();
t.init();
g = new B();
g.init();
g.start(this);
}
pubic void update (Event e)
{
// Performs updating of t based on event
}
}
public class C
{
public C() { ... }
public void init() { ... }
}
public class B
{
public B() { ... }
public void init() { ... }
public void start(A s) {
e = getNextEvent();
while (e. type != Quit)
if (e.type == updateB)
update(e) ;
else
s.update(e) ;
e = getNextEvent();
}
public void update(Event e) { ... }
}
}
还有提高类凝聚力和耦合性的方法吗？我觉得还可以，但我想我缺少了一些东西。
感谢您对此的任何建议。
最佳答案
一种建议是将事件处理逻辑与控制器逻辑（A类）分离。
因此，您将有4种类型的类：
用于运行“服务器”的主要类（A）
监听事件的线程（B）
将要更新的模型层（C）
一个事件处理程序类，它将支持对事件的某些操作（D）
它可能看起来像这样：
public class Main {
private Model m;
private EventListener listener;
... main() {
m = new Model();
listener = new EventListener();
EventHandler eventHandler = new MyEventHandler();
// set the event handler
listener.setEventHandler(eventHandler);
listener.start(m);
}
public class Model {
// nothing to see here
}
public class EventListener() {
private EventHandler handler = new DefaultEventHandler();
public void start(final Model m) {
// startup
while (event.type != Event.Quit) {
// get event
handler.handleEvent(event, m);
}
// shutdown
}
public void setEventHandler(EventHandler eh) { this.handler = eh }
}
public class MyEventHandler implements EventHandler {
public void handleEvent(Event e, Model m) {
// update the model
}
}
请注意，在这个新设计中，更新模型的业务逻辑（在您的示例中为C）已移至外部类，而不是“ Runner”类。这有点干净，因为Main类不需要了解什么是事件以及如何处理它们。
另一个优点是，使用此方法，您可以使用链接的事件处理程序或多个串行事件处理程序轻松地编写复杂的事件处理代码。实现异步事件处理也非常简单，因为B仅负责调用处理程序，而无需了解事件类型。有时称为Publish/Subscribe，它使侦听器（B）和处理程序（您的update（e）方法）保持松散耦合
关于java - 提高类(class)的凝聚力和联系，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/6376637/