The making of DonutLand
techred home > mod 3.2: objects 2

Module 3.2: Java Objects 2 | Creature Invasion

Our Donut "blueprint" class is just the beginning of our adventure into Object-Oriented Java. This module builds on the essential concepts to explore how we can make two different types of Objects, each with clever methods which allow the passing of entire Objects between classes and methods.

This is our concluding module for this course. The concepts explored in here will be directly applicable to your work on the final Object Project.


Best to make sure you've completely digested Java Objects Module 3.1, including--most importantly--the readings about Java Objects.

module contents

wb_incandescentConcept Review: Object-Oriented Fundamentals
wb_incandescentPreparation Step 1: Building a Creature class
check_boxPreparation Step 2: Refactoring our Donut objects to make SizedDonut creatures.
check_boxCore Concept 1: Dissecting our Creature objects
bookExercise 1: Coding up our CreatureLand's main method
check_boxExercise 2: Digesting pointer/handle variables
check_boxExercise 3: Coding the guts of eatDonut and simulateEating methods
check_boxExercise 4:Implementing method logic in Creature and SizedDonut
check_boxModule Project: Making picky eaters out of our Creature objects

learning objectives

  1. Use calls to println() to show a program's path of execution which involves method calls across more than one class.
  2. Correctly call a method that requires a Java object as an input parameter.
  3. Write the "guts" of methods which implement desired functionality and prevent bad data from getting written into our member variables.

setup your workspace

Create a new package called objects2_creatures inside your working NetBeans project. Inside that package, create three new classes as follows:

flow chart for java if and while statements

The skeleton of both Creature and SizedDonut are provided in the sections below. You'll be coding the CreatureLand's main method along with Eric in a video tutorial.

motorcycleConcept Review: Object-Oriented fundamentals

Video tutorial segment 1: Review of Object concepts

In case you made your Donut-like objects a while back, this video's review of how Objects work in Java may come in handy. With the CIT-111 class at West Hills, Eric diagrams and discusses the core features of the object creation process using the new and pointer/"handle" variables

Object-Oriented fundamentals readings

arrow_upward back up to contents

extensionPreparation Step 1: Building a Creature class

Code up the following skeleton of the Creature class. Please INCLUDE the comments that are in this listing so that you have notes to refer back to as you proceed through the module. We'll be fleshing out the guts of several of the methods in this class later in the module.

flow chart for java if and while statements

Diagramming our Creature class

Your instructor wrote this class skeleton which means the class name was chosen, member variables and their type added, and the method signatures for each action the class can take are written. Return to the code and verify that the methods don't have any code in them yet!

We can still diagram the structure of a class even with incomplete methods. This allows us to communicate to other coders what our object "knows" (mem vars) and "does" (methods). Here's our creature class diagrammed using the Unified Modeling Language format for Object diagrams:

UML diagram of a Creature Object in java

Let NetBeans' class navigator help!

This style of class diagram is so common that you'll see it used by programmers in most Object-Oriented languages. Not only does NetBeans contain extensions that can draw a UML diagram from only your Java code.

While the UML style is great for sharing your ideas with other folks, NetBeans contains an dialog box that shows you the member variables and methods in that particular class. The list is contained in a mini-window called "Navigator". If it isn't sitting in the lower left corner of your NetBeans workspace, click Window >> Navigator to re-activate it. For example, when we view our Creature class in Navigator, we see this:

Class members and methods declared in the Navigator window of NetBeans

You can jump to any member variable or method listed by simply clicking the name. This is super handy when the classes you write span hundreds of lines and dozens of methods! Whoa!

arrow_upward back up to contents

motorcyclePreparation Step 2: Refactoring our Donut objects to make SizedDonut creatures.

Building on our work from last module, let's create a SizedDonut class that includes a special member variable called sizeInmm that our Creatures will use to determine if they will eat the donut or not.

flow chart for java if and while statements

We'll work more with this code later in the lesson!

arrow_upward back up to contents

motorcycleCore Concept 1: Dissecting our Creature objects

Video tutorial segment 2:

When we write classes that we will use to create Objects in java, we are designing member variables and methods that do stuff with the data in those member variables. Explore with the West Hills Java class how the Creature class has been designed.

This video is explanation heavy: don't tune out, though! Code along and tinker with Eric as the concepts are explained.

Key points from video tutorial

arrow_upward back up to contents

motorcycleExercise 1: Coding up our CreatureLand's main method

Video tutorial segment 3

Segment 3: We have written two object blueprints: one called Creature and one called SizedDonut. We will use the blueprints to create instances of each class and we will do all of this inside CreatureLand which contains the program's main method.

Code along with the video!

No guts were given for the main method in CreatureLand so we need to write that together. Before jumping into this video tutorial, make sure you have your package and class's setup as described at the top of this module. Have CreatureLand ready roll since you'll code along with the class.

Key points from video tutorial

But it doesn't do anything!

If you run the code in CreatureLand as of the end of this video, you would not see any output in the console window because the guts of our methods inside Creature and SizedDonut have nothing in them! In the next segments, we'll see how we can test the flow of execution through our various methods and, of course, write the actual code that implements the relationships between the classes and the methods.

arrow_upward back up to contents

motorcycleExercise 2: Digesting pointer/handle variables

Video tutorial segment 4: Mastering the essentials of point/handle variables

When we create an object, we must be able to access that chunk of RAM (short-term storage) and we do this through a fancy variable known in this class as a handle variable. Its also called a reference variable or a pointer variable. These are all names for the same concept.

confusing terminology note

Because many Object-oriented languages (Java, C++, Python, C#) create objects and must then manipulate and reference them in code, the notion of a pointer variable is common across the languages. Each language group, however, uses different terms: this course uses handle variable because it seems to be the most descriptive. The same idea of using a variable to access an Object stored on the Heap in memory is also called a reference variable or a pointer variable.

This is an exhaustive screen cast which digests each line of CreatureLand demonstrating how central the idea of a handle variable is to the way we program Java as object-oriented coders. Skim through the exercise steps following this tutorial so your brain has an idea of what you'll be doing with the skills reinforced in the screen cast here:

Super mini-project: Tinker with handle variables

program objective

This is an intermediate step in creating a working model of a Creature eating a SizedDonut. The methods in our blueprints have no guts yet (they are just empty blocks of code). We are making sure we have some more practice with object creation and access before moving on.

Write two new methods inside CreatureLand which will accept an object reference to either our Creature objects or SizedDonut and display the value of each of the member variables.

specification 1

Create a method called displayCreatureStats which takes as an input parameter a Creature object and returns nothing. Remember: These methods are not in "blueprint" classes so they STILL HAVE the static modifier.

Inside the guts of the method, access each of the object's member variables and send the result to the console with println(). Provide hard-coded text in your calls to println() so that the output to the console is interpretable (i.e. print "name of creature:" before outputting the Creature object's name member variable's value.

specification 2

Create another method called public static void displaySizedDonutStats that functions just like displayCreatureStats except is specific to SizedDonut objects. Each member variable should be sent to the console with nice formatting for easy reading. Remember, you'll need to add the input parameter to this method's name.

specification 3

With two methods ready to roll, you can now call each method from main and pass references to our Creature and SizedDonut objects to the appropriate methods for display of their internal values (using, of course, our handle variables).

In other words, we are sending our handle variable penguin down to displayCreatureStats. This method knows how to ask any Creature object passed in for the values of its member variables name, species and biteSizeInPercent.

tinkering ideas

Make a bunch of instances of each object type and send them down to each respective method to see how the handle variables actually work. Create a Creature named "Leslie" of type "sloth" who takes really big bites of SizedDonut objects. Make sure you can see all of Leslie's stats by using your new method!

Mini-project Help: Sample code

The following button will expose working code for a displayCreatureStats method. Note that you should always make your code your own, even if you use an aid.

arrow_upward back up to contents

motorcycleExercise 3: Coding the guts of eatDonut and simulateEating methods

Work along with Eric as we trace how execution flows through our three classes and their methods. We'll also code up the basic guts of our two key methods in our two "blueprint" classes. Be sure to have your classes all set up so you can pause and work through the exercises as they are done in the video.

As of the end of this video, you should have a working program that demonstrates that your Creature objects can, indeed, consume SizedDonut objects. This should be displayed on the console for easy checking!

arrow_upward back up to contents

motorcycleExercise 4: Implementing method logic in Creature and SizedDonut

We'll explore the power of private member variables which are only accessed through public methods. The methods will test their input parameters against some rules in the specification. Only if the input value passes muster will it be written into its own classes precious, private member variable.

The segement will also demonstrate how to provide messages to the user about the checks going on inside the public accessor methods (also called "getter" and "setter" methods).We can provide the user with clues about why their operations may not have been successful so they can try again more intelligently.

pro tip

Code that helps its user is a Good Thing.

This clip will demonstrate the concept and the Module Project following the video will ask you to check the SizedDout's size before the Creature will take a bite at all!

key term: methods

arrow_upward back up to contents

motorcycleModule Project: Making picky eaters out of our Creature objects

This is a culminating activity for this module. Half the process is probably just digesting the language used in the specification. Learning to convert English into Java. The video tutorials and the sample GitHub code will be your guide through this.


This is the trickiest project we've done, so don't be too hard on yourself if you put a few hours into it and come up a little short. Object-oriented manipulations are at the heart of Java, but are also, in many ways, advanced programming concepts. Do your best, share your code, and keep tinkering at your own pace.

Project specification:

Study this specification document carefully and code up your work to meet its requirements.

program objective

Write code in our Creature class's eatDonut(SizedDonut donutToEat) method that implements picky eater logic: if a donut is less than a minimum edible size, no "bite" should be taken.

program specification 1

Add a private member variable of an appropriate name that stores our Creature object's minimum SizedDonut preference.

Since the member variable is private, the user of our Creature class needs a way to set the Creature object's minimum bite size. This should happen in a method called something like setMinDonutSizeinmm.

Its guts should implement a basic sanity check on the minimum size value that is passed into the "setter" method (such as to make sure the size is positive). Any values that pass the test should be stored in the private member variable.

We also want to allow the user of our Creature class to check any given Creature object's minimum SizedDonut size in mm. This should occur in a method called something like getMinDonutSize.

program specification 2

Test your new structures inside class Creature by adjusting your code in CreatureLand's main method. Now our SizedDonut's member variable called sizeInmm matters to our Creature objects who consume them. This means the SizedDonut needs a value stored in its member variable before it should be considered for dinner by a Creature.

To make this process work, we need to set each instance of Creature to have a value for its member variable which stores this. Since your new member variable is private, you'll set an instance's value in main using the public method.

Sample output

The following output was produced with code that meets the above specifications. Note that the CreatureLand class contains methods which print out the values of the member variables of their respective object types. This was specified in Exercise 2's mini project.

Analyze this output closely: note that it tests the logic specified: our Creature only takes a bite of the SizedDonut object named Rolando because its size was above our Creature object named Pablo's minimum preferred size.

MiniProject output

Submitting your project

Upload all three files individually to your GitHub account. This can be done a few ways: the best is to "click and drag" your entire package directory that NetBeans used to store your .java files. Then a new directory with all your .java files will be created in GitHub and your code repo will stay organized.

If you have a dedicated directory for this module's code, you can open that directory in your own repo online, grab the URL to that page, and paste that into your tracking spreadsheet entry.

arrow_upward back up to contents

motorcycleExperimental Activity: Translating events in CreatureLand into Java!

Summon your creativity to try translating some of the following scenes into Java. You'll want to look at the variable "flags" that are in each photograph of a Donut object and adjust your member variables appropriately. You can write code in DonutLand or CreatureLand that does something with the member variables you'll need to create on your Donut objects.

This is a creative activity--not one that has specification. I'm piloting this for Fall 2018. If you think there is some hope to this idea, please let me know!

Scene T: Turtle Eats a Donut

DonutLand scene to translate into java inside CreatureLand

Scene P: Penguin Eats a Donut

DonutLand scene to translate into java inside CreatureLand

Scene O: Owl Investigates and eats a Donut

DonutLand scene to translate into java inside CreatureLand DonutLand scene to translate into java inside CreatureLand

Scene R: RoboDog eats a Donut

DonutLand scene to translate into java inside CreatureLand

arrow_upward back up to contents

Page created in April 2018 and last updated on 3 May 2018 and can be freely reproduced according to the site's content use agreement.