Modern Java - Writing Code
Article Index
Modern Java - Writing Code
The flow of control
Conditionals - if

Using ifs and loops is one of the most difficult parts of learning how to program. Our beginners introduction to Java reaches the part all programmers have to know and know well - how to write code.


Modern Java
With NetBeans And Swing



  1. Getting started with Java

    In chapter 1 we tell you how to get started with modern Java development in the shortest possible time. The approach uses NetBeans and Swing and all of the resources used are free to download and use.

  2. Introducing Java - Swing Objects
    In the second chapter of our beginner's guide to Modern Java we find out more about objects by exploring the Swing framework with a simple hands-on example.

  3. Writing Code

    Using ifs and loops is one of the most difficult parts of learning how to program. Our beginners introduction to Java reaches the part all programmers have know and know well - how to write code.

  4. Command Line Programs
    Command line programming means doing things in the simplest possible way. We take a careful look at how data types and code build a program.

  5. User Interface - More Swing
    Finding out how to create a User Interface (UI) using the Java Swing library is not only a useful skill, it also is an ideal way to learn about objects and to make sure that the ideas really have sunk in.

  6. Working With Class
    The Swing components have provided an easy approach to the idea of objects, but there comes a time when you have to find out how to create your own. In this part of Modern Java, we look at the standard ideas of object-oriented programming.

  7. Java Class Inheritance
    Working with classes and objects is a very sophisticated approach to programming. You can't expect to absorb all of its implications in one go. We have already looked at the basics of class and objects. Now we need to look at encapsulation, constructors, overloading and inheritance.

  8. Java Data Types - Numeric Data 
    After looking at some of the advanced ideas of classes and objects we need to return to some simpler topics to make our understanding complete. We need to look more closely at data and, to get things moving, numeric data. 

  9. Java Data Types - Arrays And Strings
  10. Building a Java GUI - Containers
    In this chapter we get to grips with the idea of a container that is used to host components to build a user interface. We also find out how the Swing GUI Builder generates code to make it all much easier. 
  11. Advanced OOP - Type, Casting, Packages
  12. Value And Reference 
  13. Java Lambdas, SAMs And Events



This chapter is a complete beginners introduction to Java's control statements - the if, if else, for, while and do while.

If you have programed in any other language you will find many of the ideas explained at great length in this chapter very obvious - because once you have seen such things in one language you have seen them in all languages.

If you are in this position skip this chapter or read the condensed summary of the same ideas at the end just to make sure you do know it all. On the other hand this isn't a completely "dumb" introduction to the ideas and you might find it worth a skim read even if you are an ace coder.


Although it is very easy to focus on objects, properties and methods the fact of the matter is that at some point you have to write a lot of Java instructions to make an application work - that is you have to create some "code".

The beginner using a modern approach to creating a user interface via the drag-and-drop designer can avoid writing much code for a long time - but there comes a time when you have to do more.

Creating code that does something is the traditional core of the programming skill - today it often gets lost in many other considerations. 

In this chapter we are going to look at the fundamentals of creating lists of commands that get the job done. It might not be the glamorous end of programming but it is essential. 

A Program is?

A program is a list of instructions.

The computer simply reads the list of instructions in the order that you present them and obeys each one in turn.

In the days before objects, properties, methods and events were invented that really was all there was to programming. You started up a text editor, typed in lines of code - i.e. instructions in what ever language you were writing in - and then ran the code. There was no need to worry about objects, properties, methods or, in most cases events.

Today what a program does is mostly determined by the code contained within methods. A method is simply a chunk of code that belongs to an object. It is something the object can do. For example, a button might have a method called disable which would set the button into a disabled state when used.

Some methods are special in that are activated in response to an event. For example, the button's click event handler is a method that is automatically obeyed when the user clicks the button.

The key idea is that we have to write code in methods to make something happen. Let's look a the sort of things that we can write in a very general way.

Variables, assignment and expressions

Before we can move on and look at instructions - the verbs of the program - we have to have something for them to work with  - the nouns of the program.

As we have already discovered the nouns of Java are objects with properties and methods but there is a more fundamental entity that we have to consider - the variable.

A variable is roughly speaking a chunk of storage that you have given a name to. What you can store there depends on what you specify when you create the variable.

For example, in Java, and most modern languages you can store an integer (whole number) value in an int variable (int is just short for integer).

So for example

int a;

creates a variable called a that you can store an integer in.

How do you store a value in a variable?

You use the assignment operator "=". For example:


isn't a statement that a is equal to ten, it is an instruction to store the value 10 in the variable a.

Understanding what is going on becomes much easier if you always read the equals as "assign to" as in "assign 10 to a" or "store in" as in "store 10 in a". (The point is never read it as "a equals 10" because this could be a statement or a question.)

A variable can only store one value at a time so if you store another value in it then the anything already stored is lost.

For example:


stores 20 in a and any record of the 10 previously stored is lost.

Most programmers who have been working with variables quickly forget that there is any other way it could be done and might even wonder why I'm bothering to tell you all this. 

If you are happy with these basic ideas then we can add two more observations. You can both create and store a value in a variable at the same time. That is instead of writing:

int a;

you can write

int a=1;

It's just a shorthand.

The second idea is slightly more complicated. You can use a variable on both sides of an assignment. For example,


this retrieves the value stored in b and stores it in a. After this instruction a and b store the same value. (Again it is important not to read this as "a equals b" but "store the contents of b in a" - its a command not a question.)

You can also write things like:


and the right hand side, an arithmetic expression, will be worked out and stored in a. Notice you can use variables on the right hand side and their values will be retrieved and used in the calculation. 

You can generally write arithmetic expressions as you would normally but notice that the multiplication sign is "*" an asterisk and the division sign is /. Also feel free to use brackets to make sure things are worked out in the correct order. More on arithmetic and other types of expression later.

An expression can be thought of as a mini-program. It is a recipe for how to combine values stored in variables and constants to produce a new value. 

An arithmetic expression that causes a lot of problems when you first see it is:


Which if you read it as "a equals a plus 1" sounds like nonsense. What is does is to increase the value stored in a by one - i.e. its increments the value in a. If you read it as "retrieve the value in a, add one to it and store the result back in a" - then all should be clear.

Adding one to a variable is so common that Java has a special command for it:


is the same as a=a+1;

There are lots of different types of data that can be stored in a variable but for the moment integer variables will serve well as an example.

Now we have something to write instructions about lets see what sort of things we can do.