diff --git a/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/Main.java b/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/Main.java index cad5849f1..de67c8a41 100644 --- a/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/Main.java +++ b/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/Main.java @@ -1,8 +1,14 @@ package org.launchcode; -public class Main { + public class Main { - public static void main(String[] args) { - // write your code here + public static void main(String[] args) { + MenuItem item1 = new MenuItem(10.99, "Caesar Salad", "Appetizer", true); + MenuItem item2 = new MenuItem(15.99, "Steak Dinner", "Main Course", false); + // Create more menu items as needed... + + // Test the methods of your MenuItem class here + item1.printMenuItem(); + // You can use other methods to set and get properties as well. + } } -} diff --git a/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/MenuItem.java b/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/MenuItem.java index 776c2764d..32d2da3b9 100644 --- a/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/MenuItem.java +++ b/classes-part-one/studio/restaurant-menu/src/main/java/org/launchcode/MenuItem.java @@ -6,26 +6,61 @@ public class MenuItem { private String category; private boolean isNew; - public MenuItem(double p, String d, String c, boolean iN) { - this.price = p; - this.description = d; - this.category = c; - this.isNew = iN; + public MenuItem(double price, String description, String category, boolean isNew) { + this.price = price; + this.description = description; + this.category = category; + this.isNew = isNew; + } + + public double getPrice() { + return price; } public void setPrice(double price) { this.price = price; } + public String getDescription() { + return description; + } + public void setDescription(String description) { this.description = description; } + public String getCategory() { + return category; + } + public void setCategory(String category) { this.category = category; } - public void setNew(boolean aNew) { - isNew = aNew; + public boolean isNew() { + return isNew; + } + + public void setNew(boolean isNew) { + this.isNew = isNew; + } + + // Method to determine whether two menu items are equal + public boolean equals(MenuItem other) { + if (this == other) return true; + if (other == null || getClass() != other.getClass()) return false; + + if (Double.compare(other.price, price) != 0) return false; + if (isNew != other.isNew) return false; + if (!description.equals(other.description)) return false; + return category.equals(other.category); + } + + // Method to print a single menu item + public void printMenuItem() { + System.out.println("Description: " + description); + System.out.println("Category: " + category); + System.out.println("Price: $" + price); + System.out.println("New: " + (isNew ? "Yes" : "No")); } } diff --git a/control-flow-and-collections/exercises/collections-exercises b/control-flow-and-collections/exercises/collections-exercises new file mode 160000 index 000000000..7839f590a --- /dev/null +++ b/control-flow-and-collections/exercises/collections-exercises @@ -0,0 +1 @@ +Subproject commit 7839f590ae90a0acf6c978ed25e2797d364d8c07 diff --git a/control-flow-and-collections/studio/counting-characters b/control-flow-and-collections/studio/counting-characters new file mode 160000 index 000000000..5e963c79a --- /dev/null +++ b/control-flow-and-collections/studio/counting-characters @@ -0,0 +1 @@ +Subproject commit 5e963c79adfb27b331c95b45a26e6d0e3847e4c0 diff --git a/control-flow-and-collections/studio/studio.iml b/control-flow-and-collections/studio/studio.iml new file mode 100644 index 000000000..174c8bcef --- /dev/null +++ b/control-flow-and-collections/studio/studio.iml @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/datatypes/datatypes-exercises/src/main/java/org/launchcode/HelloWorld.java b/datatypes/datatypes-exercises/src/main/java/org/launchcode/HelloWorld.java new file mode 100644 index 000000000..36d6e01d4 --- /dev/null +++ b/datatypes/datatypes-exercises/src/main/java/org/launchcode/HelloWorld.java @@ -0,0 +1,13 @@ +package org.launchcode; + +import java.util.Scanner; + +public class HelloWorld { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + + System.out.println("Hello, what is your name:"); + String name = input.nextLine(); + System.out.println("Hello " + name); + } +} diff --git a/datatypes/datatypes-exercises/src/main/java/org/launchcode/InputOutput.java b/datatypes/datatypes-exercises/src/main/java/org/launchcode/InputOutput.java new file mode 100644 index 000000000..9f4da8a80 --- /dev/null +++ b/datatypes/datatypes-exercises/src/main/java/org/launchcode/InputOutput.java @@ -0,0 +1,4 @@ +package org.launchcode; + +public class InputOutput { +} diff --git a/datatypes/datatypes-exercises/src/main/java/org/launchcode/RectangleArea.java b/datatypes/datatypes-exercises/src/main/java/org/launchcode/RectangleArea.java new file mode 100644 index 000000000..5a2fbcec1 --- /dev/null +++ b/datatypes/datatypes-exercises/src/main/java/org/launchcode/RectangleArea.java @@ -0,0 +1,19 @@ +package org.launchcode; + +import java.util.Scanner; + +public class RectangleArea { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + + System.out.println("Enter the length of the rectangle:"); + double length = input.nextDouble(); + + System.out.println("Enter the width of the rectangle:"); + double width = input.nextDouble(); + + double area = length * width; + + System.out.println("The area of the rectangle is: " + area); + } +} diff --git a/datatypes/datatypes-exercises/src/main/java/org/launchcode/SearchTerm.java b/datatypes/datatypes-exercises/src/main/java/org/launchcode/SearchTerm.java new file mode 100644 index 000000000..e1f2df0f8 --- /dev/null +++ b/datatypes/datatypes-exercises/src/main/java/org/launchcode/SearchTerm.java @@ -0,0 +1,17 @@ +package org.launchcode; + +import java.util.Scanner; + +public class SearchTerm { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + + String sentence = "Alice was beginning to get very tired..."; + System.out.println("Enter a term to search for:"); + String searchTerm = input.nextLine(); + + boolean found = sentence.toLowerCase().contains(searchTerm.toLowerCase()); + System.out.println("Search term found: " + found); + } +} + diff --git a/datatypes/datatypes-exercises/src/main/java/org/launchcode/StringManipulation.java b/datatypes/datatypes-exercises/src/main/java/org/launchcode/StringManipulation.java new file mode 100644 index 000000000..41903413c --- /dev/null +++ b/datatypes/datatypes-exercises/src/main/java/org/launchcode/StringManipulation.java @@ -0,0 +1,27 @@ +package org.launchcode; + +import java.util.Scanner; + +public class StringManipulation { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + + String sentence = "Alice was beginning to get very tired..."; + System.out.println("Enter a word to search for:"); + String word = input.nextLine(); + + int index = sentence.toLowerCase().indexOf(word.toLowerCase()); + int wordLength = word.length(); + + if (index != -1) { + System.out.println("Word found at index: " + index); + System.out.println("Word length: " + wordLength); + + // Remove the word + String updatedSentence = sentence.substring(0, index) + sentence.substring(index + wordLength); + System.out.println("Updated sentence: " + updatedSentence); + } else { + System.out.println("Word not found in the sentence."); + } + } +} diff --git a/datatypes/datatypes-studio/src/main/java/org/launchcode/Area.java b/datatypes/datatypes-studio/src/main/java/org/launchcode/Area.java new file mode 100644 index 000000000..f699d2956 --- /dev/null +++ b/datatypes/datatypes-studio/src/main/java/org/launchcode/Area.java @@ -0,0 +1,16 @@ +package org.launchcode; + +import java.util.Scanner; + +public class Area { + public static void main(String[] args) { + Scanner input = new Scanner(System.in); + + System.out.println("Enter a radius: "); + double radius = input.nextDouble(); + + double area = Circle.getArea(radius); + + System.out.println("The area of a circle of radius " + radius + " is: " + area); + } +} diff --git a/datatypes/datatypes-studio/src/main/java/org/launchcode/Circle.java b/datatypes/datatypes-studio/src/main/java/org/launchcode/Circle.java new file mode 100644 index 000000000..6fddf4633 --- /dev/null +++ b/datatypes/datatypes-studio/src/main/java/org/launchcode/Circle.java @@ -0,0 +1,7 @@ +package org.launchcode; + +public class Circle { + public static Double getArea(Double radius) { + return 3.14 * radius * radius; + } +} diff --git a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/BaseDisc.java b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/BaseDisc.java new file mode 100644 index 000000000..41d2e26e3 --- /dev/null +++ b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/BaseDisc.java @@ -0,0 +1,56 @@ +package org.launchcode; + +public abstract class BaseDisc { + + // Fields + //name : Store the name of the disc + private String name; + + //Store the storage capacity of the disc + private double storageCapacity; + + //Store the data content of the disc + private String contents; + + // Constructors + //Initializes the name and storage capacity of the disc and sets the initial contents to an empty string. + //Getters and Setters: Provide access to the fields. + public BaseDisc(String name, double storageCapacity) { + this.name = name; + this.storageCapacity = storageCapacity; + this.contents = ""; + } + + // Getters and Setters + public String getName() { + return name; + } + + public double getStorageCapacity() { + return storageCapacity; + } + + public String getContents() { + return contents; + } + + public void setContents(String contents) { + this.contents = contents; + } + + // Custom Methods + // Represents the common spinning behavior for all optical discs. This method is inherited by both CD and DVD classes but can be overridden. + public void spinDisc() { + // This method can be common for both CD and DVD + System.out.println("A disc spins."); + } + + //Represents the common behavior for ejecting a disc + public void ejectDisc() { + // Common method for ejecting a disc + System.out.println("Ejecting the disc."); + } + + // An abstract method that forces subclasses (CD and DVD) to provide their own implementation to return information about the disc + public abstract String discInfo(); +} diff --git a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/CD.java b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/CD.java index 51781c249..5a2a0f8d7 100644 --- a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/CD.java +++ b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/CD.java @@ -1,8 +1,47 @@ package org.launchcode; -public class CD { - // TODO: Implement your custom interface. - // TODO: Determine which fields, methods, and constructors can be extended from the base class and which ones - // need to be declared separately. +//This class extends BaseDisc and implements the OpticalDisc interface. It provides the specific implementation for CDs +public class CD extends BaseDisc implements OpticalDisc { + + public CD(String name, double storageCapacity) { + super(name, storageCapacity); + } + + //Overrides the spinDisc() method to provide CD-specific spinning behavior. + //Implements the methods defined in the OpticalDisc interface for CD-specific behavior + + @Override + public void spinDisc() { + // Override spinDisc() method for CD + System.out.println("A CD spins at a rate of " + CD_MIN_SPIN_SPEED + " - " + CD_MAX_SPIN_SPEED + " rpm."); + } + + //Stores data on the CD. + @Override + public void storeData(String data) { + // Implementation specific to CD + setContents(data); + } + + //Reads data from the CD. + @Override + public String readData() { + // Implementation specific to CD + return getContents(); + } + +//Writes data to the CD. + @Override + public void writeData(String data) { + // Implementation specific to CD + setContents(data); + } + + //Provides CD-specific information about the disc. + @Override + public String discInfo() { + // Implementation specific to CD + return "CD Name: " + getName() + ", Storage Capacity: " + getStorageCapacity() + " MB"; + } } diff --git a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/DVD.java b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/DVD.java index 7c2442568..024677ef3 100644 --- a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/DVD.java +++ b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/DVD.java @@ -1,8 +1,47 @@ package org.launchcode; -public class DVD { - // TODO: Implement your custom interface. - // TODO: Determine which fields, methods, and constructors can be extended from the base class and which ones - // need to be declared separately. +//This class also extends BaseDisc and implements the OpticalDisc interface. It provides the specific implementation for DVDs +public class DVD extends BaseDisc implements OpticalDisc { + + public DVD(String name, double storageCapacity) { + super(name, storageCapacity); + } + + // method to provide DVD-specific spinning behavior. + //Implements the methods defined in the OpticalDisc interface for DVD-specific behavior + @Override + public void spinDisc() { + // Override spinDisc() method for DVD + System.out.println("A DVD spins at a rate of " + DVD_MIN_SPIN_SPEED + " - " + DVD_MAX_SPIN_SPEED + " rpm."); + } + + //Stores data on the DVD + @Override + public void storeData(String data) { + // Implementation specific to DVD + setContents(data); + } + + //Reads data from DVD + @Override + public String readData() { + // Implementation specific to DVD + return getContents(); + } + + + //Writes data to the DVD + @Override + public void writeData(String data) { + // Implementation specific to DVD + setContents(data); + } + + // Provides DVD specific information about DVD + @Override + public String discInfo() { + // Implementation specific to DVD + return "DVD Name: " + getName() + ", Storage Capacity: " + getStorageCapacity() + " GB"; + } } diff --git a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/Main.java b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/Main.java index 7d00acf4c..e14e0016d 100644 --- a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/Main.java +++ b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/Main.java @@ -3,8 +3,22 @@ public class Main { public static void main(String[] args) { - // TODO: Declare and initialize a CD and a DVD object. + // Declare and initialize a CD and a DVD object. + CD myCd = new CD("Sample CD", 700); + DVD myDvd = new DVD("Sample DVD", 4.7); - // TODO: Call each CD and DVD method to verify that they work as expected. + // Call each CD and DVD method to verify that they work as expected. + myCd.spinDisc(); + myDvd.spinDisc(); + + // Example usage of other methods: + myCd.storeData("Data for CD"); + myDvd.storeData("Data for DVD"); + + System.out.println("CD Contents: " + myCd.readData()); + System.out.println("DVD Contents: " + myDvd.readData()); + + System.out.println(myCd.discInfo()); + System.out.println(myDvd.discInfo()); } -} \ No newline at end of file +} diff --git a/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/OpticalDisc.java b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/OpticalDisc.java new file mode 100644 index 000000000..69803d78e --- /dev/null +++ b/interfaces/studio/spinning-discs-studio/src/main/java/org/launchcode/OpticalDisc.java @@ -0,0 +1,27 @@ +package org.launchcode; + +public interface OpticalDisc { + + // Constants + double CD_MIN_SPIN_SPEED = 200; + double CD_MAX_SPIN_SPEED = 500; + double DVD_MIN_SPIN_SPEED = 570; + double DVD_MAX_SPIN_SPEED = 1600; + + // Method signatures + //This method signature represents the spinning behavior of optical discs. It's an essential behavior for both CDs and DVDs, but the specific implementation differs. + void spinDisc(); + + + //This method signature represents storing data on the disc + void storeData(String data); + + // This method signature represents reading data from the disc. + String readData(); + + //This method signature represents writing data to the disc + void writeData(String data); + + //This method signature represents getting information about the disc, such as its name and storage capacity + String discInfo(); +} diff --git a/qodana.yaml b/qodana.yaml new file mode 100644 index 000000000..cee4e3dbb --- /dev/null +++ b/qodana.yaml @@ -0,0 +1,31 @@ +#-------------------------------------------------------------------------------# +# Qodana analysis is configured by qodana.yaml file # +# https://www.jetbrains.com/help/qodana/qodana-yaml.html # +#-------------------------------------------------------------------------------# +version: "1.0" + +#Specify inspection profile for code analysis +profile: + name: qodana.starter + +#Enable inspections +#include: +# - name: + +#Disable inspections +#exclude: +# - name: +# paths: +# - + +projectJDK: 17 #(Applied in CI/CD pipeline) + +#Execute shell command before Qodana execution (Applied in CI/CD pipeline) +#bootstrap: sh ./prepare-qodana.sh + +#Install IDE plugins before Qodana execution (Applied in CI/CD pipeline) +#plugins: +# - id: #(plugin id can be found at https://plugins.jetbrains.com) + +#Specify Qodana linter for analysis (Applied in CI/CD pipeline) +linter: jetbrains/qodana-jvm-community:latest diff --git a/unit-testing/chapter-example/car-example/src/test/java/org/launchcode/CarTest.java b/unit-testing/chapter-example/car-example/src/test/java/org/launchcode/CarTest.java index f7b0c6f6e..092d5bf50 100644 --- a/unit-testing/chapter-example/car-example/src/test/java/org/launchcode/CarTest.java +++ b/unit-testing/chapter-example/car-example/src/test/java/org/launchcode/CarTest.java @@ -1,11 +1,38 @@ package org.launchcode; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class CarTest { + private Car testCar; + + @BeforeEach + public void createCarObject() { + testCar = new Car("Toyota", "Prius", 10, 50); + } + + @AfterEach + public void cleanup() { + // Perform any cleanup tasks here (e.g., closing resources, resetting states) + } + + @Test + public void emptyTest() { + assertEquals(10, 10, 0.001); + } + + @Test + public void testInitialGasTank() { + assertEquals(10, testCar.getGasTankLevel(), 0.001); + } + + // TODO: Add more test methods as needed for your Car class //TODO: add emptyTest so we can configure our runtime environment (remove this test before pushing to your personal GitLab account) //TODO: constructor sets gasTankLevel properly //TODO: gasTankLevel is accurate after driving within tank range //TODO: gasTankLevel is accurate after attempting to drive past tank range //TODO: can't have more gas than tank size, expect an exception -} \ No newline at end of file +} + diff --git a/unit-testing/studio/balanced-brackets/src/main/java/org/launchcode/BalancedBrackets.java b/unit-testing/studio/balanced-brackets/src/main/java/org/launchcode/BalancedBrackets.java index 890783e59..37a10d048 100644 --- a/unit-testing/studio/balanced-brackets/src/main/java/org/launchcode/BalancedBrackets.java +++ b/unit-testing/studio/balanced-brackets/src/main/java/org/launchcode/BalancedBrackets.java @@ -1,5 +1,7 @@ package org.launchcode; + public class BalancedBrackets { + /* * The function BalancedBrackets should return true if and only if * the input string has a set of "balanced" brackets. @@ -11,10 +13,10 @@ public class BalancedBrackets { * The string may contain non-bracket characters as well. * * These strings have balanced brackets: - * "[LaunchCode]", "Launch[Code]", "[]LaunchCode", "", "[]" + * "[LaunchCode]", "Launch[Code]", "[]LaunchCode", "", "[]" * * While these do not: - * "[LaunchCode", "Launch]Code[", "[", "][" + * "[LaunchCode", "Launch]Code[", "[", "][" * * @param str - to be validated * @return true if balanced, false otherwise @@ -27,7 +29,51 @@ public static boolean hasBalancedBrackets(String str) { } else if (ch == ']') { brackets--; } + + // If brackets go negative at any point, return false + if (brackets < 0) { + return false; + } } return brackets == 0; } -} \ No newline at end of file + + // Additional unit tests + public static void main(String[] args) { + // Test 1: Only brackets in correct order + System.out.println(hasBalancedBrackets("[]")); // Should return true + + // Test 2: Only brackets in reverse order + System.out.println(hasBalancedBrackets("][")); // Should return false + + // Test 3: Brackets in the middle of a string + System.out.println(hasBalancedBrackets("Launch[Code]")); // Should return true + + // Test 4: Brackets with non-bracket characters + System.out.println(hasBalancedBrackets("[Hello] World!")); // Should return true + + // Test 5: Unbalanced brackets + System.out.println(hasBalancedBrackets("[LaunchCode")); // Should return false + + // Test 6: Empty string + System.out.println(hasBalancedBrackets("")); // Should return true + + // Test 7: Nested brackets + System.out.println(hasBalancedBrackets("[[Nested]]")); // Should return true + + // Test 8: Only open bracket + System.out.println(hasBalancedBrackets("[LaunchCode")); // Should return false + + // Test 9: Only close bracket + System.out.println(hasBalancedBrackets("Launch]Code]")); // Should return false + + // Test 10: Balanced brackets with spaces + System.out.println(hasBalancedBrackets("[Launch Code]")); // Should return true + + // Test 11: Nested brackets with non-bracket characters + System.out.println(hasBalancedBrackets("La[un]ch[Co]de")); // Should return true + + // Test 12: Non-bracket characters with no brackets + System.out.println(hasBalancedBrackets("LaunchCode")); // Should return true + } +} diff --git a/unit-testing/studio/balanced-brackets/src/test/java/org/launchcode/BalancedBracketsTest.java b/unit-testing/studio/balanced-brackets/src/test/java/org/launchcode/BalancedBracketsTest.java index a9d8821b3..2616f3f4b 100644 --- a/unit-testing/studio/balanced-brackets/src/test/java/org/launchcode/BalancedBracketsTest.java +++ b/unit-testing/studio/balanced-brackets/src/test/java/org/launchcode/BalancedBracketsTest.java @@ -1,13 +1,37 @@ package org.launchcode; import org.junit.jupiter.api.Test; - import static org.junit.jupiter.api.Assertions.*; class BalancedBracketsTest { - //TODO: add tests here + + @Test + public void testCorrectlyBalancedBrackets() { + assertTrue(BalancedBrackets.hasBalancedBrackets("[]")); + assertTrue(BalancedBrackets.hasBalancedBrackets("[LaunchCode]")); + assertTrue(BalancedBrackets.hasBalancedBrackets("Launch[Code]")); + assertTrue(BalancedBrackets.hasBalancedBrackets("[]LaunchCode")); + assertTrue(BalancedBrackets.hasBalancedBrackets("")); + assertTrue(BalancedBrackets.hasBalancedBrackets("[]")); + assertTrue(BalancedBrackets.hasBalancedBrackets("[[Nested]]")); + assertTrue(BalancedBrackets.hasBalancedBrackets("[Launch Code]")); + assertTrue(BalancedBrackets.hasBalancedBrackets("La[un]ch[Co]de")); + assertTrue(BalancedBrackets.hasBalancedBrackets("LaunchCode")); + } + @Test - public void emptyTest() { - assertEquals(true, true); + public void testIncorrectlyBalancedBrackets() { + assertFalse(BalancedBrackets.hasBalancedBrackets("[LaunchCode")); + assertFalse(BalancedBrackets.hasBalancedBrackets("Launch]Code]")); + assertFalse(BalancedBrackets.hasBalancedBrackets("][")); + assertFalse(BalancedBrackets.hasBalancedBrackets("]LaunchCode[")); + assertFalse(BalancedBrackets.hasBalancedBrackets("[La[unc]hCo[de")); + assertFalse(BalancedBrackets.hasBalancedBrackets("Launch]Code")); + assertFalse(BalancedBrackets.hasBalancedBrackets("[LaunchCode]Extra]")); + assertFalse(BalancedBrackets.hasBalancedBrackets("[[Nested]")); + assertFalse(BalancedBrackets.hasBalancedBrackets("Launch][Code]")); + assertFalse(BalancedBrackets.hasBalancedBrackets("]")); } -} \ No newline at end of file + + // Additional test cases can be added here as needed +}