有关Java中OOP的一些问题

Question

I have a GUI class with a menu of buttons and textfields. Depending on what choices that is made in the menu and the input, methods in the GUI class are calling methods in the Logic class to send the input and create new objects of Customer class and Account class and so on.

To be able to communicate between the GUI- and the Logic class, I first create an object of the Logic class and I do that inside the GUI class, since it's here I have my main method. It this the best way to do it? Do I need some kind of reference variable between GUI- and Logic class or just use the reference when the object was created in the beginning of the GUI class? I guess to be able to communicate with a class, it must be an object first!? Thanks!

Logic logic = new Logic(); 

logic.addCustomer(name, number);

Answer 1

Ideally you shouldn't directly create the logic class. You should break down the functionality into a number of small classes, each of which satisfy a responsibility.

A simplistic way would be for the GUI class to create listeners which listen to the user events. In response the to the use event they fire events that your logic registers itself for. Then when the event is received the logic class can perform the functionality. You should read about observer pattern, event driven design...

You can read about event driven programming here http://en.wikipedia.org/wiki/Event-driven_programming .

Answer 2

I would suggest you do some researches on the MVC architecture . Your GUI (view) shouldn't interact directly with your model (logic). Implement a controller that will get the "signals" from your view and will be in charge to create your "logic objects" and work with them.

Answer 3

I would instantiate the Logic class outside the GUI, but pass it as an argument to the GUI constructor. It's nearly equivalent to what you are already doing, but I think it makes it clearer that the GUI uses a Logic object. Also, it's possible that Logic does some other things before/after the GUI starts/closes; it might not be the case now, but it could be true in the future if you extend your program.

Many other answers tell you to look at MVC, but that might be overkill for your project. It can decrease complexity for a large project, but increase it for a small one.

EDIT:

Logic login = new Logic();
...
MyGUI gui = new MyGUI(logic);
...

Answer 4

您可以在主对象中创建Logic类型的on对象，并将该对象的引用存储在Window对象中-这样，只要窗口存在，就可以访问Logic对象。

Answer 5

对于这种琐碎的场景，您应该查找Singleton设计模式 。

Answer 6

By default, Java uses Reference variables. Hence, if you instantiate your object in GUI class, make sure you send the object via method calls to your processing class.

Alternatively, you can look into singleton classes, which will return only one instance of the class. Inside that class, instantiate all the objects that you will need globally, and re-use that instance throughout your program.

Answer 7

Generally you can. If your application is very simple.

But this approach is not scalable. As your application gets more complex it became much harder for development and support. Try to consider Model–view–controller pattern to define a best way for your design. (according to your nick name I'll take a risk to propose an alternative link )