BHSawesome AP CSA

One of the great things about Java is the number of libraries written by other programmers that we can use. One such library is the Turtle Java library, written by one of the author’s of this book, Dr. Barbara Ericson and built into this book. It allows us to create drawings using animated turtles that move around the screen. Try clicking run below to see a turtle in action.

The Turtle library is named after its main class, Turtle. Classes are the main building blocks of Java programs and libraries. We’ll discuss writing our own classes in Chapter 8 Classes, but in this unit, we just want to focus on using classes that other programmers have written.

Each class defines a new kind of value similar to how each primitive type—int, double, and boolean—define a particular kind of value, such as a 32-bit integer quantity for an int or a 64-bit floating point value for a double. These new kinds of values, defined by classes, are called objects which is where object-oriented programming gets its name. The values defined by the Turtle class represent turtles that can move around the screen, drawing lines. Objects are also called instances of their class.

Classes define the structure of objects in terms of attributes and behaviors. Attributes are the data that makes up the object, each stored in a variable defined by the class. Objects can be more complex than primitive values since they can consist of an arbitrary number of attributes unlike primitive values which are always just one value. And unlike primitive values, which can only be operated on with a fixed set of operators like + and *, objects can have an arbitrary number of behaviors that describe what we can do with those objects. These behaviors are defined in the class as methods.

The following picture of a turtle shows some of the attributes every Turtle object has, such as a color, xPos, yPos, and heading as well as behaviors implemented as methods like forward(), backward(), turnLeft(), and turnRight() shown in the picture written around the turtle.

While the class Turtle defines what attributes each turtle has, every turtle object has its own value for each attribute. So we can have one blue turtle at position 200,100 and one red turtle at position 50,75, just like we can have one int whose value is 2 and another whose value is 10. The actual Turtle class defines several more attributes than the ones shown in the image but these are the main ones we need to know about to understand drawing with turtles.

Similarly, the behaviors defined by the Turtle class are shared among all turtle objects, but their exact effects will usually depend on the attributes of the specific turtle object the method is called on. For instance, the forward() method, as you’ll see in the next exercise, causes a turtle to move forward and draw a line. Where the line is drawn will depend on the turtle’s position and heading attributes and the color of the line will be determined by the turtle’s color. Calling forward() on a different turtle value would still draw a line but it would likely be in a different position and might be a different color. Calling a method may also change an object’s attributes—after we called forward() the turtle’s position will have changed but its heading and color will stay the same.

To see an example of this, look at the the Java program in the exercise below. It creates a Turtle object and stores a reference to it in the variable yertle. The following two lines of code are used to tell the turtle to move forward and then turn right.

yertle.forward();
yertle.turnRight();

The period (.) after yertle in both those lines is called the dot operator and it allows us to access the attributes and methods of an object. In the first line the dot says get the method named forward() defined in the Turtle class and call it on the turtle object named by the variable yertle. The exact behavior of the method will depend on the current values of yertle’s attributes such as its color, its x and y position, and its heading. For instance, calling forward() will cause the turtle to draw a line from its current x and y position to a new position 100 pixels away in whatever direction the turtle is facing. The color of the line will be determined by the turtle’s color.

public class TurtleTest {
---
    public static void main(String[] args) {
---
        World habitat = new World(300,300);
        Turtle yertle = new Turtle(habitat);
---
        yertle.turnRight();
---
        yertle.right(); #paired
---
        yertle.forward();
---
        yertle.forward() #paired
---
        yertle.turnLeft();
---
        yertle.forward(50);
---
        habitat.show(true);
---
    } // end main
} // end class

While classes are the main building blocks of Java programs, most programs and libraries are made up of multiple classes that need to be used together. In Java, related classes can be grouped together into a package. You can think of a package like a folder where you store related documents. Classes that work together will likely be grouped into a single package just to keep things organized. But more importantly, when we want to use a class defined in a package in our own program, we can import it and then use it as if we had written it in our own program.

Because related classes are usually collected into the same package, Java programmers tend to use the terms library, API, and package somewhat interchangeably. But to be precise, a library is a collection of classes that you can use, the library’s API describes how you use it, and the classes in the library are probably organized into one or more Java packages.

Later on, we will learn to import classes from Java packages to use in our code, but first let’s talk about a package whose classes are always available in any Java program: java.lang.

The java.lang package contains key classes that are fundamental to the Java programming language, such as String and System. Like all packages that are part of Java, java.lang is documented in Javadocs, Java’s version of online API documentation. Learning to read and navigate Javadocs is a key part of being a Java programmer.

The Javadocs for a class will document all the publicly available attributes (called fields in Javadocs) and behaviors (called methods). How can you tell fields and methods apart when you look at library documentation? Well, for one thing, they’re in different sections. And another easy way is that methods will always have parentheses after them, for example forward() or println(). Sometimes there’s nothing between the parentheses, but they are still necessary. Other times they contain data that the method needs to do its job, for example what to print. Since attributes, a.k.a. fields, are just variables they will not have parentheses after the name.

Make yertle the Turtle draw a shape. For example, have it draw a square or a zigzag shape or a block letter by calling the forward method and a turn method multiple times. We encourage you to work in pairs for this challenge. In the next lessons, we will draw more complicated shapes. Here are some simple turtle methods that you could use or look at the Turtle Javadocs for the complete list.