Please enable JavaScript.

Coggle requires JavaScript to display documents.

Lógica de programação (Java), Tamanho, Valores, Valor Padrão - Coggle…

- - - - 1º lugar: *, / e %
      - 2º lugar: -, +
      - Quando a precedência é a mesma, resolve-se a expressão da esquerda para direita.
      - Expressões entre parênteses são as primeiras a serem resolvidas (ordem: parênteses mais internos para mais externos)
- - - - Teclado
    - - Para fazer entrada de dados, cria-se um objeto do tipo "Scanner"
        
        Scanner sc = new Scanner(System.in);
        
        sc.close();
        
        Desaloca o objeto quando não deseja-se usá-lo
        
        import java.util.Scanner
        
        Importar a classe Scanner (ctrl+shift+o)
      - Para ler uma palavra (variável do tipo String)
        
        x = sc.next();
        
        Lê apenas uma palavra
      - Para ler um número inteiro
        
        x = sc.nextInt();
      - Para ler um número com ponto flutuante
        
        x = sc.nextDouble();
        
        Localidade do sistema (se o separador decimal do sistema for uma vírgula, deve-se digitar o número com vírgula)
        
        Para mudar o separador para "." utilizar o comando Locale.setDefault(Locale.US);
      - Para ler um caractere
        
        x = sc.next().charAt(0);
      - Para ler vários dados na mesma linha
        
        (digitar os dados separados por espaço)
      - Para ler um texto até uma quebra de linha (até digitar "Enter")
        
        s1 = sc.nextLine();
      - ATENÇÃO: quebra de linha pendente
        
        Quando você usa um comando de leitura diferente do nextLine() e dá alguma quebra de linha, essa quebra de linha fica "pendente" na entrada padrão. Se você usar um nextLine(), aquela quebra de linha pendente será absorvida pelo nextLine()
        
        Solução: faça um nextLine() extra antes de fazer o nextLine() de seu interesse.
  - - - Comando de atribuição (sintaxe)
        
        <variável> = <expressão>;
        
        Lê-se: "a variável recebe o resultado da expressão"
        
        Boa prática
        
        Sempre indique o tipo do número, se a expressão for de ponto flutuante (não inteira)
        
        Para double use: .0
        
        Para float use: f
      - Casting
        
        Avisa ao compilador o tipo da expressão
        
        result = (double) a / b;
        
        Nessa situação, a e b são do tipo int; caso o casting não fosse usado, o compilador truncaria o resultado da divisão
  - - - Monitor
    - - Para escreve um texto na tela
        
        System.out.println("Bom dia!");
        
        Com quebra de linha
        
        System.out.print("Bom dia!");
        
        Sem quebra de linha
      - Para escrever o conteúdo de uma variável de algum tipo básico
        
        System.out.println(y);
      - Escrever o conteúdo de uma variável com ponto flutuante
        
        Sem controle de casas decimais
        
        System.out.println(x);
        
        Com formatação (controle de casas decimais)
        
        System.out.printf("%.2f%n", x);
        
        Imprime com 2 casas decimais
        
        O printf por padrão pega o formato sendo usado (separador decimal)
        
        Locale.setDefault(Locale.US);
        
        Define separador decimal como "ponto"
      - Para concatenar vários elementos em um mesmo comando de escrita usa-se o "+"
        
        Usando print e println
        
        System.out.println("RESULTADO = " + x + " METROS");
        
        Usando o printf
        
        System.out.printf("RESULTADO = %.2f metros%n", x);
        
        Marcadores para inserção dos valores das variáveis
        
        %f = ponto flutuante
        
        %n = quebra de linha
        
        %d = números inteiros
        
        %b = valores booleanos
        
        %c = valores char
        
        %2f = double
        
        %s = texto
- - - - Não pode começar com dígito: usar letra ou _
        
        int _5minutes;
        
        int _5minutes;
      - Não pode ter espaço em branco
        
        int salarioDoFuncionario;
        
        int salario do funcionario;
      - Não usar acentos ou til
        
        int salario;
        
        int salário;
      - Sugestão: usar o padrão "camel case" (iniciar com letra minúscula)
      - Use nomes que tenham um significado
- - - - 16 bits
        
        -32768 a 32767
        
        0
    - - 32 bits
        
        -2147483648 a 2147483647
        
        0
    - - 8 bits
        
        -128 a 127
        
        0
    - - 64 bits
        
        -9223372036854770000 a
        9223372036854770000
        
        0L
  - - - 32 bits
        
        -1,4024E-37 a 3,4028E+38
        
        0.0f
    - - 64 bits
        
        -4,94E-307 a 1,79E+308
        
        0.0
  - - - 16 bits
        
        '\u0000' a '\uFFFF'
        
        '\u0000'
  - - - 1 bit
        
        [false, true}
        
        false
- - - - Substituir um caractere por outro informado
        
        original.replace(char, char)
      - Substituir uma substring por outra
        
        original.replace(string, string)
    - - Última ocorrência
        
        original.lastIndexOf("bc");
      - Primeira ocorrência
        
        original.indexOf("bc");
    - - Montar uma nova String a partir da posição informada de outra String
        
        original.substring(início)
      - Montar uma String a partir de um intervalo de posições de outra String
        
        original.substring(inicio, fim)
    - - Exemplo
        
        String s = "potato apple lemon";
        
        String[] vect = s.split(" ");
        
        Cada posição armazena o nome de uma fruta
    - - Converter para letras minúsculas
        
        original.toLowerCase()
      - Converter para letras maiúsculas
        
        original.toUpperCase()
      - Eliminar os espaços nas extremidades da String
        
        original.trim()
    - - Considerando a string: String original = "abcde FGHIJ ABC abc DEFG "
- - - - maior (>)
      - menor (<)
      - maior ou igual (>=)
      - menor ou igual (<=)
      - igual (==)
      - diferente (!=)
  - - - E (&&)
        
        Todas as condições da expressão devem ser verdadeiras para o resultado da expressão ser verdadeiro
        
        Se X = 5
        
        X <= 20 && X == 10 -> resultado: Falso
      - OU (||)
        
        Pelo menos uma das condições da expressão deve ser verdadeira para que o resultado seja verdadeiro
        
        Se X = 5
        
        X == 10 || X <= 20 -> Resultado: Verdadeiro
      - NÃO (!)
        
        O operador NÃO inverte a condição.
        
        Suponto X=5
        
        !(X == 10) -> Resultado é Verdadeiro
  - - - Estrutura de controle que permite definir que um certo bloco de comandos somente será executado dependendo de uma condição
      - Controle para direciona o fluxo do programa (se a condição for verdadeira, executa-se um bloco de comandos; caso contrário executa-se outro.
    - - Simples
        
        if ( <condição> ) {<comando 1><comando 2>
        }
        
        Regra:
        V: executa o bloco de comandos
        F: pula o bloco de comandos
        
        Repare na endentação
      - Composta
        
        if ( <condição> ) {
        <comando 1>
        <comando 2>
        else {
        <comando 3>
        <comando 4>
        }
        
        Regra:
        V: executa somente o bloco do if
        F: executa somente o bloco do else
      - Encadeamaneto de estruturas condicionais
        
        Esse formato é usado para evitar o crescimento da endentação, tornando o código mais organizado
      - Observação: As chaves são opcionais quando existe apenas uma linha de comando dentro do if ou else.
  - - - default - caso padrão executado quando todas as opções são falsas
  - - - ( condição ) ? valor_se_verdadeiro : valor_se_falso
    - - ( 2 > 4 ) ? 50 : 80
        
        Resultado: 80
      - ( 10 != 3 ) ? "Maria" : "Alex"
        
        Resultado: "Maria"
      - double preco = 34.5;
        double desconto = (preco < 20.0) ? (preco 0.1) : (preco 0.05);
  - - - É a região do programa onde a variável é válida, ou seja, onde ela pode ser referenciada.
      - Toda estrutura de um programa (if-else, switch-case, for, while) possui seu próprio escopo, e as variáveis declaradas dentro do seu escopo só existirão dentro do escopo.
    - - Se não for iniciada o compilador acusa um erro de compilação
      - Se uma variável for declarada em um escopo mais externo e é iniciada em uma estrutura if dentro desse escopo, caso tente imprimi-la, o compilador indicará que a variável não foi iniciada
        
        Pode-se utilizar um else para evitar esse problema
  - - - a = a + b;
    - - a = a - b;
    - - a = a * b;
    - - a = a / b;
    - - a = a % b;
- - - - for (início; condição; incremento) {
        comando 1
        comando 2
        }
        
        Condição
        V: executa e volta
        F: pula fora
        
        incremento: executa toda vez depois de voltar
        
        início: executa somente na primeira vez
  - - - 2) Para iniciar o debug:
        
        Botão direito na classe -> Debug as -> Java Application
        
        3) Para executar uma linha:
        
        F6
        
        4) Para interromper o debug:
        
        O Eclipse destaca a próxima linha a ser executada
        
        Pode-se mudar a perspectiva para a de debug que permite visualizar os valores das variáveis
- - - - Operação "E" bit a bit
    - - Operação "OU" bit a bit
    - - Operação "OU-exclusivo" bit a bit
- - - - Parâmetros e variáveis declaradas dentro do bloco do método são locais, e existem apenas durante a execução do método
  - - - Calcula a raiz quadrada de um valor
    - - função responsável por mostrar algo no console (saída de dados)
    - - É a primeira função a ser executada ao rodar o programa
      - Se a classe é um programa executável, ela deve ter o método main
  - - - Divide-se o programa em várias partes/módulos
    - - Delega-se a lógica de calcular/executar algo para outro lugar - programa mais enxuto
    - - Pode-se reaproveitá-la diversas vezes