Ejemplos Open/Close

public enum CustomerType {
    Regular,
    Premium,
    Newbie
}

public class DiscountCalculator {
    public double CalculateDiscount(double price, CustomerType customerType) {
        switch (customerType) {
            case Regular:
                return price * 0.1;  // 10% discount for regular customers
            case Premium:
                return price * 0.3;  // 30% discount for premium customers
            case Newbie:
                return price * 0.05; // 5% discount for new customers
            default:
                throw new IllegalArgumentException();
        }
    }
}

public interface IDiscountStrategy {
    double CalculateDiscount(double price);
}

//Implement this interface for each discount type
public class RegularDiscount implements IDiscountStrategy {
    public double CalculateDiscount(double price) {
        return price * 0.1;
    }
}

public class PremiumDiscount implements IDiscountStrategy {
    public double CalculateDiscount(double price) {
        return price * 0.3;
    }
}

public class NewbieDiscount implements IDiscountStrategy {
    public double CalculateDiscount(double price) {
        return price * 0.05;
    }
}

//Modify the DiscountCalculator class to accept an IDiscountStrategy
public class DiscountCalculator {
    private final IDiscountStrategy _discountStrategy;

    public DiscountCalculator(IDiscountStrategy discountStrategy) {
        _discountStrategy = discountStrategy;
    }

    public double CalculateDiscount(double price) {
        return _discountStrategy.CalculateDiscount(price);
    }
}

//Testing the Open-Closed Principle
public class Program {
    public static void main(String[] args) {
        RegularDiscount regularDiscount = new RegularDiscount();
        DiscountCalculator calculator = new DiscountCalculator(regularDiscount);
        double discountedPrice = calculator.CalculateDiscount(100); // 10% discount applied

        PremiumDiscount premiumDiscount = new PremiumDiscount();
        calculator = new DiscountCalculator(premiumDiscount);
        discountedPrice = calculator.CalculateDiscount(100); // 30% discount applied
    }
}

public enum ProductCategory
    {
        Electronics,
        Groceries,
        Clothing
    }

    public class Product
    {
        public string Name { get; set; }
        public double Price { get; set; }
        public ProductCategory Category { get; set; }
    }

    public class TaxCalculator
    {
        public double CalculateTax(Product product)
        {
            switch (product.Category)
            {
                case ProductCategory.Electronics:
                    return product.Price * 0.15; // 15% tax
                case ProductCategory.Groceries:
                    return product.Price * 0.05; // 5% tax
                case ProductCategory.Clothing:
                    return product.Price * 0.10; // 10% tax
                default:
                    throw new ArgumentException("Unsupported product category");
            }
        }
    }

public enum ProductCategory {
    Electronics,
    Groceries,
    Clothing
}

public class Product {
    public String Name;
    public double Price;
    public ProductCategory Category;
}

//Define an interface for tax calculation
public interface ITaxStrategy {
    double CalculateTax(Product product);
}

//Implement this interface for each category
public class ElectronicsTaxStrategy implements ITaxStrategy {
    public double CalculateTax(Product product) {
        return product.Price * 0.15;
    }
}

public class GroceriesTaxStrategy implements ITaxStrategy {
    public double CalculateTax(Product product) {
        return product.Price * 0.05;
    }
}

public class ClothingTaxStrategy implements ITaxStrategy {
    public double CalculateTax(Product product) {
        return product.Price * 0.10;
    }
}

//Refactor the main tax calculator to utilize these strategies
public class TaxCalculator {
    private final ITaxStrategy _taxStrategy;

    public TaxCalculator(ITaxStrategy taxStrategy) {
        _taxStrategy = taxStrategy;
    }

    public double CalculateTax(Product product) {
        return _taxStrategy.CalculateTax(product);
    }
}

//Testing the Open-Closed Principle
public class Program {
    public static void main(String[] args) {
        Product electronicsProduct = new Product();
        electronicsProduct.Name = "Laptop";
        electronicsProduct.Price = 1000;
        electronicsProduct.Category = ProductCategory.Electronics;
        ITaxStrategy electronicsTaxStrategy = new ElectronicsTaxStrategy();
        TaxCalculator taxCalculator = new TaxCalculator(electronicsTaxStrategy);
        System.out.printf("Tax for %s: $%.2f\n", electronicsProduct.Name, taxCalculator.CalculateTax(electronicsProduct));
    }
}