Symulowanie ADT w Javie

Question

Aplikacja może działać w dwóch trybach - "w czasie rzeczywistym", w której analizuje każdą aktualizację do stanu świata, lub "próbkowaną", gdy patrzy tylko na stan świata co T milisekund .

Gdybym pisanie Haskell (lub dowolnego języka z ADTS) bym tego modelu jako

data Mode = RealTime | Sampled Int 

które mogą być wykorzystane w następujący typu bezpieczny sposób

case mode of 
    RealTime   -> -- do realtime stuff 
    Sampled interval -> -- do sample stuff with 'interval' 

powiedzieć, że jest "bezpieczny dla typu", ponieważ jeśli pracujesz w trybie czasu rzeczywistego, nie możesz próbować uzyskać dostępu do pola interval (które jest dostępne w momencie, gdy jest potrzebne, jeśli pracujesz w trybie próbkowania).

Jak mogę modelować to samo w Javie w bezpieczny sposób? Oznacza to, że chcę

• Aby zdefiniować klasę (lub enum), który odróżnia między tymi dwoma trybami i
• Aby zabronić dostępu do pola interval w trybie czasu rzeczywistego, a
• Aby mieć wszystko to sprawdzane przez kompilator.

Czy to możliwe w Javie? Jeśli nie, jaki jest idiomatyczny sposób osiągnięcia tego rodzaju bezpieczeństwa?

Answer 1

Tradycyjny sposób naśladować zamkniętych algebraiczne typy danych w językach takich jak Java, że ​​tylko dostarcza otwarte zajęcia (które mogą być dziedziczone w każdej chwili) w typie bezpieczny sposób jest Visitor pattern:

abstract class Mode { 
    public abstract <T> T accept(ModeVisitor<T> visitor); 
} 

final class RealTime extends Mode { 
    public RealTime() {} 

    public <T> T accept(ModeVisitor<T> visitor) { 
     return visitor.visit(this); 
    } 
} 

final class Sampled extends Mode { 
    private final int interval; 

    public Sampled(int interval) { 
     this.interval = interval; 
    } 

    public int getInterval() { 
     return this.interval; 
    } 

    public <T> T accept(ModeVisitor<T> visitor) { 
     return visitor.visit(this); 
    } 
} 

// The recursion principle itself 
abstract class ModeVisitor<T> { 
    public abstract T visit(RealTime mode); 
    public abstract T visit(Sampled mode); 
} 

// Concrete uses of the recursion principle 
final class ModeShow extends ModeVisitor<String> { 
    private ModeShow() {} 

    public static String show(Mode mode) { 
     return mode.accept(new ModeShow()); 
    } 

    public String visit(RealTime mode) { 
     return "RealTime"; 
    } 

    public String visit(Sampled mode) { 
     return "Sampled " + mode.getInterval(); 
    } 
} 

Jako @ user3237465 zauważono, że możliwe jest kilka kodowań typów danych, które zdarzają się, aby pokryć się, gdy typ danych nie jest rekursywny: kodowanie Kościoła jest krotnością: pozwala gromadzić wartość przez rekursję w zakodowanym kościele typie danych. Kodowanie Scott odpowiada faktycznemu dopasowaniu do wzorca. W każdym przypadku użytkownicy mogą zostać wykorzystani do implementacji wszystkich tych kodowań. Dzięki za szturchnięcie @ user3237465!

Answer 2

Można zadeklarować interfejs Mode

public interface Mode { 
    void doSmth(); 
} 

I wtedy można mieć dwie klasy implementujące ten interfejs

public class Realtime implements Mode { 
    @Override 
    public void doSmth() { 
     // Do realtime stuff 
    } 
} 

public class Sampled implements Mode { 
    private final int interval; 

    public Sampled(final int interval) { 
     this.interval = interval; 
    } 

    @Override 
    public void doSmth() { 
     // Do sampled stuff 
    } 
} 

Następnie należy zadeklarować zmienną typu Mode

final Mode mode = ... // Initialize however you want, calling one of the constructors. 

I następnie, od mode jest typu Mode, będziesz mieć dostęp tylko do tego, co zostało zadeklarowane w interfejsie. Możesz więc zadzwonić pod numer mode.doSmth() i, w zależności od tego, jak zainicjowałeś mode, uruchomi się w czasie rzeczywistym lub spróbuje.

Jeśli klasy mają jakiś kod, można zadeklarować klasę abstract zamiast interface i mają obie klasy extend tej klasy. Tak więc mogą wywołać wspólne metody, które są zadeklarowane w klasie abstract (która powinna być zadeklarowana z widocznością protected, tak aby tylko podklasy mogły je zobaczyć)

Answer 3

Tak, z corse jest to możliwe, ale zależy od poziomu złożoności jesteś gotowy do osiągnięcia.

Jeśli chcesz osiągnąć najwyższy poziom typu solidność, polecam Ci zadeklarować abstrakcję (o nazwie AbstractModeManager), który odpowiedzialny będzie kwerendy stan świata i przechowywać go w zmiennych instancji, które powinny być dostępne za pomocą publicznych metod pozyskiwania.I musi też wiedzieć, kiedy nastąpiła zmiana:

abstract class AbstractModeManager 
{ 
    // Instance variables to contain the last state read. 
    private ... state; 

    protected void queryTheStateOfTheWorld(...) throws ... 
    { 
     ... fill this.state ... 
    } 

    public ... getState() 
    { 
     return this.state; 
    } 

    public abstract void updateOccurred(...); 
} 

Under że trzeba zakodować dwie implementacje: jeden dla czasu rzeczywistego, a inny dla objętych próbą:

class RealTimeModeManager extends AbstractModeManager 
{ 
    public void updateOccurred(...) 
    { 
     // In this implementation, every time there has been an update, 
     // a query must be performed: 
     queryTheStateOfTheWorld(...); 
    } 
} 

class SampledModeManager extends AbstractModeManager 
{ 
    public SampledModeManager(int interval) 
    { 
     ... program a timer to call the queryTheStateOfTheWorld ... 
    } 

    public void updateOccurred(...) 
    { 
     // Do nothing. 
    } 
} 

i ostatni, musisz zdecydować, które z nich należy stosować w każdym przypadku, należy go przechowywać w zmiennej:

private AbstractModeManager mode=... 

... I powołać systematycznie go przy każdej aktualizacji w System:

mode.updateOccurred(...) 

W ten sposób, po uruchomieniu tej zmiennej, nie będzie obchodziło, który tryb jest uruchomiony system: To zachowanie jest pozostawione do abstrakcji.