Comentários em linguagens de programação são trechos de texto que não são executados pelo computador, mas desempenham um papel essencial na clareza e documentação do código. Eles são usados para explicar o propósito de partes do código, fornecer informações úteis aos programadores, facilitar a depuração de erros e, às vezes, desativar temporariamente seções do código. Comentários são uma prática fundamental para tornar o código mais compreensível, colaborativo e fácil de manter.
Permite comentar apenas uma linha
// ComentárioPermite comentar várias linhas
/*
Comentário
*/Comentários de documentação são usados para gerar documentação automática usando ferramentas como o Javadoc.
/**
Este é um comentário de documentação.
@param var_int -> variavel de número inteiro
*/Tipos referem-se às categorias de dados, como inteiros, strings ou booleanos, determinando como os valores são armazenados e manipulados.
Variáveis são contêineres que mantêm valores desses tipos, permitindo aos programadores armazenar informações e manipulá-las dinamicamente no código.
Atribuições são ações que associam um valor a uma variável, possibilitando o armazenamento de dados e a execução de cálculos, facilitando o controle e a manipulação das informações dentro de um programa.
Os tipos de dados em Java são inferidos estaticamente, o que significa que o tipo de uma variável deve ser declarado explicitamente no momento da criação da variável e é verificado em tempo de compilação. Alguns dos tipos mais comuns:
public class Java_02_00_00 {
public static void main(String[] args) {
//Armazena valores inteiros de 8 bits
byte var_byte = 5;
//Armazena valores inteiros de 16 bits
short var_short = 5;
//Armazena valores inteiros de 32 bits
int var_int = 5;
//Armazena valores inteiros de 64 bits
long var_long = 5;
//Armazena valores de ponto flutuante de precisão simples
float var_float = 1.5;
//Armazena valores de ponto flutuante de precisão dupla
double var_double = 10.55;
//Armazena valores verdadeiros ou falsos
boolean var_boolean = true;
//Armazena sequências de caracteres
String var_string = "nome";
//Armazena apenas 1 caractere
char var_char = "A";
//Armazena coleções de elementos do mesmo tipo
Array var_array = [0,1,2,3,4,5];
}
}A "tipagem forte" significa que a linguagem impõe regras rígidas para a conversão de tipos, garantindo que as operações sejam realizadas apenas entre tipos compatíveis, o que pode ajudar a prevenir erros de tipo durante a execução do programa.
public class Java_02_01_00 {
public static void main(String[] args) {
//Atribui-se o tipo inteiro "int" a variavel "var_int" e "var_result"
int var_int = 5;
int var_result;
//Atribui-se o tipo string "String" a variavel "var_string"
String var_string = "10";
//Busca-se somar um inteiro com uma string
var_result = var_int + var_string;
System.out.println(var_result);
}
}Erro de Tipos. Falha na Compilação. Isto pois não se permite realizar operações com tipos diferentes.
Já a "tipagem estática" obriga que se declare o tipo de uma variável no momento da criação, com esse tipo sendo verificado em tempo de compilação. Isso significa que o tipo da variável não pode mudar durante a execução do programa.
public class Java_02_01_01 {
public static void main(String[] args) {
//Atribui-se o tipo inteiro
int var_int = 5;
int var_result;
//Atribui-se o tipo string
String var_string = "10";
//Não é permitido alterar a variavel, ao mudar atribuição de String para Inteiro
var_string = 10;
//E não se pode realizar o calculo
var_result = var_int + var_string
System.out.println(var_result);
}
}Ocorrem dois Erros de tipos incompatíveis. Um ao tentar armazenar um inteiro numa variavel String e outro ao tentar somar inteiro com string.
public class Java_03_00_00 {
public static void main(String[] args) {
double var_double = 10.0; //para permitir casas depois da virgula
int var_int = 3;
//Soma com variaveis
System.out.println(var_int1 + var_int2);
//Soma direta
System.out.println(10 + 3);
}
}13.0
13.0
public class Java_03_01_00 {
public static void main(String[] args) {
//Soma
System.out.println(10.0 + 3);
//Subtração
System.out.println(10.0 - 3);
//Multiplicação
System.out.println(10.0 * 3);
//Divisão, obtendo o divisor da divisão
System.out.println(10.0 / 3);
//Módulo, obtendo o resto da divisão
System.out.println(10.0 % 3);
//Exponenciação
System.out.println(10.0 ** 3);
}
}13.0
7.0
30.0
3.3333333333333335
1.0
1000.0
public class Java_03_02_00 {
public static void main(String[] args) {
double var_double = 10.0;
//Soma
System.out.println(var_double += 3);
var_double = 10.0;
//Subtração
System.out.println(var_double -= 3);
var_double = 10.0;
//Multiplicação
System.out.println(var_double *= 3);
var_double = 10.0;
//Divisão, obtendo o divisor da divisão
System.out.println(var_double /= 3);
var_double = 10.0;
//Módulo, obtendo o resto da divisão
System.out.println(var_double %= 3);
}
}13.0
7.0
30.0
3.3333333333333335
1.0
1000.0
public class Java_03_03_00 {
public static void main(String[] args) {
//Igual a
System.out.println(10 == 3);
//Diferente de
System.out.println(10 != 3);
//Menor que
System.out.println(10 < 3);
//Maior que
System.out.println(10 > 3);
//Menor ou igual a
System.out.println(10 <= 3);
//Maior ou igual a
System.out.println(10 >= 3);
}
}false
true
false
true
false
true
public class Java_03_04_00 {
public static void main(String[] args) {
int var_int = 10;
// Adiciona 1
var_int++;
System.out.println(var_int);
var_int = 10;
// Reduz 1
var_int--;
System.out.println(var_int);
}
}11
9
public class Java_03_05_00 {
public static void main(String[] args) {
//e
System.out.println("true && true => " + (true && true));
System.out.println("true && false => " + (true && false));
System.out.println("false && true => " + (false && true));
System.out.println("false && false => " + (false && false));
//ou
System.out.println("true || true => " + (true || true));
System.out.println("true || false => " + (true || false));
System.out.println("false || true => " + (false || true));
System.out.println("false || false => " + (false || false));
//não
System.out.println("!true => " + (!true));
System.out.println("!false => " + (!false));
}
}true && true => true true && false => false false && true => false false && false => false true || true => true true || false => true false || true => true false || false => false !true => false !false => true
O operador ternário é uma maneira eficiente e concisa de lidar com expressões condicionais simples e pode ser útil para atribuir valores com base em uma única condição.
Estrutura:
condicao ? valor_se_verdadeiro : valor_se_falso
public class Java_03_06_00 {
public static void main(String[] args) {
int var_int = 18;
String var_string = (var_int >= 18) ? "Maior de idade" : "Menor de idade";
System.out.println(var_string);
}
}public class Java_03_07_00 {
public static void main(String[] args) {
// e (Bit a Bit)
System.out.println("10 & 3 => " + (10 & 3)); // 1010 (10) & 0011 (3) = 0010 (2)
// ou (Bit a Bit)
System.out.println("10 | 3 => " + (10 | 3)); // 1010 (10) | 0011 (3) = 1011 (11)
// não (Bit a Bit) - Positivo
System.out.println("~ 10 => " + (~ 10)); // 0 1010 (10) -> 1 0101 (-11)
System.out.println("~ 3 => " + (~ 3)); // 0 0011 (3) -> 1 1100 (-4)
// não (Bit a Bit) - Negativo
System.out.println("~ -10 => " + (~ -10)); // 1 0110 (-10) -> 0 1001 (9)
System.out.println("~ -3 => " + (~ -3)); // 1 1101 (-3) -> 0 0010 (2)
}
}10 & 3 => 2
10 | 3 => 11
~ 10 => -11
~ 3 => -4
~ -10 => 9
~ -3 => 2
Este operador é usado para operações de deslocamento de bits em números inteiros, a esquerda (<<), a direita apenas (>>) e a direita, junto com inserção de zeros equivalentes a esquerda (>>>).
public class Java_03_07_01 {
public static void main(String[] args) {
int var_int1 = 2; // Exemplo para <<
int var_int2 = -16; // Exemplo para >> e >>>
int var_result1, var_result2, var_result3; // Os tres resultados
// As operações
var_result1 = var_int1 << 3;
var_result2 = var_int2 >> 2;
var_result3 = var_int2 >>> 2;
// Para vermos o binário
String var_string_bin1 = Integer.toBinaryString(var_int1);
String var_string_bin2bin3 = Integer.toBinaryString(var_int2);
String var_result_bin1 = Integer.toBinaryString(var_result1);
String var_result_bin2 = Integer.toBinaryString(var_result2);
String var_result_bin3 = Integer.toBinaryString(var_result3);
// Printando na tela
System.out.println("2 << 3 => " + var_result1 + ", Binário: " + var_string_bin1 + " << 3 => " + var_result_bin1);
System.out.println("-16 >> 2 => " + var_result2 + ", Binário: " + var_string_bin2bin3 + " >> 2 => " + var_result_bin2);
System.out.println("-16 >>> 2 => " + var_result3 + ", Binário: " + var_string_bin2bin3 + " >>> 2 => " + var_result_bin3);
}
}2 << 3 => 16, Binário: 10 << 3 => 10000
-16 >> 2 => -4, Binário: 11111111111111111111111111110000 >> 2 => 11111111111111111111111111111100
-16 >>> 2 => 1073741820, Binário: 11111111111111111111111111110000 >>> 2 => 00111111111111111111111111111100
Por fim, como vimos diferentes precedencias nos exemplos acima, aqui ficará claro a ordem geral dos operadores que foram apresentados anteriormente:
//1 - Parenteses
//2 - Operadores unários (-, +, !, ~)
//3 - Operadores de exponenciação (**)
//4 - Operadores de multiplicação, divisão e módulo (*, /, %)
//5 - Operadores de adição e subtração (+, -)
//6 - Operadores de deslocamento (<<, >>)
//7 - Operadores de comparação (<, >, <=, >=, ==, !=, ===)
//8 - Operadores lógicos de alta precedencia (&&, ||, !)
//9 - Operadores lógicos de baixa precedencia (and, or, not)
//10 - Operadores de atribuição (=, +=, -=, *=, /=, %=, **=)
//11 - Operador de índice "[]" e acesso a propriedades "[] e {}"Conversão de valores refere-se à transformação de um tipo de dado em outro. Isso é útil para adequar dados a contextos específicos, realizar operações com tipos compatíveis e garantir que as informações sejam processadas corretamente.
Elas podem ser implícitas (Casting Implícito), explícitas (Casting Explícito):
public class Java_04_00_00 {
public static void main(String[] args) {
int var_int = 5;
double var_double1 = 3.0;
double var_result1 = var_int + var_double1; // Conversão implícita de int para double
double var_double2 = 3.1415;
int var_result2 = (int) var_double2; // Conversão explícita de double para int
System.out.println(var_result1 + ", " + var_result2);
Object var_object = "Turtle";
String var_string = (String) var_object
}
}8.0, 3
public class Java_04_01_00 {
public static void main(String[] args) {
byte var_byte = 5;
short var_short = 55;
long var_long = 150500;
float var_float = 1.5f;
double var_double = 842.248;
String var_string = "50";
char var_char = 'A';
boolean var_boolean = true;
int var_int;
var_int = var_byte;
System.out.println("byte " + var_byte + " para int: " + var_int);
var_int = var_short;
System.out.println("short " + var_short + " para int: " + var_int);
var_int = (int) var_long;
System.out.println("long " + var_long + " para int: " + var_int);
var_int = (int) var_float;
System.out.println("float " + var_float + " para int: " + var_int);
var_int = (int) var_double;
System.out.println("double " + var_double + " para int: " + var_int);
var_int = Integer.parseInt(var_string);
System.out.println("String " + var_string + " para int: " + var_int);
var_int = (int) var_char;
System.out.println("char " + var_char + " para int: " + var_int);
var_int = var_boolean ? 1 : 0;
System.out.println("boolean " + var_boolean + " para int: " + var_int);
}
}byte => 5 para int => 5 short => 55 para int => 55 long => 150500 para int => 150500 float => 1.5 para int => 1 double => 842.248 para int => 842 String => 50 para int => 50 char => A para int => 65 boolean => true para int => 1
public class Java_04_02_00 {
public static void main(String[] args) {
}
}3.14
#Passado um inteiro "1"
var_int = 1
#Usando metodo to_s para converter inteiro em string
var_result = 10 - var_int
#A soma é agora entre strings, alterando a função para juntar em vez de somar
puts var_result.to_s + " restantes"9 restantes
#Converte o objeto var_range em um array
var_range = 1..5
p var_array1 = var_range.to_a
#Converte o hash var_hash em um array
var_hash = {"nome" => "Jabuti", "idade" => 50}
p var_array2 = var_hash.to_a
#Converte cada algorismo do inteiro var_int em um array
var_int = 124816
p var_array3 = var_int.to_s.chars.map(&:to_i)[1, 2, 3, 4, 5]
[["nome", "Jabuti"], ["idade", 50]]
[1, 2, 4, 8, 1, 6]
var_string = "Jabuti"
var_int = 50
puts "Um " + var_string
puts "Um " + var_string + " pode viver mais do que " + var_int + " anos!"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
var_string = "Jabuti"
var_int = 50
puts "Um #{var_string}"
puts "Um #{var_string} pode viver mais do que #{var_int} anos!"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
var_string = "Jabuti"
var_int = 50
puts "Um #{var_string}"
puts "Um #{var_string} pode viver mais do que #{var_int} anos!"
puts "Já alguns poucos #{var_string}s pode viver mais do que #{var_int + 70} anos!"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
Já alguns poucos Jabutis podem viver mais do que 120 anos!
var_array = ["Jabuti", "Cágado", "Tartaruga"]
puts "Um #{var_array}"
puts "Nomes: #{var_array.map{ |nome| nome.upcase }.join(", ")}"Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
Já alguns poucos Jabutis podem viver mais do que 120 anos!
var_string = "Jabuti"
var_int = 50
printf("Um %s", var_string)
printf("Um %s pode viver mais do que %d anos!", var_string, var_int)Um JabutiUm Jabuti pode viver mais do que 50 anos!
var_string = "Jabuti"
var_int = 50
puts "Um %s" % [var_string]
puts "Um %s pode viver mais do que %d anos!" % [var_string, var_int]Um Jabuti
Um Jabuti pode viver mais do que 50 anos!
Funções são blocos de código reutilizáveis que realizam uma tarefa específica. As funções são usadas para modularizar o código, tornando-o mais organizado, legível e fácil de manter, uma vez que permitem que partes do programa sejam isoladas e reutilizadas em diferentes partes do código, promovendo a eficiência e a reutilização de lógica.
Existem vários tipos de funções, onde neste primeiro momento, é apresentado de forma sucinta 3 das formas mais básicas, utilizando de 5 formas diferentes de expressar as mesmas.
#Usando métodos
def salutation(func_var_string)
puts "Olá, #{func_var_string}!"
end
salutation("Mundo")
#Usando procs
salutation = Proc.new do |func_var_string| puts "Olá, #{func_var_string}!" end
salutation.call("Mundo")
#Usando procs (simplificado)
salutation = Proc.new {|func_var_string| puts "Olá, #{func_var_string}!"}
salutation.call("Mundo")
#Usando lambdas
salutation = lambda {|func_var_string| puts "Olá, #{func_var_string}!"}
salutation.call("Mundo")
#Usando funções anônimas (lambda simplificado)
salutation = -> (func_var_string) {puts "Olá, #{func_var_string}!"}
salutation.call("Mundo")Olá, Mundo!
#Usando métodos
def salutation(func_var_string1, func_var_string2)
return func_var_string1 + func_var_string2
end
puts salutation("Olá, ", "Mundo!")
#Usando procs
salutation = Proc.new do |func_var_string1, func_var_string2| func_var_string1 + func_var_string2 end
puts salutation.call("Olá, ", "Mundo!")
#Usando procs (simplificado)
salutation = Proc.new {|func_var_string1, func_var_string2| func_var_string1 + func_var_string2}
puts salutation.call("Olá, ", "Mundo!")
#Usando lambdas
salutation = lambda {|func_var_string1, func_var_string2| func_var_string1 + func_var_string2}
puts salutation.call("Olá, ", "Mundo!")
#Usando funções anônimas (lambda simplificado)
salutation = -> (func_var_string1, func_var_string2) {func_var_string1 + func_var_string2}
puts salutation.call("Olá, ", "Mundo!")Olá, Mundo!
#Usando métodos
def salutation(func_var_string = "Mundo")
puts "Olá, #{func_var_string}!"
end
salutation
salutation("Amigo")
#Usando procs
salutation = Proc.new do |func_var_string = "Mundo"| "Olá, #{func_var_string}!" end
puts salutation.call
puts salutation.call("Amigo")
#Usando procs (simplificado)
salutation = Proc.new {|func_var_string = "Mundo"| "Olá, #{func_var_string}!"}
puts salutation.call
puts salutation.call("Amigo")
#Usando lambdas
salutation = lambda {|func_var_string = "Mundo"| "Olá, #{func_var_string}!"}
puts salutation.call
puts salutation.call("Amigo")
#Usando funções anônimas (lambda simplificado)
salutation = -> (func_var_string = "Mundo") {"Olá, #{func_var_string}!"}
puts salutation.call
puts salutation.call("Amigo")Olá, Mundo!
Olá, Amigo!