Блог

Я только начинаю разбираться в функциях первого порядка и замыканиях после обнаружения блоков в Objective-C. Java — это еще один язык, где я слышал о закрытиях (или их отсутствии) и о том, как анонимные классы в некоторой степени компенсируют это.

Я определенно вижу преимущества замыканий в виде блоков в Objective-C, но каковы ограничения анонимных классов Java? В какой степени они «несколько» компенсируют отсутствие истинных замыканий?

Анонимные классы Java действительно, действительно многословны. Помимо огромного количества шаблонов, которые вам нужны только для их определения, некоторые дизайнерские решения Java означают, что многие общие задачи намного более подробны, чем на других языках. Например, импорт изменяемых повышающих значений в замыкание — это заноза в заднице в Java.

В принципе, Java не поддерживает значения up; вместо этого они моделируются путем передачи их (по значению) в класс через невидимые параметры конструктору класса. Поскольку они передаются по значению, их изменение внутри класса не повлияет на копию в методе, который создал класс, поэтому компилятор заставляет вас объявлять их окончательными, чтобы избежать путаницы. например:

 Runnable function()
{
   final int i = 4;
   return new Runnable()
   {
       public void run()
       {
            System.out.println("i=" i);
            // can't modify i here
       }
   }
}
  

В случаях, когда вам действительно необходимо изменить переменную, например, практически во всех случаях, когда замыкания были бы полезны, вам приходится хитрить:

 Runnable function()
{
   final int[] i = new int[1];
   i[0] = 4;
   return new Runnable()
   {
       public void run()
       {
            System.out.println("i=" i[0]);
            i[0] = i[0]   1;
       }
   }
}
  

Здесь i сам по себе остается неизменяемым, но поскольку он указывает на изменяемый объект, я могу изменить содержимое объекта. (Естественно, в реальной жизни я бы использовал класс, а не массив, потому что использование массивов действительно уродливо. И это делает его еще более многословным.)

Я понимаю, что в следующем выпуске Java будет синтаксический сахар, чтобы упростить все это, но прямо сейчас программирование, ориентированное на замыкание, довольно громоздко на Java. Я нахожу, что часто проще изменить логику, чтобы не использовать замыкания, просто чтобы позволить мне сохранить объем используемого кода достаточно маленьким, чтобы быть понятным.

Я действительно не знаю о версии closures для objective-C, но я знаю их из Smalltalk и Lua.

Замыкание — это, по сути, функция, которая имеет доступ к локальной переменной какой-либо другой функции / блока (обычно той, в которую замыкание синтаксически вложено). Таким образом, локальная переменная может существовать дольше, чем блок, в котором она определена. Когда у вас есть несколько замыканий на одну и ту же переменную, они могут обмениваться данными, используя эту переменную.

Локальные классы Java (частным случаем которых являются анонимные классы) поддерживают ограниченную версию этого: они разрешают доступ к final переменной, то есть переменной, которая не может изменить свое значение. Это реализуется путем копирования значения этой переменной в объект локального класса при его создании. Вы можете эмулировать реальные замыкания, используя изменяемый объект в этой переменной (в простейшем случае одноэлементный массив).

Кроме того, синтаксис Java для этого довольно уродлив, но он прекрасно вписывается в остальную часть языка и обеспечивает безопасность статического типа (в отличие от некоторых обсуждаемых вариантов с более коротким синтаксисом).