Thread: Coding Theory

Here's my problem: I know what it is I need to do for the project. I have no idea how to implement this using code. We have to create a Connect Four game and I know that I am going to need the Scanner class for imputs, arrays, and an enum class. The thing is, how do I go about coding this? When it comes to methods, I know what I need to do, I just don't know how to do it. Any tips on how to turn my ideas into code?

For reference this is the project. http://www.csee.umbc.edu/courses/und...ects/project2/

So you're unsure of the Java syntax and language/standard API features?

A good place to start is to look at The Java Tutorials. These go over many different aspects of using the Java platform, including the basic syntax as well as many different parts of the standard API. Look over the Covering the Basics section first to get an understanding of the fundamental syntaxes and classes you'll likely use with Java.

Start by writing down what you want to do, and how you're going to do it. Go line by line, pretending you're a computer.

There are many ways to develop code depending on the level of complexity and you're preferences.

I general like top-down/divide and conquer approaches for larger projects and handling data representation while I do line-by-line for algorithms, program logic, and smaller projects.

Top-down/divide and conquer approach:

Block out the key features you need. For example, you know there are players, a board, and pieces. Those sound like good classes so that would be a logical way to divide the data representation. You'll also probably want some sort of game engine type class which operates the game rules and runs the logic.

Once you have these high-level blocks, pick any one of these and start working your way down. I usually prefer to flush out data representation and manipulation before working on program logic.

Let's take the player class as an example. The requirements state that players should have a name, so that's something you'll want to include. A player will also have some pieces, so it may make sense to keep track of the player's pieces in the player class, but it isn't necessary. You could also keep track of all the pieces in the board class, you'll need to investigate which of these options makes more sense or is easier to manipulate as far as the game is concerned. Hint: if you're unsure which route is better to pursue, read the instructions. They hint/guide you towards one of these two solutions.

Once you've finished blocking out the player class, move onto the board class, then the piece class, and then the game engine class until you've roughly flushed out what each class should have and do.

The next step is to get a rough idea of what the program logic should do. Luckily, the assignment lays out roughly the flow of the game logic so you can start working from there.

The first step is to get the name of each player. How would you go about accomplishing that? Write down line by line the process for doing that. Then move onto the next step. FYI, this is the line-by-line approach.

Note that up to this point you may have not actually written any Java code yet, or you may have a rough class representation with empty methods that have comments describing how they should work and what needs to be done to accomplish that. Now you just need to fill in the blanks with actual code. The more work you put in up-front, the easier this step will be.

For example:

public static void main(String[] args)
{
    // ask player 1 for their name
    // ask player 2 for their name
    // ask for the board size
    // ...
}

As you're filling in the code, be sure to test often! One of the listed assignment goals is to use unit tests. These are very helpful for debugging a small section of code to ensure it is functioning as you intended it to. There are various ways to write effective unit tests, you can either write these before writing the actual code or you can write the two together at the same time. You could also write these afterwards, but I find these tend to be somewhat less effective in general (but not always). Also don't be afraid to re-run old tests as you code in other sections. This is done to ensure that whatever new code you wrote doesn't break the old code. Usually this isn't terribly important if your unit tests test code that's run completely independent from other code, but sometimes it's very difficult or impossible to decouple code from everything else so changing code in one place may affect how some other code runs.

If you need help figuring out how to fill in any of these individual sections, ask about them specifically, or better yet use your favorite internet search engine.