Mobile App Development · Dart/Flutter
Sete exercícios, um grupo de operadores por vez: aritméticos, atribuição composta, relacionais, lógicos, igualdade de Strings, precedência e um resumo combinando todos.
Exercício
Demonstra os cinco operadores aritméticos básicos: +, -, *, / (sempre retorna double) e % (resto da divisão).
// Exercício: demonstrar os cinco operadores aritméticos básicos do Dart.
// +, -, *, / retornam números; % (módulo) retorna o resto da divisão inteira.
void main() {
// Operandos usados em todas as operações abaixo.
final int a = 10;
final int b = 5;
print('Soma: ${a + b}'); // 15
print('Subtracao: ${a - b}'); // 5
print('Multiplicacao: ${a * b}'); // 50
print('Divisao: ${a / b}'); // 2.0 (retorna double)
// Módulo: resto de 10 ÷ 5 = 0
print('Resto: ${a % b}');
}Saída esperada
Soma: 15 Subtracao: 5 Multiplicacao: 50 Divisao: 2.0 Resto: 0
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/01_Operadores_Aritmeticos.dart
Exercício
Demonstra os operadores de atribuição compostos +=, -=, *= e ~/= (divisão inteira composta), cada um combinando uma operação aritmética com a atribuição.
// Exercício: demonstrar os operadores de atribuição compostos do Dart.
// Cada operador combina uma operação aritmética com a atribuição: x += 3 é x = x + 3.
void main() {
// Valor inicial que será modificado pelos operadores de atribuição compostos.
int x = 10;
x += 3; // x = x + 3 = 13
print('x += 3 -> $x');
x -= 2; // x = x - 2 = 11
print('x -= 2 -> $x');
x *= 4; // x = x * 4 = 44
print('x *= 4 -> $x');
// ~/ é divisão inteira (truncada); ~/= combina divisão inteira com atribuição.
x ~/= 3; // x = x ~/ 3 = 14
print('x ~/= 3 -> $x');
}Saída esperada
x += 3 -> 13 x -= 2 -> 11 x *= 4 -> 44 x ~/= 3 -> 14
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/02_Operadores_Atribuicao.dart
Exercício
Demonstra os operadores relacionais ==, !=, > e <, todos retornando bool, usados para comparar dois valores int.
// Exercício: demonstrar os operadores relacionais (de comparação) do Dart.
// Todos retornam bool (true ou false), usados principalmente em condições.
void main() {
// Dois valores para comparar entre si.
final int valor1 = 5;
final int valor2 = 8;
// == verifica igualdade; != verifica diferença.
print('valor1 == valor2: ${valor1 == valor2}'); // false
print('valor1 != valor2: ${valor1 != valor2}'); // true
// > e < comparam a magnitude dos valores.
print('valor1 > valor2: ${valor1 > valor2}'); // false
print('valor1 < valor2: ${valor1 < valor2}'); // true
}Saída esperada
valor1 == valor2: false valor1 != valor2: true valor1 > valor2: false valor1 < valor2: true
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/03_Operadores_Igualdade.dart
Exercício
Demonstra os operadores lógicos &&, || e !. Atenção: a segunda linha impressa tem um rótulo "(OR)" mas o código atual apenas imprime maiorDeIdade isoladamente, sem de fato usar o operador || — o comentário e a saída real não combinam entre si. O código abaixo é exatamente o que está no arquivo-fonte.
// Exercício: demonstrar os operadores lógicos &&, || e ! do Dart.
// && exige que ambas as condições sejam true; || exige ao menos uma; ! inverte.
void main() {
// Dois bools usados para combinar com os operadores lógicos.
bool maiorDeIdade = true;
bool possuiCarteira = false;
// &&: ambas precisam ser true para o resultado ser true.
print('Pode dirigir (AND): ${maiorDeIdade && possuiCarteira}'); // false
// ||: basta uma ser true para o resultado ser true.
print('Pode entrar (OR): ${maiorDeIdade}'); // true
// !: inverte o valor booleano (false vira true).
print('Negacao de possuiCarteira: ${!possuiCarteira}'); // true
}Saída esperada
Pode dirigir (AND): false Pode entrar (OR): true Negacao de possuiCarteira: true
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/04_Operadores_Logicos.dart
Exercício
Compara Strings com == e != e combina duas comparações com &&. Em Dart, == em Strings compara o conteúdo, não a referência.
// Exercício: comparar Strings e combinar condições com operadores lógicos.
// Em Dart, == compara o conteúdo de Strings (não a referência).
void main() {
// Duas Strings usadas nas comparações abaixo.
final String cor = 'vermelho';
final String tamanho = 'grande';
// == verifica se o conteúdo das Strings é idêntico.
print('Cor eh vermelho? ${cor == "vermelho"}'); // true
print('Tamanho diferente de pequeno? ${tamanho != "pequeno"}'); // true
// Combina dois == com && para checar ambas as condições simultaneamente.
print('Combinacao: ${cor == "vermelho" && tamanho == "grande"}'); // true
}Saída esperada
Cor eh vermelho? true Tamanho diferente de pequeno? true Combinacao: true
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/05_Operadores_Igualdade.dart
Exercício
Compara o resultado da mesma expressão com e sem parênteses, mostrando que * e / têm precedência maior que + e -.
// Exercício: comparar o resultado de expressões com e sem parênteses.
// A precedência define a ordem em que os operadores são avaliados:
// * e / têm precedência maior que + e -; parênteses forçam a ordem desejada.
void main() {
// Sem parênteses: * é avaliado antes de +, resultando em 10 + 10 = 20.
final int semParenteses = 10 + 5 * 2;
// Com parênteses: + é forçado antes de *, resultando em 15 * 2 = 30.
final int comParenteses = (10 + 5) * 2;
print('10 + 5 * 2 = $semParenteses'); // 20
print('(10 + 5) * 2 = $comParenteses'); // 30
}Saída esperada
10 + 5 * 2 = 20 (10 + 5) * 2 = 30
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/06_Operadores_Precedencias.dart
Exercício
Resume os quatro grupos de operadores em um único programa: aritméticos, relacionais, lógicos e o operador ternário.
// Exercício: demonstrar os quatro grupos de operadores do Dart em um único programa.
// Aritméticos (+,-,*,/), relacionais (>,==), lógicos (&&) e ternário (?:).
void main() {
final int a = 5;
final int b = 2;
// Exibe resultados de operações aritméticas e de comparação na mesma linha.
print('Aritmeticos: + ${a + b}, - ${a - b}, * ${a * b}, / ${a / b}');
print('Comparacao: a > b = ${a > b}, a == b = ${a == b}');
print('Logicos: true && false = ${true && false}');
// Operador ternário: condição ? valor_se_true : valor_se_false.
final String status = a >= 5 ? 'Aprovado' : 'Reprovado';
print('Ternario: $status');
}Saída esperada
Aritmeticos: + 7, - 3, * 10, / 2.5 Comparacao: a > b = true, a == b = false Logicos: true && false = false Ternario: Aprovado
Como executar
dart run 05-Operadores/02_Exercicios/codigo_fonte/operadores.dart