Self-bounded types

 Self-bounded types(自限定的类型)

You can't inherit directly from a generic parameter.However,you can inherit from a class that uses that generic parameter in its own definition.That is, you can say:(你不能直接继承一个泛性参数，但是，你可以继承一个类，这个这类在它的定义中使用泛性参数，也就是说，可以声明：) 

class GenericType<T> {} 
public class CuriouslyRecurringGeneric  
    extends GenericType<CuriouslyRecurringGeneric>{ 
 
} 
 

This could be called curiously recurring generics(CRG) after Jim Coplien's Curiously Recurring Template Pattern in C++.The "curiously recurring" part refers to the fact that your class appears,rather curiously,in its own base class.（你的类又在你的基类中出现，说的是作为你的类的父类的泛性参数）

 

To understand what this means,try saying it aloud:"I'm creating a new class that inherits from a generic type that takes my class name as its parameter."What can the generic base type accomplish（完成） when given the derived class name?Well,generics in Java are about arguments and return types,so it can produce a base class that uses the derived type for its arguments and return types.It can also use the derived type for field types,even though those will be erased to Object.(这里面说的意思是在泛性基类中泛性参数T，在使用子类的时候都会被替换成子类，子类是父类的属性的类型，子类是父类方法的返回值的类型，记住是在子类对象中使用任何父类的方法)

public class BasicHolder<T> { 
    T element; 
    void set(T arg){ element = arg; } 
    T get(){ return element; } 
    void f(){ 
        System.out.println(element.getClass().getSimpleName()); 
    } 
} 

It's an ordinary generic type with methods that both accept and produce objects of the parameter type,along with a method that operates on the stored field(althought it only performs Object opreations on that field).

 

class Subtype extends BasicHolder<Subtype> {} 
 
public class CRGWithBasicHolder{ 
    public static void main(String[] args){ 
        Subtype st1 = new Subtype(), st2 = new Subtype(); 
        st1.set(st2); 
        Subtype st3 = st1.get(); 
        st1.f(); 
    } 
     
} 

Notice something important here:The new class Subtype takes arguments and return values of Subtype,not just the base class BasicHolder.This is the essence of CRG:The base class substitutes the derived class for its parameters.(基类用子类替换基类的参数)This means that the generic base class becomes a kind of template for common functionality for all of its derived classes,but this functionality will use the derived type for all of its argumetns and return values.That is，the exact type instead of the base type will be used in the resulting class.So in Subtype,both the argument to set() and the return type of get() are exactly Subtypes.

 

 

Selft-bounding

The BasicHolder can use any type as its generic parameter,as seen here:

class Other{} 
class BasicOther extends BasicHolder<Other>{} 
public class Unconstrained { 
    public static void main(String[] args){ 
        BasicOther b = new BasicOther(), 
                   b2 = new BasicOther(); 
        b.set(new Other()); 
        Other other = b.get(); 
        b.f(); 
    } 
} 

Self-bounding takes the extra step of forcing the generic to be used as its own bound argument.（自限定将采取额外的步骤，强制泛性当作其自己的边界参数来使用）Look at how the resulting class can and can't be used:

class SelfBounded<T extends SelfBounded<T>> { 
    T element; 
    SelfBounded<T> set(T arg){ 
        element = arg; 
        return this; 
    } 
    T get(){ return element; } 
} 
 
class A extends SelfBounded<A>{} 
class B extends SelfBounded<A>{} //Also OK 
 
class C extends SelfBounded<C>{ 
    C setAndGet(C arg){ set(arg); return get();} 
} 
 
class D{} 
 
//Can't do this: 
/* 
- Bound mismatch: The type D is not a valid substitute for  
 the bounded parameter <T extends SelfBounded<T>> of the  
 type SelfBounded<T> 
- Occurrence of 'D' 
*/ 
//class E extends SelfBounded<D>{} 
//Compile error:Type parameter D is not within its bound 
 
//Alas,you can do this,so you can't force the idiom: 
class F extends SelfBounded{} 
 
public class SelfBounding{ 
    public static void main(String[] args){ 
        A a = new A(); 
        a.set(new A()); 
        a = a.set(new A()).get(); 
        a = a.get(); 
        C c = new C(); 
        c = c.setAndGet(new C()); 
    } 
     
} 

 What self-bounding does is require the use of the class in an inheritance relationship like this: 

class A extends SelfBounded<A>{}

 

This forces you to pass the class That you are defining as a parameter to the base class.

What's the added value in self-bounding the parameter?The type parameter must be the same as the class being defined.As you can see in the definition of class B,you can also derive from a SelfBound that uses a parameter of another SelfBounded,although the predominant(主要的) use seems to be the one that you see for class A.The attempt to define E shows that you cannot use a type parameter that is nto a SelfBounded.

 

Unfortunately,F compiles without warnings,so the self-bounding idion is not enforceable.If it's really important,it may require an external tool to ensure that raw types are not being used in place of parameterized types.

 

Notice that you can remove the constraint and all the classes will still compile,but E will also compile:

public class NotSelfBounded<T> { 
    T element; 
    NotSelfBounded<T> set(T arg){ 
        element = arg; 
        return this; 
    } 
     
    T get(){ return element;} 
} 
 
class A2 extends NotSelfBounded<A2>{} 
class B2 extends NotSelfBounded<A2>{} 
 
class C2 extends NotSelfBounded<C2>{ 
    C2 setAndGet(C2 arg){ set(arg); return get();} 
} 
 
class D2{} 
//Now this is Ok: 
class E2 extends NotSelfBounded<D2>{} 

So clearly,the self-bounding constraint serves only to force the inheritance relationship.If you use self-bounding,you know that type parameter used by the class will be the same basic type（相同的基类） as the class that's using that parameter.It forces anyone using that class to follow that form.

It's also possible to use self-bounding for generic methods:

public class SeleBoundingMethods { 
    static <T extends SelfBounded<T>> T f(T arg){ 
        return arg.set(arg).get(); 
    } 
    public static void main(String[] args){ 
        A a = f(new A()); 
    } 
} 

This prevents the method from being applied to anything but a self-bounded argument of the form shown.

 

在这里说一点我自己的理解：

不管是这种形式：

class GenericType<T> {} 
public class CuriouslyRecurringGeneric  
    extends GenericType<CuriouslyRecurringGeneric>{ 
 
} 
 

还是这种形式：

1. class SelfBounded<T extends SelfBounded<T>> { 
2.     T element; 
3.     SelfBounded<T> set(T arg){ 
4.         element = arg; 
5.         return this; 
6.     } 
7.     T get(){ return element; } 
8. } 
9.  
10. class A extends SelfBounded<A>{} 
11. class B extends SelfBounded<A>{} //Also OK 

都会用子类或者是从父类继承出来的子类来作为父类的实际参数，只不过第二种会直接强迫你要使用从父类继承出来的子类来作为参数，可以是本身或者是其他子类

11