How do you structure a java program?

Question

For quite awhile I have been trying to make a simple "game" in Java that is really just an applet with a square and a grid. What I want it to do in the end is the user clicks and the square will move to where the user clicked rounded to the nearest grid square.

The problem is I am a self taught beginner and I am having a hard time figuring out how to actually structure the program, some examples:

• should I have a separate class listening for mouse clicks?
• When I receive a click should I send it to some other object that represents the box and let it decide what it wants to do or just call some function that makes the box move?

I really want to learn all this "when to use what" stuff for myself so any links or general advice is appreciated.

Answer 1

What you're really asking is how to develop a game, which is notably different from a typical Java application. However, I'll give you a few ideas to at least point you in the right direction.

• Take advantage of the fact that Java is an object-oriented language. That is, objects should each have their own responsibility .

• Separate your game into three key layers: the application layer, the game logic layer, and the presentation layer.

  • The application layer should contain all of your helpers and generic subsystems, things like random number generators, text parsers, file access modules, mesh loaders, etc.
  • The game logic layer should implement all of the rules of your game, and be responsible for maintaining canonical state. Basically, when you press the "W" on the keyboard to move forward, the game logic layer should receive MOVE_FORWARD_REQUEST from the UI.
  • The presentation layer should be responsible for two things: getting input, and rendering your world. When it gets input, like the "W" key, it should map that to an action, and send that to the game logic layer to be processed. Then, it should render the world based on whatever the game logic told it to do.

Game development is obviously an entire realm with many books dedicated to it. One of my favorites is Game Coding Complete , which does focus on C/C++, but should give you a good idea about how you ought to structure your game.

Good luck!

Answer 2

One main principle of good software development is the Single Responsibility Priciple . It states that a function or class should only have one responsibility.

This way your classes and objects shouldn't become too big and unmanageable.

Answer 3

I think one of the most important concepts to master when developing software is the concept or Orthogonality . It's not the simplest definition, but in essence it means that one component (such as reading mouse clicks) shouldn't be directly tied to an unrelated component (moving a square on the screen).

In your case, the code reading mouse clicks should be separate from the code that actually moves the box. Whether you implement this as inner/anonymous classes or not is up to you. But if you follow the Orthogonality principle, it will be easy to change at a later date should you change your mind.

Answer 4

One problem here is that all the rules have some leeway in them where you have to use your own best judgement.

For example, the app you are describing now seems to me so simple I'd probably do it in a single class, with perhaps a couple of nested, perhaps anonymous classes. In any event, I could make a decent case for fitting the whole thing into a single source file, claiming that multiple source files would actually increase the complexity of the whole thing.

But if your GUI had a number of different controls, perhaps each controlling different behavior, it would become time to split the functionality up so you're not ending up with a big bowl of spaghetti code.

The Java GUI libraries try to naturally separate (view+controller) from model. You are encouraged to define and display the GUI in one module (= file) but to have your data model and perhaps functionality in another. For complicated GUIs, there may also be multiple GUI implementation modules held together by code.

One way to keep things "clean" is to work in "layers" where each layer "knows" only what it needs to know. To be specific, the GUI layer needs to know about the existence of its underlying models – tables and lists and whatnot need to be connected to TableModel s and ListModel s, etc. It doesn't need to know about details of these models though, so it can simply refer to those models by interface.

The model layer, on the other hand, need know nothing about the GUI. The less it knows, the better, and this would theoretically enable you to exchange GUIs without needing to touch the models.

My model can also contain ActionListener s to respond to actions undertaken by eg pushing buttons in the GUI.

Of course, actions and changes to the model will often result in changes to the GUI. How to communicate these changes to the GUI if the model layer doesn't know about the GUI? You can use bound bean properties here. Here's a short tutorial: http://www.javalobby.org/java/forums/t19476.html . So you have the same kind of structure: Changes happen in your model, they're communicated to beans with property change support within the model, and the GUI can attach listeners to those properties to find out something changed.

Whether you perform actual, effective actions (eg writing files, converting data, whatever) within your model code or whether you split "processing" code off into yet another module is up to you and will again depend on how cluttered your model already is. If there's a tiny handful of fields and methods feeling lonely in there, you may decide to mash things together but the moment it starts to look messy you'll want to refactor your processing code out into its own module. Processing sounds like the kind of module that doesn't want to know about other modules either; you may end up just calling its methods from the model level.

I've described my basic style for doing GUI development. There are certainly other recommendations out there, and you will likely develop your own style based on your experience. This is just intended to give you an idea and a possible starting point.

Answer 5

... the user clicks and the square will move to where the user clicked rounded, to the nearest grid square.

Here is an example of doing this in a scaled view.

Answer 6

Step 1 - find the demo applets supplied by Sun. http://java.sun.com/applets/jdk/

Step 2 - read those demo applets. At least three. Preferably all of them.

One you've read several applets, you should see a little more clearly how to organize programs. You can then ask questions with a lot more focus pointing to specific applet examples and your specific programming problem.

Answer 7

Yeah, I'm a beginner programmer myself. Yeah, segregating functionality across multiple classes is a good way to reduce complexity and increase cohesion of individual classes.

Increasing cohesion good because by having more complex data structure your algorithms become less complex and your code is less dependent on each other.

For instance in your case it might be a good idea to separate the classes in accordance to MVC ( Model View Controler ).

• You have a Model which represents the way your game data is structured.
• You have a Viewer which present your Model in what ever form you please.
• Have a Controller which picks up changes in the Model (via Listeners) and then updates the Viewer

Now you can change your Model and add extra functionality requiring only small changes in the way the Viewer works.

There are many Patterns out there but there isn't a hard rule when to use one over the other. There are some cases in which you can use several and there are cases in which will require you to chose one design pattern over the other.

Answer 8

Every beginning Java programmer should start with the Sun Tutorials. They are quite good.

Another good source, especially among free sources, is Bruce Eckel's "Thinking in Java", available from http://www.mindview.net/Books/TIJ/ .

But the latter is a little dated compared to the former. That is why I recommend both.

Answer 9

Step 1 - find the demo applets supplied by Sun. http://java.sun.com/applets/jdk/

Step 2 - read those demo applets. At least three. Preferably all of them.

One you've read several applets, you should see a little more clearly how to organize programs. You can then ask questions with a lot more focus pointing to specific applet examples and your specific programming problem.