Имитация ADT в Java

Question

Приложение может работать в двух режимах - «в реальном времени», где оно смотрит на каждое обновление до состояния мира или «отбирается», когда оно смотрит только на состояние мира каждые три миллисекунды ,

Если бы я писал Haskell (или любой другой язык с АТД) Я бы смоделировать это как

data Mode = RealTime | Sampled Int 

, который может быть использован следующим способом типобезопасного

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

Я говорю, что он «безопасен по типу», потому что если вы работаете в режиме реального времени, вам не удается получить доступ к полю interval (который предоставляется в то время, когда он вам нужен, если вы работаете в режиме дискретизации).

Как смоделировать одно и то же в Java безопасным способом? То есть, я хочу

• Для определения класса (или перечисления), который отличает между этими двумя режимами, и
• Чтобы запретить доступ к interval полю в режиме реального времени, и
• Чтобы все это проверено компилятором.

Возможно ли это на Java? Если нет, то каков идиоматический способ достижения такого рода безопасности?

Answer 1

Традиционный способ эмулировать замкнутые алгебраические типы данных в языке, как Java, что обеспечивает только открытые классы (которые могут быть унаследованы в любое время) в пути типобезопасного является 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(); 
    } 
} 

Как @ user3237465 отмечено, что возможны несколько кодировок типов данных, которые происходят, чтобы совпадать, когда тип данных не является рекурсивным: Церковное кодирование является сгибом: оно позволяет вам накапливать значение путем рекурсии по типу данных, закодированному Церковью. Кодировка Скотта соответствует фактическому сопоставлению шаблонов. В любом случае, посетители могут быть использованы для реализации всех этих кодировок. Спасибо за толчок, @ user3237465!

Answer 2

Вы можете объявить интерфейс Mode

public interface Mode { 
    void doSmth(); 
} 

И тогда вы можете иметь два класса, реализующие этот интерфейс

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 
    } 
} 

Затем вы объявляете переменную типа Mode

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

И то, поскольку mode имеет тип Mode, вы сможете получить доступ только к тому, что объявлено в интерфейсе. Таким образом, вы можете просто позвонить mode.doSmth() и, в зависимости от того, как вы инициализировали mode, он будет работать в режиме реального времени или сэмпла.

Если классы имеют некоторый код, вы можете объявить класс abstract вместо interface и иметь оба класса extend этот класс. Таким образом, то они могут вызвать общие методы, которые заявлены в abstract класса (который должен быть объявлен с protected видимости, так что только подклассы могут видеть их)

Answer 3

Да, Corse можно, Altough он dependes на уровне сложности, которую вы готовы достичь.

Если вы хотите, чтобы достичь самого высокого уровня типа-безопасности, я рекомендую вам объявить абстракции (названной AbstractModeManager), который ответственностью будет запрашивать состояние мира и сохранить его в переменных экземпляра, которые должны быть доступными через общедоступные методы получения.И он также должен знать, когда произошло обновление:

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(...); 
} 

Под этим, вы должны кодировать две реализации: один для реального времени, а другой для пробы:

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. 
    } 
} 

И наконец, вы должны решить, какие из них должны быть использованы в каждом случае, хранить его в переменной:

private AbstractModeManager mode=... 

... И взывать систематически его при каждом обновлении в Система:

mode.updateOccurred(...) 

Таким образом, после инициализации этой переменной, то все равно, в каком режиме система работает: Это поведение остается на ваше абстракции.