• Learn how to use inheritance

• Give you a big head start on P4 part 2
  
• Give you the opportunity to do more fun graphics on your own

Hopefully you have noticed that a major principle of computer science is eliminating duplicated code. We write methods and classes so that we can call things and create things many times while only writing it once. We use parameters and conditional statements so we can let one pice of code do many different things when it is called. We use loops and arrays so we can use code and values over and over while only writing it once.

We used interfaces so that classes that were very similar could be treated as a single type. That way we use any of several completely different solutions in one place. However, the interfaces had no code in them, and the classes could not share any code. If we have classes that are very similar, but with several important differences, we may be forced to write a single very complicated class, or we may have to write the shared code several times. As computer scientists, we don't like this. Duplicated code takes time to write, and it's much harder to debug and maintain.

This is why we use inheritance. Given some class that has code we'd like to use, we can extend that class. The new class (the subclass) has the all the instance fields and methods of the original class (the superclass). However, it can also have additional methods and fields. The subclass is a special, more specific type of the superclass. For example, if we write an Animal class, we create Bird and Fish as subclasses. If we wish to write a Parrot and a Flamingo class, they can use Bird for their superclass (thus Animal is also a superclass). All animals might have a weight and length, but only Fish would have an isSaltWaterFish() method.

This project relies heavily on inheritance. To complete this project, you should have a solid grasp of inheritance. Read this section and the book again if you are still unclear. To complete this project, you will need to understand many things about inheritance. Among them are these:

• To extend a class, you need to add extends className to the class header
• Subclasses may be stored in a variable with with a type that is a super class.
• Subclasses share data members, but that does not mean they can access them--the variables are probably private.
• Subclasses share methods. If the subclass declares a method with the same header (name, return type, parameters) it will override the super method--the object will use the overriding method instead. Otherwise, it will just use the super classes method
• Subclasses can call methods from its superclass even if they are overriden by calling super.methodName(...)
• When constructing an instance of a subclass, it is built on top of an instance of the super class. Thus the first line of sub classes should include a call to a constructor from the super class using super(...)
• While a class can implement several interfaces, they can only extend one class.

• The Particle class now has methods to retrieve its position, color and velocity
• Particles are no longer affected by Gravity (you'll add gravity back in later)
• The Particles are now bigger so you can see what's happening.
• You can set the Position and Velocity of Particles
• The ParticleList and FireworksController, which you worked on last time are supplied.  The ParticleList is the same, but the FireworksController is considerably different.
• Size is handled more elegantly.  The FireworksController has a new windowSize field.
• The FireWorks controller now accepts keyboard input.  You can press the number keys to select a type of Particle to fire.  Clicking will now launch a stream of Particles of that type.  More on this later.