Praticando Java: variáveis e tipos

Variáveis e tipos - Apresentação

Boas-vindas! Meu nome é Jacqueline Oliveira, sou engenheira de software e instrutora na Alura, e irei te acompanhar ao longo dessa jornada de aprendizagem.

Audiodescrição: Jacqueline se descreve como uma mulher de pele branca, de olhos castanho-escuros, cabelos longos e lisos com reflexos loiros, e sobrancelhas castanho-claras. Ela veste uma blusa verde-escura e está sentada em frente a um microfone cinza, com uma parede clara ao fundo iluminada em gradiente azul. À esquerda da instrutora, móveis brancos contendo enfeites, livros, plantas, e um ponto de iluminação amarela.

O que vamos aprender?

Neste curso, iremos estudar e praticar sobre variáveis e tipos.

Para isso, abordaremos os seguintes tópicos:

• O que são variáveis;
• Como atribuir valores às variáveis de acordo com seu tipo;
• Padrão de nomenclatura;
• Tipos primitivos;
• Tipos referenciados;
• Conversão de tipos;
• E escopo de variáveis.

Conclusão

Todos esses conteúdos nos ajudarão a aprimorar nossos conhecimentos em variáveis e tipos, e a praticar ainda mais. Nos encontramos no próximo vídeo!

Variáveis e tipos - Variáveis e tipos

Neste vídeo, falaremos sobre variáveis e tipos.

Variáveis e tipos

O que são variáveis?

Para dar continuidade aos estudos sobre variáveis e tipos, é importante entender primeiro o que são variáveis. As variáveis são espaços na memória do computador usados para armazenar valores.

Esses valores podem ser alterados durante a execução do programa. Se fossem valores fixos, poderíamos colocá-los diretamente no código que escrevemos, compilamos e disponibilizamos.

No entanto, como são valores que podem mudar ao longo da utilização da aplicação, precisamos armazená-los em um lugar diferente. Por isso, usamos a memória do computador. Cada variável precisa ter um nome, um tipo de dado e um valor que será armazenado.

Conhecendo os tipos de variáveis

No Java, existem dois tipos de variáveis:

• As variáveis de tipos primitivos;
• E as variáveis de tipos referenciados.

Mostraremos um exemplo de cada tipo de variável trabalhando no IntelliJ IDEA.

Entendendo os tipos primitivos

Suponha que queremos criar uma aplicação que cuide da saúde, estabelecendo metas de passos, verificando se já atingimos a meta, além de registrar altura e peso. Trabalharemos com essas informações, e o primeiro passo será declarar a variável. Como definir o tipo e o nome de uma variável? Para entender os tipos primitivos, vamos analisar a tabela abaixo:

Todos os tipos citados na coluna "Tipo", como byte, short, int, long, float, double, char e boolean, são tipos primitivos. Quando alocamos um espaço na memória para uma variável de tipo primitivo, ela armazena o valor junto, diferente dos tipos referenciados que ainda conheceremos.

Declarando e inicializando variáveis

Precisamos analisar o tipo de dado desejado para determinar a forma mais apropriada de usá-lo na declaração da variável. Por exemplo: se quisermos guardar a meta diária de passos, podemos utilizar uma variável do tipo int. Com a IDE aberta, vamos acessar o arquivo Principal.java e digitar primeiro o tipo int, definindo depois o nome da variável, que será quantidadePassos.

Principal.java:

package br.com.alura;

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos
    }
}

Por que escrevemos quantidadePassos dessa forma?

Para nomes de variáveis, utilizamos um padrão chamado Camel Case. A primeira palavra é sempre iniciada com letra minúscula, e as palavras subsequentes têm a primeira letra maiúscula. O Camel Case é um padrão de nomenclatura de variáveis no Java.

Uma vez que definimos o tipo e o nome da variável, precisamos inicializá-la. Podemos começar a meta com 0 passos e, ao longo do programa, a pessoa usuária informar sua meta, ou podemos começar com uma meta padrão, de 500 passos. Nesse caso, utilizaremos a meta padrão:

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
    }
}

Assim, indicamos int como tipo de dado, quantidadePassos como nome da variável, e usamos o sinal = para atribuir o valor à variável. Por fim, o valor atribuído deve estar conforme a tabela, sem ultrapassar os limites. Se quisermos outros dados, como a altura em metros, por exemplo, podemos definir double alturaEmMetros recebendo 1.60. Com isso, teremos duas variáveis.

package br.com.alura;

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
    }
}

Cada tipo de variável assume valores específicos, como:

• boolean, que assume true ou false;
• int para números inteiros;
• float para números decimais;
• E double para números decimais de alta precisão.

É importante definir um tipo adequado ao que precisamos.

Entendendo os tipos referenciados

Agora que entendemos os tipos primitivos, o que são tipos referenciados?

O Java é uma linguagem fortemente tipada. Portanto, em vez de criar várias variáveis diferentes para tratar de situações de determinado paciente, podemos criar um tipo específico chamado Paciente, por exemplo. No arquivo Paciente.java, esse paciente é representado por uma classe Paciente, que possui vários atributos, como nome, peso, altura e sexo.

Paciente.java:

package br.com.alura;

public class Paciente {
    private String nome;
    private double peso;
    private double altura;
    private char sexo;

    public String getNome() {
        return nome;
    }
}

Para criar uma variável do tipo Paciente, o processo é diferente.

Se fôssemos criar um novo paciente no arquivo Principal.java, colocaríamos o tipo Paciente e o nome do paciente, como jose, que recebe new Paciente().

Observação: estamos falando sobre objetos e classes, temas que serão melhor explicados quando estudarmos programação orientada a objetos.

Principal.java:

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        Paciente jose = new Paciente();
    }
}

É importante definir que, diferente do tipo primitivo, quando criamos uma variável jose do tipo Paciente, a própria variável jose não guarda a informação do paciente; apenas o endereço de memória que contém as informações do José.

A variável quantidadePassos, por ser um tipo primitivo, guarda o valor junto na memória. Já no caso de jose, a variável guarda apenas o endereço que contém os dados do José.

Portanto, tipos referenciados têm essa característica:

São referências para uma posição na memória e não guardam exatamente o valor.

A variável String, por exemplo, é um tipo referenciado que utilizamos para texto. Podemos declarar String nome e atribuir "José", entre aspas duplas.

Embora seja um tipo referenciado, trabalhamos com ela sem nos preocupar com a posição na memória. Vamos abstrair isso por enquanto e trabalhar com ela no mesmo formato que usamos para tipos primitivos, declarando tipo, nome e valor.

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        String nome = "José";
    }
}

Conversão de tipos

No momento, temos três tipos de variáveis em Principal.java. Suponha que queremos uma variável para calcular a altura em metros e, em algum momento, transformar para centímetros, para manipular a informação de outra maneira.

Nesse caso, precisamos nos preocupar com a conversão de tipos. Não podemos atribuir um tipo a outro livremente; existem tipos de conversão que podemos fazer.

Abaixo, temos uma tabela de conversão de tipos, onde podemos definir uma conversão implícita ou explícita. Vamos observar na prática o que isso significa?

Como exemplo, vamos criar a variável int alturaEmCentimetros. Queremos que ela receba a alturaEmMetros multiplicada por 100, o que representa a altura em centímetros.

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        String nome = "José";

        int alturaEmCentimetros = alturaEmMetros * 100;
    }
}

Quando tentamos fazer isso, a IDE retorna um erro, indicando que precisamos de uma variável do tipo int, mas fornecemos o tipo double. Um double é maior do que um tipo int, então não podemos simplesmente atribuí-lo à variável sem fazer uma conversão.

Para realizar essa conversão, por ser um tipo maior, precisamos fazer uma conversão explícita.

Realizando uma conversão explícita

Em uma conversão explícita, utilizamos o typecasting, adicionando (int) antes de alturaEmMetros, indicando que deve ser assumido o valor inteiro dela, multiplicado por 100 ao final.

Assim, forçamos a transformação em inteiro.

Importante! Precisamos primeiro multiplicar e depois atribuir ao inteiro, respeitando a hierarquia e utilizando parênteses ((int) (alturaEmMetros * 100)).

Dessa forma, obtemos 160. A conversão explícita requer cuidado.

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        String nome = "José";

        int alturaEmCentimetros = (int) (alturaEmMetros * 100);
        System.out.println(alturaEmCentimetros);
    }
}

Observação: existem riscos ao fazer isso. Se não tivermos certeza sobre o dado, podemos receber uma informação errada. Por exemplo, se não multiplicarmos a variável por 100 e apenas coletarmos a parte inteira de alturaEmMetros, ao imprimir alturaEmCentimetros com System.out.println(), será exibido 1 em vez de 160.

Realizando uma conversão implícita

Podemos fazer o processo inverso? Sim, podemos atribuir uma variável int a uma double sem problemas. Por exemplo: vamos definir alturaEmCentimetros como 170 e, ao fazer o casting para alturaEmMetros, dividir por 100. Nesse caso, a conversão é implícita, pois a variável alturaEmCentimetros é do tipo int, enquanto alturaEmMetros é do tipo double.

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        String nome = "José";

        int alturaEmCentimetros = 170;
        alturaEmMetros = alturaEmCentimetros / 100;
        System.out.println(alturaEmMetros);
    }
}

Ao imprimir alturaEmMetros, é exibido 1.0, pois ao dividir 170 por 100, ainda lidamos com uma variável inteira, gerando um valor inteiro. Para corrigir, basta atribuir alturaEmCentimetros a alturaEmMetros, e dividir alturaEmMetros por 100 em System.out.println().

Dessa forma, receberemos como retorno 1.7.

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        String nome = "José";

        int alturaEmCentimetros = 170;
        alturaEmMetros = alturaEmCentimetros;
        System.out.println(alturaEmMetros / 100);
    }
}

Ao trabalhar com tipos e conversões, é necessário atenção para evitar erros. Precisamos verificar casos em que realmente precisamos converter. Por isso, criamos variáveis nos tipos adequados.

Escopo de variáveis

Outro tópico importante ao tratar de variáveis é o escopo.

No Java, podemos ter quatro tipos de escopo: escopo de classe, escopo de instância, escopo local e escopo de método. Apresentaremos apenas o escopo local.

Observação: os demais escopos serão abordados em outros cursos na plataforma da Alura, pois exigem um conhecimento mais aprofundado sobre classes e instâncias.

Para começar, vamos excluir do arquivo Principal.java as linhas em que declaramos alturaEmCentimetros, chamamos a variável alturaEmMetros, e imprimimos alturaEmMetros.

Trecho a ser removido do arquivo Principal.java:

int alturaEmCentimetros = 170;
alturaEmMetros = alturaEmCentimetros;
System.out.println(alturaEmMetros / 100);

Suponha que queremos fazer uma condição (if): se a quantidade de passos (quantidadePassos) for menor que (<) 1000, queremos sugerir algo. No escopo do bloco, criaremos uma variável do tipo String chamada sugestao, atribuindo o texto "Sugiro que você tente aumentar a meta!".

Por fim, vamos imprimir a variável sugestao.

Principal.java:

// código omitido

public class Principal {
    public static void main(String[] args) {
        int quantidadePassos = 500;
        double alturaEmMetros = 1.60;
        String nome = "José";

        if (quantidadePassos < 1000) {
            String sugestao = "Sugiro que você tente aumentar a meta!";
            System.out.println(sugestao);
        }
    }
}

Ao tentar usar sugestao fora do bloco if, ele não será reconhecido. Precisamos declarar a variável sugestao fora do bloco if se quisermos utilizá-la dentro e fora dele. O que é declarado no escopo de um bloco, só pode ser usado dentro dele. Portanto, os escopos são bem definidos.

No método main(), podemos usar quantidadePassos ou alturaEmMetros sem problemas, mas o inverso é falso. Podemos modificar valores, mas o que criamos no if não pode ser usado fora.

A questão de escopo é muito importante.

Conclusão

Contemplamos bastante sobre variáveis: o que são, tipos, como atribuir valores, padrão de nomenclatura, conversão implícita e explícita, e escopo de variáveis.

Agora, há bastante conteúdo e exercícios para você praticar.

Em caso de dúvidas, entre em contato conosco através do fórum ou pela comunidade no Discord. Ao final, deixe sua avaliação sobre o curso e nos ajude a criar conteúdos melhores.

Esperamos você em um próximo curso. Até mais!

Sobre o curso Praticando Java: variáveis e tipos

O curso Praticando Java: variáveis e tipos possui 20 minutos de vídeos, em um total de 16 atividades. Gostou? Conheça nossos outros cursos de Java em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Variáveis e tipos