Metodo Java Restituisce Tipo illimitato

1

Stavo leggendo questo articolo, link , sulla sottoclasse di una classe di builder. Ho capito l'articolo ma ce n'era un pochino che mi ha infastidito. C'era questo metodo,

public static Builder<?> builder() {
        return new Builder2();
}

Quando ho cambiato Builder<?> in Builder , un tipo non elaborato, il compilatore non ha compilato il codice. Qual è l'informazione aggiuntiva che è stata trasmessa al compilatore tramite il <?> aggiuntivo?

Ho incollato il codice qui:

public class Shape {

  private final double opacity;

     public static class Builder<T extends Builder<T>> {
         private double opacity;

         public T opacity(double opacity) {
             this.opacity = opacity;
             return self();
         }

 /*
         public T height(double height) {
             System.out.println("height not set");
             return self();
         }
 */
         protected T self() {
             System.out.println("shape.self -> " + this);
             return (T) this;
         }

         public Shape build() {
             return new Shape(this);
         }
     }

     public static Builder<?> builder() {
         return new Builder();
     }

     protected Shape(Builder builder) {
         this.opacity = builder.opacity;
     }
 }

 public class Rectangle extends Shape {
     private final double height;

     public static class Builder<T extends Builder<T>> extends Shape.Builder<T> {
         private double height;

         public T height(double height) {
             System.out.println("height is set");
             this.height = height;
             return self();
         }

         public Rectangle build() {
             return new Rectangle(this);
         }
     }

     public static Builder<?> builder() {
         return new Builder();
     }

     protected Rectangle(Builder builder) {
         super(builder);
         this.height = builder.height;
     }

     public static void main(String[] args) {
         Rectangle r = Rectangle.builder().opacity(0.5).height(250).build();
     }
}
    
posta thlim 19.03.2014 - 09:25
fonte

2 risposte

2

Se rimuovi la parte generica <?> di Builder<?> , tutte le informazioni generiche vengono rimosse e il T nella tua classe Builder diventa Object - Object non ha un metodo opacity() .

    
risposta data 19.03.2014 - 11:52
fonte
0

Il simbolo ? è una variabile di tipo. È un nome senza nome, il che significa che non puoi farvi riferimento in codice, ma il compilatore lo utilizzerà ancora e lo sostituirà con il tipo effettivo con cui Builder funziona (come Rectangle ). Il compilatore può quindi utilizzare questo tipo di informazioni aggiuntive, inclusa la risoluzione corretta del metodo opacity .

Senza <?> , questa ulteriore informazione sul tipo in fase di compilazione viene persa, quindi il compilatore deve presupporre che funzioni con Object . Di conseguenza, esegui il casting esplicito per richiamare qualsiasi metodo che Object non abbia.

    
risposta data 20.03.2014 - 18:25
fonte

Leggi altre domande sui tag