Czy dobrym przykładem jest instancja?

Question

Mam listę obiektów, które rozciągają się od klasy bazowej. Teraz chcę zastosować konkretną operację tylko na jednej instancji klas na liście.

Czy jest to dobra praktyka z zakresu instanceof? Czy raczej powinienem odróżnić obiekty np. Od niestandardowego enum?

abstract class Base; 
class Foo extends Base; 
class Bar extends Base; 

List<Base> bases; 

for (Base base : bases) { 
    if (base instanceof Bar.class) { 
    //execute my custom operation on the base object 
    doSomething((Bar) base); 
    } 
} 

Jeśli to podejście nie jest ogólnie przyjemne, jak mogę to zrobić lepiej?

Answer 1

Tak naprawdę nie ma powodu, aby używać przykładu tutaj. Może być sensowne, aby klasa podstawowa była domyślnie zachowana, tak aby nic nie robić i nadpisywać ją w rozszerzaniu klas, gdy zajdzie taka potrzeba. W ten sposób nadpisujesz go tylko w razie potrzeby (opuściłem to jako abstrakcyjną klasę, której należy przestrzegać z pytaniem, które nie jest potrzebne w tym przykładzie). Na przykład:

abstract class Base{ 
    public void doSomething(){} 
} 

public class B0 extends Base{ 
    @Override 
    public void doSomething(){//actually do something} 
} 

public class B1 extends Base{} 

Przykładem zastosowania może to być coś takiego:

public class SomeOtherClass{ 
    public void something(List<Base> bases){ 
     for(Base base:bases) 
      base.doSomething(); 
    } 
} 

Answer 2

abstract class Base;//abstract function doSomething() 
class Foo extends Base;//implements doSomething() 
class Bar extends Base;//dito 

List<Base> bases; 

for (Base base : bases) { 
    base.doSomething(); 
} 

Aby odpowiedzieć na pytanie: nie jest dobrym pomysłem użycie instanceof.

Answer 3

wystąpienie nie jest dobrą praktyką tutaj.

Prawidłowe rozwiązanie zależy od tego, co dokładnie dzieje się w metodzie doSomething. Jeśli zrobisz to na swój sposób, to poza tym naruszysz Liskov Substitution Principle. Zakładam, że zdecydowałeś, że potrzebujesz tej hierarchii przede wszystkim z powodu czegoś, a także założę, że podtypy mają nieco więcej zachowań niż tylko metodę Zrób coś. W tym przypadku, co możesz zrobić, pokazano poniżej. Zasadniczo tylko typy, które powinny to zrobić, a reszta typów powinna być podobna do no operation. W ten sposób możesz używać tych obiektów, nie wiedząc, jakiego typu naprawdę są.

Powinieneś także zadać sobie pytanie, czy naprawdę potrzebujesz klasy bazowej, aby być klasą abstrakcyjną. Może potrzebujesz tylko interfejsu. Może być lepsze podejście, ale w oparciu o posiadane informacje i to, co założyłem, wydaje się, że wszystko jest w porządku.

public abstract class Base 
{ 
    public abstract void doSomething(); 

    public void someOtherMethod() 
    { 
     // which does stuff 
    } 
} 

public class SubTypeWhichCanDoSomething extends Base 
{ 
    @Override 
    public void doSomething() 
    { 
     // actually implement method and DO something 
    } 
} 

public class DoesNothing extends Base 
{ 
    @Override 
    public void doSomething() 
    { 
     // does nothing 
     return; 
    } 
} 

// then your code looks like these 
for(Base base : bases) 
{ 
    base.doSomething(); 
}