Programming Fundamentals with Java and Processing

Computers are programmable machines that process information by manipulating data. As the data can represent any real world information, and programs can be readily changed, computers are capable of solving many kinds of problems.

Programs are created in a programming language by writing a series of instructions into a text file. The files containing the program (source) code are translated into executable applications or software. Most programs are intended to serve as interactive tools for people referred to as users. Users interact with programs in many ways including:

There are many different programming languages for programmers to choose from. Each language has its own advantages and disadvantages, and new languages gain popularity while older ones slowly lose ground. In this book, we use the Java programming language. It is popular in both academia and industry.

There are many different environments where a programmer may write and test Java. We will setup a few in this chapter, but use a wide variety throughout the semester.

Processing is a Java based coding environment for graphics. We use it throughout the semester as a context for real world coding.

IntelliJ is a Java Integrated Development Environment. We use it throughout the semester for larger projects.

Programming is about processing data. Data is organized into different types. There are an endless number of data types in Java. In fact, many programmers spend most of their time coming up with new ones. Still, most Java coding is built on top of the basic data types below.

You should now be able to look at any line of Java code and identify all of its data values and their corresponding data type. Anything that is not a value, is something else that you will learn later.

Variables are (virtual) boxes that store values for reuse later. A variable has a name and a current value. Each variable can only hold one value at a time. Variables are created by specifying a data type and a name. They are assigned a value using the single equal sign (=). As Java executes one line at a time, variables come into existence on the line where they are first assigned.

Processing data is all about operations (like +). Each type of data has its own set of relevant operations. Operations usually act on 2 values and return a value (Ex: 2 + 3 returns 5). As such, they can be chained into larger expressions (Ex: 3 * (2 + 6)). Although there is an order to operation processing (* happens before +), it is always best to explicitly specify the intended order using parenthese. Java always processes the deepest parentheses first.

Variables can be modified using the = sign. Variables can only hold 1 value. The previous value is lost. Do not specify the data type when modifying a variable. Specifying a data type attempts to create a new variable.

In chapter 1 we used methods from Processing like size(), fill(), and rect(). In Chapter 2, we introduced dot methods for strings like .length() and .substring(). Calling methods tells Java to perform tasks with specific parameter values.

For example, consider the call to the rect() method below.

Calling the rect() method requires that we specify the name of the method followed by parentheses containing 4 integer parameters representing the x, y, width, height of our rectangle. That tells Java to go execute the code necessary to draw a rectangle.

Before a method can be called, it must be defined. Most methods we have used this semester have been pre-defined for you by other programmers. Here, we introduce how to define your own custom methods. Once defined, you and other programmers will be able to use them like any other method. Thus, by defining your own methods, you are adding new functionality to Java. The fundamental approach to solving large programming problems is breaking them down into small method definitions, and then calling those methods to solve the original complex problem.

Consider the Processing example below:

In this book we use some examples (like Processing) that are technically not 100% Java. These examples circumvent some of the complex syntax that a pure Java program requires. In other examples (like Java Visualizer) we stick with pure Java. In pure Java, programmers are required to organize and annotate their code with keywords that prevent other programmers from misusing code. These keywords are class, public, and static. For now, when you see one, just copy it and move on. Below are some very rough descriptions in the context of methods in case you are curious.

We will learn the full meaning of these keywords later.

When variables are created they are automatically assigned a block (chunk of code between {}) where they exist. Any attempt to use that variable outside of its block will fail. We call that block, the variable’s scope.

Earlier we introduced Processing’s setup() method, which is called automatically when Processing starts. Here we introduce the draw() method, which is called after setup() and repeated every 60 seconds enabling animations!

Up until now, every method definition we have seen has used the void keyword to declare that the method did not return a value. Now we demonstrate using a data type instead of void to setup return values.

Computers make decisions that give the illusion of "thinking". For example, a digital thermostat turns on or off the heater depending on the current temperature in the room. IBM’s Big Blue computer decides what chess piece to move next when beating world chess champions. Google’s self-driving car decides when to apply the brakes depending on what is in front of it. All computer decisions are based on conditions built out of a simple logic called Boolean logic.

Boolean logic allows a program to make a decision based on a condition. The if statement executes specific lines of code only when the condition is true. If the condition is false, the lines are skipped. The lines of code to be executed are grouped into a block using {}.

As we learned above, if statements will either execute or skip 1 block of code depending on the condition. In some situations, we want to choose between 2 blocks of code depending on the condition. This can be done with the if …​else…​ statement.

As we learned above, if else statements will execute 1 block out of 2 options, the if block or the else block. What if we want to force Java to choose 1 block out of 3 or more options? The answer is the _else if block.

As we learned above, the if statement allows us to execute a code block one time if a condition is true. The while statement, on the other hand, allows us to execute a code block repeatedly while a condition is true. This allows our code to loop potentially infinite times. To prevent infinite looping, the code block typically modifies the variable used in the condition. For example, the value of x is increased with every loop in the code snippet below.

The indexes of each value in an array are identical to the indexes for each character in a string. They start with the first value at position 0 and end with the last value at position length - 1. The indexes for the array ["Apple", "Plum", "Kiwi"] are below. Note that the array is of length 3 and thus has indexes from 0 to 2.

In many situations, we want to access every value of an array one at a time. This is accomplished by using each index from 0..length - 1 in a loop.

Computers are extremely fast at looping through arrays and searching for values that match criteria. They can process billions of values per second!

While loops that follow the standard template below can be reduced to for loops.

So far we have introduced int, doubles, boolean, characters, and Strings. Here we demonstrate how to convert from one to the other with casting for primitives and other methods for Strings.

A console, also known as a shell or terminal, is a user interface which allows programs to interact with humans through text. Unlike graphical user interfaces, a console does not allow for images, sound, video, or even mouse input.

There are a variety of methods which allow us to display (print) text to the console and read (input) data from the console.

At this point, we have learned how to solve small problems (roughly less than 10 lines of code). How do we solve large problems? There are a variety of strategies to divide and conquer large problems in programming including Object Oriented, Procedural, and Functional programming. Although Java is designed for Object Oriented programming, we choose to first explore procedural programming as it was historically the earliest and easiest approach. A procedure is another word for function or method, and in Java, is typically created with the public static keywords. We have been defining these since chapter 3. The goal is to divide the large problem into smaller methods, implement those methods, and then call them in a combination that solves the original problem.

The following exercise (to be completed by you) demonstrates the procedural approach to programming.

Notice how the final method, playKirbyFriends(), is mostly variable creation and prints to the user. In fact, without those, the logic is short and sweet.

Thus a complex problem, when broken down into simpler pieces, can have a straightforward solution. This is also known as problem decomposition. In the next chapter, we dive into Object Oriented Programming, the problem decomposition technique Java was designed for!

Let us review the main data types and corresponding operations we have learned so far.

You will immediately notice several irregularities with the String data type:

This is all due to the fact that Strings are not primitive data types.

Primitive data types, like int or boolean, are never capitalized and can only be manipulated with operators, like + or &&. Non-primitive types, like String, are called classes. They should always be capitalized and can use dot methods like .substring(). Furthermore, they can be much more sophisticated, containing complex combinations of other data types.

To defina a new data type in Jave, we use the keyword class (like class of car). Once this new data type is created, we can create values of that type. We call those values objects or instances.

Every data type has 4 essential pieces:

There is no point in creating a new data type if we don’t then create values of that type. Values of a class are called objects and are instantiated with the new keyword.

Instance methods can of course call other instance methods on the same instance / object. Use the this keyword to explicitly call instance methods using the same object. For example, since 2 dates must be either earlier, later, or equal to each other, we could implement the logic for earlier than by checking that it is not later than nor equal to another date.

Of course, classes are a very useful way to organize processing code. Take a look at the exercise below.

Anytime Java wants to convert any object into a String, it calls the toString() instance method. If your class does not have one, it uses a default version which tells us very little. Take a look at the example below:

The fields of a class can be other classes. As an example, the Date class from section 7.3 was made out of 3 int values representing month, day, and year, but we might create a Student class out of 2 objects, String and Date, representing name and birthday. The technique of using objects to build more complex objects is called object composition.

Many of the processing assignments in the remaining chapters work together to build a cannon game. The video below shows the final result in the final chapter.

As we get into more traditional layouts for class files, it is important that we take a moment to summarize the naming conventions most Java programmers stick to. As names cannot contain spaces, we use a technique called CamelCase to combing separate words into a name capitalizing the first letter of extra words in the name.

Fields, also know as instance variables, are the members of a class that make up its data. We can control whether or not other classes use them directly by declaring them as public or private.

In the example below we use the public access modifier to allow the Main class to access the Point class’s fields: