3.1 Purpose of the Bicycle class

This week you will see how to write Java code to create a class called Bicycle and how to create instances of that class. Before we look at the code, though, let’s consider why we want to have this class. Remember how we thought this class could be used in a program. A Bicycle class should allow objects to be created that model the way that the road speed of a real bike responds to change in pedalling speed and gear selection.

This would be important in some program where the speed of a bicycle is important. For example, it could be a game that involves characters racing or chasing each other on bicycles, and the pedalling speed and gear are set by the players’ controls. If the Bicycle class models the bicycles’ behaviour correctly, then the game will make sense to the players. Or, it could be a program that is built in to a computerised exercise bike, where rider wants to see a display of the speed he or she would be achieving for the amount of effort being put in.

For now it doesn’t matter, we are just looking at the Bicycle class itself, not a whole program.

3.2 Code blocks

In Java, lines of code that belong together are grouped as code blocks. The start and end of a code block are marked by curly braces:

{
    line or lines of code
    inside code block
}

Code inside a block is often indented as shown in the example above. This makes the organisation of the code much easier to understand while reading it. Actually the compiler doesn’t care about indenting, but it is good practice to indent your code carefully so that other programmers (and yourself) can read it easily. The compiler does care, very much, about code blocks, though. Putting braces in the wrong place or missing them out is a common source of compiler errors.

Code blocks can be nested inside other blocks – you will see shortly why this is useful. Nested blocks are usually further indented for readability.

{
    line or lines of code
    inside code block
    {
       line or lines of code
       inside nested code block
    }
}

The way Java uses blocks is an important part of its syntax, and is very similar to the syntax of a range of other popular programming languages.

3.3 Creating a class

The most important kind of code block is a class. The code for a whole class is enclosed in a single block. In order to define any useful behaviour, this code will almost always include other blocks nested inside it. The only part of the class outside the block is the class header, which needs to come just before the opening brace.

public class Bicycle
{
   //code for class
}

The header’s main job is to specify the name of the class, which, by convention should start with an upper case (capital) letter. The case matters – as far as Java is concerned, Bicycle is definitely not the same thing as bicycle. Using names with the wrong case is another common source of compiler errors. A further widely followed convention is that names which consist of more than one word are written with an upper case character starting each subsequent word – look out for examples of that as you study the code.

Good programmers follow conventions when writing code, and naming classes is a good example. Like indentation, the compiler doesn’t care (as long as you are consistent), but if you follow naming conventions it is much easier for other programmers to read your code and see at a glance what is the name of a class and what isn’t. It works the other way, too, making it easier for you to read someone else’s code.

The words public and class in the Bicycle class header are examples of key words. A key word has a special meaning in Java and is not the name of something. In fact, you should never try to use a key word as the name of anything in a program. BlueJ helpfully colour codes key words differently from other words to make them obvious when you read the code.

The meaning of the key word class is probably fairly obvious – it indicates that the following code block contains a class. You will learn something about the meaning of public, and see more key words, later.

3.4 Fields

Let’s start to look inside the class. The first things you see defined after the class’s opening brace are the fields.

public class Bicycle
{
    int pedalRpm;
    int gear;
    double wheelDiameter;
    int numberOfGears; 

Fields are the properties specific to an object created from that class. Each bicycle object will have its own value for pedalRpm, and so on. These are the values you see when you inspect an object in the object bench in BlueJ. Each field has a data type, e.g int and a name, e.g. pedalRpm.

The field definitions are always:

● inside the class block
● not inside any other code block within the class

They are usually defined at the start of the class, as in this example, but they don’t have to be as long as they are not inside a nested block. As usual, though, it is a good idea to follow common convention and put them at the start.

It is sometimes useful to draw a diagram of an object showing the fields and their values, rather like the window you see when you inspect an object in BlueJ. Here is an object diagram of an example bicycle object.

Another name for fields is instance variables.

💡 Read more about Instance Variables

3.7 Accessing fields of an object

When a Bicycle object is created the code in the constructor assigns values to the fields. We can now write code that reads the field values, or changes them by assigning new values. Assuming that we have run the code in the previous section, and have a variable bicycle1 that is a reference to a Bicycle object, the following code expression represents the gear field of the object:

bicycle1.gear

Similarly, bicycle1.numberOfGears represents the numberOfGears field.

Note the dot notation as mentioned above – object name.field name. Here, the object name is the name of the variable that is a reference to the object. The name we use to refer to the object also gives a way to work with that object.

This line of code declares a new int variable x and assigns to it the current value of the gear field of bicycle1.

int x = bicycle1.gear;

We can also change the field value by assigning a new value to it:

bicycle1.gear = 4;

3.8 Constructor parameters

What would happen if you tried to create an object with this code?

bicycle1 = new Bicycle(0.5);

What about this?

bicycle1 = new Bicycle(0.5, “5” );

The code for the constructor declares two parameters, the first of type double, the second of type int. These two lines supply parameters that don’t match the constructor. The first supplies only one parameter; the second supplies a second parameter that is a string, not an int.

These lines are not valid ways of creating a bicycle object. The supplied parameters must match the number and types of the parameters declared in the constructor. In either case, the compiler will find the mistake and report it as a compiler error. The compiler does a very important job of checking code and finding mistakes like this.

What about this?

bicycle1 = new Bicycle();

This is actually valid! A class can have more than one constructor – as many as you like, as long as the parameter list is different for each one. This is called constructor overloading. If you look at the code for the whole Bicycle class, you will see that there is a second constructor that takes no parameters at all, which matches the line of code above. This constructor sets sensible default values when no actual values are specified, and is known as a default constructor.

So, when the compiler finds code which creates a new object it:

Summary

You’ve been introduced in this lecture to the following concepts:

Code blocks, Code for classes, Fields, Variables, Constructors, Creating Objects

In the next lecture you will start learn how to write methods in your classes that allow objects to perform actions.