Salma
💻
Through this example, the handling of invalid operations (e.g., mismatched currencies or + * invalid inputs) is demonstrated using custom exceptions. Logging is used for transparency. + * + *
This highlights the practical application of object-oriented principles such as encapsulation
+ * and validation in a financial context.
+ */
+public class App {
+
+ // Initialize the logger
+ private static final Logger logger = Logger.getLogger(App.class.getName());
+ /**
+ * Program entry point.
+ *
+ * @param args command line args
+ */
+ public static void main(String[] args) {
+ // Create instances of Money
+ Money usdAmount1 = new Money(50.00, "USD");
+ Money usdAmount2 = new Money(20.00, "USD");
+
+ // Demonstrate addition
+ try {
+ usdAmount1.addMoney(usdAmount2);
+ logger.log(Level.INFO, "Sum in USD: {0}", usdAmount1.getAmount());
+ } catch (CannotAddTwoCurrienciesException e) {
+ logger.log(Level.SEVERE, "Error adding money: {0}", e.getMessage());
+ }
+
+ // Demonstrate subtraction
+ try {
+ usdAmount1.subtractMoney(usdAmount2);
+ logger.log(Level.INFO, "Difference in USD: {0}", usdAmount1.getAmount());
+ } catch (CannotSubtractException e) {
+ logger.log(Level.SEVERE, "Error subtracting money: {0}", e.getMessage());
+ }
+
+ // Demonstrate multiplication
+ try {
+ usdAmount1.multiply(2);
+ logger.log(Level.INFO, "Multiplied Amount in USD: {0}", usdAmount1.getAmount());
+ } catch (IllegalArgumentException e) {
+ logger.log(Level.SEVERE, "Error multiplying money: {0}", e.getMessage());
+ }
+
+ // Demonstrate currency conversion
+ try {
+ double exchangeRateUsdToEur = 0.85; // Example exchange rate
+ usdAmount1.exchangeCurrency("EUR", exchangeRateUsdToEur);
+ logger.log(Level.INFO, "USD converted to EUR: {0} {1}", new Object[]{usdAmount1.getAmount(), usdAmount1.getCurrency()});
+ } catch (IllegalArgumentException e) {
+ logger.log(Level.SEVERE, "Error converting currency: {0}", e.getMessage());
+ }
+
+ }
+}
+
diff --git a/money/src/main/java/com/iluwatar/CannotAddTwoCurrienciesException.java b/money/src/main/java/com/iluwatar/CannotAddTwoCurrienciesException.java
new file mode 100644
index 000000000000..587c8917ecef
--- /dev/null
+++ b/money/src/main/java/com/iluwatar/CannotAddTwoCurrienciesException.java
@@ -0,0 +1,14 @@
+package com.iluwatar;
+/**
+ * An exception for when the user tries to add two diffrent currencies.
+ */
+public class CannotAddTwoCurrienciesException extends Exception {
+ /**
+ * Constructs an exception with the specified message.
+ *
+ * @param message the message shown in the terminal (as a String).
+ */
+ public CannotAddTwoCurrienciesException(String message) {
+ super(message);
+ }
+}
\ No newline at end of file
diff --git a/money/src/main/java/com/iluwatar/CannotSubtractException.java b/money/src/main/java/com/iluwatar/CannotSubtractException.java
new file mode 100644
index 000000000000..881b458c0481
--- /dev/null
+++ b/money/src/main/java/com/iluwatar/CannotSubtractException.java
@@ -0,0 +1,15 @@
+package com.iluwatar;
+/**
+ * An exception for when the user tries to subtract two diffrent currencies or subtract an amount he doesn't have.
+ */
+public class CannotSubtractException extends Exception {
+ /**
+ * Constructs an exception with the specified message.
+ *
+ * @param message the message shown in the terminal (as a String).
+ */
+ public CannotSubtractException(String message) {
+ super(message);
+ }
+
+}
\ No newline at end of file
diff --git a/money/src/main/java/com/iluwatar/Money.java b/money/src/main/java/com/iluwatar/Money.java
new file mode 100644
index 000000000000..e0afe4c7cbb9
--- /dev/null
+++ b/money/src/main/java/com/iluwatar/Money.java
@@ -0,0 +1,91 @@
+package com.iluwatar;
+
+import lombok.Getter;
+
+/**
+ * Represents a monetary value with an associated currency.
+ * Provides operations for basic arithmetic (addition, subtraction, multiplication),
+ * as well as currency conversion while ensuring proper rounding.
+ */
+@Getter
+public class Money {
+ private @Getter double amount;
+ private @Getter String currency;
+
+ /**
+ * Constructs a Money object with the specified amount and currency.
+ *
+ * @param amnt the amount of money (as a double).
+ * @param curr the currency code (e.g., "USD", "EUR").
+ */
+ public Money(double amnt, String curr) {
+ this.amount = amnt;
+ this.currency = curr;
+ }
+
+ /**
+ * Rounds the given value to two decimal places.
+ *
+ * @param value the value to round.
+ * @return the rounded value, up to two decimal places.
+ */
+ private double roundToTwoDecimals(double value) {
+ return Math.round(value * 100.0) / 100.0;
+ }
+
+ /**
+ * Adds another Money object to the current instance.
+ *
+ * @param moneyToBeAdded the Money object to add.
+ * @throws CannotAddTwoCurrienciesException if the currencies do not match.
+ */
+ public void addMoney(Money moneyToBeAdded) throws CannotAddTwoCurrienciesException {
+ if (!moneyToBeAdded.getCurrency().equals(this.currency)) {
+ throw new CannotAddTwoCurrienciesException("You are trying to add two different currencies");
+ }
+ this.amount = roundToTwoDecimals(this.amount + moneyToBeAdded.getAmount());
+ }
+
+ /**
+ * Subtracts another Money object from the current instance.
+ *
+ * @param moneyToBeSubtracted the Money object to subtract.
+ * @throws CannotSubtractException if the currencies do not match or if the amount to subtract is larger than the current amount.
+ */
+ public void subtractMoney(Money moneyToBeSubtracted) throws CannotSubtractException {
+ if (!moneyToBeSubtracted.getCurrency().equals(this.currency)) {
+ throw new CannotSubtractException("You are trying to subtract two different currencies");
+ } else if (moneyToBeSubtracted.getAmount() > this.amount) {
+ throw new CannotSubtractException("The amount you are trying to subtract is larger than the amount you have");
+ }
+ this.amount = roundToTwoDecimals(this.amount - moneyToBeSubtracted.getAmount());
+ }
+
+ /**
+ * Multiplies the current amount of money by a factor.
+ *
+ * @param factor the factor to multiply by.
+ * @throws IllegalArgumentException if the factor is negative.
+ */
+ public void multiply(int factor) {
+ if (factor < 0) {
+ throw new IllegalArgumentException("Factor must be non-negative");
+ }
+ this.amount = roundToTwoDecimals(this.amount * factor);
+ }
+
+ /**
+ * Converts the current amount of money to another currency using the provided exchange rate.
+ *
+ * @param currencyToChangeTo the new currency to convert to.
+ * @param exchangeRate the exchange rate to convert from the current currency to the new currency.
+ * @throws IllegalArgumentException if the exchange rate is negative.
+ */
+ public void exchangeCurrency(String currencyToChangeTo, double exchangeRate) {
+ if (exchangeRate < 0) {
+ throw new IllegalArgumentException("Exchange rate must be non-negative");
+ }
+ this.amount = roundToTwoDecimals(this.amount * exchangeRate);
+ this.currency = currencyToChangeTo;
+ }
+}
diff --git a/money/src/test/java/com/iluwater/money/MoneyTest.java b/money/src/test/java/com/iluwater/money/MoneyTest.java
new file mode 100644
index 000000000000..94d93359b0ad
--- /dev/null
+++ b/money/src/test/java/com/iluwater/money/MoneyTest.java
@@ -0,0 +1,125 @@
+package com.iluwater.money;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+import com.iluwatar.CannotAddTwoCurrienciesException;
+import com.iluwatar.CannotSubtractException;
+import com.iluwatar.Money;
+import com.iluwatar.App;
+
+
+ class MoneyTest {
+
+ @Test
+ void testConstructor() {
+ // Test the constructor
+ Money money = new Money(100.00, "USD");
+ assertEquals(100.00, money.getAmount());
+ assertEquals("USD", money.getCurrency());
+ }
+
+ @Test
+ void testAddMoney_SameCurrency() throws CannotAddTwoCurrienciesException {
+ // Test adding two Money objects with the same currency
+ Money money1 = new Money(100.00, "USD");
+ Money money2 = new Money(50.25, "USD");
+
+ money1.addMoney(money2);
+
+ assertEquals(150.25, money1.getAmount(), "Amount after addition should be 150.25");
+ }
+
+ @Test
+ void testAddMoney_DifferentCurrency() {
+ // Test adding two Money objects with different currencies
+ Money money1 = new Money(100.00, "USD");
+ Money money2 = new Money(50.25, "EUR");
+
+ assertThrows(CannotAddTwoCurrienciesException.class, () -> {
+ money1.addMoney(money2);
+ });
+ }
+
+ @Test
+ void testSubtractMoney_SameCurrency() throws CannotSubtractException {
+ // Test subtracting two Money objects with the same currency
+ Money money1 = new Money(100.00, "USD");
+ Money money2 = new Money(50.25, "USD");
+
+ money1.subtractMoney(money2);
+
+ assertEquals(49.75, money1.getAmount(), "Amount after subtraction should be 49.75");
+ }
+
+ @Test
+ void testSubtractMoney_DifferentCurrency() {
+ // Test subtracting two Money objects with different currencies
+ Money money1 = new Money(100.00, "USD");
+ Money money2 = new Money(50.25, "EUR");
+
+ assertThrows(CannotSubtractException.class, () -> {
+ money1.subtractMoney(money2);
+ });
+ }
+
+ @Test
+ void testSubtractMoney_AmountTooLarge() {
+ // Test subtracting an amount larger than the current amount
+ Money money1 = new Money(50.00, "USD");
+ Money money2 = new Money(60.00, "USD");
+
+ assertThrows(CannotSubtractException.class, () -> {
+ money1.subtractMoney(money2);
+ });
+ }
+
+ @Test
+ void testMultiply() {
+ // Test multiplying the money amount by a factor
+ Money money = new Money(100.00, "USD");
+
+ money.multiply(3);
+
+ assertEquals(300.00, money.getAmount(), "Amount after multiplication should be 300.00");
+ }
+
+ @Test
+ void testMultiply_NegativeFactor() {
+ // Test multiplying by a negative factor
+ Money money = new Money(100.00, "USD");
+
+ assertThrows(IllegalArgumentException.class, () -> {
+ money.multiply(-2);
+ });
+ }
+
+ @Test
+ void testExchangeCurrency() {
+ // Test converting currency using an exchange rate
+ Money money = new Money(100.00, "USD");
+
+ money.exchangeCurrency("EUR", 0.85);
+
+ assertEquals("EUR", money.getCurrency(), "Currency after conversion should be EUR");
+ assertEquals(85.00, money.getAmount(), "Amount after conversion should be 85.00");
+ }
+
+ @Test
+ void testExchangeCurrency_NegativeExchangeRate() {
+ // Test converting currency with a negative exchange rate
+ Money money = new Money(100.00, "USD");
+
+ assertThrows(IllegalArgumentException.class, () -> {
+ money.exchangeCurrency("EUR", -0.85);
+ });
+ }
+
+
+ @Test
+ void testAppExecution() {
+ assertDoesNotThrow(() -> {
+ App.main(new String[]{});
+ }, "App execution should not throw any exceptions");
+ }
+
+}
diff --git a/pom.xml b/pom.xml
index 97128f9f3cc2..fc1e6e80f9fd 100644
--- a/pom.xml
+++ b/pom.xml
@@ -218,7 +218,9 @@
The Table Inheritance pattern models a class hierarchy in a relational database by creating
+ * separate tables for each class in the hierarchy. These tables share a common primary key, which in
+ * subclass tables also serves as a foreign key referencing the primary key of the base class table.
+ * This linkage maintains relationships and effectively represents the inheritance structure. This
+ * pattern enables the organization of complex data models, particularly when subclasses have unique
+ * properties that must be stored in distinct tables.
+ */
+
+public class App {
+ /**
+ * Manages the storage and retrieval of Vehicle objects, including Cars and Trucks.
+ *
+ * This example demonstrates the **Table Inheritance** pattern, where each vehicle type
+ * (Car and Truck) is stored in its own separate table. The `VehicleDatabase` simulates
+ * a simple database that manages these entities, with each subclass (Car and Truck)
+ * being stored in its respective table.
+ *
+ * The `VehicleDatabase` contains the following tables:
+ * - `vehicleTable`: Stores all vehicle objects, including both `Car` and `Truck` objects.
+ * - `carTable`: Stores only `Car` objects, with fields specific to cars.
+ * - `truckTable`: Stores only `Truck` objects, with fields specific to trucks.
+ *
+ * The example demonstrates:
+ * 1. Saving instances of `Car` and `Truck` to their respective tables in the database.
+ * 2. Retrieving vehicles (both cars and trucks) from the appropriate table based on their ID.
+ * 3. Printing all vehicles stored in the database.
+ * 4. Showing how to retrieve specific types of vehicles (`Car` or `Truck`) by their IDs.
+ *
+ * In the **Table Inheritance** pattern, each subclass has its own table, making it easier
+ * to manage specific attributes of each subclass.
+ *
+ * @param args command-line arguments
+ */
+
+ public static void main(String[] args) {
+
+ final Logger logger = Logger.getLogger(App.class.getName());
+
+ VehicleDatabase database = new VehicleDatabase();
+
+ Car car = new Car(2020, "Toyota", "Corolla", 4, 1);
+ Truck truck = new Truck(2018, "Ford", "F-150", 60, 2);
+
+ database.saveVehicle(car);
+ database.saveVehicle(truck);
+
+ database.printAllVehicles();
+
+ Vehicle vehicle = database.getVehicle(car.getId());
+ Car retrievedCar = database.getCar(car.getId());
+ Truck retrievedTruck = database.getTruck(truck.getId());
+
+ logger.info(String.format("Retrieved Vehicle: %s", vehicle));
+ logger.info(String.format("Retrieved Car: %s", retrievedCar));
+ logger.info(String.format("Retrieved Truck: %s", retrievedTruck));
+
+ }
+}
diff --git a/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Car.java b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Car.java
new file mode 100644
index 000000000000..b7332bf2a6b0
--- /dev/null
+++ b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Car.java
@@ -0,0 +1,50 @@
+package com.iluwatar.table.inheritance;
+import lombok.Getter;
+/**
+ * Represents a car with a specific number of doors.
+ */
+
+@Getter
+public class Car extends Vehicle {
+ private int numDoors;
+
+ /**
+ * Constructs a Car object.
+ *
+ * @param year the manufacturing year
+ * @param make the make of the car
+ * @param model the model of the car
+ * @param numDoors the number of doors
+ * @param id the unique identifier for the car
+ */
+ public Car(int year, String make, String model, int numDoors, int id) {
+ super(year, make, model, id);
+ if (numDoors <= 0) {
+ throw new IllegalArgumentException("Number of doors must be positive.");
+ }
+ this.numDoors = numDoors;
+ }
+
+ /**
+ * Sets the number of doors for the car.
+ *
+ * @param doors the number of doors
+ */
+ public void setNumDoors(int doors) {
+ if (doors <= 0) {
+ throw new IllegalArgumentException("Number of doors must be positive.");
+ }
+ this.numDoors = doors;
+ }
+
+ @Override
+ public String toString() {
+ return "Car{"
+ + "id=" + getId()
+ + ", make='" + getMake() + '\''
+ + ", model='" + getModel() + '\''
+ + ", year=" + getYear()
+ + ", numberOfDoors=" + getNumDoors()
+ + '}';
+ }
+}
diff --git a/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Truck.java b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Truck.java
new file mode 100644
index 000000000000..5d093c688c9e
--- /dev/null
+++ b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Truck.java
@@ -0,0 +1,57 @@
+package com.iluwatar.table.inheritance;
+
+import lombok.Getter;
+
+/**
+ * Represents a truck, a type of vehicle with a specific load capacity.
+ */
+@Getter
+public class Truck extends Vehicle {
+ private double loadCapacity;
+
+ /**
+ * Constructs a Truck object with the given parameters.
+ *
+ * @param year the year of manufacture
+ * @param make the make of the truck
+ * @param model the model of the truck
+ * @param loadCapacity the load capacity of the truck
+ * @param id the unique ID of the truck
+ */
+ public Truck(int year, String make, String model, double loadCapacity, int id) {
+ super(year, make, model, id);
+ if (loadCapacity <= 0) {
+ throw new IllegalArgumentException("Load capacity must be positive.");
+ }
+ this.loadCapacity = loadCapacity;
+ }
+
+ /**
+ * Sets the load capacity of the truck.
+ *
+ * @param capacity the new load capacity
+ */
+ public void setLoadCapacity(double capacity) {
+ if (capacity <= 0) {
+ throw new IllegalArgumentException("Load capacity must be positive.");
+ }
+ this.loadCapacity = capacity;
+ }
+
+ /**
+ * Returns a string representation of the truck.
+ *
+ * @return a string with the truck's details
+ */
+ @Override
+ public String toString() {
+ return "Truck{"
+ + "id=" + getId()
+ + ", make='" + getMake() + '\''
+ + ", model='" + getModel() + '\''
+ + ", year=" + getYear()
+ + ", payloadCapacity=" + getLoadCapacity()
+ + '}';
+ }
+}
+
diff --git a/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Vehicle.java b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Vehicle.java
new file mode 100644
index 000000000000..1333f6a166ee
--- /dev/null
+++ b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/Vehicle.java
@@ -0,0 +1,48 @@
+package com.iluwatar.table.inheritance;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * Represents a generic vehicle with basic attributes like make, model, year, and ID.
+ */
+
+@Setter
+@Getter
+public class Vehicle {
+
+ private String make;
+ private String model;
+ private int year;
+ private int id;
+
+ /**
+ * Constructs a Vehicle object with the given parameters.
+ *
+ * @param year the year of manufacture
+ * @param make the make of the vehicle
+ * @param model the model of the vehicle
+ * @param id the unique ID of the vehicle
+ */
+ public Vehicle(int year, String make, String model, int id) {
+ this.make = make;
+ this.model = model;
+ this.year = year;
+ this.id = id;
+ }
+
+ /**
+ * Returns a string representation of the vehicle.
+ *
+ * @return a string with the vehicle's details
+ */
+ @Override
+ public String toString() {
+ return "Vehicle{"
+ + "id=" + id
+ + ", make='" + make + '\''
+ + ", model='" + model + '\''
+ + ", year=" + year
+ + '}';
+ }
+}
diff --git a/table-inheritance/src/main/java/com/iluwatar/table/inheritance/VehicleDatabase.java b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/VehicleDatabase.java
new file mode 100644
index 000000000000..403112c32aa8
--- /dev/null
+++ b/table-inheritance/src/main/java/com/iluwatar/table/inheritance/VehicleDatabase.java
@@ -0,0 +1,73 @@
+package com.iluwatar.table.inheritance;
+
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+
+
+/**
+ * Manages the storage and retrieval of Vehicle objects, including Cars and Trucks.
+ */
+public class VehicleDatabase {
+
+ final Logger logger = Logger.getLogger(VehicleDatabase.class.getName());
+
+ private Map
+
+
+
+
+
+
+## Table Inheritance Pattern Database Schema
+
+### Vehicle Table
+| Column | Description |
+|--------|-------------------------------------|
+| id | Primary key |
+| make | The make of the vehicle |
+| model | The model of the vehicle |
+| year | The manufacturing year of the vehicle |
+
+### Car Table
+| Column | Description |
+|------------------|-------------------------------------|
+| id | Foreign key referencing `Vehicle(id)` |
+| numberOfDoors | Number of doors in the car |
+
+### Truck Table
+| Column | Description |
+|-------------------|-------------------------------------|
+| id | Foreign key referencing `Vehicle(id)` |
+| payloadCapacity | Payload capacity of the truck |
+
+---
+
+## When to Use the Table Inheritance Pattern in Java
+
+- When your application requires a clear mapping of an object-oriented class hierarchy to relational tables.
+- When subclasses have unique attributes that do not fit into a single base table.
+- When scalability and normalization of data are important considerations.
+- When you need to separate concerns and organize data in a way that each subclass has its own
+table but maintains relationships with the superclass.
+
+## Table Inheritance Pattern Java Tutorials
+
+- [Software Patterns Lexicon: Class Table Inheritance](https://softwarepatternslexicon.com/patterns-sql/4/4/2/)
+- [Martin Fowler: Class Table Inheritance](http://thierryroussel.free.fr/java/books/martinfowler/www.martinfowler.com/isa/classTableInheritance.html)
+
+---
+
+## Real-World Applications of Table Inheritance Pattern in Java
+
+- **Vehicle Management System**: Used to store different types of vehicles like Car and Truck in separate tables but maintain a relationship through a common superclass `Vehicle`.
+- **E-Commerce Platforms**: Where different product types, such as Clothing, Electronics, and Furniture, are stored in separate tables with shared attributes in a superclass `Product`.
+
+## Benefits and Trade-offs of Table Inheritance Pattern
+
+### Benefits
+
+- **Clear Structure**: Each class has its own table, making the data model easier to maintain and understand.
+- **Scalability**: Each subclass can be extended independently without affecting the other tables, making the system more scalable.
+- **Data Normalization**: Helps avoid data redundancy and keeps the schema normalized.
+
+### Trade-offs
+
+- **Multiple Joins**: Retrieving data that spans multiple subclasses may require joining multiple tables, which could lead to performance issues.
+- **Increased Complexity**: Managing relationships between tables and maintaining integrity can become more complex.
+- **Potential for Sparse Tables**: Subclasses with fewer attributes may end up with tables that have many null fields.
+
+## Related Java Design Patterns
+
+- **Single Table Inheritance** – A strategy where a single table is used to store all classes in an
+inheritance hierarchy. It stores all attributes of the class and its subclasses in one table.
+- **Singleton Pattern** – Used when a class needs to have only one instance.
+
+
+## References and Credits
+
+- **Martin Fowler** - [*Patterns of Enterprise Application Architecture*](https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420)
+- **Java Persistence with Hibernate** - [Link to book](https://www.amazon.com/Java-Persistence-Hibernate-Christian-Bauer/dp/193239469X)
+- **Object-Relational Mapping on Wikipedia** - [Link to article](https://en.wikipedia.org/wiki/Object-relational_mapping)
diff --git a/table-inheritance/pom.xml b/table-inheritance/pom.xml
new file mode 100644
index 000000000000..9a886307ffe7
--- /dev/null
+++ b/table-inheritance/pom.xml
@@ -0,0 +1,31 @@
+
+