Могут ли некоторые проиллюстрировать концепцию языка, такого как Java или Groovy, который рассматривается как статически или динамически типизированный или динамический язык?

Статическая и динамическая типизация - это в основном описание того, как набираются переменные (а также аргументы функций и возвращаемые значения). Во многих статически типизированных языках вам нужно будет объявить тип переменной, чтобы компилятор знал, какие операции допустимы и какую перегруженную версию функций / операторов следует использовать. Несколько современных языков со статической типизацией (включая большинство функциональных языков) имеют вывод типа, поэтому в большинстве случаев вам не нужно объявлять тип переменной. Однако переменная по-прежнему должна иметь фиксированный тип. Если вы присвоите одной и той же переменной значения разных типов, компилятор либо откажется от компиляции, либо позволит вам выполнить только общую для всех операцию. По-настоящему строго типизированный язык не может иметь ошибок времени выполнения, связанных с типом.

На языке с динамической типизацией переменная - это просто имя. Вы можете присвоить значения любого типа любой переменной, и тип можно изменить, присвоив значение другого типа. Допустимость вызова функции или операции с переменной можно проверить только во время выполнения оператора. (Вы можете думать об этом как об объявлении каждой переменной в Java как об объекте и приведении их к желаемому типу при использовании. Конечно, компилятор не будет пытаться определить, будет ли приведение успешным, и будет вставлять проверки приведения, которые могут вызвать сбой при запуске время.)

Динамические языки в целом означают ослабление большинства вещей, проверенных компилятором (синтаксис, пожалуй, единственное, что проверяется заранее). Обычно это означает, что существование переменной и даже допустимость вызова функции не проверяются до тех пор, пока в этом нет необходимости. Обычно они используют динамическую типизацию, потому что статическая типизация противоречит релаксации.

Я поставил это как комментарий, но он был немного похоронен.

def ДЕЙСТВИТЕЛЬНО дает тип, он использует тип "Object". Это как если бы каждая переменная, определенная в Java, была определена как объект ... (так что def x = 7 в Groovy в точности совпадает с Object x = 7 в Java, не более или менее типизированным).

Эти объекты ВСЕГДА хранят информацию о своем типе на обоих языках. Эти два также эквивалентны:

Groovy:
def x=5
assert(x == 5)
x="Hey, I changed type!"
assert(x == "Hey, I changed type!")

Java:
Object x=5
assert(x == 5);
x="Hey, I--well I kinda changed my type!"
assert(x.equals("Hey, I--well I kinda changed my type!"))

Большая разница в том, что Java требует (во время компиляции), что вы вызываете ТОЛЬКО известные методы для того типа класса, который, по ее мнению, у вас есть ... поэтому в приведенном выше примере .toString () и .equals () действительно являются единственными полезными методами. . Чтобы заниматься математикой, вам нужно сделать что-то вроде этого:

Object x=5;
Object y=7;
Object z=(int)x + (int) y;
assert(z == 12);  
// I believe Integer z will automatically turn 
// to an int here, but this might not compile :)

В Groovy язык все равно будет пытаться вызвать метод, и во время выполнения будет либо успешно, либо неуспешно.

Это можно эмулировать с помощью Java с помощью отражения, вы можете набрать все как «Object» (как в случае с Groovy «def») и написать отражающую утилиту, которая будет делать что-то вроде этого:

Object s="Hey, Wassup???";
Object s2=magic(s, "toLowerCase")
assert(s2.equals("hey, wassup???"));

Groovy просто скрывает «волшебство».

Поэтому я не думаю, что вы могли бы сказать, что один по своей сути более динамичен, чем другой, хотя вы, вероятно, могли бы сказать, что использование отражения делает оба языка динамическими, и вы также можете сказать, что Groovy использует отражение НАМНОГО больше, чем java ...

Обратите внимание, что в Java вам нужно было указать полный тип переменной. 'int' в вашем примере. Вы могли бы сказать «float», «Map» или «MyClassWithALongName».

В Groovy вы просто сказали def, чтобы указать, что существует переменная, но не сказали ей ничего о типе содержимого.