 <p>Consider this simplified problem</p> <pre><code>interface Item&lt;C extends Container&lt;Item&lt;C&gt;&gt;&gt; interface Container&lt;I extends Item&lt;Container&lt;I&gt;&gt;&gt; </code></pre> <p>It doesn't work, because subtypes of <code>Container&lt;Item&lt;C&gt;&gt;</code> are quite limited - <code>Container&lt;MyItem&gt;</code> is not a subtype of it, just like <code>List&lt;string&gt;</code> is not a subtype of <code>List&lt;Object&gt;</code></p> <p>We can relax it with wildcards:</p> <pre><code>interface Item&lt;C extends Container&lt;? extends Item&lt;C&gt;&gt;&gt; interface Container&lt;I extends Item&lt;? extends Container&lt;I&gt;&gt;&gt; </code></pre> <p>Now it works fine</p> <pre><code>class MyItem implements Item&lt;MyContainer&gt; class MyContainer implements Container&lt;MyItem&gt; </code></pre> <p>mostly. The following declaration is also allowed, but not what we intended</p> <pre><code>class HerItem implements Item&lt;MyContainer&gt; // nooo! </code></pre> <p>This is because we relaxed the constraints too much. Well, it's not a really serious problem. Sure, our type system isn't as tight as we want (no type system is), but programmers would instinctively follow the intended constraints, don't go out of their ways to write bizarre stuff just because they can.</p> <p>Ideally, we would want a <code>This</code> type, and our intended constraints can be expressed as</p> <pre><code>interface Item&lt;C extends Container&lt;This&gt;&gt;&gt; interface Container&lt;I extends Item&lt;This&gt;&gt; </code></pre> <p>Since we don't have <code>This</code>, one would attempt to approach it by a type parameter</p> <pre><code>interface Item&lt;C extends Container&lt;This, C&gt;&gt;, This extends Item&lt;C, This&gt; &gt; interface Container&lt;I extends Item&lt;This, I&gt;, This extends Container&lt;I, This&gt;&gt; </code></pre> <p>(or, more symmetrically </p> <pre><code> interface Item&lt;C extends Container&lt;I, C&gt;&gt;, I extends Item&lt;C, I&gt; &gt; interface Container&lt;I extends Item&lt;C, I&gt;, C extends Container&lt;I, C&gt;&gt; </code></pre> <p>)However, this is not really tight either. <code>This</code> isn't really the "this type". It's possible to</p> <pre><code>class HerItem implements Item&lt;MyContainer, MyItem&gt; // uh? </code></pre> <p>Once again, we must rely on programmer's discipline not to do stuff like that.</p>