Share
Explore
Project Title: Java Storytellers
Project Title: Java Storytellers - From Sketch to Code
Project Grading Rubric:
Delivering the Project:
To get a passing Grade: I will run your Program 10 times. The Turtle should win at least 7 times out of 10.
The hand in for your project:
Make a Word Document - save as StudentName_studentid.docx
Into this Word Document:
Put all your Code
Screen shots of the Running Program.
Where to upload your Word Document Submission File:
Grading rubric for the Tortoise and Hare race project, designed to evaluate the core Java concepts and the storytelling elements.
Grading Rubric (100 points total)
Functionality (50 points)
Object-Oriented Design (30 points)
Storytelling and Creativity (20 points)
How to do this project: https://app.screencast.com/8pgDAYqXpx3vY
Submission Instructions: Due: APRIL 14, 2024
Objective:
To design and implement a Java application that tells a story, beginning with a hand-drawn analysis of the story's business domain, and then translating that analysis into object-oriented code.
🌟 Welcome to the Java Storytellers Project! 🌟
Embark on a Journey of Creativity and Code
Code meets creativity.
Logic intertwines with lore, and where every line of Java brings a story to life
This isn't just another coding assignment – it's an adventure into the heart of programming, storytelling, and imagination.
In the Java Storytellers Project, you'll embark on a unique mission:
**to transform a narrative of your choice into a living, breathing Java application**.
But this is no ordinary task. You'll be breathing life into characters, crafting digital worlds, and setting the stage for events that unfold through the logic and structure of Java.
#### 📖 Your Quest: From Story to Software
You will choose a story – a tale you love, a fable you admire, or maybe even a saga of your own creation – and turn it into an interactive Java experience. This story will be your blueprint; your code, the building blocks.
🚀 Unleash Your Imagination
- **Design with Flair**: Craft your story's characters, settings, and plots as Java objects. What attributes will they have? What methods will allow them to interact within your digital realm?
- **Inheritance and Polymorphism**: Use the power of Java's inheritance to define relationships between your story's entities. Watch as polymorphism brings versatility and depth to your narrative.
- **Exceptional Circumstances**: Implement custom exceptions to handle the unexpected twists and turns of your tale.
#### 🧰 Tools and Techniques
Arm yourselves with Java's powerful toolkit:
- The JDK as your forge.
- Integrated Development Environments (IDEs) as your workshop.
- Version control for collaboration and keeping track of your epic journey.
#### 🌌 Why This Journey Matters
This isn't just about fulfilling an assignment. It's about mastering the art of translating abstract concepts into concrete, functional programs. It's about understanding that at the core of every complex program is a simple story, waiting to be told.
Overview:
Students will conceptualize a story and represent it through a series of interconnected objects. This project starts with a hand-drawn design of these objects, their attributes, and interactions, serving as a preliminary business domain analysis. Students will then translate this design into a functional Java application.
Project Phases:
Phase 1: Conceptualization and Domain Analysis
Phase 2: Code Development
Phase 3: Finalization and Presentation
Submission:
Evaluation Criteria:
Deadline:
Present a representative business domain analysis telling the story of the tortoise and the hare. The rabbit thought it was faster but fooled around and got distracted. The turtle won the race by staying focused and on task. Emphasize that this is just a starter example and they should imagine their own business domain to model.
Let's create a simplified business domain analysis for the story of the Tortoise and the Hare. This example will serve as a starting point to illustrate how a story can be broken down into a domain model, which can then be translated into an object-oriented design. Students should use this as a guide to develop their own unique domain models for their stories.
Business Domain Analysis: The Tortoise and the Hare
1. Story Overview
2. Main Characters (Objects)
3. Supporting Elements
4. Interactions
5. Relationships
6. Process Flow
7. Potential Extensions
8. Visual Representation
Note to Students:
This example serves as a basic guideline. For your project, be imaginative and create a unique business domain to model. Think of a story or scenario that interests you, identify the key objects, their attributes, methods, and how they interact within your story. Remember, the more creative and detailed your analysis, the more robust your object-oriented design will be.
A skeleton code framework to show them a structure of how to get started
Below is a skeleton code framework for the Tortoise and the Hare story.
This will provide students with a basic structure to start their Java projects. It's important to note that this is a simplistic example, and students should expand and modify it to fit their chosen stories.
javaCopy code
// Main class to initiate and control the race
public class RaceController {
public static void main(String[] args) {
Race race = new Race(100); // 100 meters race
Tortoise tortoise = new Tortoise(10); // speed in meters per minute
Hare hare = new Hare(25); // speed in meters per minute
race.startRace(tortoise, hare);
}
}
// Race class
class Race {
private int distance;
private boolean isFinished;
public Race(int distance) {
this.distance = distance;
this.isFinished = false;
}
public void startRace(Tortoise tortoise, Hare hare) {
// Implement race logic here
}
// Additional methods like checkStatus, declareWinner can be added
}
// Tortoise class
class Tortoise {
private int speed;
private int distanceCovered;
public Tortoise(int speed) {
this.speed = speed;
this.distanceCovered = 0;
}
public void move() {
// Implement movement logic for Tortoise
}
// Additional methods like checkProgress can be added
}
// Hare class
class Hare {
private int speed;
private int distanceCovered;
private boolean isDistracted;
public Hare(int speed) {
this.speed = speed;
this.distanceCovered = 0;
this.isDistracted = false;
}
public void move() {
// Implement movement logic for Hare
}
public void getDistracted() {
// Implement distraction logic for Hare
}
// Additional methods like checkProgress can be added
}
Instructions for Students:
This framework is meant to be a guide. Encourage creativity and innovation in translating your story into a well-structured object-oriented program.
Illustrative code of how inheritance and polymorphism may be applied here.
To illustrate inheritance and polymorphism in the context of the Tortoise and the Hare story, we can introduce a superclass, perhaps RaceParticipant, from which both Tortoise and Hare classes will inherit.
This superclass will define common attributes and methods that are shared by both tortoise and hare. We'll then use method overriding to demonstrate polymorphism.
Here's how this can be structured:
Superclass: RaceParticipant
javaCopy code
public abstract class RaceParticipant {
protected int speed;
protected int distanceCovered;
Want to print your doc?
This is not the way.
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.