Demonstrates a frail implementation of the AbstractFactory pattern.

DataProviderTest.java

import java.util.*;
import java.lang.*;

class DataProviderTest
{
	public static void main (String[] args) throws java.lang.Exception
	{
		String provider = "oracle"; //"derby"
		DataProviderFactory factory = DataProviderFactory.getInstance();
		DataProvider dp = factory.getProvider(provider);
		System.out.println(dp.getConnectString());
	}
}

interface DataProvider {
	String getConnectString();
}

/**
* You'd normally register all providers in a configuration file, which
* is read into a Properties instance during construction.
*/
final class DataProviderFactory {
	private static final DataProviderFactory INSTANCE = new DataProviderFactory();

	private DataProviderFactory(){}

	public static DataProviderFactory getInstance() {
		return INSTANCE; //better to use lazy initialization
	}

	public DataProvider getProvider(String provider) throws Exception {
		String className = provider.substring(0, 1).toUpperCase() + provider.substring(1, provider.length()) + "Provider";
		Class<?> c = Class.forName(className);
		return (DataProvider)c.newInstance();
	}
}

class OracleProvider implements DataProvider {
	public String getConnectString() {
		return "oracle:thin:jdbc@";
	}
}

class DerbyProvider implements DataProvider {
	public String getConnectString() {
		return "jdbc:derby@";
	}
}