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
/*
PLUG: http://plug.org, #utah on irc.freenode.net
Unsubscribe: http://plug.org/mailman/options/plug
Don't fear the penguin.
*/
