🚀 go-pugleaf

On Mon, 04 Sep 2006 19:28:54 -0500, A.L. <alewando@fala2005.com>
wrote:
 
>
Kawalek mi ucielo

A.L.
>

>Here is a small excerpt from the definitions of the interfaces List and Iterator in package
>Java.util:
>public interface List<E> { void add(E x);
>     Iterator<E> iterator();
>}
>public interface Iterator<E> { E next();
>     boolean hasNext();
>}
 
>
>"You might imagine that List<Integer> stands for a version of List
>where E has been uniformly replaced by Integer:
>
>public interface IntegerList { void add(Integer x)
>Iterator<Integer> iterator();
>}
>
>This intuition can be helpful, but it’s also misleading.
>It is helpful, because the parameterized type List<Integer> does
>indeed have methods that look just like this expansion.
>
>It is misleading, because the declaration of a generic is never
>actually expanded in this way. There aren’t multiple copies of the
>code: not in source, not in binary, not on disk and not in memory.
>If you are a C++ programmer, you’ll understand that this is
>very different than a C++ template. 
>
>A generic type declaration is compiled once and for all, and turned
>into a single class file, just like an ordinary class or interface
>declaration. Type parameters are analogous to the ordinary
>parameters used in methods or constructors.
>Much like a method has formal value parameters that describe the
>kinds of values it operates on, a generic declaration has formal
>type parameters. When a method is invoked, actual arguments are
>substituted for the formal parameters, and the method body is
>evaluated. When a generic declaration is invoked, the actual type
>arguments are substituted for the formal type parameters..."
>