Upload 3 files

CohesionExamples.java

@@ -0,0 +1,128 @@
+import java.util.ArrayList;
+import java.util.List;
+
+// Functional Cohesion Example
+class UserAuthentication {
+    private String username;
+    private String password;
+
+    public UserAuthentication(String username, String password) {
+        this.username = username;
+        this.password = password;
+    }
+
+    public String hashPassword() {
+        // Hash the password
+        return "hashed_" + password;
+    }
+
+    public boolean checkPasswordStrength() {
+        // Check if the password meets security requirements
+        return password.length() >= 8;
+    }
+
+    public boolean authenticate() {
+        // Authenticate the user
+        return username != null && password != null;
+    }
+}
+
+// Sequential Cohesion Example
+class OrderProcessor {
+    public Order processOrder(Order order) {
+        Order validatedOrder = validateOrder(order);
+        Order calculatedOrder = calculateTotal(validatedOrder);
+        return submitOrder(calculatedOrder);
+    }
+
+    private Order validateOrder(Order order) {
+        // Validate the order
+        order.setValid(true);
+        return order;
+    }
+
+    private Order calculateTotal(Order order) {
+        // Calculate the total price
+        order.setTotal(100.0); // Dummy calculation
+        return order;
+    }
+
+    private Order submitOrder(Order order) {
+        // Submit the order to the system
+        order.setSubmitted(true);
+        return order;
+    }
+}
+
+// Communicational Cohesion Example
+class UserManager {
+    private User userData;
+
+    public UserManager(User userData) {
+        this.userData = userData;
+    }
+
+    public boolean validateUser() {
+        // Validate user data
+        return userData.getName() != null && userData.getEmail() != null;
+    }
+
+    public void saveUser() {
+        // Save user to database
+        System.out.println("User saved: " + userData.getName());
+    }
+
+    public void sendWelcomeEmail() {
+        // Send welcome email to user
+        System.out.println("Welcome email sent to: " + userData.getEmail());
+    }
+}
+
+// Helper classes for the examples
+class Order {
+    private boolean isValid;
+    private double total;
+    private boolean isSubmitted;
+
+    public void setValid(boolean valid) { this.isValid = valid; }
+    public void setTotal(double total) { this.total = total; }
+    public void setSubmitted(boolean submitted) { this.isSubmitted = submitted; }
+}
+
+class User {
+    private String name;
+    private String email;
+
+    public User(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+
+    public String getName() { return name; }
+    public String getEmail() { return email; }
+}
+
+public class CohesionExamples {
+    public static void main(String[] args) {
+        // Functional Cohesion
+        UserAuthentication auth = new UserAuthentication("user1", "password123");
+        System.out.println("Password hashed: " + auth.hashPassword());
+        System.out.println("Password strength: " + auth.checkPasswordStrength());
+        System.out.println("User authenticated: " + auth.authenticate());
+
+        // Sequential Cohesion
+        OrderProcessor processor = new OrderProcessor();
+        Order order = new Order();
+        Order processedOrder = processor.processOrder(order);
+        System.out.println("Order processed successfully.");
+
+        // Communicational Cohesion
+        User user = new User("John Doe", "[email protected]");
+        UserManager userManager = new UserManager(user);
+        System.out.println("User valid: " + userManager.validateUser());
+        userManager.saveUser();
+        userManager.sendWelcomeEmail();
+
+        System.out.println("Cohesion examples created successfully.");
+    }
+}

CouplingExamples.java

@@ -0,0 +1,85 @@
+// Tight Coupling Example
+class Database {
+    public User getUser(int userId) {
+        // database logic here
+        return new User(userId);
+    }
+}
+
+class UserService {
+    private Database db;
+
+    public UserService() {
+        this.db = new Database();
+    }
+
+    public User getUserInfo(int userId) {
+        return db.getUser(userId);
+    }
+}
+
+// Loose Coupling Example
+class LooselyCoupledUserService {
+    private Database db;
+
+    public LooselyCoupledUserService(Database database) {
+        this.db = database;
+    }
+
+    public User getUserInfo(int userId) {
+        return db.getUser(userId);
+    }
+}
+
+// Decoupling with Interfaces Example
+interface DatabaseInterface {
+    User getUser(int userId);
+}
+
+class DatabaseImpl implements DatabaseInterface {
+    public User getUser(int userId) {
+        // database logic here
+        return new User(userId);
+    }
+}
+
+class DecoupledUserService {
+    private DatabaseInterface db;
+
+    public DecoupledUserService(DatabaseInterface database) {
+        this.db = database;
+    }
+
+    public User getUserInfo(int userId) {
+        return db.getUser(userId);
+    }
+}
+
+// Helper class for the examples
+class User {
+    private int id;
+
+    public User(int id) {
+        this.id = id;
+    }
+}
+
+public class CouplingExamples {
+    public static void main(String[] args) {
+        // Tight Coupling
+        UserService tightlyCoupleddService = new UserService();
+        User user1 = tightlyCoupleddService.getUserInfo(1);
+
+        // Loose Coupling
+        Database database = new Database();
+        LooselyCoupledUserService looselyCoupleddService = new LooselyCoupledUserService(database);
+        User user2 = looselyCoupleddService.getUserInfo(2);
+
+        // Decoupling with Interfaces
+        DatabaseInterface databaseInterface = new DatabaseImpl();
+        DecoupledUserService decoupledService = new DecoupledUserService(databaseInterface);
+        User user3 = decoupledService.getUserInfo(3);
+
+        System.out.println("Coupling examples created successfully.");
+    }
+}

MonolithicEcommerceApp.java

@@ -0,0 +1,151 @@
+import java.util.*;
+
+class EcommerceApp {
+    private Map<String, User> users = new HashMap<>();
+    private Map<Integer, Product> products = new HashMap<>();
+    private Map<Integer, Order> orders = new HashMap<>();
+    private Map<Integer, Payment> payments = new HashMap<>();
+    private Map<String, List<String>> userPreferences = new HashMap<>();
+
+    public void registerUser(String username, String password) {
+        users.put(username, new User(username, password));
+        userPreferences.put(username, new ArrayList<>());
+    }
+
+    public void addProduct(int productId, String name, double price, String category) {
+        products.put(productId, new Product(productId, name, price, category));
+    }
+
+    public Integer createOrder(String user, int productId, int quantity) {
+        if (users.containsKey(user) && products.containsKey(productId)) {
+            int orderId = orders.size() + 1;
+            orders.put(orderId, new Order(orderId, user, productId, quantity));
+            userPreferences.get(user).add(products.get(productId).getCategory());
+            return orderId;
+        }
+        return null;
+    }
+
+    public boolean processPayment(int orderId, String paymentMethod) {
+        if (orders.containsKey(orderId)) {
+            payments.put(orderId, new Payment(paymentMethod, "completed"));
+            return true;
+        }
+        return false;
+    }
+
+    public List<Product> recommendProducts(String user, int numRecommendations) {
+        if (!userPreferences.containsKey(user) || userPreferences.get(user).isEmpty()) {
+            return new ArrayList<>(products.values()).subList(0, Math.min(numRecommendations, products.size()));
+        }
+
+        List<String> userCategories = userPreferences.get(user);
+        String mostCommonCategory = getMostCommonCategory(userCategories);
+
+        List<Product> recommendedProducts = products.values().stream()
+                .filter(p -> p.getCategory().equals(mostCommonCategory))
+                .limit(numRecommendations)
+                .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
+
+        if (recommendedProducts.size() < numRecommendations) {
+            List<Product> otherProducts = products.values().stream()
+                    .filter(p -> !p.getCategory().equals(mostCommonCategory))
+                    .limit(numRecommendations - recommendedProducts.size())
+                    .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
+            recommendedProducts.addAll(otherProducts);
+        }
+
+        return recommendedProducts;
+    }
+
+    private String getMostCommonCategory(List<String> categories) {
+        return categories.stream()
+                .collect(java.util.stream.Collectors.groupingBy(c -> c, java.util.stream.Collectors.counting()))
+                .entrySet().stream()
+                .max(Map.Entry.comparingByValue())
+                .map(Map.Entry::getKey)
+                .orElse(null);
+    }
+}
+
+class User {
+    private String username;
+    private String password;
+
+    public User(String username, String password) {
+        this.username = username;
+        this.password = password;
+    }
+}
+
+class Product {
+    private int id;
+    private String name;
+    private double price;
+    private String category;
+
+    public Product(int id, String name, double price, String category) {
+        this.id = id;
+        this.name = name;
+        this.price = price;
+        this.category = category;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    @Override
+    public String toString() {
+        return name + " ($" + price + ")";
+    }
+}
+
+class Order {
+    private int id;
+    private String user;
+    private int productId;
+    private int quantity;
+
+    public Order(int id, String user, int productId, int quantity) {
+        this.id = id;
+        this.user = user;
+        this.productId = productId;
+        this.quantity = quantity;
+    }
+}
+
+class Payment {
+    private String method;
+    private String status;
+
+    public Payment(String method, String status) {
+        this.method = method;
+        this.status = status;
+    }
+}
+
+public class MonolithicEcommerceApp {
+    public static void main(String[] args) {
+        EcommerceApp app = new EcommerceApp();
+
+        app.registerUser("alice", "password123");
+        app.addProduct(1, "Laptop", 999.99, "Electronics");
+        app.addProduct(2, "Smartphone", 499.99, "Electronics");
+        app.addProduct(3, "Headphones", 99.99, "Electronics");
+        app.addProduct(4, "T-shirt", 19.99, "Clothing");
+
+        Integer orderId = app.createOrder("alice", 1, 1);
+        if (orderId != null) {
+            app.processPayment(orderId, "credit_card");
+        }
+
+        List<Product> recommendations = app.recommendProducts("alice", 2);
+        System.out.println("Recommended products for Alice:");
+        for (Product product : recommendations) {
+            System.out.println("- " + product);
+        }
+
+        System.out.println("Monolithic architecture example created successfully.");
+    }
+}