The document outlines the requirements for a programming application that teaches students about animal characteristics through software using inheritance. Developers are instructed to create a program that includes classes for animals and allows for adding specific types, particularly mammals and birds, with future extensibility options. Key features include handling user input, creating a factory method to prevent plain animal creation, and implementing testing methods to ensure functionality and correctness.

1. Application: Animal Characteristics
In today’s fast-paced world, it is important for programmers to
think about potential
future changes that impact their programs. One way that
software developers can
address this concern is by designing programs that are easy to
upgrade and are
adaptable to new technologies. In this Application, you work
toward this goal by writing
a program that uses the concept of inheritance to allow for later
additions.
For this Application:
Create a program using the principles of inheritance based on
the following scenario:
Scenario: The teachers of a local school need a program to teach
their students the
basics about animals and their characteristics. The teachers
want the program to
contain a database of animals, from which the teachers can
choose animals to add to a

2. list. The list will be displayed on the students’ monitors so they
can study the animals
and their characteristics. Right now, the teachers want a
program that handles only
mammals and birds, but in the future they may want to add
other types of animals. The
teachers also expect the program to run smoothly and be
thoroughly tested to handle
extraneous input.
Create a program that fulfills the specifications outlined in the
scenario above. Use the
concept of inheritance to allow for later additions to the
program. Also use the TDD
concepts from Unit 1 to test the program as you go.
Follow the steps below to create the program:
Create a class Animal with these variables:

3. Add these methods:
strings
“I walk on four legs.” or “I run on four legs.” depending on
whether fast is false or true, respectively.
Create two classes, Mammal and Bird, each of which extends
Animal.
In the constructor for Mammal, set the variable integument to
the string “hair”. Do
not declare the variable again; it has already been declared in
Animal. Similarly, in the
constructor for Bird, set integument to the string “feathers”.
In the Bird class, override the movement method to return either
“I walk on two
legs.” or “I fly.” depending on the setting of the fast parameter.
Use the
@Override annotation.
Create additional classes to represent specific kinds of animals

4. (each extends either
Mammal or Bird). In each class, set the kind variable and
override the sound()
method. For example, you might create a Duck class, setting the
kind to “duck” and
overriding the sound() method to return the string “„quack‟” (in
single quotes).
Note: Remember to test the methods as you go. Use the
principles of TDD that you
examined in Unit 1. The methods you write in this program are
simple and only return
strings, so they are relatively easy to test.
Users should be able to create animals of any kind you have
defined (duck, cow, etc.),
but you should also prevent the user from creating a “plain”
animal, because there's no
such thing. Every animal has to be a specific kind. Do this by
writing a factory method in
the Animal class—that is, a method to create objects of various
animal kinds. Here's

5. how:
t, prevent users from creating a “plain” animal by writing
a no-argument
constructor for Animal, but making it private.
takes the
desired kind of animal (such as “duck”), calls the constructor
for that particular
kind of animal, and returns the result. If given an unrecognized
string, the method
should not crash; it should return null.
Your test of the newInstance method must verify that the
objects it creates are equal
to objects created by calling the appropriate constructor (for
instance, new Duck())
directly. Testing equality (that is, calling assertEquals) requires
an equals method in
the Animal class. There are five different characteristics that
should be equal for two
animals to be equal—their kinds, their integuments, their slow
and fast movements, and

6. the sounds they make. You don't need to test for every kind of
animal you define, but
you should test at least one kind of bird and one kind of
mammal. Also, don't forget to
test the newInstance method with an unrecognized (or
misspelled) kind of animal.
Write a print method in your Animal class. When called, it
should print out all the
information about “this” animal, for instance:
I am a duck.
I have feathers.
When I go slowly, I walk on two legs.
When I go fast, I fly.
The sound I make is „quack‟.
Note that the sound of the animal has single quotes around it
when you see it displayed
in the output of your program. The sound method returns a
string which contains a
single quote, the sound, and then another single quote.

7. Write a class called AnimalStuff containing a main method. In
this class, define an
ArrayList of Animal.
In case you are not familiar with ArrayList, you need to import
java.util.ArrayList and your declaration should look something
like
ArrayList<Animal> myList = new ArrayList<Animal>();
Although a normal array has a fixed size which you specify, an
ArrayList does not
and can grow as elements are added to it. You can find more
information about
ArrayList in the Java API.
An ArrayList<Animal> can hold a mixture of all kinds of
animals.
Finally, in your main class, write a loop asking the user which
of three things to do: Add
an animal of a chosen type to the list, print (every animal in)
the list, or quit the

8. program. If the user asks for an animal your program doesn't
recognize, don't add null
to the list, but do inform the user of the problem.
Use a Scanner (import java.util.Scanner) to read input from the
user. First,
create a Scanner object:
Scanner scanner = new Scanner(System.in);
Then, to read a word typed in by the user, you can use the
following:
String word = scanner.next();
To read in an entire line, use:
String line = scanner.nextLine();
To read in an integer, use:
int number = scanner.nextInt();

9. To read in a floating-point number, say:
double fpNumber = scanner.nextDouble();
Include screenshots of your program running as part of your
submission. Show five
valid animals being added and two invalid animals trying to be
added. Also show
screenshots of the printed list after each animal is added.
Include screenshots of your
program being tested with JUnit.
Save your NetBeans Project and screen shots of the working
program as a ".zip" file.