Metodo ereditato restituito tipo di riferimento

Question

Sono di fronte al problema descritto in this question ma vorrei trovare una soluzione (se possibile) senza tutti i cast e le annotazioni @SuppressWarning.

Una soluzione migliore sarebbe quella che si basa sul fatto riferimento a uno a:

• rimozione @SuppressWarning
• rimozione calchi

soluzioni presentate qui sarà classificato con 2 punti in base al criteri. Bounty va in soluzione con la maggior parte dei punti o il "più elegante" se ce n'è più di uno con 2 punti.

Answer 1

No cast, non @SuppressWarning, solo poche righe:

public abstract class SuperClass<T extends SuperClass<T>> { 
    protected T that; 
    public T chain() { 
     return that; 
    } 
} 

public class SubClass1 extends SuperClass<SubClass1> { 
    public SubClass1() { 
     that = this; 
    } 
} 

public class SubClass2 extends SuperClass<SubClass2> { 
    public SubClass2() { 
     that = this; 
    } 
} 

Answer 2

Una soluzione è sovrascrivere il metodo nella classe figlio e modificare il tipo restituito in uno più specifico, ad es. il tipo di bambino. Questo richiede il casting. Invece di utilizzare la tipica (Child) cast, utilizzare il metodo Class#cast(Object)

public class Parent { 
    public Parent example() { 
     System.out.println(this.getClass().getCanonicalName()); 
     return this; 
    } 
} 

public class Child extends Parent { 
    public Child example() { 
     return Child.class.cast(super.example()); 
    } 

    public Child method() { 
     return this; 
    } 
} 

Il cast è nascosto all'interno del metodo standard. Dalla sorgente di Class.

public T cast(Object obj) { 
    if (obj != null && !isInstance(obj)) 
     throw new ClassCastException(cannotCastMsg(obj)); 
    return (T) obj; 
} 

Answer 3

Un approccio è quello di definire un metodo astratto getThis() in Parent classe, e fare tutte le classi Child sostituirla, restituendo il riferimento this. Questo è un modo per recuperare il tipo di oggetto this in una gerarchia di classi.

Il codice sarebbe simile a questa:

abstract class Parent<T extends Parent<T>> { 

    protected abstract T getThis(); 

    public T example() { 
     System.out.println(this.getClass().getCanonicalName()); 
     return getThis();   
    } 
} 

class ChildA extends Parent<ChildA> { 

    @Override 
    protected ChildA getThis() { 
     return this; 
    } 

    public ChildA childAMethod() { 
     System.out.println(this.getClass().getCanonicalName()); 
     return this; 
    } 
} 

class ChildB extends Parent<ChildB> { 

    @Override 
    protected ChildB getThis() { 
     return this; 
    } 

    public ChildB childBMethod() { 
     return this; 
    } 
} 


public class Main { 

    public static void main(String[] args) throws NoSuchMethodException { 
     ChildA childA = new ChildA(); 
     ChildB childB = new ChildB(); 

     childA.example().childAMethod().example(); 
     childB.example().childBMethod().example(); 
    } 
} 

Secondo il requisito, non v'è alcuna Casting e nessun @SuppressWarnings. Ho imparato questo trucco qualche giorno fa da Angelika Langer - Java Generics FAQs.

Riferimento:

• How do I recover the actual type of the this object in a class hierarchy?