java, inizializzare SubClass da SuperClass

Question

public class Base { 
    //long list of attributes 
    // no Constructor using fields 
    // no init methode 
    // i cannot change this class 
} 

ora ho esteso la classe di base come:

public class subClass extends Base{ 
    private boolean selected; 

    ... 
    getter und setter 
    ... 
} 

divento un elenco di oggetti Base List<Base>

ma ho bisogno la stessa lista ma come List<SubClass> è c'è un modo per inizializzare la Sottoclasse dalla Base Class?

esempio:

for(Base b: list){ 
    SubClass sub = (SubClass)b; // Thats wrong i know 
    if(...){ 
     sub.setSelected(true); 
    } 
    newList.add(sub); 
} 

cerco di evitare l'init manuale di ciascun attributo della Base Class alla sottoclasse

aggiorno mia interrogazione, come richiesto nei commenti: il disegno qui sopra è solo un esempio. il mio QUESTIN ESATTAMENTE È:

perché la conversione di BaseClass in SubClass (sione Subclass extends BaseClass) non è possibile? perché Java dos non mi permetterà di fare il seguente:

esempio:

Class Base{ 
    private String name; 
..... 
} 
Class SubClass extends Base{ 
    private String title; 
} 

poi

Base b = DBController.getById(...); 
SubClass sub = (SubClass)b; 

dopo che l'oggetto sub dovrebbe avere il nome attributo dall'oggetto b e la title L'attributo è nullo

perché non è questo il caso in java?

dispiace per il mio cattivo inglese, grazie

Answer 1

Se si dispone di un List<Base>, allora non si può convertirlo in un List<SubClass>. Ciò è principalmente dovuto al fatto che l'elenco non può contenere istanze di SubClass. Il meglio che puoi fare è:

List<SubClass> newList = new List<SubClass>(); 
for(Base b: list){ 
    if (b instanceof SubClass) { 
     SubClass sub = (SubClass)b; 
     . . . 
     newList.add(sub); 
    } 
} 

In generale, tuttavia, quando vi trovate a fare questo genere di cose, c'è qualcosa di sbagliato con il vostro disegno. È possibile evitare la sottoclasse Base e utilizzare composition instead.

EDIT sulla base di osservazioni, suona come si vuole costruire una lista di SubClass istanze tramite un elenco di Base casi come un inizio. Un approccio consiste nel definire un costruttore per SubClass che accetta un argomento come Base.

public class SubClass extends Base{ 
    private boolean selected; 

    public SubClass() { 
     // default constructor 
    } 

    public SubClass(Base original) { 
     // copy constructor -- initialize some fields from 
     // values in original, others with default values 
    } 
    ... 
    getter und setter 
    ... 
} 

Poi si può costruire la vostra nuova lista con:

List<SubClass> newList = new List<SubClass>(); 
for(Base b: list){ 
    SubClass sub = new SubClass(b); 
    . . . 
    newList.add(sub); 
} 

Answer 2

Si sembrano avere una classe con un sacco di attributi e non c'è modo semplice di tutti loro impostazione. Ora hai eseguito un problema in cui hai bisogno di una classe con un attributo aggiuntivo, ma devi affrontare quel casino di una classe base.

suggerisco, invece di creare una sottoclasse e la colata, si crea una classe wrapper per il brutto:

public class BigDumbClass { 
    // A lot of attributes 
    // No Constructor 
    // No init method 
} 

public class Wrapper { 
    private BigDumbClass base; 
    private boolean selected; 

    public Wrapper(BigDumbClass base) { 
     this.base = base; 
     this.selected = false; 
    } 

    //getters and setters 
} 

Ora, quando si deve creare quella nuova lista si può avvolgere tutto nella vecchia lista

List<BigDumbClass> oldList = someData(); 
List<Wrapper> wraps = aNewList(); 
for (BigDumbClass bigDumb : oldList) { 
    Wrapper wrap = new Wrapper(bigDumb); 
    if (someCondition()) { 
     wrap.setSelected(true); 
    } 
    wraps.add(wrap); 
} 

Idealmente, sarebbe BigDumbClass implementare un'interfaccia che involucro potrebbe anche implementare, consentendo l'involucro di differire tutte le chiamate verso l'istanza è avvolto.

public class BigDumbClass implements SharedInterface { 
    // All the stuff outlined above 
} 

public class Wrapper implements SharedInterface { 
    // All the stuff outlined above 

    // Methods defined in SharedInterface 
    public void doSomething() { 
     base.doSomething(); 
    } 
} 

In caso contrario, è possibile fornire un getter all'istanza e accedervi direttamente.

BigDumbClass base = wrapper.getBase(); 
base.doSomething(); 

Answer 3

C'è una via: based manipulation Vari Java Beans spec.

Ad esempio:

Commons BeanUtils

for(Base base: list){ 
    SubClass sub = new SubClass(); 
    PropertyUtilsBean.copyProperties(sub, base); 
    if(...){ 
     sub.setSelected(true); 
    } 
    newList.add(sub); 
} 

Questa Funziona sulla base di ricevere/setter con lo stesso nome. Non copia i campi interni.

Se è necessario copiare i campi interni, in realtà non è così difficile da implementare utilizzando javax.lang.reflect.