Constants (and enums)

There are various ways of making and using constants. We'll look at different ways of doing them and when each method is appropriate

1. Using variables for state variables

Often you have a program where you need to know what state it is in. For example, in a paint program you might need to know what mode you are painting in.

In the initialization, you might have:

String mode = "line"; //default mode

and then in paintComponent() something like this:

switch (mode) {
case "pencil":
   ...
   break;
case "line":
   ...
   break;
case "erase":
   ...
   break;
}

and in your ActionListener something like this:

if (e.getActionCommand().equals("erase")) {
	mode="erase";
	firstClick = true;
	drawingPanel.repaint();
}

if (e.getActionCommand().equals("pencil")) {
	mode="pencil";
	...

Problems:

Any typo will totally mess up the program. e.g. mode = "Pencil"; instead of mode = "pencil";. Nothing checks the spelling.
There is no one place (e.g. at the top of the program) where you can see all of the different possible modes. Did you use "clear" or "erase" for the mode that clears the screen?

Where should you use this approach? Nowhere.

2. Using constants

Constants in Java are written as: static final int AAA = 13;.

Note that you always use static final - which means that there is only one copy of this variable and that it can never be changed.
Note also that in almost all programming languages, constants are CAPITALIZED which makes them really easy to recognise.
and ... make sure that the name is descriptive.

— for constant numbers

Example 1:

static final int GRIDSIZE=7;
static final int SCRSIZE = 600;
static final Color BCKCOLOR = new Color(240,240,0);

later on you would use these in your code:

this.setPreferredSize(new Dimension(SCRSIZE, SCRSIZE));
panelTop.setBackground(BCKCOLOUR);
    ...
	
for (int i=0; i<GRIDSIZE; i++) {
	for (int j=0; j<GRIDSIZE; j++) {
		dotsarray[i][j] = (int)(Math.random() * 4 + 1);
	}
}

Advantages: There are some very important reasons for using constants.

Your IDE (or compiler) will automatically tell you if you made a typo e.g. this.setPreferredSize(new Dimension(SCRSIZE, SCRSZ)); will NOT work.
Using constants lets you change one number at the top, and your program automatically adjusts for it.
When people don't do this, it is called "using magic numbers" - and is BAD form in programming. So ... there is some number in your code, and no one knows what it is for or what happens when you change it.
You can see that for (int i=0; i<GRIDSIZE; i++) is better than for (int i=0; i<7; i++) because the constant acts like a variable which tells you what the number is used for.

Problems:

It is still possible to screw up your program, if you type in a stupid number. e.g. static final int SCRSIZE = -200;. Nothing is idiot proof.

Where should you use this approach? Wherever needed.

The examples above are good. Also see this example, in our robot program, where constants are used for many things.
Note: to import a separate file of constants (final static) in Java, you need to write import static myPackage.RobotMap.*;

— for state variables

Constants can be used for state variables too, as in these examples.

static final int LEFT = 1;
static final int RIGHT = 2;
static final int UP = 3;
static final int DOWN = 4;
  ...
int direction = UP;
  ...
switch (direction) {
case LEFT:
   ...
   break;
case RIGHT:
   ...
   break;
case UP:
   ...
   break; 
case DOWN:
   ...
   break; 
}

Advantages:

This does prevent typos, just like with using other constants
It is a lot better than having to remember that left=1, right=2, etc. You don't have to worry about what the actual number is

Problems: There are a couple of serious problems:

There is nothing in the program that will stop you from writing direction = 16;. This will totally mess up your program.
There is nothing to ensure that the constants are all different. You could easily have accidentally set both UP and DOWN to 3. The program will compile and run, but will never work the way you want it to.

Where should you use this way of doing things? for simple programs when ENUMS are too much work

The much much better way of doing this is to use enums.
The problem is that enums are a bit more complicated.
So, you can use constants for your state variables to get your program working, but any serious, major program should be rewritten to use enums.