Raising Java-induced over-engineering to a new level

Michael Torrie torriem at chem.byu.edu
Sat Jul 14 21:15:32 MDT 2007


Of course we all know Java is renowned for lending itself well to
over-engineering and pattern abuse.  This little clip is amazing!
Without comments it's still a little under 100 lines of code!  To top it
off, it's not even thread safe they tell me.

If I got paid by the lines of code I'd switch to Java for sure. :)

/**
 * This program is an elaborate joke about the strucuture of the Java
 * programming language. Technically you'll have to put all the
 * public interfaces and classes in their own file to get it to
 * compile. The actual code came from a slashdot post, comments were 
 * later added by ookabooka.
 * 
 * Originally Copyright 2002 MillionthMonkey.
 * 
 * Ridiculously verbose and mostly useless comments (AKA good
 * commenting) added by ookabooka Copyright 2007.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 		http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an "AS IS"
 * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 * 
 * TODO:
 * Add some try/catches and a plethora of exceptions to further insult
 * Java.
 * 
 * @author ookabooka
 * @version 2.41.54b_2-rc4
 * @see http://ask.slashdot.org/article.pl?sid=07/07/14/2011208
 */
 
/**
 * This interface simply houses one method (not to be confused with "function"
 * from other languages like C++) without parameters and like everything in this
 * program is definately not needed.
 */
public interface MessageStrategy {
 
	/**
	 * Sends a message
	 * 
	 * @return
	 */
	public void sendMessage();
}// MessageStrategy
 
/**
 * The AbstractStrategyFactory will be used to as a template for
 * StrategyFactories to take a MessageBody and create a useful Strategy whos
 * parameters is defined by the MessageBody.
 * 
 */
public abstract class AbstractStrategyFactory {
 
	/**
	 * Abstract method that creates the MessageStrategy. Any classes that
	 * inherit this abstract class should use this method to create their
	 * MessageStrategies.
	 * 
	 * @param mb
	 *            MessageBody object to initialize the MessageStrategy
	 */
	public abstract MessageStrategy createStrategy(MessageBody mb);
}// AbstractStrategyFactory
 
public class MessageBody {
 
	Object payload;// This is the data that this class will be handling
 
	/**
	 * Simple "getter" method because it's a lot cooler than accessing a public
	 * variable.
	 * 
	 * @return the data that this class is handling.
	 */
	public Object getPayload() {
		return payload;
	}// getPayload
 
	/**
	 * Sets the payload for this TODO: Change to setPayload because that is the
	 * common convention.
	 * 
	 * @param obj
	 *            the object that you want this MessageBody to handle.
	 */
	public void configure(Object obj) {
		payload = obj;
	}// configure
 
	/**
	 * Runs the sendMessage method on the MessageStrategy. Why you don't just
	 * call it directly instead of using this method I will never know.
	 * 
	 * @param ms
	 *            the MessageStrategy you want to call sendMessage() on.
	 */
	public void send(MessageStrategy ms) {
		ms.sendMessage();
	}// send
}// MessageBody
 
/**
 * This class inherits from AbstractStrategyFactory and will be doing the bulk
 * of the work to print the "Hello World" string.
 * 
 * 
 */
public class DefaultFactory extends AbstractStrategyFactory {
	/**
	 * Default constructor, this is completely and totally not needed at all as
	 * it does absolutely nothing and takes no parameters.
	 * 
	 */
	private DefaultFactory() {
	}// DefaultFactory
 
	static DefaultFactory instance;// an instance of the factory
 
	/**
	 * This method returns the instance of DefaultFactory, creating a new one if
	 * there isn't one initialized already.
	 * 
	 * @return DefaultFactory object ready for use.
	 */
	public static AbstractStrategyFactory getInstance() {
		if (null == instance)// If we don't have an instance
			instance = new DefaultFactory();// Initialize one
		return instance;// return the instance to the DefaultFactory
	}// getInstance()
 
	/**
	 * This creates the relevant MessageStrategy defined by the passed
	 * MessageBody and defines it's sendMessage() method. I didn't even know you
	 * could define functions like this. Obviously as a factory this is the most
	 * useful and relevant function in this class.
	 * 
	 * @param the
	 *            MessageBody to you want the strategy to work with
	 * @return the MessageStrategy associated with the passed MessageBody
	 */
	public MessageStrategy createStrategy(final MessageBody mb) {
		/*
		 * This is actually really neato here, the constructor is actually
		 * defined right here as it's created.
		 */
		return new MessageStrategy() {
			MessageBody body = mb;// set the body to the parameter
 
			/**
			 * This simply gets MessageBody's payload and prints it out
			 */
			public void sendMessage() {
				Object obj = body.getPayload();// get the payload
				System.out.println(obj.toString());// finally a println
				// TODO: Change to System.out.println(body.getPayload());
			}// sendMessage()
		};// MessageStrategy()
	}// createStrategy
}// DefaultFactory
 
/**
 * The main class of the program, this contains the main method and initializes
 * the Factory and MessageBody and then proceeds indirectly print out the
 * message by calling the MessageBody.send method with the "Hello World"
 * MessageBody object.
 * 
 */
public class HelloWorld {
 
	/**
	 * The main method, this is what gets run when the program is executed. This
	 * is also all this class has in it.
	 * 
	 * @param args
	 *            completely ignored, here for compliance reasons
	 */
	public static void main(String[] args) {
		MessageBody mb = new MessageBody();// initilize MessageBody object
		mb.configure("Hello World!");// set the body to "Hello World"
		//get an instance of DefaultFactory
		AbstractStrategyFactory asf = DefaultFactory.getInstance();
 
		//initialize a strategy associated with the MessageBody
		MessageStrategy strategy = asf.createStrategy(mb);
 
		//Have the message body send using the passed strategy
		mb.send(strategy);
	}// main
}// HelloWorld




More information about the PLUG mailing list