Skimpy OOP: Introduction to Object-Oriented Programming Using Java

Source code examples from this chapter and associated videos are available on GitHub.

It’s fun to create programs that display stuff on the screen, but that’s pretty limited. To start doing things that are more interesting—​and useful—​we’ll need to keep track of some information. In computer programming, a piece of information is called data.

In broad terms, there are two kinds of data:

In our Hello World code, the letters and characters we output are constant data.

The only way to change what’s output is by editing that constant—​in the quotation marks—​in our source code, before we run the program.

In order for our programs to be flexible and responsive, we’ll need variables. I encourage beginning students to think of a variable like a container, such as a cup.

The container can hold one thing at a time. We can put coffee in it, or we can put water in it—​but we can’t put both. If we start with coffee and decide we want to put water in there, the coffee gets dumped out and is gone forever. That’s fine, but we better make sure we don’t want the coffee anymore before we put something else in the mug.

A variable works the same way. It can hold one value, and that value can vary—​remember, that’s where the name comes from—​but once it’s changed, that old value is lost.

I guess we could mix coffee and water, but then that’s really a new substance and we can’t get back our plain coffee (or our water). If we want to store coffee and water, we can do that by using two different containers.

From a programming perspective—​rather than a coffee perspective—​a variable is a location in the computer’s memory where we can store a value. In order to use that value, we have to know where to find it, so we give the memory location a name, technically called an identifier.

And the computer will need to know how much memory to set aside for that variable, which depends on the kinds of values we want to store. Storing the number 7 doesn’t take very much space; storing a picture of John Elway takes a lot more space (but it’s worth it). The type of data we can store in a variable is called its

…​drumroll, please…​

data type.

Reserving a memory location by specifying a data type and identifier is known as declaring a variable. Placing data in that variable is referred to as assigning a value to a variable.

Variable names (more properly called variable identifiers) are the character sequences that identify a variable. There are a few rules that determine whether or not an identifier is valid:

In addition to those technical rules about identifier names, the convention in Java is to use descriptive names in "camel case" format, as described in the preceding video. Single-letter variable names, like x for a number, are fine in your math class, but are generally not okay when you’re coding. The expectation in my course is that your code will align with those conventions—​because that’s what industry people expect—​and you will lose points if you don’t.

Variables for storing numbers come in two flavors: integers and floating-point numbers. As you may remember from your math class, an integer is a whole number; that is, a number that doesn’t include any decimal places or fractional values. 5 is an integer, -824 is an integer, while 3.14 and 7 1/2 are not.

A floating-point number includes decimals, so 3.14 can be stored as a floating-point number. 7 1/2 can also be stored as a floating-point number, but only as a decimal (i.e., 7.5).

The most common numeric data types in Java are int for integers and double for floating-point numbers. You can get pretty far in programming just using those two, and in courses I teach you won’t need to use any other numeric data types—​but others do exist.

Other data types for integers are byte, short, and long. These different types exist because they use different amounts of memory. byte and short are smaller than int, while long is larger. The impact of these different memory sizes (or memory allocations) is that the types can store values of different sizes. For example, a byte uses 8 bits of memory and can store a number between -128 and 127 (inclusive), while an int takes 32 bits and can store a value between -2,147,483,648 and 2,147,483,647 (inclusive).

The other floating-point data type in Java is called float. It’s called "single" in some programming languages, which helps understand where the name double comes from: double uses twice as much memory (64 bits) as a float or "single" (32 bits)--and therefore its range of values is twice as big. Be aware that to make a float number in Java, you have to add the letter F (in capital or lowercase form) at the end of the number.

A boolean variable has only two possible values: true and false. It’s useful for tracking information that is only one thing or the other. Am I passing this class? The answer to that is either true or false--there is no other possibility. Does Julia own a car? Again, only two possible answers to that question; she either owns one or she doesn’t.

The best practice is to name a boolean variable in a way that expresses this either/or state. That is to say, we usually name our boolean variables using words like is, has, can, and so on.

boolean variables go hand-in-hand with Boolean expressions which are statements that evaluate to be either true or false, like those questions above. We’ll look at this "Boolean logic" in the chapter on decisions.

If we want to store a single character, like a student’s letter grade or their first initial, we can use the char data type. Char literals are created by putting a character in single quotes, and that character can be a letter, number, punctuation mark or symbol—​or some other weird stuff, too.

A char is really just an integer, but the number it holds conforms to a standard list of character values called ASCII (with the fun pronunciation "Ass key"). In this standard, the number 65 is a capital 'A', 66 is 'B', and so on. Lowercase letters are considered different characters, so 97 is 'a' and 98 is 'b'. Check out the complete ASCII table if you’re curious.

A char is pretty limited since it can only hold a single character. If we want to put a collection of characters together to make words and sentences, we need multiple chars grouped into a single variable. That data type is called String, because it strings together a bunch of chars, like a string of holiday lights.

A String is different from the other data types we’ve looked at so far. The types we’ve seen so far are primitive data types, and String is what’s called a reference data type (though some folks might prefer the more generic "non-primitive data type"). Primitives are stored differently in memory, and they are not objects--which we’ll learn more about later. For now, a really important thing to notice and remember is that primitive types start with a lowercase letter (int, double, etc.) and reference types start with a capital letter: so you have to remember to type String with a capital S.

String literals are denoted with double quotation marks.

Strings are really important and there’s all kinds of fun and useful stuff we can do with them, but we’ll need to save all of that for later while we stay focused on the basics.

A constant is similar to a variable, with two rules:

To create a constant, add the keyword final at the start of your statement, followed by the rest of a declaration and assignment statement you’d use for a variable. So that people looking at your code can easily tell it’s a constant rather than a variable, it should be named with all capital letters, using the underscore character to separate words.

There are a few different reasons to use constants in your code. For now: * Constants improve readability—​they identify the purpose of a value within your code. * Constants prevent writing code that accidentally changes a value that shouldn’t change. * Constants make code easier to maintain/update. * In some situations, constants are more efficient than variables.

Assigning a value to a variable or constant does not produce any output. If we want to display the output of a variable—​or a constant—​we just put the identifier in a print() or println() statement without any quotation marks:

This code output Sam Cooke was born in 1931. We can combine output into one statement by creating a string with multiple pieces using the + symbol.

Creating a String using the ` symbol is called _concatenating_. Be thoughtful when concatenating, because the ` symbol is also used to do addition with numbers, as you’ll see.

For our purposes, there’s no difference between outputting using separate print() statements or concatenating everything in one statement; you can use whichever approach you prefer (and we’ll learn other ways to output values, too).

To start doing some calculations, we’ll use operators. You can think of an operator as a symbol that performs a calculation or other action. You’ve been using an operator already: the assignment operator, which uses the = symbol. The action it completes is assigning the value on the right of the = symbol to the variable on the left. Arithmetic operations work in a similar way. In Java, there are five basic arithmetic operators:

The arithmetic operators work pretty much the way you’d expect, except maybe modulo--which might be a term you’ve never heard before. Each operator acts on the value to either side:

Until now, our code hasn’t been interactive—​each execution of a program results in the exact same output, and the user never has the chance to input anything. To produce output, we’ve been using System.out to send text to the "standard output device"--your monitor. For input, we’ll need to use the "standard input device" (your keyboard) by accessing System.in. We can access that input device using something called the Scanner class.

The Scanner class includes a variety methods for working with input "streams" (including input sources other than a keyboard), but the ones you’ll need for our work are shown below.