Can anyone validate my solution for the below sated problem ?

[Pooja Priyadarshini]

PROBLEM TWO: SALES TAXES

Basic sales tax is applicable at a rate of 10% on all goods, except books,
food, and medical products that are exempt. Import duty is an additional
sales tax applicable on all imported goods at a rate of 5%, with no
exemptions.

When I purchase items I receive a receipt which lists the name of all the
items and their price (including tax), finishing with the total cost of the
items, and the total amounts of sales taxes paid. The rounding rules for
sales tax are that for a tax rate of n%, a shelf price of p contains
(np/100 rounded up to the nearest 0.05) amount of sales tax.

Write an application that prints out the receipt details for these shopping
baskets...

INPUT:

Input 3:
1 imported bottle of perfume at 27.99
1 bottle of perfume at 18.99
1 packet of headache pills at 9.75
1 box of imported chocolates at 11.25

OUTPUT


Output 3:
1 imported bottle of perfume: 32.19
1 bottle of perfume: 20.89
1 packet of headache pills: 9.75
1 imported box of chocolates: 11.85
Sales Taxes: 6.70
Total: 74.68

-----------------------------------------------------------------------------

package thoughtWorks.salesTax;

import java.math.BigDecimal;
import java.util.LinkedList;
import java.util.Queue;

public class Client {

	public static void main(String[] args){
		try{
			
			// Command Pattern
			Queue<Order> orderList = new LinkedList<Order>();
			/*Order order = new Order(true,"perfume",new BigDecimal("27.99"),1,ItemCategories.OTHERS);
			orderList.add(order);
			order = new Order(false,"perfume",new BigDecimal("18.99"),1,ItemCategories.OTHERS);
			orderList.add(order);
			order = new Order(false,"Head Ache Pills",new BigDecimal("9.75"),1,ItemCategories.MEDICINE);
			orderList.add(order);
			order = new Order(true,"Chocolates",new BigDecimal("11.25"),1,ItemCategories.FOOD);
			orderList.add(order);*/
			
			
			Order order = new Order(false,"book",new BigDecimal("12.49"),1,ItemCategories.BOOKS);
			orderList.add(order);
			order = new Order(false,"Music CD",new BigDecimal("14.99"),1,ItemCategories.OTHERS);
			orderList.add(order);
			order = new Order(false,"Chocolate Bar",new BigDecimal("0.85"),1,ItemCategories.FOOD);
			orderList.add(order);
			

			OrderManager manager = new OrderManager();
			manager.setOrderList(orderList);

			Invoice invoice = new Invoice();
			invoice.makeInvoice(manager);
		}catch(Exception exception){
			exception.printStackTrace();
		}



	}

}

------------------------------------------------------------------------------------------------------

package thoughtWorks.salesTax;

import java.math.BigDecimal;

public class ImportDutyCalculator implements TaxCalculator {


	private BigDecimal importDuty = new BigDecimal("0.05");
	public void calculateTax(Order order) {
		if(order.isImportedGoods()){
			order.setImportDuty(order.getPrice().multiply(importDuty));
		}


	}

}

--------------------------------------------------------------------

package thoughtWorks.salesTax;

import java.math.BigDecimal;

public class Invoice {

	BigDecimal totalPrice = new BigDecimal("0.0");
	BigDecimal totalTax = new BigDecimal("0.0");

	TaxCalculator salesTaxCalculator = new SalesTaxCalculator();
	TaxCalculator importDutyCalculator = new ImportDutyCalculator();
	public void makeInvoice(OrderManager manager){
		while(manager.hasNext()){
			Order order = manager.next();
			salesTaxCalculator.calculateTax(order); // Decorator Pattern
			importDutyCalculator.calculateTax(order); // Decorator Pattern
			calculate(order);
			System.out.println(order.toString());
		}

		System.out.println("Total Price" + totalPrice);
		System.out.println("Total Tax " + totalTax);
	}


	private void calculate(Order order){
		BigDecimal sellingPrice = new BigDecimal("0.0");
		BigDecimal tax = new BigDecimal("0.0");

		sellingPrice = (order.getPrice().add(order.getImportDuty()).add(order.getSalesTax())).multiply(new BigDecimal(order.getQuantity()));
		sellingPrice = sellingPrice.setScale(2,BigDecimal.ROUND_HALF_DOWN);
		
		tax = order.getSalesTax().add(order.getImportDuty());
		tax = tax.setScale(2,BigDecimal.ROUND_HALF_DOWN);
		order.setSellingPrice(sellingPrice);

		totalPrice = totalPrice.add(sellingPrice);
		totalTax = totalTax.add(tax);

	}
}

----------------------------------------------------------------

package thoughtWorks.salesTax;

import java.util.HashSet;
import java.util.Set;

public class ItemCategories {
	
	public static Set excludedGoods; 
	
	public static final int FOOD = 1;
	
	public static final int MEDICINE = 2;
	
	public static final int BOOKS = 3;
	
	public static final int OTHERS = 99;
	
	static{
		excludedGoods = new HashSet();
		excludedGoods.add(FOOD);
		excludedGoods.add(MEDICINE);
		excludedGoods.add(BOOKS);
	}

	

}

----------------------------------------------------------------------

package thoughtWorks.salesTax;

import java.math.BigDecimal;

public class Order {

	private int quantity;
	private String item;
	private boolean importedGoods;
	private BigDecimal price;
	private int itemType;
	private BigDecimal salesTax = new BigDecimal("0.0");
	private BigDecimal importDuty = new BigDecimal("0.0");
	private BigDecimal sellingPrice;
	
	
	public Order(boolean importedGoods, String item, BigDecimal price,
			int quantity , int itemType) {
		super();
		this.importedGoods = importedGoods;
		this.item = item;
		this.price = price;
		this.quantity = quantity;
		this.itemType = itemType;
	}
	public int getQuantity() {
		return quantity;
	}
	public void setQuantity(int quantity) {
		this.quantity = quantity;
	}
	public String getItem() {
		return item;
	}
	public void setItem(String item) {
		this.item = item;
	}
	public boolean isImportedGoods() {
		return importedGoods;
	}
	public void setImportedGoods(boolean importedGoods) {
		this.importedGoods = importedGoods;
	}

	public int getItemType() {
		return itemType;
	}
	public void setItemType(int itemType) {
		this.itemType = itemType;
	}
	@Override
	public String toString() {
		StringBuffer sb = new StringBuffer();
		sb.append("Order to purchase");
		sb.append(getQuantity()+" ");
		if(isImportedGoods())
		sb.append("imported ");
		sb.append(getItem());
		sb.append(" @ the price : ");
		sb.append(getPrice());
		
		if(getSellingPrice() != null){
			sb.append(" @ the Selling price : ");
			sb.append(getSellingPrice());
		}
		
		
		return sb.toString();
	}


	public BigDecimal getPrice() {
		return price;
	}


	public void setPrice(BigDecimal price) {
		this.price = price;
	}
	public BigDecimal getSalesTax() {
		return salesTax;
	}
	public void setSalesTax(BigDecimal salesTax) {
		this.salesTax = salesTax;
	}
	public BigDecimal getImportDuty() {
		return importDuty;
	}
	public void setImportDuty(BigDecimal importDuty) {
		this.importDuty = importDuty;
	}
	public BigDecimal getSellingPrice() {
		return sellingPrice;
	}
	public void setSellingPrice(BigDecimal sellingPrice) {
		this.sellingPrice = sellingPrice;
	}
	
	


}

--------------------------------------------------------------

package thoughtWorks.salesTax;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;


// Iterator Pattern
public class OrderManager implements Iterator<Order>{
	private Queue<Order> orderList = new LinkedList<Order>();

	public void setOrderList(Queue<Order> orderList) {
		this.orderList = orderList;
	}

	public boolean hasNext() {
		if (orderList.size() > 0)
			return true;			
		else
			return false;
	}

	public Order next() {
		return orderList.poll();
	}

	public void remove(){
	}
}

--------------------------------------------------------------------------------

package thoughtWorks.salesTax;

import java.math.BigDecimal;

public class SalesTaxCalculator implements TaxCalculator {

	private BigDecimal salesTax = new BigDecimal("0.10");
	public void calculateTax(Order order) {
		if(!ItemCategories.excludedGoods.contains(order.getItemType())){
			order.setSalesTax(order.getPrice().multiply(salesTax));
		}
		
	}

}

-----------------------------------------------------------------------------------

package thoughtWorks.salesTax;

public interface TaxCalculator {
	
	public void calculateTax(Order order);

}

[S. Nitesh]

Please post your code in code tags. You can use edit button.

[Campbell Ritchie]

Since he's new, I'll add the code tags, and we can see how much better it looks.

What do you want us to validate? Does the code work? Does it print the correct totals? You will doubtless have checked all those things already.

Your package names do not follow the recommended style

Why are you using new BigDecimal("0.0") when there is a ready-made object available?

Why are you using a LinkedList rather than other List implementations?

don't use "if (somethingBoolean) return true; else return false;" Use "return somethingBoolean;"

Why are you using a Queue inside your Iterator object?

[Greg Brannon]

What are you asking? Does your program run and give the desired answer? If so, what are you hoping to get from The Ranch? If not, what are the errors, what help do you need?

[Pooja Priyadarshini]

Could you please validate my programming approach .. And how better i can do the same

[Stephan van Hulst]

Look, normally I wouldn't post a working example, but it looks like you put enough effort into this, and I think that a full example with an explanation might be helpful. If the moderators think otherwise, I'm sure they will edit my post.

package thoughtWorks.salesTax;

import java.math.BigDecimal;
import java.math.RoundingMode;

final class Item {
  private static final BigDecimal BASIC_TAX_RATE  = new BigDecimal("0.1");
  private static final BigDecimal IMPORT_TAX_RATE = new BigDecimal("0.05");
  private static final BigDecimal TWENTY          = new BigDecimal("20");

  private final String name;
  private final Category category;
  private final BigDecimal price;

  Item(String name, Category category, BigDecimal price) {
    if (name == null || category == null || price == null)
      throw new NullPointerException();

    this.name = name;
    this.category = category;
    this.price = price;
  }

  String name() {
    return name;
  }

  Category category() {
    return category;
  }

  BigDecimal price() {
    return price;
  }

  BigDecimal getSalesTax(boolean imported) {
    BigDecimal taxRate = category.isExempt() ? BigDecimal.ZERO : BASIC_TAX_RATE;
    if (imported)
      taxRate = taxRate.add(IMPORT_TAX_RATE);

    BigDecimal result = price.multiply(taxRate);
    result = result.multiply(TWENTY).setScale(0, RoundingMode.CEILING).divide(TWENTY).setScale(2); // round up to 5 cents
    return result;
  }

  @Override
  public String toString() {
    return name + " at " + price;
  }
}

package thoughtWorks.salesTax;

enum Category {

  FOOD     (true),
  MEDICINE (true),
  BOOKS    (true),
  OTHER    (false);

  private final boolean exempt;

  private Category(boolean exempt) {
  	this.exempt = exempt;
  }

  boolean isExempt() {
  	return exempt;
  }
}

Most of the logic of the problem is in this one class, Item. All you need now is a class Invoice which simply maintains a list (hint: ArrayList) of orders, each order containing the Item, the quantity of the item, and whether it's imported. Note the following:

- This setup eliminates a lot of your classes. You don't really need a decorator pattern to calculate the taxes, it is much more simple and readable to let the Item calculate its own tax.
- The Item class is immutable. Always strive to make your classes immutable, unless it's impractical to do so. Note how all members are final, as well as the class itself.
- Visibility is reduced where possible. Think long and hard before you use public or protected access modifiers. If you don't need them, don't use them.
- Category is an enum. Always prefer enums over a collection of constants.
- Tax is calculated on the fly. It isn't added as a member variable of the Order or Item, because it can dynamically be calculated from the members in Item.
- Normally I would also include equals and hashCode methods, but for brevity I left them out.

Please tell me whether you understand why this code is 'better'. If someone thinks this code is worse, please tell me, so I can learn about your ideas as well.