Object Oriented Design: Abstract Class vs. Interface

[Aryeh Golob]

I am currently designing an e-commerce application and am trying to devise the best design structure for the product.

1) I have a notion of a GenericProduct that can be used to do many things. The most simple use of of this class is for insertion into a web site.

2) I also have supplier specific product such as AcmeProduct that extend GenericProduct's capabilities to do things like add all the Acme specific attributes and stuff to the product while still leveraging polymorphism to insert any GenericProduct into the database.

3) I am currently building a sub component to the application that can insert a GenericProduct in Google Base (Google's free shopping comparison service).

4) Not all products need to go into Google Base, so I thought of creating an interface called GoogleBaseInsertableProduct that AcmeProduct will implement that will allow me to enforce a contract on all Google Base insertable products.

My issue, however, is this ....

In-order to insert a product to Google Base I need lots of GenericProduct stuff such as the ability to get the number of products in-stock, the price, the URL of product ... etc.

If, however, my AcmeProduct implements GoogleBaseInsertableProduct and I use GoogleBaseInsertableProduct to send to my Google Base insertion method, I loose the ability to call GenericProduct functions such as getQuanitity(), getSku(), getPrice() etc ....

What I really need is a GenericProduct that implements GoogleBaseInsertableProduct that I can have AcmeProduct extend.

The problem is, is that I don't want every GenericProduct to implement GoogleBaseInsertableProduct, a GenericProduct should be just that, generic, and not be forced to define Google Base specific methods.

The only thing I can think of is to do something like this ....

   
public class GoogleBaseInsertableProduct extends GenericProduct implements GoogleBaseInsertabe  {
}

public class AcmeProduct extends GoogleBaseInsertableProduct {
}

The problem with this, however, is lets say I want to do something else like give AcmeProduct the ability to interact with Amazon Marketplace and still be able to do things like getPrice(), getUrl() etc. ... then I will not be able to do that because AcmeProduct will forever be a GoogleBaseInsertableProduct.

One other thing I could do would be to declare all those GenericProduct methods like getPrice(), getUrl() etc. in GoogleBaseInsertableProduct and then simply do this ....

    
public class AcmeProduct extends GenericProduct implements GoogleBaseCompatibleProduct {
}

public interface GoogleBaseCompatibleProduct {
 // Google Base specific methods such as getBaseDefinition() ... blah blah

 // Now all the GenericProduct methods ... should we really need to be defining this again?
 public float getPrice();

 public String getSku();

 public URL getUrl();
 
 // etc. etc.
}

The problem with this approach is that I need to redefine all the basic GenericProduct methods such as getPrice(), getSku() ...

Perhaps this is the correct design, but it seems redundant ... no?


Here is some sample Code so that you get the gist of what I am trying to do.

    
	// osCommerce implementation of abstract parent class method
	public void addBaseEntry(GenericProduct liveProd, DbProductMeta dbProd) {
		// Is there a reason we should not add this product to base?
		// Logging is done on the local implementation of GenericProduct as 
		// there may be different reasons for this occuring.
		if(!liveProd.addToBase()) {
			return;
		}

		String sku = liveProd.getSku();
		float price = liveProd.getPriceFloatValue();
		int qty = liveProd.getQuantity();
		//DataUtil.print(sku+" price="+price+" qty"+qty);
		//DataUtil.print(sku+" url="+productUrl);
		
		String url = this.getBaseUrl();
		//DataUtil.print("imgDir="+imgDir);
		String pid = dbProd.getProductIdString();
		// 'product_type' base attributes 
		String taxonomy = this.getProductTaxonomy(liveProd, dbProd);
		//DataUtil.print("taxonomy="+taxonomy);

		String prodUrl = liveProd.getOscUrl(url, pid);
		String imgUrl = liveProd.getOscImageUrl(url);
		//DataUtil.print(prodUrl);

		// Create GoogleBaseEntry as this product is not yet in base
		GoogleBaseEntry baseEntry = new GoogleBaseEntry();

		String title = liveProd.getBaseTitle();
		baseEntry.setTitle(TextConstruct.create(TextConstruct.Type.TEXT, title, null));
		//DataUtil.print("sku="+sku+" title="+title);

		GoogleBaseAttributesExtension attExt = baseEntry.getGoogleBaseAttributes();
		attExt.setItemType("Products");
		attExt.addTextAttribute("id", sku);
		attExt.setPrice(price, "USD");
		attExt.setQuantity(qty);
		attExt.addTextAttribute("condition", "New");
		attExt.addTextAttribute("product_type", taxonomy);
		attExt.addTextAttribute("item_language", "en");
		attExt.addTextAttribute("target_country", "US");
		//DataUtil.print(attExt.toString()+"\n");

		// add image url
		attExt.addImageLink(imgUrl);

		// add product url
		Link prodLink = new Link();
		prodLink.setHref(prodUrl);
		prodLink.setType("text/html");
		prodLink.setRel("alternate");
		baseEntry.getLinks().add(prodLink);


	}

[Steve Luke]

You need to leverage interfaces a bit more. Something like:

public interface Product
{
    /* methods everything share */
}

public interface GoogleBaseProduct extends Product
{
    /* new methods Google Base needs */
}

public interface AmazonProduct extends Product
{
    /* new methods Amazon needs */
}

public abstract class GenericProduct implements Product
{
    /* implementations for base Product methods */
}

public abstract class AcmeProduct extends GenericProduct implements GoogleBaseProduct
{
    /* implements Acme-specific stuff and Google Base stuff */
}

public abstract class AmazonReadyAcmeProduct extends AcmeProduct implements AmazonProduct
{
    /* implements Amazon stuff */
}

Then any GoogleBaseProduct or AmazonProduct reference can be used as a Procuct, and any AcmeProduct can be used as a GoogleBaseProduct, and those sub-class of AmazonReadAcmeProcucts can be used as GoogleBaseProducts or AmazonProduct, or simple Product, etc...

[Aryeh Golob]

Thanks Steve ... I appreciate the clear and concise breakdown.

This makes lots of sense .... cheers ....