Need to implement an UML to java code. Choose one of the two UML's and just implement.

Overview - Teaching children good behavior is a central activity to parenting. Generally there are two models for doing so:

• Positive reinforcement, in which children are rewarded for good behavior. For example, a parent may add a marble to a cup every time the child exhibits good behavior, and after a certain number of marbles are collected, the child may cash them in for a reward (like ice cream, a new video game, etc.) (The parent could also remove marbles for bad behavior.)
• Punishment, in which children are given negative consequences for bad behavior. With this model, a parent may add a marble to a cup every time the child exhibits bad behavior, and after a certain number of marbles are collected, the child must experience some negative consequence (like losing video game privileges, doing extra chores, etc.) (The parent could also remove marbles for good behavior.)

In either model, parents often find it hard to keep track of a child's rewards or consequences, especially when they have multiple children. Thus, your client wants you to develop Behave!, a program that allows parents to manage their children's behavior by keeping track of their rewards and/or consequences, much like in the above examples, but in an automated way. Below are the detailed requirements for Behave! The program will be developed in Java.

Tokens - In Behave!, all behavior is rewarded/punished in the form of tokens. Tokens are equivalent to marbles in the above examples.

Modes - A parent must choose a mode for each child: positive or negative.

• In positive mode, tokens are positive, meaning that the parent gives the child one or more tokens for good behavior (as in example 1 above), and can take them away for bad behavior. In this mode, tokens should look positive (e.g., have a happy face on them).
• In negative mode, tokens are negative, meaning that the parent gives the child one or more tokens for bad behavior (as in example 2 above), and can take them away for good behavior. In this mode, tokens should look negative (e.g., have a sad face on them).

 Users - There are two types of users: parents and children.

Parents should be able to:

• add, edit and delete children
• add, edit and delete tokens

When a token is added, it should be time stamped and the parent can optionally add a note about why the token was added

• view the status of all their children (number of tokens and info about each token)
• redeem a child's tokens for a reward (positive mode) or a consequence (negative mode)
• define, per child, the number of tokens required for redemption and (optionally) what the tokens will be redeemed for
• define one mode per child
• schedule tokens to be automatically added periodically (e.g., one per day)

Children should be able to:

• view the status of their tokens (number of tokens and info about each token)
• redeem their tokens for a reward (positive mode)

Simplifications/Clarifications/Assumptions -

This initial version of Behave! will be a simplified proof-of-concept version to demonstrate the feasibility of the approach. Thus, there are some simplifications that you can make:

• No authentication is needed, just identifying users by a simple username is fine.
• For this version of Behave!, there doesn't have to be a GUI-it can all work through the command line if that is easier for you.
• The program does not need to save anything-when it is closed all data is lost, and that is fine

Future Changes -

For future versions of Behave!, the customer is planning the following features:

• Adding a GUI (if you don't already have one)
• The addition of other types of modes
• The ability to have multiple modes for one child
• Saving data and allowing the user to load it again over multiple uses of the program
• A "view history" feature in which users can view behavior history over time
• Allowing parents to choose customized images to represent tokens in the GUI
• Adding a teacher user so that parents and teachers can collaborate to manage children's behavior

Assignment: Behave! Implementation

Description -

You are to implement someone else's design, namely, the design that you ranked first (although you are allowed to change your mind at any point if you wish). In making this implementation, you have two goals:

1. To hand in a fully working Behave! program, adhering to all the original requirements (not future changes) of Behave! The only requirement that is optional for this assignment is the console input/output. If you feel it would be easier to make a GUI, you are welcome to, but it is not necessary.

2. To adhere to the chosen design as much as possible

Deliverables

1. Submitted as a single zip file via Canvas:

Working Java code (both source and a JAR file)

Brief instructions on how to provide input to the program

The original design you implemented

A revised UML document describing the design underlying the code (i.e., the design you eventually implemented)

A document describing any and all changes you had to make to the original design with a motivation as to why:

Why you made these changes

Why these changes could not be avoided.

Assignment - https://www.dropbox.com/s/gs0ksj8lmmmgcpi/Assignment.zip?dl=0