Return to Video

LTP CAP02 VA02 TIPOS DADOS VARIAVEIS PT01

  • 0:05 - 0:09
    Ao trabalhar com programação
    em qualquer linguagem de programação,
  • 0:09 - 0:13
    um dos itens mais importantes
    é o armazenamento de variáveis.
  • 0:13 - 0:15
    O que é o armazenamento
    de variáveis?
  • 0:15 - 0:17
    Por exemplo, eu tenho um sistema
    que eu tenho que armazenar
  • 0:17 - 0:19
    as informações
    de idade.
  • 0:19 - 0:22
    Então, eu tenho que armazenar
    a idade de uma pessoa
  • 0:22 - 0:24
    dentro do meu programa
    para poder utilizar
  • 0:24 - 0:26
    para uma tela
    ou para um banco de dados.
  • 0:26 - 0:30
    O Java é uma linguagem
    de programação tipada.
  • 0:30 - 0:31
    O que significa isso?
  • 0:31 - 0:35
    Para eu poder criar essas
    variáveis de armazenamento
  • 0:35 - 0:38
    eu preciso dizer qual é
    o tipo de informação
  • 0:38 - 0:41
    que estará
    naquela variável.
  • 0:41 - 0:43
    Idade, por exemplo,
    é um número.
  • 0:43 - 0:46
    Então, eu preciso informar
    que aquela variável idade
  • 0:46 - 0:48
    vai armazenar
    um número, ok?
  • 0:48 - 0:51
    Então, a linguagem
    de programação Java é tipada.
  • 0:51 - 0:52
    Então, eu preciso
    informar isso
  • 0:52 - 0:55
    porque existem várias linguagens
    de programação que não são tipadas,
  • 0:55 - 0:58
    que isso é resolvido
    em tempo de execução.
  • 0:58 - 1:01
    Para a criação de um nome
    de uma variável,
  • 1:01 - 1:02
    existem algumas
    regrinhas.
  • 1:02 - 1:05
    A regra principal, é claro,
    é que tenha significado.
  • 1:05 - 1:09
    Então, se eu vou armazenar
    uma informação de idade,
  • 1:09 - 1:13
    o nome dessa variável tem
    que ser idade ou algo parecido.
  • 1:13 - 1:16
    Mas existem outras regras
    relacionadas ao Java.
  • 1:16 - 1:20
    Então, eu não posso começar uma variável,
    por exemplo, com um número.
  • 1:20 - 1:25
    Eu não posso trabalhar uma variável
    começando com um caractere especial, ok?
  • 1:25 - 1:27
    Então, eu preciso
    começar com letras.
  • 1:27 - 1:31
    Podem ser maiúsculas ou minúsculas,
    de preferência minúsculas, que é um padrão.
  • 1:31 - 1:34
    Mais à frente vocês
    vão entender o porquê.
  • 1:34 - 1:39
    Ou eu posso, no máximo, começar
    com underline ou com cifrão.
  • 1:39 - 1:42
    No mais, eu não posso
    trabalhar com isso.
  • 1:42 - 1:45
    Vou exemplificar aqui para vocês
    entenderem um pouquinho mais.
  • 1:45 - 1:49
    Estou lá no nosso programa HelloJava
    e vou criar uma variável
  • 1:49 - 1:52
    que vai ser do tipo
    inteiro,
  • 1:52 - 1:55
    e o nome dela
    vai ser "preço".
  • 1:55 - 2:00
    Então, eu posso fazer isso,
    criei uma variável chamada preço,
  • 2:00 - 2:02
    tanto que ela nem
    me deu erro aqui.
  • 2:02 - 2:05
    Só que agora eu quero
    colocar um número
  • 2:05 - 2:07
    para começar o nome
    daquela variável.
  • 2:07 - 2:10
    Vocês vão ver que dá erro
    de compilação, não é permitido.
  • 2:10 - 2:15
    Quero colocar um caractere especial,
    como por exemplo, um asterisco.
  • 2:15 - 2:19
    Também não pode porque é
    uma palavra, ou um símbolo, reservado.
  • 2:19 - 2:21
    Vocês vão entender
    um pouquinho mais à frente.
  • 2:21 - 2:24
    Eu posso colocar
    tanto o underline
  • 2:24 - 2:27
    ou eu também
    posso colocar o cifrão
  • 2:27 - 2:29
    para poder iniciar
    aquela variável.
  • 2:29 - 2:31
    Então, estas são
    regras básicas.
  • 2:31 - 2:33
    "Ah, professor, mas depois
    eu posso colocar numeração
  • 2:33 - 2:35
    no meio do nome daquela
    variável e tudo mais?".
  • 2:35 - 2:37
    Aí eu posso. Então, se eu
    quiser pegar, por exemplo,
  • 2:37 - 2:39
    a variável preço
    que eu criei aqui
  • 2:39 - 2:43
    e colocar um 34 no meio,
    eu posso, não tem problema.
  • 2:43 - 2:45
    Mas não se esqueçam
    da regra principal,
  • 2:45 - 2:49
    o nome da variável tem que fazer
    sentido para a informação
  • 2:49 - 2:51
    que, de fato,
    ela vai armazenar.
  • 2:51 - 2:54
    Outro detalhe bem importante
    na criação de variáveis
  • 2:54 - 2:57
    é que o Java é
    "case-sensitive".
  • 2:57 - 2:58
    O que significa isso?
  • 2:58 - 3:03
    Que ele tem sensibilidade entre letras
    minúsculas e letras maiúsculas.
  • 3:03 - 3:05
    Então, se eu criar uma variável
    com uma letra maiúscula,
  • 3:05 - 3:08
    eu tenho que usar
    com letra maiúscula
  • 3:08 - 3:11
    em todos os lugares
    que eu for referenciar.
  • 3:11 - 3:13
    Se eu criar uma classe
    com letra maiúscula,
  • 3:13 - 3:16
    eu também tenho que referenciar
    da mesma maneira, ok?
  • 3:16 - 3:19
    Outro item muito importante
    é que o nome de uma variável,
  • 3:19 - 3:22
    e até o nome de uma classe
    ou o nome de um método,
  • 3:22 - 3:26
    não pode ser o nome
    de uma palavra reservada.
  • 3:26 - 3:28
    O que é uma palavra
    reservada?
  • 3:28 - 3:31
    São palavras que já existem
    dentro da linguagem de programação
  • 3:31 - 3:34
    que já têm algum fim,
    já têm algum destino.
  • 3:34 - 3:37
    É como se já fosse um comando
    que já existisse, ok?
  • 3:37 - 3:39
    Vou exemplificar
    um pouquinho aqui.
  • 3:39 - 3:43
    Existe uma tabela de referência
    das palavras reservadas
  • 3:43 - 3:45
    que não podem
    ser utilizadas.
  • 3:45 - 3:48
    Vou exemplificar aqui
    um erro que acontece.
  • 3:48 - 3:51
    Supondo que eu queira criar
    uma variável chamada "private".
  • 3:51 - 3:54
    Então, se eu colocar aqui
    "int private",
  • 3:54 - 3:56
    vai aparecer um erro
    de compilação.
  • 3:56 - 3:57
    Se eu passar o mouse,
    ele vai falar:
  • 3:57 - 4:00
    "Olha, essa variável
    não pode existir",
  • 4:00 - 4:04
    porque ela já é
    uma palavra reservada, ok?
  • 4:04 - 4:07
    Então, todas as palavras reservadas
    dessa tabela de referência
  • 4:07 - 4:11
    não podem ser utilizadas
    nem para a criação de outras variáveis
  • 4:11 - 4:14
    e também nem para criação
    de classes ou métodos.
  • 4:14 - 4:16
    Vamos falar um pouquinho
    agora da tipagem.
  • 4:16 - 4:19
    Dentro do Java existem
    quatro categorias de tipagens
  • 4:19 - 4:22
    para tipos
    primitivos de dados.
  • 4:22 - 4:25
    Os tipos primitivos de dados
    são os tipos básicos de dados,
  • 4:25 - 4:28
    como números, caracteres,
    tipos booleanos.
  • 4:28 - 4:29
    Quais são
    as quatro categorias?
  • 4:29 - 4:34
    São os tipos numéricos inteiros,
    os pontos flutuantes,
  • 4:34 - 4:36
    os caracteres
    e os booleanos.
  • 4:36 - 4:40
    Dentro da primeira categoria,
    que são tipos inteiros,
  • 4:40 - 4:42
    nós temos quatro
    tipos de tipagem.
  • 4:42 - 4:47
    Nós temos o byte,
    o short, o int e o long.
  • 4:47 - 4:50
    O que difere
    cada um deles?
  • 4:50 - 4:53
    Difere a capacidade
    de armazenamento de informações.
  • 4:53 - 4:56
    Por exemplo, se eu quiser
    armazenar a idade,
  • 4:56 - 5:00
    eu não preciso escolher
    nem o short, nem o int, nem o long.
  • 5:00 - 5:03
    Eu posso escolher o byte
    porque o byte consegue armazenar,
  • 5:03 - 5:08
    desde o negativo até o positivo,
    até três dígitos, ok?
  • 5:08 - 5:12
    Então, eu preciso analisar qual o tipo
    de informação que vai ser armazenada
  • 5:12 - 5:16
    para melhor escolher qual
    a tipagem que eu vou utilizar
  • 5:16 - 5:18
    para armazenamento
    numérico.
  • 5:18 - 5:20
    É muito comum usar
    int, int, int, toda hora.
  • 5:20 - 5:23
    Mas para um programador
    qualificado,
  • 5:23 - 5:27
    é sempre bom pensar nessa
    otimização de armazenamento.
  • 5:27 - 5:30
    A segunda categoria é de pontos
    flutuantes, ou números decimais,
  • 5:30 - 5:33
    onde nós temos o tipo
    de dado float e o double.
  • 5:33 - 5:36
    O float para armazenamento
    de até 4 bytes
  • 5:36 - 5:38
    e o double
    de até 8 bytes.
  • 5:38 - 5:40
    Então, o que diferencia
    em ambos?
  • 5:40 - 5:43
    Exemplos básicos: se eu
    quiser armazenar um valor,
  • 5:43 - 5:47
    que é um preço de um produto,
    é melhor eu usar o float ou o double?
  • 5:47 - 5:50
    Vai depender se esse valor
    será colocado num cálculo,
  • 5:50 - 5:53
    porque quanto mais armazenamento
    de números eu tenho,
  • 5:53 - 5:57
    maior a precisão que eu vou
    ter dentro de um cálculo.
  • 5:57 - 6:00
    Agora, se esse valor vai ser
    simplesmente apresentado numa tela,
  • 6:00 - 6:02
    então eu posso
    apresentar via float
  • 6:02 - 6:04
    porque eu não vou ter que fazer
    nenhum cálculo preciso
  • 6:04 - 6:06
    a respeito
    daquela informação.
  • 6:06 - 6:10
    A terceira categoria
    é de caractere, ou char.
  • 6:10 - 6:11
    O que é
    um caractere?
  • 6:11 - 6:14
    Um caractere é o armazenamento
    de um único caractere.
  • 6:14 - 6:16
    Diferentemente
    de um texto.
  • 6:16 - 6:19
    Para trabalhar com um texto em Java
    nós usamos a classe String.
  • 6:19 - 6:22
    A classe String não é
    um tipo de dado primitivo,
  • 6:22 - 6:23
    mesmo porque
    é uma classe.
  • 6:23 - 6:26
    Agora, para trabalhar
    com um único caractere,
  • 6:26 - 6:28
    eu tenho o tipo
    primitivo char.
  • 6:28 - 6:30
    E, no fundo, se eu quiser trabalhar
    com um texto inteiro,
  • 6:30 - 6:33
    então eu vou ter que ter
    uma sequência, ou um "array",
  • 6:33 - 6:35
    de tipos chars, ok?
  • 6:35 - 6:39
    Então, se vocês fizerem a analogia,
    a classe String, que trabalha com texto,
  • 6:39 - 6:43
    é nada mais nada menos
    que uma sequência, ou um array,
  • 6:43 - 6:45
    do tipo primitivo char.
  • 6:45 - 6:47
    O quarto tipo primitivo
    é o boolean.
  • 6:47 - 6:49
    O boolean é simples.
  • 6:49 - 6:51
    É para um armazenamento
    de verdadeiro ou falso,
  • 6:51 - 6:54
    ou, em inglês,
    true or false.
  • 6:54 - 6:55
    E para que serve?
  • 6:55 - 6:59
    Serve para você gerar variáveis
    que armazenem poderes de decisão,
  • 6:59 - 7:00
    se tem ou não tem.
  • 7:00 - 7:03
    Imaginem que, num sistema,
    eu tenho uma variável chamada
  • 7:03 - 7:06
    "Tem filhos?", ou seja,
    uma pergunta.
  • 7:06 - 7:08
    Eu posso armazenar
    num tipo booleano,
  • 7:08 - 7:11
    tem ou não tem,
    true or false.
  • 7:11 - 7:15
    Vamos testar um pouquinho agora
    as tipagens do Java aqui?
  • 7:15 - 7:17
    Deem uma olhada no código
    que eu vou mostrar para vocês,
  • 7:17 - 7:20
    e se vocês também quiserem
    brincar no computador de vocês,
  • 7:20 - 7:21
    é uma ótima ideia.
  • 7:21 - 7:24
    Aqui eu criei
    quatro variáveis.
  • 7:24 - 7:27
    A variável "idade",
    que é do tipo int,
  • 7:27 - 7:31
    e que eu estou atribuindo
    um valor a ela, que é o valor 10.
  • 7:31 - 7:35
    Como eu faço esse processo
    de atribuição de um valor a uma variável?
  • 7:35 - 7:37
    Basta eu usar
    o operador "=".
  • 7:37 - 7:39
    Quando eu utilizo
    o operador "="
  • 7:39 - 7:43
    eu estou falando que esse
    valor será atribuído àquela variável
  • 7:43 - 7:48
    que está representada
    por esse tipo de dado, ok?
  • 7:48 - 7:50
    Então, a ordem é
    exatamente sempre essa.
  • 7:50 - 7:54
    Logo abaixo, eu criei uma outra
    variável chamada "preço"
  • 7:54 - 7:56
    que vai ter um armazenamento
    do tipo double,
  • 7:56 - 7:59
    que é aquele ponto
    flutuante de precisão.
  • 7:59 - 8:03
    Essa variável vai receber
    um valor que é 10.0.
  • 8:03 - 8:07
    Atente-se ao detalhe:
    aqui no Java eu não uso vírgula,
  • 8:07 - 8:10
    eu uso ponto
    para decimais.
  • 8:10 - 8:11
    Então, se eu
    colocar uma vírgula,
  • 8:11 - 8:16
    ele vai dar erro porque vírgula
    é utilizada na programação
  • 8:16 - 8:18
    como sendo
    um comando, ok?
  • 8:18 - 8:22
    Então, eu coloco,
    por exemplo, 10.0, 10.5.
  • 8:22 - 8:24
    Eu estou trabalhando
    com números decimais.
  • 8:24 - 8:28
    Então, esse valor 10.5
    será atribuído à variável "preço"
  • 8:28 - 8:32
    que está preparada
    para armazenar valores double.
  • 8:32 - 8:36
    Na linha de baixo, eu criei
    uma outra variável chamada "sexo",
  • 8:36 - 8:41
    que é do tipo char, ou seja,
    vai armazenar um único caractere.
  • 8:41 - 8:45
    Então, eu coloquei aqui a letra M,
    ou seja, uma única letra.
  • 8:45 - 8:48
    Será que eu posso escrever
    um texto aqui dentro?
  • 8:48 - 8:51
    Não, porque isso daqui
    não é uma variável de texto
  • 8:51 - 8:53
    e sim de um único
    caractere.
  • 8:53 - 8:57
    Eu simplesmente coloquei
    a letra M entre aspas simples.
  • 8:57 - 8:59
    Quando você coloca as informações
    entre aspas simples,
  • 8:59 - 9:03
    você está dizendo ao Java
    que é um único caractere.
  • 9:03 - 9:06
    "Ah, mas posso colocar um número aqui,
    como por exemplo, o número 3?"
  • 9:06 - 9:09
    Pode. Esse número será
    tratado como um caractere,
  • 9:09 - 9:11
    desde que entre
    aspas simples.
  • 9:11 - 9:12
    Então, esse 3...
  • 9:12 - 9:15
    Claro, vamos mudar aqui
    para deixar o exemplo mais claro.
  • 9:15 - 9:19
    Então, eu coloquei o M,
    que vai ser atribuído à variável "sexo",
  • 9:19 - 9:24
    que está preparada para receber
    uma informação do tipo char.
  • 9:24 - 9:27
    Um quarto exemplo que eu
    coloquei aqui é o tipo booleano.
  • 9:27 - 9:29
    Então, eu criei uma variável
    chamada "temFilhos",
  • 9:29 - 9:31
    que é quase
    que uma questão,
  • 9:31 - 9:33
    e falei que ela é
    do tipo booleano,
  • 9:33 - 9:37
    que só vai receber
    true ou false.
  • 9:37 - 9:39
    São as duas
    informações básicas.
  • 9:39 - 9:42
    Então, eu vou colocar aqui
    que a variável "temFilhos"
  • 9:42 - 9:45
    está recebendo true.
  • 9:45 - 9:48
    Essa variável true será armazenada
    na variável "temFilhos",
  • 9:48 - 9:52
    que está preparada para receber
    informações booleanas.
  • 9:52 - 9:54
    Somente para testar
    essas variáveis aqui,
  • 9:54 - 9:55
    vamos fazer alguns
    prints na tela.
  • 9:55 - 9:58
    Lembram do atalho
    para fazer o print?
  • 9:58 - 10:02
    Então, ensinando novamente,
    eu vou escrever aqui "sysout",
  • 10:02 - 10:03
    vou dar
    um Ctrl + espaço,
  • 10:03 - 10:08
    ele já abre o comando
    "System.out.println".
  • 10:08 - 10:10
    Vou colocar aqui
    o nome das variáveis.
  • 10:10 - 10:14
    Então, eu vou colocar primeiro
    o nome da variável "idade",
  • 10:14 - 10:16
    na linha de baixo eu vou
    fazer um outro sysout,
  • 10:16 - 10:20
    vou colocar a variável "preço"
    e assim por diante,
  • 10:20 - 10:21
    completar todas
    as variáveis.
  • 10:21 - 10:27
    "Sexo" e também
    a variável "temFilhos".
  • 10:27 - 10:30
    Note o seguinte: ele também tem
    "autocomplete" para as variáveis.
  • 10:30 - 10:33
    Então, por exemplo, eu quero
    completar a variável "temFilhos",
  • 10:33 - 10:35
    eu coloco só o comecinho,
    a palavra "tem",
  • 10:35 - 10:37
    e ele já apresenta
    o complemento
  • 10:37 - 10:40
    da variável
    ou as sugestões possíveis.
  • 10:40 - 10:43
    Bom, feito isso, meu
    código Java está pronto.
  • 10:43 - 10:47
    Até dei um "up" nele aqui
    para ficar um pouquinho maior na tela.
  • 10:47 - 10:51
    Vou salvar esse código Java
    e vou executar novamente.
  • 10:51 - 10:53
    Para executar,
    eu já falei para você
  • 10:53 - 10:55
    que é possível
    você vir no play aqui,
  • 10:55 - 10:59
    mas você também pode dar
    simplesmente um F11.
  • 10:59 - 11:02
    Quando você der um F11,
    é um atalho um pouquinho mais rápido,
  • 11:02 - 11:06
    ele também faz a execução
    e apresenta a informação,
  • 11:06 - 11:08
    o resultado,
    na console.
  • 11:08 - 11:13
    Então, ele apresentou idade 10,
    preço 10,5, sexo M,
  • 11:13 - 11:15
    e tem filhos
    como true.
Title:
LTP CAP02 VA02 TIPOS DADOS VARIAVEIS PT01
Video Language:
Portuguese, Brazilian
Duration:
12:49

Portuguese, Brazilian subtitles

Incomplete

Revisions