Linguagem tipada

Linguagem tipada, ou linguagem tipificada, é uma linguagem de programação que usa variáveis com tipos específicos.

Classificação

Linguagens fortemente tipadas

Linguagens fortemente tipadas (ou linguagens fortemente tipificadas) são aquelas em que todas as variáveis tem um tipo específico e seus tipos são importantes para a linguagem. Java, C♯, Fortran e Cobol são exemplos deste tipo de linguagem. Normalmente as linguagens fortemente tipadas também são estaticamente tipadas, o que significa que uma vez que a variável foi declarada com um tipo ela será até o seu fim do mesmo tipo e também normalmente possuem declaração explicita de tipo onde o tipo da variável deve ser especificado logo na sua declaração. Uma vez que tais linguagens levam em consideração o tipo, operações entre tipos diferentes ocasionam erro:

int num1 = 10;
String num2 = "5";
int num3 = num1 * num2;
// erro

Pode haver exceções onde, em determinadas ocasiões e linguagens, a soma de uma variável do tipo texto (string) com uma variável numérica não ocasiona um erro, mas sim a concatenação dos valores — como no Java —, mas isso não significa que a linguagem é tolerante em alguns casos ou que é fracamente tipada, mas sim que aconteceu uma conversão implícita do tipo numérico para string, conversão esta que pode também ser feita explicitamente caso o programador deseje. As linguagens C e C++ também são fortemente tipadas, apesar da discussão em torno do tipo union. Muitos acreditam que o union permite que o programador atribua dados de diversos tipos a uma mesma variável, o que tornaria estas linguagens fracamente tipadas. O que acontece na realidade é que o union sozinho não é um tipo, e sim uma palavra chave para definição de um novo tipo estruturado, como struct. A partir do momento que uma variável é declarada com esse novo tipo, este não pode ser modificado. Além disso, quando o programador quiser atribuir um valor a uma variável, ele deve especificar qual é o tipo que ele está atribuindo através da seleção definida na própria declaração do tipo.

Linguagens fortemente tipadas e dinamicamente tipadas

Linguagens fortemente tipadas e dinamicamente tipadas (ver sistema de tipos) são aquelas linguagens em que o tipo das variáveis são importantes, porém, elas podem ser alteradas durante a execução do programa. Isso causa muita confusão fazendo com que muitos pensem que linguagens dinamicamente tipadas são a mesma coisa que linguagens fracamente tipadas. Acontece que a linguagem não permite que uma variável numérica realize uma operação com uma variável do tipo string, mesmo que o conteúdo do texto seja composto por números causando um erro, por exemplo:

var1 = 120
var2 = "10"
var3 = var1 * var2
# Erro

Isso acontece pois a linguagem é fortemente tipada, porém, a qualquer momento, o tipo pode ser alterado sem a necessidade de se criar uma nova variável:

var1 = 120
var2 = "10"
var2 = 10
var3 = var1 * var2
# resultado: 1200

Desta última forma o código funcionaria pois trata-se de uma operação com dois tipos iguais. Exemplo de linguagens fortemente tipadas e dinamicamente tipadas é o Ruby.

Linguagens fracamente tipadas

Linguagens fracamente tipadas são aquelas que não se importam com o tipo de dados contido em uma variável. Permitem que o programador não tenha de fazer conversões de tipos (cast). Neste caso o exemplo abaixo funcionaria sem erros mesmo sendo de tipos diferentes:

var1 = 120
var2 = "10"
var3 = var1 * var2
// resultado: 1200

Exemplos destas linguagens são PHP e Javascript.

Linguagens não tipadas, são aquelas em que existe apenas um tipo genérico ou mesmo nenhum tipo de dados. Entre estas estão a Linguagem de montagem ou Assembly, BCPL, Perl e algumas versões de Forth.