Event - события в объектно-ориентированном программировании

/**
 * Функция генерации случайного значения от -5 до 5 с событиями
 */
function randomInt(callbackPositive, callbackNegative, callbackZero) {
    let rndInt = randomInteger(-5, 5);
    if (rndInt < 0)
        callbackNegative(rndInt)
    else if (rndInt > 0)
        callbackPositive(rndInt)
    else
        callbackZero();
}

/**
 * Callback-функция на событие выпадания случайного положительного значения
 */
function funcCallbackPositive(rndInt) {
    print("Получено положительное число " + rndInt + ".");
}

/**
 * Callback-функция на событие выпадания отрицательного значения
 */
function funcCallbackNegative(rndInt) {
    print("Получено отрицательное число " + rndInt + ".");
}

/**
 * Callback-функция на событие выпадания нуля
 */
function funcCallbackZero() {
    print("Получен ноль.");
}

function randomInteger(min, max) {
  // случайное число от min до (max+1)
  let rand = min + Math.random() * (max + 1 - min);
  return Math.floor(rand);
}

function main() {
    for (let i=0; i<20; i++) {
        randomInt(funcCallbackPositive, funcCallbackNegative, funcCallbackZero);
    }
}

main();

import random

def random_int(callback_positive, callback_negative, callback_zero):
    """ Функция генерации случайного значения от -5 до 5 с событиями """
    rnd_int = random.randint(-5, 5)
    if rnd_int < 0:
        callback_negative(rnd_int)
    elif rnd_int > 0:
        callback_positive(rnd_int)
    else:
        callback_zero()

def func_callback_positive(rnd_int):
    """ Callback-функция на событие выпадания случайного положительного значения """
    print("Получено положительное число {}.".format(rnd_int))

def func_callback_negative(rnd_int):
    """ Callback-функция на событие выпадания случайного отрицательного значения """
    print("Получено отрицательное число {}.".format(rnd_int))

def func_callback_zero():
    """ Callback-функция на событие выпадания нуля """
    print("Получен ноль.")
    
    
def main():
    for i in range(0, 10):
        random_int(func_callback_positive, func_callback_negative, func_callback_zero)
        
if __name__ == '__main__':
    main()

using System;
class MainClass {
  delegate void CallBackFunction(int i); 
  static Random rnd;
  
  static void Main() {
    rnd = new Random();
    for (int i = 0; i < 10; i++)
        RandomInt(FuncCallbackPositive, FuncCallbackNegative, FuncCallbackZero);
    }

   /**
    * Функция генерации случайного значения от -5 до 5 с событиями
    */
    static void RandomInt(CallBackFunction callbackPositive, CallBackFunction callbackNegative, CallBackFunction callbackZero) {
        int rndInt = rnd.Next(-5, 6);
        if (rndInt < 0)
            callbackNegative(rndInt);
        else if (rndInt > 0)
            callbackPositive(rndInt);
        else
            callbackZero(rndInt);
    }
    
   /**
    * Callback-функция на событие выпадания случайного положительного значения
    */
    static void FuncCallbackPositive(int rndInt) {
        Console.WriteLine("Получено положительное число {0}.", rndInt);
    }

   /**
    * Callback-функция на событие выпадания случайного отрицательного значения
    */
    static void FuncCallbackNegative(int rndInt) {
        Console.WriteLine("Получено отрицательное число {0}.", rndInt);
    }

   /**
    * Callback-функция на событие выпадания нуля
    */    
    static void FuncCallbackZero(int rndInt) {
        Console.WriteLine("Получен ноль.");
    }
}

import random

def random_int(callback_functions):
    """ Функция генерации случайного значения от -5 до 5 с событиями """
    rnd_int = random.randint(-5, 5)
    if rnd_int < 0:
        callback_functions.callback_negative(rnd_int)
    elif rnd_int > 0:
        callback_functions.callback_positive(rnd_int)
    else:
        callback_functions.callback_zero()


class callback_functions:
    """ Класс содержащий callback-функции """
    def callback_positive(rnd_int):
        """ Callback-функция на событие выпадания случайного положительного значения """
        print("Получено положительное число {}.".format(rnd_int))

    def callback_negative(rnd_int):
        """ Callback-функция на событие выпадания случайного отрицательного значения """
        print("Получено отрицательное число {}.".format(rnd_int))
    
    def callback_zero():
        """ Callback-функция на событие выпадания нуля """
        print("Получен ноль.")


def main():
    for i in range(0, 10):
        random_int(callback_functions)
        
if __name__ == '__main__':
    main()

using System;
    class MainClass {
        public interface ICallBackFunctions {
            void CallbackPositive(int rndInt);
            void CallbackNegative(int rndInt);
            void CallbackZero();
        }
    
    static Random rnd;
    
    static void Main() {
        rnd = new Random();
        for (int i = 0; i < 10; i++)
            RandomInt(new CallbackFunctions());
    }
  
   /**
    * Функция генерации случайного значения от -5 до 5 с событиями
    */
     static void RandomInt(ICallBackFunctions CallbackFunctions) {
        int rndInt = rnd.Next(-5, 6);
        if (rndInt < 0)
            CallbackFunctions.CallbackNegative(rndInt);
        else if (rndInt > 0)
            CallbackFunctions.CallbackPositive(rndInt);
        else
            CallbackFunctions.CallbackZero();
    }
    
   /**
    * Класс реализующий интерфейс callback-функций
    */
    public class CallbackFunctions : ICallBackFunctions {
       /**
        * Callback-функция на событие выпадания случайного положительного значения
        */
	    public void CallbackPositive(int rndInt) {
	         Console.WriteLine("Получено положительное число {0}.", rndInt);
	    }

       /**
        * Callback-функция на событие выпадания случайного отрицательного значения
        */	    
	    public void CallbackNegative(int rndInt) {
	        Console.WriteLine("Получено отрицательное число {0}.", rndInt);
	    }
	
       /**
        * Callback-функция на событие выпадания нуля
        */	    
	    public void CallbackZero() {
	        Console.WriteLine("Получен ноль.");
	    }
	}
}

import random

class Event:
    """ Класс события """
    def __init__(self):
        self.__handlers = []

    def __iadd__(self, handler):
        """ Добавляет обработчик события """
        self.__handlers.append(handler)
        return self

    def __isub__(self, handler):
        """ Удаляет обработчик события """
        self.__handlers.remove(handler)
        return self

    def __call__(self, *args, **keywargs):
        """ Запускает обработчики события """ 
        for handler in self.__handlers:
            handler(*args, **keywargs)


class GameDice:
    def __init__(self):
        self.on_throw = Event()
        self.on_double = Event()
    
    def throw(self):
        # Выбрасываем две кости, и получаем два случайных значения в диапазоне
        # от 1 до 6.
        dice_val1 = random.randint(1, 6)
        dice_val2 = random.randint(1, 6)
        # Инициируем событие выбрасывание костей с параметром полученной суммы
        # значения костей.
        self.on_throw(dice_val1 + dice_val2)
        
        # Если значение двух костей одинаковы,
        if dice_val1 == dice_val2:
            # то дополнительно инициируем событие выпадания "дубля" с параметром
            # значения дубля.
            self.on_double(dice_val1)


def main():
    # Создаем класс новой игры,
    game_dice = GameDice()
    # и добавляем обработчики события на результат выбрасывание костей,
    game_dice.on_throw += lambda val: print("Выпало значение {0}.".format(val))
    # и на результат выпадания дубля.
    game_dice.on_double += lambda val: print("Выпал дубль {0}:{0}.".format(val))
    
    # Выбрасываем кости десять раз.
    for i in range(0, 10):
        game_dice.throw()
        
if __name__ == '__main__':
    main()

using System;
class MainClass {
  static void Main() {
    // Создаем класс новой игры,
    GameDice gameDice = new GameDice();
    // и добавляем обработчики события на результат выбрасывание костей,
    gameDice.ThrowEvent += ThrowHandler;
    // и на результат выпадания дубля.
    gameDice.DoubleEvent += DoubleHandler;
    
    // Выбрасываем кости десять раз.
    for (int i = 0; i < 10; i++)
        gameDice.Throw();
    }
   
    /**
    * Функция обработки события выбрасования костей
    */
    static void ThrowHandler(object sender, DiceArgs args) {
       Console.WriteLine("Выпало значение {0}.", args.Val);
    }
   
    /**
    * Функция обработки события выпадения дубля
    */   
    static void DoubleHandler(object sender, DiceArgs args) {
       Console.WriteLine("Выпал дубль {0}:{0}.", args.Val);
    }
  
    class GameDice {
        public delegate void DiceEventDelegate(object sender, DiceArgs args);
        public event DiceEventDelegate ThrowEvent;
        public event DiceEventDelegate DoubleEvent;
      
        Random rnd;
      
        public GameDice() {
            rnd = new Random();
        }
      
        public void Throw() {
            // Выбрасываем две кости, и получаем два случайных значения в диапазоне
            // от 1 до 6.
            int diceVal1 = rnd.Next(1, 7);
            int deceVal2 = rnd.Next(1, 7);
            // Инициируем событие выбрасывание костей с параметром полученной суммы
            // значения костей.
            OnThrow(diceVal1 + deceVal2);
            
            // Если значение двух костей одинаковы,
            if (diceVal1 == deceVal2) 
                // то дополнительно инициируем событие выпадания "дубля" с параметром
                // значения дубля.
                OnDouble(diceVal1);
        }
        
        /**
        * Обработка события выбрасования костей
        */
        protected virtual void OnThrow(int val) {
            DiceArgs args = new DiceArgs(val);
            ThrowEvent?.Invoke(this, args);
        }
      
        /**
        * Обработка события выпадения дубля
        */
        protected virtual void OnDouble(int val) {
            DiceArgs args = new DiceArgs(val);
            DoubleEvent?.Invoke(this, args);
        }
    }
    
    /**
    * Класс аргумента события игры в кости
    */
    public class DiceArgs: EventArgs {
        public int Val { get; }
      
        public DiceArgs(int val) {
            Val = val;
        }
    }
}

import java.util.Random;
import java.util.*;

public class Main
{
	public static void main(String[] args) {
        Main main = new Main();
        main.Start();
    }
    
    public void Start() {
        // Создаем класс новой игры,
	    GameDice gameDice = new GameDice();
	    // и добавляем класс слушателя (обработчика событий).
	    gameDice.addListener(gameDice);
	    
	    // Выбрасываем кости десять раз.
		for (int i = 0; i < 10; i++)
		    gameDice.Throw();
    }
	
    public class GameDice implements IGameDiceListener {
        ArrayList<IGameDiceListener> listeners = new ArrayList<IGameDiceListener>();
        Random rand;
      
        public GameDice() {
            rand = new Random();
        }
      
        public void Throw() {
            // Выбрасываем две кости, и получаем два случайных значения в диапазоне
            // от 1 до 6.
            int diceVal1 = rand.nextInt(6) + 1;
            int diceVal2 = rand.nextInt(6) + 1;
            // Инициируем событие выбрасывание костей с параметром полученной суммы
            // значения костей.
            onThrow(diceVal1 + diceVal2);
            
            // Если значение двух костей одинаковы,
            if (diceVal1 == diceVal2) 
                // то дополнительно инициируем событие выпадания "дубля" с параметром
                // значения дубля.
                onDouble(diceVal1);
        }
        
        /**
        * Добавляет слушателя (обработчик события)
        */
        public void addListener(IGameDiceListener listener)
	    {
		    listeners.add(listener);
	    }
	    
	    /**
        * Удаляет слушателя (обработчик события)
        */
    	public void removeListeners(IGameDiceListener listener)
    	{
    		listeners.remove(listener);
    	}	    
        
        /**
        * Обработка события выбрасования костей
        */
        public void onThrow(int val) {
            for (IGameDiceListener listener : listeners)
                listener.ThrowHandler(new GameDiceEvent(this, val));
        }
      
        /**
        * Обработка события выпадения дубля
        */
        public void onDouble(int val) {
            for (IGameDiceListener listener : listeners)
                listener.DoubleHandler(new GameDiceEvent(this, val));
        }
        
        /**
        * Функция обработки события выбрасования костей
        */        
        public void ThrowHandler(GameDiceEvent event) {
            System.out.printf("Выпало значение %d.\n", event.val);
        }
        
        /**
        * Функция обработки события выпадения дубля
        */  
        public void DoubleHandler(GameDiceEvent event) {
            System.out.printf("Выпал дубль %d:%d.\n", event.val, event.val);
        }
    }
    
    /**
    * Интерфейс слушателя (класса обработчика события) игра в кости.
    */     
    public interface IGameDiceListener {
        void ThrowHandler(GameDiceEvent event);
        void DoubleHandler(GameDiceEvent event);
    }
    
    /**
    * Класс аргумента события игры в кости
    */
    public class GameDiceEvent extends EventObject {
        public int val;
        
        public GameDiceEvent(Object arg0, int val) {
            super(arg0);
            this.val = val;
        }
    }
}