Week 13
Source Code
import java.util.*;
public class Week13 {
public static void main(String[] args) {
String myName = ""; // add your name
System.out.println("Week 13" + " - " + myName);
// Menu
System.out.println("Menu");
System.out.println("E1 - Example 1");
// setup Scanner
Scanner in = new Scanner(System.in);
System.out.print("Choice: ");
String choice = in.nextLine();
// switch choices
switch (choice) {
case "E1":
System.out.println("Example 1");
example1();
break;
case "E2":
System.out.println("Example 2");
example2();
break;
case "E3":
System.out.println("Example 3");
example3();
break;
case "E4":
System.out.println("Example 4");
example4();
break;
case "E5":
System.out.println("Example 5");
example5();
break;
case "E6":
System.out.println("Example 6");
example6();
break;
case "E7":
System.out.println("Example 7");
example7();
break;
default:
System.out.println("Invalid choice");
}
}
// example1 method
public static void example1() {
// Create two points
// Display the points
}
// example2 method
public static void example2() {
// Create two points
// Display the points
// Swap the coordinates
// Display the points
}
// example3 method
public static void example3() {
}
// example4 method
public static void example4() {
}
// example5 method
public static void example5() {
// Create coins for two players
// Each player flips their coin
// Show the results of the flips
// Determine the winner
}
// example6 method
public static void example6() {
// Using the default constructor
}
// example7 method
public static void example7() {
// Using the parameterized constructor
}
}
Point.java
/**
* The Point class represents a point in 2D space
* with x and y coordinates.
*/
public class Point {
// instance variables
/**
* Constructs a Point with specified x and y coordinates.
*
* @param x The x-coordinate of the point.
* @param y The y-coordinate of the point.
*/
/**
* Sets the x-coordinate of the point.
*
* @param x The new x-coordinate.
*/
/**
* Sets the y-coordinate of the point.
*
* @param y The new y-coordinate.
*/
/**
* Gets the x-coordinate of the point.
*
* @return The x-coordinate.
*/
/**
* Gets the y-coordinate of the point.
*
* @return The y-coordinate.
*/
/**
* Returns a string representation of the point.
*
* @return A string in the format "(x, y)".
*/
@Override
}Coin.java
/**
* The Coin class represents a coin with two sides: Heads and Tails.
* It provides methods to flip the coin, check if it's heads,
* and retrieve the current state as a string.
*/
public class Coin {
// instance variables
// 0 for Heads, 1 for Tails
/**
* Initializes the coin by flipping it to set a random initial state.
*/
/**
* Flips the coin to randomly set the state to Heads or Tails.
*/
/**
* Checks if the current state of the coin is Heads.
*
* @return true if the coin is heads, false otherwise.
*/
/**
* Returns a string representation of the current state of the coin.
*
* @return "Heads" if the coin is heads, "Tails" otherwise.
*/
@Override
}Book.java
public class Book {
// Properties
// Constructor
// Getters
// Method to mark the book as read
// Method to provide a string representation of the book
@Override
// Main method to test the Book class
public static void main(String[] args) {
// Create three instances of your favorite books
// Print the title, author, and pages for each book
// Mark all books as read
// Print each book's string representation
}
}
Ingredient.java
/**
* The Ingredient class represents an ingredient in a recipe or inventory.
* Each ingredient has a name, an amount, a unit of measurement, and an
* indication of whether it is organic.
*/
public class Ingredient {
// Instance variables
private String name;
private double amount;
private String unit;
private boolean organic;
/**
* Constructs a new Ingredient with the specified properties.
*
* @param name The name of the ingredient.
* @param amount The quantity of the ingredient.
* @param unit The unit of measurement for the ingredient.
* @param organic True if the ingredient is organic; false otherwise.
*/
public Ingredient(String name, double amount, String unit, boolean organic) {
this.name = name;
this.amount = amount;
this.unit = unit;
this.organic = organic;
}
/**
* Returns the name of the ingredient.
*
* @return The name of the ingredient.
*/
public String getName() {
return name;
}
/**
* Returns the amount of the ingredient.
*
* @return The quantity of the ingredient.
*/
public double getAmount() {
return amount;
}
/**
* Returns the unit of measurement for the ingredient.
*
* @return The unit of measurement (e.g., "cups", "grams").
*/
public String getUnit() {
return unit;
}
/**
* Checks if the ingredient is organic.
*
* @return True if the ingredient is organic, false otherwise.
*/
public boolean isOrganic() {
return organic;
}
}Recipe.java
/**
* The Recipe class represents a recipe with a name, a main ingredient,
* a secondary ingredient, and a cooking time. It provides methods to calculate
* the cost of the recipe, check if the recipe is fully organic, and determine
* the nutritional rating based on ingredient properties.
*/
public class Recipe {
// Instance variables
private Ingredient mainIngredient;
private Ingredient secondaryIngredient;
private String name;
private int cookingTime;
/**
* Constructs a new Recipe with the specified name, ingredients, and cooking
* time.
* If invalid parameters are provided, default values are used instead.
*
* @param name The name of the recipe.
* @param main The main ingredient of the recipe.
* @param secondary The secondary ingredient of the recipe.
* @param cookingTime The cooking time in minutes. If less than or equal to
* zero, defaults to Integer.MIN_VALUE.
*/
public Recipe(String name, Ingredient main, Ingredient secondary, int cookingTime) {
this.name = name.trim();
this.mainIngredient = main;
this.secondaryIngredient = secondary;
// Validate and assign cooking time
if (cookingTime <= 0) {
this.cookingTime = Integer.MIN_VALUE;
} else {
this.cookingTime = cookingTime;
}
}
/**
* Calculates the total cost of the recipe.
*
* @return The total cost of the recipe.
*/
public double getCost() {
double baseCost = mainIngredient.getAmount() * 2.5 +
secondaryIngredient.getAmount() * 1.5;
if (isFullyOrganic()) {
baseCost *= 1.5; // Organic premium
}
return baseCost;
}
/**
* Checks if the recipe is fully organic.
*
* @return True if both ingredients are organic, false otherwise.
*/
public boolean isFullyOrganic() {
return mainIngredient.isOrganic() &&
secondaryIngredient.isOrganic();
}
/**
* Determines the nutritional rating of the recipe.
*
* @return The nutritional rating ("A", "B", or "C").
*/
public String getNutritionalRating() {
if (isFullyOrganic()) {
return "A";
} else if (mainIngredient.isOrganic() || secondaryIngredient.isOrganic()) {
return "B";
} else {
return "C";
}
}
/**
* Returns the cooking time for the recipe.
*
* @return The cooking time in minutes.
*/
public int getCookingTime() {
return cookingTime;
}
/**
* Returns a string representation of the recipe.
*
* @return A string containing the recipe details.
*/
@Override
public String toString() {
String recipeString = "Recipe: " + name + "\n";
recipeString += "Main Ingredient: " + mainIngredient.getName() + "\n";
recipeString += "Secondary Ingredient: " + secondaryIngredient.getName() + "\n";
recipeString += "Rating: " + getNutritionalRating() + "\n";
recipeString += "Cooking Time: " + getCookingTime() + " minutes";
return recipeString;
}
}
MealPlan.java
/**
* The MealPlan class represents a weekly meal plan, including two recipes,
* the total number of servings, and methods to calculate cost and check if
* the plan is fully organic.
*/
public class MealPlan {
/**
* Constructs a MealPlan with the specified name, recipes, and servings.
* If invalid parameters are provided, default values are used.
*
* @param name The name of the meal plan.
* @param breakfastRecipe The breakfast recipe.
* @param lunchRecipe The breakfast recipe.
* @param dinnerRecipe The dinner recipe.
*/
/**
* Calculates the total cost of the meal plan for the week.
*
* @return The total cost of the meal plan.
*/
/**
* Checks if the meal plan is fully organic.
*
* @return True if both recipes are fully organic, false otherwise.
*/
/**
* Returns a summary of the meal plan, including its name, total cost,
* and organic status.
*
* @return A summary string of the meal plan.
*/
public static void main(String[] args) {
// breakfast recipe
// lunch recipe
// dinner recipe
// Valid meal plan
}
}
Calculator.java
import java.util.*;
/**
* The Calculator class provides basic arithmetic operations.
* @author CGA Student
*/
public class Calculator {
/**
* Adds two integers.
*
* @param a the first integer
* @param b the second integer
* @return the sum of a and b
*/
public int add(int a, int b) {
return a + b;
}
/**
* Main method.
*
* @param args command line arguments (not used)
*/
public static void main(String[] args) {
Calculator calculator = new Calculator();
// Example
System.out.println("Addition: " + calculator.add(10, 5));
// Ask the user for two numbers
}
}
Last updated
Was this helpful?