This is an old revision of the document!
Table of Contents
Defining Classes in Java
We are going to write a simple class for implementing a counter similar to one of these:1)
In case you've never seen one of these bits of advanced technology before, it's a tally counter or, as I prefer to call it, a clicker counter. It has two controls: a button on top you click to advance the counter by one and another button elsewhere you press to reset the count to zero. Our goal is to build one of these in software using object-orientation.
We first have to decide what a counter thing is. One way to start building this model for a class is to start listing the public-facing behavior (or the interface) you want an object of that class to have. A pretty comprehensive list of the things you might do with a clicker-counter is:
- click: makes the count increase by one.
- reset: sets the count to zero.
Next we can think about what attributes we'll need to keep track of the state of a clicker-counter. In this case, it's pretty simple: all we really need is one integer to store the count value.
So, a summary of what we need so far is:
- a click operation
- a reset operation
- an integer to store the count
In Java, object attributes, which together make up the state, are defined in variables called instance variables. A class definition can include as many instance variables as it needs to store the state. In our case, we are getting off easy: the clicker-counter only needs one. The operations our object will be capable of, which make up behavior, are defined using methods. We call anything belonging to a class (e.g., instance variables and methods) a member of the class.
Our first Java class
Class names in Java traditionally use CamelCase with the first letter capitalized.
Here's a Java definition for a ClickerCounter
class:
public class ClickerCounter { int count; void click(){ count++; } void reset(){ count = 0; } }
This definition states that an instance of a ClickerCounter will consist of a count
member variable, a method click()
that increments the count, and a reset()
method that resets the count.
Where does the definition go?
The easy-for-beginners way
If there's only one custom class in your program, an easy way to write your program is to incorporate the definition and the program's main()
method.
This isn't generally recommended though because very often you will write more than one custom class in your program.
The better way
In Java, class definitions need to go in their own files, and the files need to be called the name of the class with the .java
extension.2) I have deliberately not used any comments in the definition so you can more easily see the code.
In the above, count
is an attribute/instance variable that keeps track of the state of the object. the click
and reset
methods implement the behavior. In actuality, this is a pretty crappy class definition for reasons we'll see later. But for now it's enough to get us started
Instantiation and use
The above is just a class definition. It doesn't actually make an object we can use.
The program below shows you how to make, or instantiate a ClickerCounter
and then call the object's methods to change the state of the object.
- ClickerExample.java
public class ClickerExample { public static void main(String[] args) { var myCounter = new ClickerCounter(); // instantiate a ClickerCounter myCounter.reset(); // count is 0 myCounter.click(); // count is 1 System.out.println(myCounter.count); myCounter.click(); // count is 2 myCounter.click(); // count is 3 System.out.println(myCounter.count); myCounter.reset(); // count is 0 System.out.println(myCounter.count); } }
Access specifiers
The ClickerCounter
class definition above effectively encapsulates the state and behavior of a clicker counter. But it has issues. For example, if we change our example as follows:
- ClickerExample.java
public class ClickerExample { public static void main(String[] args) { var myCounter = new ClickerCounter(); myCounter.reset(); myCounter.count = 492341; // <- LOOK HERE! System.out.println(myCounter.count); myCounter.click(); myCounter.click(); System.out.println(myCounter.count); } }
the object will happily oblige the user's wish to set the count to some arbitrary value. That's not something you can typically do with a clicker counter. In other words, the object offers no protection of its state. This is easy enough to solve with Java's access modifiers. Let's look at a modified version of our class definition that gives us some protection using access modifiers:
- ClickerCounter.java
public class ClickerCounter { private int count; public void click(){ count++; } public void reset(){ count = 0; } }
Access modifiers are placed before the start of a member. Java offers four levels of protection, and they just so happen to all start with the letter 'p':
package
: this is what you get by default (i.e., when you don't specify anything, as in our first definition of the class). It means anything within the same package as the class definition is able to access the member.public
: anyone anywhere can access the member. This is a good choice for methods that are part of the class' interface.private
: only those of the same class can access the member.protected
: only those of the same _or a derived_ class can access the member. 3)
With the changes made above, if we try to run ClickerExample
we will see that the code will refuse to compile. When the compiler hits the statement
myCounter.count = 492341;
it cannot access the count
member of myCounter
because we said it's private. Remember, we want our objects to be self-governing, and this helps make sure this is the case.
In Java programming, it's considered a best practice to make all member variables private
or protected
, except in some rare situations.
Methods can be at whatever access level is appropriate for their use. If it is part of the class' interface, it should be public
. If it's for use only internally by the object, it will typically be private
or protected
.
Copyright © 2020 Mithat Konar. All rights reserved.
private
and protected
won't be clear until you've studied class inheritance.