Project 3 - Preliminary

The programming concept that I'm going to use is Objects, I have chosen this because It's an integral part of Object Oriented Programming.
Seeing as the idea of an Object is quite literal I'm going to focus on how an Object is built from its Class and Sub-Classes creating the Objects State, and how an Objects Behavior is affected with Functions.
With this in mind I've put the development of Objects into steps and have thought of design ideas around this. The first step being defining the Class, the second step affecting the Class Attributes and Behavior, and the third step the output of the Object.

1st Idea - Cookie Cutter
Class - Cookie cutter
Attributes - Icing
Object - Cookies
*has no behavior

2nd Idea - Object Program
Class - Ball
Attributes - Velocity, direction, colour, size
Object - Moving ball
*time consuming

3rd Idea - Blueprint -> Flowchart Diagram -> Image

Class - Blueprint image (vehicle)
Sub-Class - Blueprint image (different types of vehicles)
Attributes - Flowchart (Color-coded for State Attributes and Behavior Attributes)
Object - Image of Selected vehicle
*a path showing the selection process from Class to Object
*got to come up with attributes

Would like to incorporate the flowchart into a program but time constraints
time management plan - get it done by the 27th
cost/equipment - wall to stick paper on, paper printed on

Project 3 - pre 5

program that allows the user to fill in variables to make an object act in different ways. shows the modularity of objects

Project 3 - pre 4

pixels, magnets, photos

Project 3 - pre 3

class is a blueprint for object
object is an instance of the class

- blueprint pic (car blueprint)
- object pic (proper car with color)
- run time movement (car doing stuff)

or

- blueprint of armyman
- object is individual armymen all lined up
- run time is armymen moving round

Project 3 - pre 2

Focus on

1. Modularity: The source code for an object can be written and maintained independently of the source code for other objects. Once created, an object can be easily passed around inside the system.
2. Information-hiding: By interacting only with an object's methods, the details of its internal implementation remain hidden from the outside world.
3. Code re-use: If an object already exists (perhaps written by another software developer), you can use that object in your program. This allows specialists to implement/test/debug complex, task-specific objects, which you can then trust to run in your own code.
4. Pluggability and debugging ease: If a particular object turns out to be problematic, you can simply remove it from your application and plug in a different object as its replacement. This is analogous to fixing mechanical problems in the real world. If a bolt breaks, you replace it, not the entire machine.

Project 3

I'm thinking of classes and objects,

cookie cutter, cookie

Project2 - Final(2)

http://openprocessing.org/visuals/?visualID=27876

Link to my openprocessing sketch.