Seção 03: Fundamentos

[JayCesar]

📌Variáveis e Constantes

package fundamentos;

public class AreaCircunferencia {

    public static void main(String[] args) {

        double raio = 3.4; // Isso é uma variável
        final double PI = 3.14159; // Isso é uma CONSTANTE

        double area = raio * PI; // Outra variável
        // É uma convenção utilizar letras maiúsculas para nome de constantes
        System.out.println(PI * raio);

        raio = 10;
        area = PI * raio * raio;
        System.out.printf("Area = %.2f", area);

    }
}

Challenge

Transformar Fahrenheit em Celsius Obs: jshell é um comando que faz entrar no interpretador do Java

// (F - 32) x 5/9 = C
32 é uma constante
5 / 9 é uma constante

[JayCesar]

📌 Inferência de tipo

Surgiu a partir do Java 10

package fundamentos;

public class Inferencia {

    public static void main(String[] args){

        double a = 4.5;
        System.out.println();

        var b = 4.5;
        // Aqui a variável será do tipo do valor que eu colocar (isso é inferência e tem haver com o quê o Mulero disse)

        var c = "Texto"; // A variável c será do tipo String
        System.out.println(c);

        c = "Outro texto";
        System.out.println(c);
        // Mas eu não posso mudar o tipo da variável!

        // IMPORTANTE!
        double d;
        d = 123.65;
        // Eu não consigo fazer isso utilizando o 'var' pois eu preciso já inicializar ela! 
        // Porque só assim o Java consegue inferir o tipo dessa variável
    }
}

[JayCesar]

📌 Tipos primitivos

Existem 8 tipos primitivos em Java: 6 São numéricos e os outros 2 são booleanos

Inteiros

Byte Short Int Long

Decimais

Float e Double

Outros

Char e Boolean

Valor literal é o próprio número que eu coloco do lado da variável.

Cuidado com o Casting

---

No Código:

package fundamentos;

public class TiposPrimitivos {

    public static void main(String[] args) {
        // Informações do funcionário

        // TIPOS NUMÉRICOS INTEIROS
        byte anosDeEmpresa = 23;
        short numeroDeVoos = 542;
        int id = 56789;
        long pontosAcumulados = 3_234_845_223L; 
        /* Quando eu tenho um valor literal maior do que o range;
         * Eu preciso colocar a letra para dizer qual é o tipo;
         * Aqui eu coloquei 'L' pois em de 'Long';
         * O tipo padrão (default) do Java é inteiro;
        */

        // TIPOS NUMÉRICOS REAIS
        float salario = 11_445.44F;
        /* Quando coloco um literal, preciso colocar o 'F' 
         * (pois aqui o valor sem 'F' é um double)
         * O default de um tipo flutuante é double! (por isso o 'l');
        */
        double vendasAcumuladas = 1_234_798_103.01;

        // TIPO BOOLEANO
        boolean estaDeFerias = false; // true
        char status = 'A'; // ativo

        // Dias de Empresa
        System.out.println(anosDeEmpresa  * 365);

        // Número de viagens
        System.out.println(numeroDeVoos / 2);

        // Pontos por real
        System.out.println(pontosAcumulados / vendasAcumuladas);

        System.out.println(id + ": ganha -> " + salario);
        System.out.println("Férias? " + estaDeFerias);
        System.out.println("Status: " + status);    

    }

}

[JayCesar]

📌Notação Ponto

package fundamentos;

public class NotacaoPonto {

    public static void main(String[] args) {

        double a = 2.3;
        String s = "Bom dia X";
        System.out.println(s);

        s = s.toUpperCase();
        System.out.println(s);

        s = s.replace("X", "Senhora");
        System.out.println(s);

        s = s.concat("!!!!");
        System.out.println(s);

        String x = "Leo".toLowerCase();
        System.out.println(x);

        String y = "Bom dia X"
                .replace("X", "Gui")
                .toLowerCase()
                .concat("!!!!");
        System.out.println(y);
        // Eu posso quebrar as linhas nos ponto

        // TIPOS PRIMITIVOS NÃO TEM O OPERADOR "."      
    }
}

[JayCesar]

📌 Import (CTRL + SHIFT + O)

package fundamentos;

import java.util.Date;
import javax.swing.JButton;

public class Import {

    public static void main(String[] args) {

        String s = "Bom dia!";
        System.out.println(s);

        Date d = new Date();
        System.out.println(d);

        JButton botao = new JButton();

    } 
}

[JayCesar]

📌 Tipo String

package fundamentos;

// String é IMUTÁVEL. Eu só consigo SUBSTITUIR um valor, e não modificar o valor original!
public class TipoString {

    public static void main(String[] args) {

        System.out.println("Olá pessoal".charAt(0));

        String s = "Boa tarde";
        System.out.println(s.concat("!!!"));
        System.out.println(s.toLowerCase().startsWith("boa"));
        System.out.println(s.endsWith("tarde"));
        System.out.println(s.length());
        System.out.println(s.equalsIgnoreCase("boa tarde")); // Isso substitui o toLowerCase e o toUpperCase

        var nome = "Pedro";
        var sobrenome = "Santos";
        var idade = 33;
        var salario = 12344.987;

        System.out.printf("O senhor %s %s tem %d anos e ganha R$ %.2f", nome, 
                sobrenome, idade, salario);

        String frase = String.format("\nO senhor %s %s tem %d anos e ganha R$ %.2f", nome, 
                sobrenome, idade, salario);

        System.out.println(frase);

        System.out.println("Frase qualquer".contains("qual"));
        System.out.println("Frase qualquer".indexOf("qual"));
        System.out.println("Frase qualquer".substring(6));
        System.out.println("Frase qualquer".substring(6, 10));
    }

}

[JayCesar]

📌 Console (Buffer de entrada - Bug do nextLine)

package fundamentos;

import java.util.Scanner;

public class Console {

    public static void main(String[] args) {

        System.out.println("Bom");

        System.out.printf("Valores: %d %d %d%n", 1, 2, 3);
        System.out.print("a");
        System.out.printf("Nome: %s%n", "João");

        Scanner entrada = new Scanner(System.in);

        entrada.close();
    }

}

Passando para esclarecer uma particularidade dos métodos nextInt() e nextDouble(). Ambos os métodos têm a mesma particularidade, mas vou explicá-la através do nextInt() com o exemplo abaixo.

Scanner teclado = new Scanner(System.in);

    System.out.println("Qual a sua idade?");
    int idade = teclado.nextInt();
    System.out.println("Qual o seu nome?");
    String nome = teclado.nextLine();
    System.out.println("Qual o seu sobrenome?");
    String sobrenome = teclado.nextLine();

    teclado.close();

À primeira vista, parece que está tudo bem com este código. Mas quando o rodamos, o que é impresso no console (contendo os inputs) é o seguinte:

1 - Qual a sua idade? 25 2 - Qual o seu nome? Qual o seu sobrenome? Silva

Isso acontece por causa da maneira como o nextInt() faz a leitura dos valores.

Esse método faz a leitura de um único número, por exemplo, 58 ou 958. Mas quando digitamos os inputs, além do valor que deve ser lido, também apertamos enter, o que gera um caracter "\n" no buffer de entrada (fila de coisas que devem ser lidas), que é uma representação do enter.

Então, o que acontece é: "Qual a sua idade?" é impresso, digitamos o valor e apertamos enter. Quando fazemos isso, o buffer de entrada fica com o conteúdo "25\n", e quando o nextInt() faz a leitura, ele lê apenas o 25, deixando o "\n" para trás. Depois disso, "Qual o seu nome?" é impresso, e o método nextLine() vai ler tudo que estiver no buffer de entrada até encontrar um "\n". Como o nextInt() deixou um "\n" para trás, é esse o valor que o nextLine() lê. Isso conclui a leitura e a próxima linha de código, que é "Qual o seu sobrenome?", é impressa.

Para resolver esse problema, precisamos "pegar" o "\n" que o nextInt() não lê. Isso pode ser feito colocando um comando nextLine() depois do nextInt(), de modo que o código abaixo vai funcionar da maneira como queríamos.

Scanner teclado = new Scanner(System.in);

    System.out.println("Qual a sua idade?");
    int idade = teclado.nextInt();
    teclado.nextLine(); //lê o "\\\\n" que o teclado.nextInt() deixa para trás.
    System.out.println("Qual o seu nome?");
    String nome = teclado.nextLine();
    System.out.println("Qual o seu sobrenome?");
    String sobrenome = teclado.nextLine();

    teclado.close();

[JayCesar]

📌 Objeto vs Primitivo

package fundamentos;

public class PrimitivoVsObjeto {

    public static void main(String[] args) {

        // Wrappers (aquilo que envolve)
        // Wrapper são a versão objeto dos tipos primitivos
        // 8 tipos primitivos = 7 Wrappers
        int a = 123;
        System.out.println();

        Integer b = 123;
        System.out.println();
    }

}

[JayCesar]

📌 Wrappers

package fundamentos;

public class Wrapper {

    public static void main(String[] args) {

        Byte b = 100;
        Short s = 1000;
        Integer i = 10000;
        Integer convertedInteger = Integer.parseInt("1000");
        Long l = 100000L;

        System.out.println(b.byteValue());
        System.out.println(s.toString());
        System.out.println(convertedInteger);

        Float f = 123F;
        System.out.println(f);

        Double d = 124.2;
        System.out.println(d);

        Boolean bo = Boolean.parseBoolean("true");
        System.out.println(bo);
        System.out.println(bo.toString());

        Character c = '#';
        System.out.println(c + "...");

    }
}

---

[JayCesar]

📌 Conversão de tipos primitivos

Existem conversões que eu não consigo fazer

---

Quando há perdão de informação, o java pede que o programador seja explícito nessa conversão (Setas vermelhas).

---

package fundamentos;

public class ConversãoTiposPrimitivosNumericos {

    public static void main(String[] args) {

        double a = 1; // Conversão implícita
        float b = (float) 1.0; // Conversão explícita (isso é o CASTING)

        int c = 300;
        byte d = (byte) c; // Conversão explícita (isso é o CASTING)
        System.out.println(d);

        double e = 1.9999;
        int f = (int) e; // Conversão explícita (isso é o CASTING)
        System.out.println(f);

    }
}

[JayCesar]

📌 Conversão de números para (STRING)

package fundamentos;

public class ConjversaoNumeroString {

    public static void main(String[] args) {

        Integer num1 = 10000;
        System.out.println(num1.toString().length());

        // Eu também posso converter um tipo primitivo para string
        int num2 = 100000;
        System.out.println(Integer.toString(num2));

        System.out.println(("" + num2).length());

        /*
         * Integer.toString();
         * Double.toString();
         * Long.toString();
         * Boolean.toString();
        */
    }

}

[JayCesar]

📌 Conversão de STRING para Números

• Para isso basta eu utilizar os 'parse' da cada tpo de número (os Wrappers deles possuem esse parse - esse método);

  
  package fundamentos;

public class ConversaoDeStringParaNumero {

public static void main(String[] args) {
    String valor1 = "3.4";
    String valor2 = "3.4";

    double numero1 = Double.parseDouble(valor1);
    double numero2 = Double.parseDouble(valor2);

    double soma = numero1 + numero2;
    System.out.println("Soma = " + soma);
    System.out.println("Media = " + soma / 2);

}

}

[JayCesar]

📌 Operadores

O número de operadores tem haver com o número de operandos em um operador.

• É ternário porque tem três operandos,
• É binário porque tem dois operandos;
• É unário porque tem apenas um operando;

---

Aritméticos

Relacionais

Lógicos

Atribuição

---

Formas em que o operador por aparecer:

• Ele pode vir antes, depois ou no meio.

  ---

Ordem de precedência

Operadores+Java+-+Tabela+de+Precedência.pdf

---

Aritméticos

package fundamentos;

public class OperadoresAritmeticos {

    public static void main(String[] args) {
        System.out.println(2 + 3);
        var x = 34.56; // Lembrando que é inferência
        double y = 2.2;

        System.out.println(x + y);
        System.out.println(x - y);
        System.out.println(x * y);
        System.out.println(x / y);

        int a = 8;
        int b = 3;

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / (double) b); // Assim eu consigo pegar o valor 'quebrado'

        // Módutlo (%)
        System.out.println(a % b); // Pega o resto da divisão
    }
}

---

📌 Lógicos

package fundamentos.operadores;

public class OperadoresLogicos {
    public static void main(String[] args) {
        boolean condicao1 = true;
        boolean condicao2 = 3 > 7;

        System.out.println(condicao1 && !condicao2);
        System.out.println(condicao1 || condicao2);
        System.out.println(condicao1 ^ condicao2); // Ou exclusivo
        System.out.println(!condicao1);
        System.out.println(!condicao2);
    }

}

// O 'OU' EXCLUSIVO um deles precisa ser false e o outro true

📌Operadores Relacionais

Eles possuem uma relação com os operadores lógicos!

---

📌Operador Ternário

package fundamentos.operadores;

public class Ternario {

    public static void main(String[] args) {

        double media = 7.6;

        String resultadoParcial = media >= 5.0 ? "Aprovado" : "Recuperação";

        String resultadoFinal = media >= 7.0 ?
                    "Aprovado" : "Recuperação";

        System.out.println("O aluno está " + resultadoFinal);

    }
}

[JayCesar]

📌 Comparação de String

package fundamentos;

import java.util.Scanner;

public class TipoStringEquals {
    public static void main(String[] args) {
        System.out.println("2" == "2");

        String s1 = new String("2");
        System.out.println("2" == s1); // Não funciona

        // A forma correta é essa:
        System.out.println("2".equals(s1));

        Scanner entrada = new Scanner(System.in);

        // o next() retira os espaços em branco
        // o nextLine() mantem os espacos em branco
        String s2 = entrada.next().trim(); // trim() remove os espacos em brancos

        System.out.println("2".equals(s2));
        // A moral é sempre usar equals quando forma tratar comperação de igualdade de Stringss
    }

}

[JayCesar]

📌 JRE vs JDK

Java -> .class JRE = Java Runtime Environment JDK = Java Development Kit (aqui dentro tmb o JRE)

JVM

..java-> .class (ByteCode) É o ByteCode que será interpretado pelas JVM's

"Write once read many"

[JayCesar]

📌 Java vs Javac

Para compilar = javac nameOfFile.java Para executar = java nameOfFile