Lagt till kommentarer samt ändrat till mer funtionell kod på vissa ställen

Author: codebyNorthsteep

src/main/java/com/example/warehouse/Category.java

@@ -4,34 +4,51 @@
 import java.util.Map;
 import java.util.Objects;
 
+/**
+ * Represents a product category. This class implements the Flyweight design pattern,
+ * ensuring that only one instance exists for each unique category name
+ * after normalization (e.g., "food", "Food", and "FOOD" all map to "Food").
+ */
 public class Category {
+
     private final String name;
+    //Map to store and retrieve Category instances.
     private static final Map<String, Category> categories = new HashMap<>();
 
+    /**
+     * Private constructor for the Flyweight pattern. Instances can only be created
+     * internally via the Code.of factory method.
+     *
+     * @param name The name of the category.
+     */
     private Category(String name) {
         this.name = name;
     }
-// factory method
 
+    /**
+     * Factory method to retrieve a Category instance based on the input name.
+     * The input name is validated and then normalized (first letter capitalized, rest lowercased)
+     * before checking the cache.
+     *
+     * @param name The desired category name (case-insensitive for lookup).
+     * @return A unique, cached instance of the Category.
+     * @throws IllegalArgumentException if the provided name is null or blank.
+     */
     public static Category of(String name) {
 
         if (name == null) throw new IllegalArgumentException("Category name can't be null");
         if (name.isBlank()) throw new IllegalArgumentException("Category name can't be blank");
-        //if (name.isEmpty()) throw new IllegalArgumentException("Category name can't be blank");
 
-        //Tar banan och gör om den till Banan - normaliserar namnet för att kunna matcha namnet i (flyweight/cache) syfte
         String normalized = name.trim().substring(0, 1).toUpperCase() + name.trim().substring(1).toLowerCase();
 
-        if (categories.containsKey(normalized)) {
-            return categories.get(normalized); //Återanvänd det som finns
-        } else {
-            Category category = new Category(normalized);//skapa ny om ej funnen
-            categories.put(normalized, category);
-            return category;
-        }
+        return categories.computeIfAbsent(normalized, Category::new);
     }
 
-
+    /**
+     * Retrieves the name of the category.
+     *
+     * @return The normalized name of the category (e.g., "Food").
+     */
 
     public String getName() {
         return name;

src/main/java/com/example/warehouse/ElectronicsProduct.java

@@ -4,51 +4,71 @@
 import java.math.RoundingMode;
 import java.util.UUID;
 
-import static java.lang.String.format;
-
-public class ElectronicsProduct extends Product implements Shippable{
-//    Implements Shippable.
-//    Fields: int warrantyMonths, BigDecimal weight (kg).
-//    Validation: negative warranty -> IllegalArgumentException("Warranty months cannot be negative.").
-//    productDetails() should look like: "Electronics: Laptop, Warranty: 24 months".
-//    Shipping rule: base 79, add 49 if weight > 5.0 kg.
+/**
+ * Represents an electronic item in the warehouse.
+ * An ElectronicsProduct implements Shippable (it has a weight and calculated shipping cost)
+ * and includes a specific warranty period.
+ */
+public class ElectronicsProduct extends Product implements Shippable {
+
     private final int warrantyMonths;
     private final BigDecimal weight;
+
+    /**
+     * Constructs a new ElectronicsProduct.
+     * * @param id The unique identifier for the product.
+     *
+     * @param name           The name of the electronic product.
+     * @param category       The product's category.
+     * @param price          The initial price of the product.
+     * @param warrantyMonths The length of the product warranty in months.
+     * @param weight         The weight of the product.
+     * @throws IllegalArgumentException if the warranty months or weight is negative.
+     */
     public ElectronicsProduct(UUID id, String name, Category category, BigDecimal price, int warrantyMonths, BigDecimal weight) {
-        super(name, category, price);
-        //validering om pris negativt warrantyMonths
-        if(warrantyMonths < 0)  throw new IllegalArgumentException("Warranty months cannot be negative.");
-        if(weight.compareTo(BigDecimal.ZERO) < 0)  throw new IllegalArgumentException("Weight cannot be negative.");
+        super(id, name, category, price);
+        if (warrantyMonths < 0) throw new IllegalArgumentException("Warranty months cannot be negative.");
+        if (weight.compareTo(BigDecimal.ZERO) < 0) throw new IllegalArgumentException("Weight cannot be negative.");
         this.warrantyMonths = warrantyMonths;
         this.weight = weight;
     }
 
+    /**
+     * Provides a summary of the electronics product.
+     * * @return A String containing the product name and its warranty period.
+     */
     @Override
     public String productDetails() {
         return String.format("Electronics: %s, Warranty: %s months", name(), warrantyMonths);
     }
 
+    // --- Implementation of Shippable Interface ---
+
+    /**
+     * Calculates the shipping cost for electronics, applying a surcharge for heavy items.
+     * Base cost is 79. An extra of 49 is added if the weight is over 5 units(kg).
+     * * @return The calculated shipping cost, rounded up to two decimals.
+     */
     @Override
     public BigDecimal calculateShippingCost() {
-        //Baspris 79, om vikten är över 5kg baspris + 49
-        //if (weight > 5.0)
-        //konvertera tillbaka weight som en BigDecimal
-        //HALF_UP
-        //this.weight.add(BigDecimal.valueOf(weight()));
+
         BigDecimal baseShippingCost = BigDecimal.valueOf(79);
         BigDecimal extraShippingCost = BigDecimal.valueOf(49);
 
         if (this.weight.compareTo(BigDecimal.valueOf(5)) > 0) {
             baseShippingCost = baseShippingCost.add(extraShippingCost);
         }
-      return baseShippingCost.setScale(2, RoundingMode.HALF_UP);
-
-
+        return baseShippingCost.setScale(2, RoundingMode.HALF_UP);
     }
 
+    /**
+     * Retrieves the weight of the product as a double.
+     *
+     * @return The product's weight.
+     */
     @Override
     public Double weight() {
+        // Converts the BigDecimal weight to a double for the interface contract.
         return this.weight.doubleValue();
-        //i calculateShipping - konvertera tillbaka till BigDecimal
     }
 }

src/main/java/com/example/warehouse/FoodProduct.java

@@ -3,42 +3,78 @@
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.time.LocalDate;
-import java.util.Objects;
 import java.util.UUID;
 
-//todo Rad 293 i basictest
-public class FoodProduct extends Product implements Perishable, Shippable{
+/**
+ * Represents a food product in the warehouse.
+ * A FoodProduct implements both  Perishable (has an expiration date) and
+ * Shippable (has a weight and a defined shipping cost calculation).
+ */
+public class FoodProduct extends Product implements Perishable, Shippable {
 
     private final LocalDate expirationDate;
     private final BigDecimal weight;
 
-    public FoodProduct(UUID id, String name,Category category,BigDecimal price, LocalDate expirationDate, BigDecimal weight) {
-        super(name, category, price);
-        //Validering för vikt med negativt värde
-        if(weight.compareTo(BigDecimal.ZERO) < 0)  throw new IllegalArgumentException("Weight cannot be negative.");
+    /**
+     * Constructs a new FoodProduct.
+     *
+     * @param id             The unique identifier for the product
+     * @param name           The name of the food product.
+     * @param category       The product's category.
+     * @param price          The initial price of the product.
+     * @param expirationDate The date on which the product expires.
+     * @param weight         The weight of the product.
+     * @throws IllegalArgumentException if the provided weight is negative.
+     */
+    public FoodProduct(UUID id, String name, Category category, BigDecimal price, LocalDate expirationDate, BigDecimal weight) {
+
+        // Calls the abstract Product constructor.
+        super(id, name, category, price);
+        if (weight.compareTo(BigDecimal.ZERO) < 0) throw new IllegalArgumentException("Weight cannot be negative.");
         this.expirationDate = expirationDate;
         this.weight = weight;
     }
+
+    /**
+     * Provides a summary of the food product, forced from the superclass.
+     * * @return A formatted String containing the product name and its expiration date.
+     */
     @Override
     public String productDetails() {
         return String.format("Food: %s, Expires: %s", name(), expirationDate);
     }
 
-   @Override
+    // ----- Implementation of the interface Shippable ----
+
+    /**
+     * Calculates the shipping cost based on the product's weight.
+     * Uses weight * 50, rounded to two decimals.
+     * * @return The calculated shipping cost.
+     */
+    @Override
     public BigDecimal calculateShippingCost() {
-       //Validations: negative price -> IllegalArgumentException("Price cannot be negative."); negative weight -> IllegalArgumentException("Weight cannot be negative.").
-       //Shipping rule: cost = weight * 50.
 
-       return weight.multiply(new  BigDecimal(50)).setScale(2, RoundingMode.HALF_UP);
+        return weight.multiply(new BigDecimal(50)).setScale(2, RoundingMode.HALF_UP);
     }
+
+    /**
+     * Retrieves the weight of the product as a double.
+     * * @return The product's weight.
+     */
     @Override
     public Double weight() {
 
         return this.weight.doubleValue();
     }
+    // ----Implementation of the Interface Perishable ----
+
+    /**
+     * Retrieves the specific expiration date for this food product.
+     * * @return The product's expiration date.
+     */
     @Override
     public LocalDate expirationDate() {
-        //returnera this för att referera till denna specifika instans i FoodProdukt
-        return  this.expirationDate;
+
+        return this.expirationDate;
     }
 }

src/main/java/com/example/warehouse/Perishable.java

@@ -3,15 +3,23 @@
 import java.math.BigDecimal;
 import java.time.LocalDate;
 
+/**
+ * Defines a contract for products that have an expiration date, such as food or certain chemicals.
+ * Items implementing this interface can be checked for expiration.
+ */
 public interface Perishable {
-//Ska representera produkter med utgånget datum
-    //Alla klasser som implementeras av interfacet måste använda dess metoder
-    //expose expirationDate() and a default isExpired() based on LocalDate.now().
-    //En metod för att få utgångsdatum på produkt
+
     LocalDate expirationDate();
+
+    /**
+     * Checks if the item has expired based on the current date.
+     *
+     * @return true if the expiration date has passed and false if not.
+     */
     default boolean isExpired() {
-        //returnerar true om produkten gått ut
+
         LocalDate idag = LocalDate.now();
+        // Checks if the recorded expiration date is before today's date.
         return expirationDate().isBefore(idag);
     }
 

src/main/java/com/example/warehouse/Product.java

@@ -3,39 +3,89 @@
 import java.math.BigDecimal;
 import java.util.UUID;
 
+/**
+ * An abstract base class for all products managed by the warehouse.
+ * It provides core properties (ID, name, category, price) and enforces
+ * rules, such as non-negative pricing.
+ */
 public abstract class Product {
-    //"Final" så att de ej kan ändras, endast BigDecimal ska kunna ändras för prisändring.
+
     private final UUID id;
     private final String name;
     private final Category category;
-    private BigDecimal price;
+    private BigDecimal price; // Price is not final (can be changed later)
+
+    /**
+     * protected Constructor - Constructs a new Product instance. A unique UUID is generated automatically.
+     * * @param name The product's name.
+     *
+     * @param category The product's category.
+     * @param price    The initial price of the product.
+     * @throws IllegalArgumentException if the provided price is negative.
+     */
+    protected Product(UUID id, String name, Category category, BigDecimal price) {
 
-    protected Product(String name, Category category, BigDecimal price) {
-        //jämför mot En BigDecimal med värdet 0
-        if(price.compareTo(BigDecimal.ZERO) < 0)  throw new IllegalArgumentException("Price cannot be negative.");
-        this.id = UUID.randomUUID(); // Ger ett random id-nummer (128bit)
+        if (price.compareTo(BigDecimal.ZERO) < 0) throw new IllegalArgumentException("Price cannot be negative.");
+        this.id = id; // Gives a random id-number (128bit)
         this.name = name;
         this.category = category;
         this.price = price;
     }
 
+    /**
+     * Retrieves the unique identifier (UUID) for this product.
+     *
+     * @return The UUID of the product.
+     */
     public UUID uuid() {
-    return id;
-}
-public String name() {
-    return name;
-}
-public Category category() {
-    return category;
-}
-public BigDecimal price() {
-    return price;
-}
-public void price(BigDecimal newPrice) {
-        if(price.compareTo(BigDecimal.ZERO) < 0)  throw new IllegalArgumentException("Price cannot be negative.");
-        //Uppdatera DETTA objektets fält 'price', sätt det till lika med det som skickas in som parameter:'newPrice'.
+        return id;
+    }
+
+    /**
+     * Retrieves the name of the product.
+     *
+     * @return The product's name.
+     */
+    public String name() {
+        return name;
+    }
+
+    /**
+     * Retrieves the category of the product.
+     *
+     * @return The product's Category.
+     */
+    public Category category() {
+        return category;
+    }
+
+    /**
+     * Retrieves the current price of the product.
+     *
+     * @return The price as a BigDecimal.
+     */
+    public BigDecimal price() {
+        return price;
+    }
+
+    /**
+     * Updates the product's price.
+     *
+     * @param newPrice The new price to set.
+     * @throws IllegalArgumentException if the provided new price is negative.
+     */
+    public void price(BigDecimal newPrice) {
+        if (newPrice.compareTo(BigDecimal.ZERO) < 0) throw new IllegalArgumentException("Price cannot be negative.");
+
         this.price = newPrice;
-}
+    }
+
+    /**
+     * Defines the abstract method for returning specific details about the product.
+     * Subclasses must implement this to provide their own unique description.
+     *
+     * @return A String description of the product.
+     */
+    public abstract String productDetails();
 
-public abstract String productDetails();
 }