And you thought that FewShortMethodsPerClass is the real deal ? No, let me tell you the real deal: FewShortClassesPerMethod.


The idea is that the code is then completely modular and perfectly encapsulated. Clients won't be able to see the classes of the objects they get, not even in the CodeBrowser. They just see an interface that's implemented, well, '''nowhere''' !!!  That was the whole point. Even if they have a very modern environment, smarter clients will be able to detect where the class is implemented, and even in debugger they will see something like Main''''''Class$1InsideMethod$X and some such mumbo jumbo, they won't be able to grab a hold of them, they can't instantiate. Completely sealed !!!. Just like Wirth intended them to be when he asked us to separate interface from implementation.

So this keeps you clients honest, but keeps you also honest. You cannot inherit that damn class, you just leave it there (inheritance is for weak souls, going for it like flies to the jar with honey). you cannot instantiate it in another method. More importantly, it makes almost trivial for you to have your new objects referentially transparent. Your referenced variables will be on a stack (the locals in the method), and the stacks disappears, it's almost like LinearLogic. And you can really feel the outer class acts like a module in ML. The real objects, are sealed and closed inside the methods, as they should be.

Extra points for having static methods only. Then the classes inside the static methods do not share state through the enclosing instance.
----

A modest example: the final static method of some class (we don't even care, because that's the idea, constructs the union of two ordered sets. Nobody from outside has any hold on the implementation. Although there's some imperative state creeping through the backdoor, due to some of my bad programming habits.

 /**
  * represents the union of two ordered sets
  * @author ccozianu
  */
 public static OSet Union(final OSet s0, final OSet s1) { 
	class _union extends OSet {
		public CloneableEnum getEnum() {
			class UnionENUM implements CloneableEnum { 
				CloneableEnum e0_=null, e1_=null; 
				CloneableEnum e0() { return e0_!=null? e0_ : (e0_=s0.getEnum());}
				CloneableEnum e1() { return e1_!=null? e1_ : (e1_=s1.getEnum());}
				
				// buffer
				Comparable[] holder = { null, null };
				
				public CloneableEnum clone_() {
					UnionENUM result= new UnionENUM();
					result.holder= (Comparable[]) holder.clone();
					result.e0_= e0_!=null ? e0_.clone_() :null; 
					result.e1_= e1_!=null ? e1_.clone_() :null;
					return result;
					}
				public boolean hasMoreElements() {
					fillBuffer();
					return holder[0] != ENDTAG || holder[1]!= ENDTAG;
					}
				private void fillBuffer() {
					if (holder[0]== null) pop0();
					if (holder[1]== null) pop1();
					}
				private void pop0() { holder[0]= (Comparable)e0().nextElement(); } 
				private void pop1() { holder[1]= (Comparable)e1().nextElement(); }
				private Object take0() { Object result= holder[0]; holder[0]=null; return result;}
				private Object take1() { Object result= holder[1]; holder[1]=null; return result;}
				public Object nextElement() {
					fillBuffer();
					if (holder[0]==ENDTAG)
						if (holder[1]==ENDTAG) { return ENDTAG; }
						else { return take1(); } 
					else 
						if (holder[1]==ENDTAG) { return take0();}
						else {
							int c=holder[0].compareTo(holder[1]);
							if (c<0)return take0();
							else if (c==0) {// eliminate the duplicate element
								holder[1]=null; 
								return take0();}
						 	else
						 		return take1();
							}
					}}
			return new UnionENUM();
			}
		}
		return new _union(); 
	}

----
Can you please show the class definitions?