Transcrições
1. Apresentação: Olá. Meu nome é Derek e bem-vindo
ao meu curso de Java. Você provavelmente tem seus
motivos para estar aqui. Talvez você tenha
trabalhado em Clinton recentemente apenas para descer até a seção de
qualificações e perceber que eles exigem que
você conheça Java e outras linguagens de programação
como pré-requisito básico. Talvez você esteja
analisando faixas de compensação e perceba que os engenheiros de software
recebem muito generosamente. Ou talvez você só
queira aprender algo interessante para
começar o novo ano. Independentemente do motivo pelo qual
você acabou aqui, java é uma ótima habilidade para aprender. Mas o que é Java? Java é uma linguagem de programação
popular e de desempenho, o que significa que você poderá
escrever programas rápidos. Você será muito
procurado por suas habilidades. O Java também é fácil de aprender e transferível, o que significa que, depois de
aprender Java, aprendizado de outras linguagens de
programação será ainda mais fácil. Agora tudo parece ótimo, mas existem muitas outras classes de programação por aí. Por que eles deveriam escolher este? Bem, temos muitas coisas
para você. Em primeiro lugar, temos todo
o código-fonte deste curso pronto para
você em um ambiente on-line, que
significa que tudo o que você precisa fazer é pressionar o botão verde Executar. Não é necessário passar horas
batendo a cabeça contra o computador tentando
descobrir o que há de errado com
sua configuração local. Com um clique de um botão, você está pronto para ver a
saída de seus programas. Também temos um
projeto de currículo muito visual pronto para o YouTube, o que
significa que, ao
final deste curso, você terá algo
para mostrar aos seus amigos e
colocar em seu currículo. Temos exemplos concretos
de exemplos de código em todas as aulas para que
você não se confunda conceitos abstratos, pois os conceitos
são introduzidos com uma explicação visual e fácil de
seguir. Finalmente, serei
mantido ativamente neste curso. Portanto, fique à vontade para postar perguntas
se as coisas não estiverem claras. Antes de falar com você
sobre o conteúdo do curso, eu provavelmente deveria me
apresentar primeiro. Sou engenheiro de
software profissional e, durante toda a minha carreira, trabalhei em algumas
das empresas de tecnologia mais famosas e valiosas do mundo. Tenho experiência no mundo real no fornecimento de produtos
técnicos concretos, alguns dos quais você pode
ter encontrado. Antes de ser engenheiro
de software. Eu lecionei na graduação
em Ciência da
Computação na Universidade da Califórnia, Berkeley, onde
resolvemos regularmente milhares de
estudantes neste semestre. curso foi nomeado um dos
cinco melhores do país pela Bloomberg. E atualmente sou
um dos instrutores mais populares com menos de 61 anos, um
canal departamental do YouTube em que
acumulamos cerca de 900.000
visualizações em 2022. Durante meu tempo em Berkeley, também
quero vários prêmios de
ensino e
recebi o distinto Prêmio
GSA em 2020
, concedido aos 13
melhores instrutores e a toda a ciência da computação departamento de
várias centenas. Finalmente, tenho
pós-graduação em ciência da
computação
também no Brooklyn. Como você pode ver, adoro tudo relacionado à tecnologia e
adoro ensinar. Estou super animada por ter
vocês comigo para o passeio. Uma última coisa antes de
começarmos o curso, peço que você
crie uma conta no repl it.com e verifique seu e-mail
depois de fazer isso. Agora, eu sei que sei. Talvez você tenha acabado de criar uma conta
Skillshare e provavelmente não esteja com
vontade de criar outra conta. Bem, como mencionei anteriormente,
temos um
ambiente on-line configurado para você brincar e
construir seu projeto. E acredite em mim, a alternativa
é muito, muito pior. A alternativa ao ambiente
on-line seria configurar um
ambiente de desenvolvimento local em seu computador. Há 1 milhão de
maneiras pelas quais isso pode
dar errado e a solução de problemas pode levar
horas. Então, peço que você reserve
alguns minutos agora para criar
uma conta aqui. Isso é tudo para mim neste vídeo, te
vejo no próximo. Se você quiser
acessar os slides. O link será publicado na descrição
do curso.
3. Métodos: Bem-vindos, amigos. Neste vídeo, falaremos
sobre métodos. Em primeiro lugar, o que é um método? Um método é
praticamente qualquer coisa que executa uma ação
dentro de uma classe. E a definição de
inação é bem ampla. Pode ser qualquer coisa.
Pode ser aritmética simples. Pode estar executando um algoritmo
de aprendizado de máquina. Pode estar renderizando um quadro. As classes contêm métodos e métodos contêm toda a
lógica de um programa. Agora, os métodos devem ser declarados antes que possamos começar a
escrever lógica neles. Há quatro componentes
nesta declaração. Primeiro, temos o modificador de
acesso. Temos quatro tipos:
público, privado,
privado e protegido. O modificador de acesso
em um método mirth funciona exatamente da mesma
forma que funciona para classes. Se o eixo não for declarado
explicitamente, o método assume como padrão
o pacote privado, assim como uma classe faria. Um método público é aquele que pode ser referenciado a partir de qualquer classe. O
método privado do pacote Panda só pode ser
acessado se for referenciado a partir de um método de uma classe dentro do mesmo pacote. Lembre-se também de que, prometido
anteriormente explicarei privado e protegido quando começarmos a
falar sobre métodos.
Bem, acontece que precisamos
saber ainda mais sobre Java antes de podermos
falar sobre protegido. Então, vamos deixar esse
de fora por enquanto. No entanto, podemos falar sobre o código
privado marcado como
privado que só pode ser acessado
dentro da mesma classe. Então, por exemplo, se eu declarasse o
método X como privado, isso significa
que somente
outros métodos dentro da mesma classe
poderiam referenciar o método X. Métodos de outras classes,
independentemente de seu pacote, não teria permissão para fazer
referência a um método privado. Em seguida, temos a estática. Podemos optar por omitir a palavra
estático em nossa Declaração. Nesse caso, o método
assumirá como padrão não estático. Agora, não se preocupe com o que estática realmente significa ainda. Infelizmente, você
precisará de mais contexto em Java antes de ser
capaz de entendê-lo. Então, por enquanto, esteja ciente de
que a palavra-chave estática existe e vem depois
do modificador de acesso. Em seguida, temos o tipo de retorno que sempre deve estar presente. O tipo de retorno é, como o nome sugere, o tipo do valor retornado por um método. Nesse caso, nada é
retornado por esse método. Então, dizemos que seu
tipo de retorno é nulo. Agora, você pode estar um pouco
confuso sobre o que significa para um método
retornar algo. O valor de retorno de um
método é o valor de saída. Por exemplo, imagine que temos
um método chamado add e tudo o que ele faz é
somar dois números inteiros. Então, por exemplo, a
soma de 1,2 nos dá três. Na programação,
chamaremos esses três de valor retornado
da função add. O valor de retorno é
sinônimo do valor de saída. E neste campo e
em nosso exemplo de anúncio, o tipo do
valor de retorno seria um número inteiro, já que três é um número inteiro. Finalmente, temos
o nome do método. Os nomes geralmente podem ser
o que você quiser. A única restrição,
acredito, é que o primeiro caractere do nome do
método deve ser uma letra. Agora, vamos falar
sobre tipos em Java. Como dissemos no slide
anterior, todo método precisa
retornar o tipo. Portanto, é importante que
entendamos quais podem ser alguns
desses tipos. Primeiro, temos uma sequência de caracteres, que é um texto legível por
humanos com aspas duplas. Lembre-se, no slide anterior, que
tínhamos o Hello World, bem aqui e aqui. Este é um texto de dupla cota
legível por humanos. É um exemplo de string. Em seguida, temos um inteiro, um int, que é Java
falando por inteiro. Também temos floats, que é a maneira do Java de
dizer um número com
um ponto decimal, como 1,3, por exemplo temos booleanos que são valores que só podem
ser verdadeiros ou falsos. Também temos tipos de matriz, que pareciam colchetes int, colchetes ou
colchetes booleanos. Uma matriz de itens é basicamente apenas uma coleção ordenada
de elementos do tipo. Então, por exemplo,
se especificarmos entre colchetes, isso significa
que esse valor será uma
coleção ordenada de números inteiros. E se tivermos
colchetes booleanos, colchetes, então isso será
uma coleção de valores verdadeiros ou falsos. Java tem muito mais
tipos do que justiça, mas esses são alguns dos tipos
mais comuns que veremos. E eles servirão como
uma boa base para o restante
deste curso. Em seguida, precisamos falar
sobre argumentos de métodos. Um argumento de método é apenas
uma forma formal de dizer as entradas ou
parâmetros de um método. Os argumentos do
método são especificados parênteses após o
nome do método. E o tipo Java
dos argumentos deve ser especificado explicitamente. Por exemplo, aqui temos um tipo de matriz de string e recebemos o nome
do argumento args. Isso significa que, quando
chamamos esse método, devemos fornecer a ele uma entrada
do tipo string array. Caso contrário, o Java se recusará a compilar o código
e não será executado. Há alguns
pontos sutis que você deve conhecer. A primeira é que esse método principal aqui é muito especial. Normalmente, em um aplicativo Java, teremos vários arquivos e precisaríamos
especificar um ponto de entrada. Caso contrário, o Java não
teria como saber qual parte do código
começaria a ser executada primeiro. Portanto, nesse caso,
especificaríamos que
queremos que a classe helloworld
seja nosso ponto de entrada. Nesse ponto, o java
procuraria um método principal que tivesse
exatamente essa assinatura, public static, void main com um argumento que tivesse o
tipo string array. Ele executará esse
método se ele existir como o ponto de entrada inicial
no programa. Caso contrário,
o Java emitirá um erro dizendo que não há um método
principal definido. Segundo, se você quiser que um método use
vários argumentos, precisaremos digitar
explicitamente cada um desses argumentos e
separá-los com uma vírgula. Neste exemplo de anúncio, temos dois argumentos, x e y, e especificamos os
tipos Int para ambos. E essa função
add simplesmente retorna o resultado da adição desses
dois números, retorna x mais y. Como nota lateral, observe
que quando especificamos um tipo de retorno e a assinatura do
método,
por exemplo , aqui, nós deve
incluir uma linha dentro desse método que
diz explicitamente retorno no Maine, por exemplo, temos um vazio, o que
significa que não retornamos nada. Observe que não há nenhuma linha nesse método que diga return. Em terceiro lugar, não há problema
em não ter nenhum argumento. Você simplesmente
colocaria um conjunto vazio de parênteses após
o nome do método. Agora, você pode estar pensando que
esse requisito de
digitar tudo explicitamente em Java é realmente oneroso e só
existe para atrasá-lo. Mas se isso fosse verdade, o
Java não seria uma
das linguagens de
programação mais populares e da indústria de software atualmente. A razão pela qual temos esses
requisitos é que eles permitem Java execute algo que
chamamos de verificação em tempo de compilação. Antes de executar um programa Java, seu computador deve primeiro converter o código em algo
chamado código de bytes. Chamamos esse processo de
compilação. Quando a
compilação é concluída e você executa o programa, você está realmente executando o
bytecode que é produzido. Agora, a vantagem
de ter uma
etapa de compilação antes de executar
o código é que o compilador Java
é capaz de analisar seu código e realizar
algumas verificações básicas de integridade. Uma dessas
verificações de sanidade é se todos os tipos especificados em
sua lógica são consistentes. Por exemplo, como mencionamos anteriormente aqui, espera dois números inteiros. Imagine se eu tentasse
passar o número dois, uma string, hello world
como argumentos para o anúncio. Bem, isso não faria sentido. Como você adiciona o número dois a um pedaço de texto Hello World. Portanto, a vantagem do Java é que ele executará essas
verificações de integridade em tempo
de
compilação e notificará você sobre quaisquer erros antes que
o código seja executado. Em outras linguagens, sem verificação do
tempo de compilação, pode
haver um problema
em seu código que você não conheceria
até que o código fosse executado. E isso pode ser
muito devastador se seu código for implantado em, digamos, um banco ou talvez no Google, que é usado por 1
bilhão de pessoas todos os dias. Agora, vamos falar sobre
o corpo do método. Primeiro. O corpo do método é simplesmente todo o código dentro
desses colchetes. Na verdade, não há nenhuma
restrição sobre o que você pode fazer
no corpo e o corpo do método
pode durar o quanto você quiser. Independentemente de qualquer lógica
que você decida executar. A principal coisa que você
precisa garantir é que o tipo
do valor
de retorno corresponda ao retorno
especificado na declaração do método. Aqui, estamos retornando some, que é uma variável que
declaramos e inicializamos com
o valor x mais y. Como x e y são ambos ints, a adição de dois também
é um int. Portanto, retornar
sum está em conformidade com nossa exigência de
retornar um int nesse método. O próximo ponto
que quero enfatizar é que a
linha de retorno é terminal. A compilação do Java
falhará se você tentar colocar qualquer código após a linha de
retorno em um método, que faz sentido, pois o valor de retorno é o valor de
saída do método. Por que realizar uma lógica adicional depois de já ter
gerado um valor final? Também precisamos falar
um pouco sobre as variáveis que você cria e
usa em um método. Assim como os argumentos do método, as variáveis definidas
no método devem ser digitadas explicitamente
ao criá-las. E você pode nomeá-los como
quiser, desde o primeiro caractere
do nome seja uma letra. Depois de declarar a variável
sum como um int, por exemplo, não
podemos mais alterar seu
tipo dentro do mesmo método. Então eu não posso fazer algo como
int sum é igual a x mais y. E então, na próxima linha string sum é igual a hello world. Embora você não possa
alterar o tipo de soma, você pode alterar seu valor. E quando você faz isso,
não precisa digitá-lo explicitamente. Então, depois que a
soma int mine for igual a x mais y, posso fazer algo como sum
é igual a um sem o, sem a declaração de
tipo explícita. E, a propósito, essas
três afirmações
só são verdadeiras dentro
do mesmo método. Eu poderia ter um método totalmente diferente
chamado Subtrair. E subtraindo, eu poderia declarar que soma é uma
string, se eu quiser. Essa variável teria que
permanecer uma string
dentro desse método. As variáveis de método
em um método são independentes das
variáveis do método em outro método. Agora que sabemos como
definir métodos, vamos ver como os usamos. Chamamos isso de chamada de método. Quando referenciamos
o nome do método e passamos argumentos
entre parênteses, como você provavelmente pode imaginar, de 12 fará o código de retorno x mais
y seja executado. E esse
valor retornado agora será vinculado a X no Maine. A propósito, essa coisa que
usamos o tempo todo, sistema dot out, dot print
LN também é um método. Ele consiste em uma referência
a um nome de método e tem parênteses nos quais transmitimos um argumento para que nossa viagem
seja impressa na tela. Nesse caso, o valor
de x, que é três. A razão pela qual precisamos de
todos esses pontos fará mais
sentido no vídeo futuro. Questionário pop. Como o Java sabe imprimir o valor três? Nesse caso, em vez do
caractere literal x que
passamos para impressão,
vá em frente e pause o vídeo. Eu revelarei a resposta em 321. A razão pela qual java
sabe imprimir três é que esse x não é, nós citados no X tínhamos
aspas duplas ao redor. Java trataria x como
um caractere literal x, já que não tem aspas
duplas ao redor, java entende que x é um nome de variável com um
valor associado a ela. Portanto, ele primeiro
avaliará o que é x e depois imprimirá o
resultado dessa avaliação. Aqui estão os links para os
exemplos de código usando este vídeo. Como abordamos
bastante conteúdo neste vídeo, peço que você
visite esses links. Clique, bifurque, ondule e
mexa com o código. Não precisa
ser nada chique. Experimente adicionar
variáveis aos corpos do método ou talvez alterar o tipo de retorno e a declaração do método. E, a propósito, lembre-se de
adicionar ponto e vírgula. As linhas Java devem
terminar em ponto e vírgula a menos que você esteja abrindo um novo bloco de código com colchetes
ondulados.
4. Replit demo: Neste vídeo,
quero dar uma visão geral rápida do ambiente
Ripple. E o que quero dizer quando
digo que encorajo você a
mexer no código. Primeiro, certifique-se de ter criado
uma conta no repl it.com. Eu sei que é meio chato
configurar outra conta, mas a alternativa
para isso é configurar um
ambiente de programação local no seu computador. O problema é que eu não sei qual
computador você tem. Não sei qual sistema operacional
você está executando e não
sei quais são as variáveis de
ambiente, aliases que você configurou
no seu computador. Quando eu costumava ensinar
na UC Berkeley porque às vezes
levo mais de uma hora para configurar um
ambiente local para um pequeno grupo de
talvez dez alunos. E como as classes de compartilhamento de
habilidades basicamente têm capacidade
ilimitada, a sobrecarga
associada à configuração por si só levaria um tempo
proibitivamente longo. Esta é uma aula sobre Java, não sobre computadores e repl, ela já
configurou o Java para você. Acho que esse é um recurso extremamente valioso
que você pode usar, além de ser gratuito para
nossos casos de uso. Agora, se visitarmos esses
links nos slides, veja como
fica quando
visitamos o link no slide. Depois de criar uma conta REPL, vá em frente e clique
neste botão para ver aqui. Agora temos uma cópia do
projeto em sua conta. Este é o código do
vídeo sobre anatomia de programação. A barra lateral aqui
é onde você pode explorar a
estrutura de arquivos do projeto. Podemos clicar na pasta para expandir seu conteúdo
e clicar em Inserir nomes de arquivos para
exibir seu conteúdo aqui. Neste exemplo, o método principal aqui apenas imprime Hello World. Então, vamos verificar a sanidade. Vá em frente e clique
no botão verde. Você pode ignorar os textos
enigmáticos aqui. Este é apenas REPL, seu
sistema secreto, emitindo comandos de construção e execução. Agora vamos tentar bifurcar outra ondulação e
fazer alterações nela. Aqui está o código
do vídeo de métodos. Vamos seguir em frente e tentar
fazer a mesma coisa. Então, aqui está o link. Novamente. Vamos clicar em Fork Ripple e dividi-lo em nossa conta. Agora vamos ver o que podemos fazer. Primeiro, basta verificar a sanidade com o botão verde e
garantir que
esses valores no
método principal sejam impressos. Ok, agora podemos ver que imprimimos
o número três. E se você der uma
olhada no código, isso deveria, isso
deve fazer sentido. Temos 12 e
estamos imprimindo
o resultado da adição de
1,2, que é três. Agora vamos ver se conseguimos
adicionar duas chamadas de método. Portanto, esse seria o primeiro exemplo de
mexer no código. Então, digamos que
adicionamos um a mais um. Já que ligar para um
retornará um número um. Parece razoável
que talvez um possa ser adicionado ao
resultado da adição de 1,2. Vamos seguir em frente e executar isso. Agora, você vê que
recebemos um erro. Diz que temos 21,
diz não uma declaração, faça outras conforme o
esperado, um ponto e vírgula. Então, como você deve ter notado, todas as linhas Java terminam
com um ponto e vírgula, exceto as que estão abertas, um novo bloco de código,
como declarações de métodos. Então, talvez
seja prudente
adicionarmos um ponto e vírgula
no final aqui. Agora vamos
executar esse código novamente. Ok, então ainda temos isso, não um erro de declaração, mas pelo menos nos livramos
do erro de ponto e vírgula. Portanto, não fazer uma declaração é
um grande erro. Então, vamos pesquisar
isso no Google. Vamos
copiar e colar isso. Vá para o Google e vá para Java. Não é uma declaração. Clicamos na
primeira pilha de resultados. Overflow é um recurso extremamente útil para a
maioria dos programadores. E podemos rolar para baixo até
a resposta aqui. E observe o que
eles dizem. Eles dizem. Java restringe os tipos
de expressões
permitidas e as chamadas declarações de
expressão. Ela proíbe declarações semanticamente
sem sentido, como zero ou a mais b.
Ei, adivinha? Não é exatamente isso que
estávamos fazendo antes? Estamos adicionando um a
mais um ponto e vírgula, que é basicamente o mesmo
para a mais b ponto e vírgula. Se rolarmos um pouco mais para baixo, você verá que eles
têm uma citação
da especificação da linguagem Java. Certos tipos de
expressões podem ser usados como
declarações, seguindo-as com ponto e vírgula. E então vamos dar uma
olhada na lista aqui. Bem, temos uma
tarefa
listada como um exemplo
de uma expressão válida. Então, vamos voltar ao nosso
código e transformar isso em uma expressão de atribuição
que ficaria assim. Y é igual a adicionar um a mais um. Vamos continuar e executar
isso mais uma vez. E agora o código é compilado
e executado com sucesso. Não vemos o
resultado da adição de 12.1 porque
não o imprimimos. Então, vamos adicionar
essa linha e executar novamente. Ok, e agora temos um quatro, o que faz sentido porque
adicionamos um a dois e depois adicionamos mais
um a isso, que é quatro. Agora vamos tentar
encontrar um método,
outro método que não tenha palavra-chave estática
e ver o que acontece. Então, talvez isso chame esse
público para voltar. E, novamente, observe que
omiti a palavra-chave estática. Agora vamos tentar ver
o que acontece se
fizermos 12 mais um mais dois. Vamos
executar esse código. Interessante. Desta vez, temos outro
erro de Java. O método não estático não pode ser referenciado a partir de um contexto
estático. Então, eles ainda têm esse ponto par diretamente para o método não estático
que está causando o ar. Portanto, esse é um erro de Java que, na verdade, é
um pouco mais útil. Eles informam que métodos
não estáticos não podem ser
referenciados a partir de métodos estáticos. E o segundo é nosso método
não estático. Agora, na verdade, não falamos
sobre o que significa estática. Então não se preocupe com isso. Falaremos sobre isso em um vídeo futuro e essa mensagem de erro
fará mais sentido. Então, a principal lição é a importância de
mexer no código. Apesar de termos
decifrado o
código várias vezes, aprendemos coisas sobre Java que aprendemos coisas sobre Java que nos
ajudarão mais tarde. É melhor que você
cometa esses erros agora em muitos projetos
associados esses vídeos, para não
se confundir mais tarde ao trabalhar
em projetos maiores.
5. Controle: Bem-vindos, amigos. Neste vídeo, falaremos
sobre controle. Para realizar um fluxo lógico mais
complexo em Java, precisamos primeiro entender
alguns operadores comuns. Primeiro, temos alguns operadores
aritméticos básicos que são bastante
autoexplicativos. Esses são os símbolos de mais, menos e vezes, e funcionam exatamente
como você poderia esperar. Eles somam, subtraem e
multiplicam, respectivamente. O símbolo da barra é o operador de divisão do
Java. Mas uma coisa que você deve observar é que a divisão em
números inteiros em Java uma operação de divisão de piso, que
significa que ela é arredondada
para o número inteiro mais próximo, por exemplo ,
3/2, e a linguagem normal é 1,5. No entanto, em Java três, Flórida por dois é um. Como arredondamos para baixo de 1,5%, o símbolo é chamado de
módulo ou mod, para abreviar. Ele retorna o restante
de uma divisão, por exemplo, 14 mod quatro é dois. Por quê? Porque quatro entra em 143 vezes e ficamos com
o restante de duas. Se você não está familiarizado
com o que
é o restante, recomendo que você dê uma olhada, depois volte a este vídeo e repita os
últimos segundos para confirmar que 14 mod
quatro realmente é igual a dois. O sinal de igual aqui
é como atribuímos valores às variáveis
que vimos anteriormente, como int x igual a um. Também temos alguns operadores
booleanos, como o nome sugere, são operadores que retornam
verdadeiro ou falso. Primeiro, temos alguns
operadores bastante autoexplicativos maiores que, menores
que, maiores ou iguais a e menores ou iguais a. Esse ponto de exclamação muda verdadeiro para falso e falso para verdadeiro. No
próximo slide, veremos como a sintaxe precisa
disso funciona. Agora temos dois iguais. Isso significa retornar verdadeiro se for igual, retornar falso se não for igual. Lembre-se disso, já que
é meio complicado, sinal de igual
duplo é
usado para comparar a igualdade. Um único sinal de igual é
usado para atribuir valores. e comercial duplo
significa retornar verdadeiro se ambas as condições forem verdadeiras,
caso contrário, retornar falso. E essa linha reta dupla
significa retornar verdadeiro se uma das condições for verdadeira,
caso contrário, retornar falso. Esse operador pode não ser
familiar para a maioria das pessoas. Então, aqui é onde está.
Em um teclado Logitech. Geralmente está próximo às teclas
do suporte. Vamos dar uma olhada em alguns
exemplos de uso. Primeiro, um mais dois é obviamente 3,1 menos dois é
obviamente menos um. nada complicado aí. Agora, para o quociente
em que temos 3/2, lembre-se de que a divisão Java
em números inteiros é para divisão 3/2 é um. Como estamos arredondando
para baixo de 1,5, produto é igual a seis. nada complicado aí.
Três vezes dois é seis, e o Java não faz
nada de especial com isso. O restante é igual a
um porque dois entra em cinco duas vezes e temos
um sobrando depois de obter,
depois de multiplicar dois por dois,
esse sublinhado booleano
verdadeiro e verdadeiro zero
é igual a verdadeiro porque adicionou esse ponto de
exclamação logo antes de um falso. Portanto, o ponto de
exclamação transforma as expressões falsas em expressões verdadeiras e as
expressões verdadeiras em expressões
falsas. Portanto, isso é verdade, sublinhado
verdadeiro um também é verdadeiro porque três é realmente
maior do que menos um. verdadeiro sublinhado dois também
é verdadeiro porque estamos negando zero
igual a um. Bem, zero não é igual a um. Então, essa expressão
entre parênteses retornará falsa. Então, a inversão
disso será verdadeira. Então, o verdadeiro sublinhado
dois se torna verdadeiro. sublinhado falso zero
é igual a falso. Porque lembre-se de que o sinal de transmissão
dupla só retornará verdadeiro se ambas as
expressões forem verdadeiras. O verdadeiro sublinhado zero é verdadeiro. No entanto, a inversão do sublinhado
verdadeiro será falsa. Portanto, não é
verdade que ambos sejam verdadeiros
e, portanto, o
resultado é falso. Finalmente, o verdadeiro sublinhado
três será igual a verdadeiro porque chamamos isso de linha reta
dupla Ele retorna verdadeiro se qualquer uma
das condições for verdadeira. Nesse caso, o
sublinhado falso zero é falso. No entanto, o verdadeiro sublinhado
zero é verdadeiro. Portanto, como uma
das condições era verdadeira, toda
a expressão é
avaliada como verdadeira. Agora que abordamos os operadores
básicos, vamos ver como podemos controlar o fluxo da lógica
em um programa. Primeiro, temos
o padrão if-else. Colocamos uma
expressão booleana entre parênteses imediatamente
após o operador IF. Se essa expressão aqui
for
avaliada como verdadeira, executaremos
toda
a lógica dentro das chaves que imediatamente seguem a expressão
booleana. Nesse caso, retorne x mais y. Essa expressão é
avaliada como falsa. Em seguida, ignoraríamos todo o código que
incluía as chaves aqui
e, em vez disso, executaríamos
o código dentro das chaves do caso
contrário aqui, neste caso retornaria zero. Lembre-se de um vídeo anterior que mencionei que o retorno é terminal e não devemos ter nenhuma linha de código
após uma linha de retorno. Então, por que aqui temos várias
linhas de retorno aqui? Pense nisso e
revelarei a resposta em 321. O motivo é que apenas um
desses blocos de código é executado
toda vez que o método é chamado. Esses blocos de código são mutuamente exclusivos 100% do tempo. O ponto sutil sobre as minas de
retorno serem
terminais é que elas são terminais apenas para
o determinado bloco de código em que existem. E isso faz sentido
se você pensar bem. Este exemplo de método
foi declarado para
retornar um número inteiro. Imagine se escrevêssemos apenas
essa linha de retorno x mais y, mas não tivéssemos
essa linha de retorno zero. Além disso, imagine
que passamos um x forma que essa expressão seja
avaliada como falsa. Em seguida, pularíamos essa linha de
retorno e chegaríamos
ao bloco else, onde
não temos mais um retorno
zero, então esse método não
retornaria nada. E então esse método
estaria quebrando promessa de que
retornará um número inteiro. Portanto, isso levaria a uma falha na compilação do
Java. Aqui está outro padrão if-else, mas desta vez utilizando alguns operadores sobre os
quais falamos anteriormente. Mais uma vez, colocamos toda
a
expressão booleana entre parênteses. Se x mod dois é igual a um, ou y mm R2 é igual a zero. Em seguida, executamos todo esse bloco de
código retornado X mais Y. Caso contrário, se ambas as condições
forem falsas, retornaremos zero. Aqui está outro exemplo, desta vez apresentando um novo operador. Caso contrário, o nome do
operador for bastante intuitivo e fizer o que
você esperaria se essa expressão booleana
fosse avaliada como falsa. Ele pularia a linha de retorno x mais y e, em seguida, tentaria avaliar a expressão booleana contida na linha else-if. Se essa expressão x mod
três for igual a um, for
avaliada como verdadeira, retornaremos x. Caso contrário, se essa
expressão fosse falsa, ignoraríamos o retorno x
e chegaríamos ao outro caso, nesse caso retornamos y. Agora, vamos falar sobre
o padrão selvagem. Às vezes, você pode
achar útil
executar um determinado
bloco de código várias vezes. Por exemplo, digamos que você queira
imprimir números de
um a mil. Uma maneira de fazer isso
seria escrever system.out.print
LAN 1.000 vezes. Mas outra maneira de
fazer isso seria
escrever um único sistema
dot out dot print LN e colocá-lo em
um bloco de código curinga. Então, aqui está um exemplo. A forma como isso funciona é que
primeiro avaliamos a
expressão aqui. E embora n seja
maior que zero, se isso for verdade,
executamos todo o código dentro
desse bloco de código. No final do bloco de código, voltamos ao início e avaliamos essa
expressão novamente. N é maior que zero? Nesse caso, executamos o bloco
de código novamente. E então repetimos,
voltando a essa expressão booleana
repetidamente até que ela seja falsa. Essa sintaxe aqui pode ser um
pouco estranha para você. Vamos dividi-lo
começando com esta linha, n é igual a n menos um. Lembre-se de que o operador igual significa atribuir um
valor a uma variável n. Mas antes de podermos
atribuir um valor a n, precisamos primeiro
entender qual é o valor dessa
expressão, n menos um. Então, basicamente, o que isso faz é primeiro subtrair
um de n
e, depois disso,
atribuir esse valor de volta a n. Então, efetivamente, estamos apenas diminuindo o
valor de n em um. Então, se n vem como cinco, calculamos cinco menos 15, menos um é quatro e depois atribuímos o
valor quatro de volta a n. Então n é agora para essas
outras duas retas e
menos, menos e menos é igual a um, na verdade ambos
são
abreviações para a mesma coisa, n é igual a n menos um. Portanto, todo esse
bloco de código está
efetivamente diminuindo n em três
toda vez que é executado. Existe uma sintaxe semelhante se você quiser aumentar
o valor de n, poderíamos simplesmente fazer
n
mais e mais igual a um e
n igual a n mais um. Eu também gostaria de dar
um aviso. O Java executa muitas
verificações de integridade em tempo de compilação. Mas uma coisa que
não
verifica é se seu loop
será encerrado. Por exemplo, imagine que essas três linhas fossem
todas incrementadas. Estamos aumentando o
valor de n. Então n mais e mais é igual a
um e n é igual a n mais um. Agora imagine que também
passamos um valor de n que já é
maior que zero, então esse bloco de código
aumentará n ainda mais. E essa expressão aqui, maior que zero, nunca
será falsa. Portanto, esse bloco de código será executado para sempre. Se isso acontecer, seu código não apresentará erros e o compilador
também não errará. Ele continuará funcionando para sempre até que você reconheça o
problema e interrompa o código. Portanto,
tenha cuidado ao escrever loops e certifique-se de que sua condição
acabe eventualmente. Aqui está nosso padrão
de controle final para este vídeo. Aqui está um exemplo. Temos quatro seguidas
por três expressões entre parênteses e delimitadas com ponto e vírgula. A primeira expressão está
na etapa de inicialização. A variável i ainda não
existe nesse método, então nós a declaramos e
atribuímos a um valor zero. Em seguida, temos a expressão
booleana, semelhante à
expressão booleana no loop while. Essa é uma
expressão booleana que será avaliada antes
da execução do bloco de código. Se for verdade,
executamos o bloco de código. Se for falso, saímos do bloco de código e executamos qualquer código que venha
depois desse for-loop. Finalmente, mudamos o estado. Esse I plus plus plus é executado
após a execução do bloco de código. Então, como estamos começando do zero e correndo
até que I não seja
mais do que n e I esteja aumentando em um em
cada iteração. verdade, estamos
apenas imprimindo números de zero a n menos um. Aqui estão mais alguns
exemplos de for-loops. Observe aqui que
podemos inicializar i, uma
linha de código totalmente separada. Se nenhuma inicialização for
necessária para o for-loop. Deixe-me colocar um
ponto e vírgula e deixar a primeira
expressão de inicialização vazia. Aqui temos outro exemplo. Quero que você tome nota
especial da inicialização aqui. Lembre-se de nossa lição anterior que, uma vez
declarada uma variável, as referências
futuras
a essa variável não precisam ser digitadas
para serem especificadas. Essa é a razão pela qual aqui
dizemos apenas I é igual a três, mas não int I é igual a três. As mesmas regras se aplicam
tanto à expressão de inicialização quanto às
expressões autônomas fora dos parênteses do loop for. Agora, você pode estar
se perguntando Qual é a diferença
entre um loop for e um loop while, além do fato que a sintaxe
é diferente? Bem, a resposta é que eles são efetivamente
a mesma coisa. Realmente, a única grande
diferença é sua sintaxe. Portanto, não pense muito sobre quais podem ser as diferenças
entre esses dois. Aqui está o link para o
código usado neste vídeo. Como sempre,
clique no link, clique para entender e
experimentar o código. Uma coisa que eu gostaria
que você tentasse desta vez é se deparar com
algum erro de Java que
possa achar meio
enigmático e
incentivá-lo a copiar e colar essa mensagem
de erro no Google. A causa raiz das mensagens de erro geralmente
é bem semelhante. E, muitas vezes, você encontrará resultados
muito úteis em fóruns
de programação
que direcionam o Google para o C2.
6. Objetos Parte 1: Bem-vindos, amigos. Hoje vamos
falar sobre objetos. Agora, percebi
que, isso parece muito idiota, que vamos
falar sobre objetos. Mas prometo que
você aprenderá algo valioso até
o final desta lição. Agora, antes de entrarmos
no conteúdo deste vídeo, deixe-me tentar
convencê-lo por que você deveria se preocupar com
objetos. Até agora, estamos lidando apenas com o
aspecto funcional do Java, como métodos
e lógica de controle. No entanto, Java é
na verdade o que
chamamos de linguagem
orientada a objetos. Isso significa que vemos nossos
programas como objetos com comportamentos e não como uma
coleção de funções. Isso pode ser um pouco
difícil de entender. Uma analogia que você pode imaginar é como você vê um videogame. Digamos que Mario, por exemplo, caso você não esteja
familiarizado com Mario. Aqui está uma captura de tela de
um dos jogos do Mario. Esse cara aqui é Mario. E a premissa do
jogo ainda é
superar vários obstáculos
para alcançar uma princesa. E esses
cogumelos de aparência engraçada por aqui, geralmente se movem e quando
tocam em você,
você perde uma vida. Agora, um jogo de Mario é obviamente
um trecho de código, certo? Provavelmente há algum
código que verifica a distância
do cogumelo até Mario. E à distância é
menor que algum limite. Em seguida, subtraímos um
da vida de Mario. Mas não é assim
que pensamos nesse jogo. Não pensamos nesses
cogumelos como métodos que verificam constantemente
a distância de Mario. E não pensamos que um Mario um monte de métodos
que
calculam constantemente sua velocidade vertical
e horizontal. Nós apenas pensamos em Mario como uma entidade única que exibe comportamento de pular e
correr. E pensamos nesses
cogumelos como entidades que estão ativamente tentando nos
impedir de salvar a princesa. Essa mudança de paradigma é a mesma que
temos em relação ao Java como uma linguagem funcional versus Java como uma linguagem orientada a objetos. Mesmo que não estejamos
codificando um videogame, os desenvolvedores acham
útil pensar seu código como objetos discretos exibem comportamento, em vez de como uma coleção de funções
abstratas. À medida que você trabalha em projetos Java
cada vez maiores, fica significativamente mais
fácil entender o
programa como um todo. Se você tem um design sólido orientado a
objetos, porque é
assim que os humanos percebem o mundo como uma
coleção de objetos. Aqui está um exemplo
de uma classe que exibe programação
orientada a objetos, bem
como um método principal que utiliza essa classe
como um objeto. Primeiro, gostaria de
salientar que apesar de alguma sintaxe desconhecida, na verdade, há
muita coisa aqui que já
abordamos. Aqui. Temos pacotes,
temos aulas públicas. Temos um método principal que serve como
ponto de entrada para o programa. E temos
declarações de método aqui. E temos um bloco if else aqui com uma expressão booleana. Portanto, a quantidade de coisas
que precisamos saber para
entender a programação
orientada a objetos não
é nada ruim. Vamos falar sobre esse bloco
de código aqui. Isso é algo que
chamamos de construtor. Uma maneira de
saber se esse é um construtor é que não há
tipo de retorno e a declaração do método
e o nome
desse bloco de código correspondem
ao nome da classe. Mas além do fato de
que a declaração
desse bloco de código é diferente
da declaração de um método. Basicamente, age como um método. E esse bloco de código é
executado na instanciação. instanciação é quando
criamos uma nova instância
de um objeto. Pode ser um pouco difícil
entender os
casos em termos
dessa classe de cães. Em vez disso, vamos relembrar
nossos exemplos anteriores. Quando criamos variáveis
inteiras. Imagine que temos duas
variáveis inteiras, x e y. Talvez x seja igual a um
e y seja igual a dois. Como x e y são números inteiros, você pode pensar neles como duas instâncias
do tipo inteiro. Só que eles têm valores diferentes. Da mesma forma, você pode imaginar que podemos ter duas
variáveis, x e y, ter duas
variáveis, x e y,
ambas
digitadas por Dog e valores
diferentes para
seu nome e idade. Uma instância de um objeto é
exatamente o que parece. É uma versão de um objeto. Falaremos sobre
como instanciar um objeto no próximo vídeo. Por enquanto, tudo o que você precisa saber é que, quando a
instanciação ocorrer, esse bloco de código será a
primeira coisa a ser executada. E também falaremos sobre
o que isso realmente significa. This.name é igual a nome e
essa idade de pontos é igual a idade. Aqui estão alguns exemplos do que chamamos de variáveis de instância. Para ser mais específico, eles estão declarando variáveis de
instância, mas não as inicializando
com nenhum valor específico. Poderíamos fornecer essas
variáveis e o valor
inicial na declaração, como
nome de string privada igual a Bob, aqui nesta linha. No entanto, geralmente delegamos a inicialização da variável
ao construtor, já que o construtor será
a primeira coisa
a ser chamada
de qualquer maneira. E talvez não seja uma boa ideia nomear
todos os nossos cães, Bob. Isso seria
extremamente confuso para todos os nossos amiguinhos. Como você pode ver, assim como
qualquer outra variável em Java, essas variáveis de instância devem ter um tipo
declarado explicitamente. Eles também precisam de modificadores de acesso, assim como classes e métodos. Há duas diferenças
importantes entre variáveis de método, variáveis de
instância. A primeira diferença é que as variáveis de
instância
persistem nas chamadas do método. Uma variável de método só existe enquanto o
método ainda estiver em execução. Quando um método retorna todos os valores de suas variáveis
são apagados da memória. Para objetos, esses valores de
variáveis de instância persistirão enquanto a
instância do objeto existir. Isso fará mais
sentido quando vermos um exemplo de
instanciação de objetos no próximo vídeo. A segunda diferença
são suas regras de acesso. As variáveis de método
só podem ser acessadas dentro do bloco de código mais interno
no qual são criadas. Por exemplo, se tivéssemos um loop
inteiro dentro do método getName. E dentro desse loop while, criamos uma variável. variável
só estaria acessível dentro do bloco
de código do loop while. No entanto,
as variáveis de instância são acessíveis a
partir de todos os
métodos não estáticos da mesma classe. Falaremos
sobre o que a estática realmente significa
no próximo vídeo. Mas, por enquanto, tudo o que você
precisa saber é que um método não estático
é aquele que não tem estática antes de ser declarado o tipo de retorno e
a declaração do método. Como você pode ver aqui, podemos retornar o valor do
nome e da idade a partir
desses métodos aqui. Essas variáveis de instância
são acessíveis a esses métodos, pois esses
métodos não são estáticos O prefixo desse ponto indica ao Java que estamos nos referindo a uma variável de
instância chamada nome. Agora, você pode
pensar que esse é um requisito ridículo de termos
que adicionar ainda
mais regras de linguagem
para nos referirmos que adicionar ainda
mais regras de linguagem às variáveis de instância. Mas há uma boa
razão para isso. Você pode dizer o que
é? Pause o vídeo e eu revelarei
a resposta em 321. O motivo é que podemos
ter conflitos de nomenclatura entre variáveis de instância
e variáveis de métodos. Um exemplo disso está, na verdade aqui no construtor. Temos o nome da variável declarado nos argumentos
do construtor. Se eu omitisse o prefixo, esse prefixo nesta linha,
this.name é igual a nome, então basicamente teríamos
apenas nome igual a nome, o
que não faz nada porque
nome já é igual a nome. Portanto, esse prefixo
é importante para desambiguar entre instância e variáveis
de métodos. Se não houver esse
prefixo e houver uma variável de método
com o mesmo nome variável da instância,
o Java assumirá que você está se referindo à variável do
método. Aqui está o código
usado neste vídeo. Como sempre,
clique no link, clique em Fork Ripple
e experimente. Se você encontrar alguma mensagem de erro
enigmática, tente colar sua mensagem
de erro no Google e veja o que outras
pessoas têm a dizer. Caso contrário, sinta-se à vontade para postar
perguntas neste curso.
7. Objetos Parte 2: Bem-vindos, amigos. Neste vídeo,
encerraremos nossa discussão sobre
objetos. Mencionamos a instanciação de objetos
no vídeo anterior. Vamos ver como isso funciona. Primeiro, lembre-se de que o
construtor de cães tem essa aparência. Tem dois argumentos,
nome e idade. Em nossa classe principal, criamos duas instâncias
da classe escura da seguinte forma. Primeiro, de acordo com a tradição
Java, especificamos explicitamente o tipo da variável que estamos criando, que é o tipo escuro. A próxima parte aqui parece quase uma chamada de método, exceto que temos
essa palavra-chave, nova. A nova palavra-chave emparelhada com a chamada do construtor diz
ao Java que primeiro aloque memória para
uma cópia do objeto dog. E uma vez que a memória
tenha sido alocada, ela chama o construtor. Executando qualquer código que esteja
na definição do construtor. Depois de executar essas
duas linhas de código, Bobby e Sam agora têm
seus dados de nome e idade salvos na primeira
e na segunda instância do cão. Uma vez que salvamos esses dados em suas variáveis de instância
, que persistem. Agora, vamos falar sobre estática. Aqui está a aula
de cães do último vídeo, mas com alguns complementos. Adicionamos a palavra-chave estática entre o modificador de acesso e o tipo na declaração do método
e da variável. Lembre-se de que variáveis
e métodos sem a
palavra-chave estática ou não estáticos, também conhecidos como
variáveis de instância e métodos de instância. Como o nome sugere, variáveis de
instância e métodos de
instância são específicos para instâncias
de um objeto. No entanto, variáveis estáticas e métodos
estáticos são o oposto. Eles não podem ser vinculados a uma instância
específica de um objeto. Esse exemplo sombrio pode
ajudar você a entender. Se você quiser saber o
número de pernas de um cachorro, precisa de um cão específico
para responder a essa pergunta? Claro que não. Você sabe que os cães em
geral têm quatro patas. O número de pernas
de um cão não é específico para uma
instância específica de um cão. Por outro lado,
se você quiser saber o nome ou a idade do cachorro, precisamos de um cão muito específico
para responder a essa pergunta. Portanto, métodos
e variáveis de instância são específicos para
instâncias específicas da classe. Métodos e
variáveis estáticos se aplicam a todas as instâncias da classe. Vamos dar uma
olhada em como consultamos métodos
estáticos versus métodos de
instância. Como não pernas é um atributo público
e estático, podemos pedir para acessá-lo diretamente
com dog dot non legs. Observe que o cão não é uma instância específica
da classe de cães. A classe de cães em si não
tem nome nem idade. Também podemos acessar
get numb tails diretamente na classe dot
sem uma instância. No entanto, para obter idade, precisamos acessá-lo por meio de
uma instância específica. Segundo cão, uma vez que apenas casos
específicos de cães têm dados de idade
associados a eles. Além disso, observe que ainda
podemos acessar métodos e variáveis
estáticos de uma instância de um objeto. E, novamente, se você pensar bem,
é bem intuitivo. Não sei dizer a idade
do cachorro sem um cachorro específico, mas não posso dizer
quantas pernas e caudas os cães têm em geral, se eu lhe der uma referência
específica do Dr.. Aqui está o código
usado neste vídeo. Como sempre,
clique no link para ver a ondulação e mexer no código para ver o que
funciona e o que não funciona.
8. Comentários: Bem-vindos, amigos. Neste vídeo, falaremos
sobre comentários. Às vezes, o código Java
pode ser muito confuso, especialmente se você tiver
um bloco de código que chama outros métodos e esses métodos
chamam ainda mais métodos. Isso causa problemas mais tarde pois você
descobrirá que às vezes tem problemas para entender seu código logo após alguns dias. E se você planeja
colaborar com outras pessoas, precisará se certificar de
que seus colaboradores possam entender
seu código da mesma forma. Para ajudar
na legibilidade do código, Java tem uma maneira de
os desenvolvedores adicionarem notas
legíveis por humanos ao
código. Aqui está um exemplo. Os comentários embutidos são prefaciados com barra
dupla e geralmente
são adicionados após
o código na mesma linha ou na linha
imediatamente acima do código O comentário descreve
os textos que aparecem. A barra dupla é um
texto legível por
humanos que não é
executável por Java. Ele existe apenas para
ajudar o leitor humano, o programa a entender
com o código adjacente está fazendo. Aqui está outro exemplo. Isso é o que chamamos de comentário em
um documento Java. Existem ferramentas que gerarão documentação para seu código escaneando arquivos
em busca comentários que
sigam esse formato. Não vamos usar uma ferramenta de
documentos Java neste curso, mas é bom que você
saiba como escrever descrições
de
métodos simples e bonitas. Java, doc, comentários
ou multilinha. Eles começam com uma estrela de barra, uma
estrela e uma barra de estrela. As linhas intermediárias devem ter um único asterisco
no início. Normalmente, os comentários do java
dot têm uma descrição de alto nível
do método, como a que temos aqui, seguida por Program
e nas tags de retorno. Se tivéssemos vários argumentos, teríamos vários
aplicativos por m tags. Cada um nomearia primeiro o
perímetro que está descrevendo, seguido por uma descrição
do que é o argumento. A tag de retorno está presente para métodos não nulos e contém uma descrição
do que é retornado. Não é necessário seguir
estritamente esse formato se você não estiver gerando
documentação com a ferramenta de documentos Java. Mas mesmo que você não esteja, geralmente
é uma boa prática
seguir esse formato
sempre que possível. Aqui está o código
usado neste vídeo. Visite o link, clique em
Fork, ripple e
mexa com o código.
9. Arrays e Arrays: Bem-vindos, amigos.
Parabéns por ter chegado até aqui
no curso. Neste vídeo,
falaremos sobre matrizes e listas de matrizes. Alguns vídeos atrás. Quando
abordamos os tipos Java pela primeira vez, mencionamos o tipo de matriz, mas na verdade não entramos em muitos detalhes
sobre o que é. Hoje. Vamos revisitar matrizes com muito mais detalhes. Lembre-se de que
vimos pela primeira vez uma matriz de strings
na assinatura
do método principal. Aqui está uma maneira de
criar uma matriz. Se você já sabe
quais valores
queremos usar para inicializar, podemos preenchê-los diretamente , especificando o
tipo da matriz, neste caso, uma matriz inteira, e incluindo a valores
e chaves curvas como essas. Se você ainda não sabe quais valores
deseja usar, podemos primeiro inicializar
uma matriz de zeros com a nova palavra-chave e especificar o comprimento
da matriz entre colchetes. Então, quando estivermos prontos
para preencher a matriz, podemos definir os elementos
diretamente da seguinte forma. Algumas coisas a serem observadas aqui. Primeiro, o comprimento de uma matriz é fixo e não pode ser
alterado depois de criada. Portanto, tanto a matriz um quanto a matriz dois terão o comprimento
três e sempre serão. Então. Em segundo lugar, os índices de matriz
começam em zero. Em muitas linguagens,
incluindo Java, quase todas as indexações
em estruturas de dados, também
começaremos do zero. Agora, se você quiser imprimir todos os elementos
na matriz, um por um, criamos uma variável I para se referir ao
índice da matriz. E incrementamos esse valor I em
um até atingirmos o
comprimento da matriz, que podemos pesquisar
usando esse atributo length. Podemos acessar um
elemento individual na matriz com esses colchetes e
índices de 01 ou dois, que se referem ao primeiro, segundo e terceiro elementos,
respectivamente, na matriz. Então, essas são matrizes. Em seguida, temos ArrayLists, que são uma
versão mais flexível das matrizes. Semelhante às matrizes. As listas de matrizes também são
coleções ordenadas de itens. No entanto, uma distinção
conceitual importante é que ArrayLists são redimensionáveis e ArrayLists também têm uma sintaxe
diferente. Vamos explorar essas diferenças. A primeira é que o ArrayList
é inicializado dessa forma. A coisa nos
colchetes angulares especifica o tipo de elemento
na coleção ordenada. E só precisamos fornecer
explicitamente o tipo no lado esquerdo
da inicialização. Essa linha instanciaria uma ArrayList com comprimento zero. Também notei que usamos número inteiro
maiúsculo aqui
em vez de int minúsculo. Isso é algo que chamamos
de caixa para digitar em Java. Não é muito relevante
para este curso, então não precisamos gastar
muito tempo nele. Chamamos o tipo int
de tipo primitivo e o tipo inteiro com I
maiúsculo, de tipo de referência. Ints e números inteiros geralmente são interconversíveis e mapeados
um a um para o outro. Por exemplo, um valor int de um seria mapeado para um valor
inteiro de um. Tudo o que você realmente precisa saber é que o número inteiro do
tipo de referência com I maiúsculo é necessário para algumas estruturas de dados
, como ArrayLists. Uma vez que ArrayLists só pode aceitar tipos de
referência como seus elementos. É exatamente assim que o
java foi projetado. Portanto, não se debruce muito sobre isso. Apenas tenha isso em mente. Se
você já tentou usar uma lista de matriz na próxima vez
que for às compras. A seguir, veja como você adiciona
elementos à lista. Portanto, um está no índice
012 está no índice um, menos sete está no índice
2,19 está no índice três. Também podemos remover
elementos da lista, o que excluirá o elemento
no índice especificado e
diminuirá o tamanho da lista em um. Nesse caso, removeremos
o índice dois, que em nosso exemplo
será o valor
de menos sete. Então, depois de executar essa linha, teremos o valor
um no índice zero, o valor 12 no índice um e desvalorizaremos 19 no índice dois. Uma vez que todos os valores após o índice dois serão alterados um para contabilizar a exclusão. Outra diferença é a forma como
obtemos o comprimento da matriz. Embora eu apague, tinha um tamanho de atributo
público. listas de matrizes têm um
método público chamado size. Também temos uma lista de pontos para chegar aqui em vez de colchetes
para acessar os elementos. Estamos apresentando
muitos métodos e atributos específicos para apagar uma
ArrayList neste vídeo, o que pode ser um
pouco cansativo. Se você se sente assim. Não se preocupe. A ciência da computação não é uma disciplina baseada
na memorização. Se você esquecer
algo pequeno ou estiver tentando encontrar
alguma funcionalidade extra
para essas estruturas de dados,
basta pesquisar no Google. Os resultados do Google para questões básicas de
programação geralmente
são muito relevantes, pois muitas pessoas antes de
você provavelmente tinham as mesmas perguntas a fazer quando
começaram a programar. Finalmente, gostaria de mostrar uma forma abreviada de
percorrer a lista. Esse bloco de código faz exatamente a
mesma coisa que esse bloco de código acima do elemento int
diz ao Java que estamos tratando cada item
na lista como uma variável chamada elemento com tipo int. e a lista de dois pontos diz ao Java que essa é a
lista sobre a qual queremos repetir. Como nota lateral, também
poderíamos ter escrito o tipo como um número inteiro
com a maiúsculo aqui. Lembre-se de que int e integer
geralmente são interconversíveis. Só precisávamos usar um
número inteiro com I maiúsculo quando declaramos que o tipo de ArrayList aparece inicialmente. De qualquer forma, na primeira iteração
desse bloco de código, o
elemento
será vinculado a um. Na segunda iteração, ele será vinculado a 12. Você entendeu a ideia. Java apenas
manipula o incremento
da variável de índice para você
com essa sintaxe simplificada. Agora, você pode estar se perguntando: ArrayList pode fazer tudo o
que os arrays podem. E as ArrayLists ainda têm funcionalidades
extras,
pois podem ser redimensionadas. Então, por que os
desenvolvedores de Java não simplesmente removeram ou
apagaram da linguagem? Pause o vídeo e eu
revelarei a resposta em 321. O motivo é que há
uma compensação de desempenho envolvida ao usar uma
ArrayList em vez de uma matriz. listas de matrizes com tipos de
referência
geralmente são um pouco mais lentas do que
as matrizes que usam tipos primitivos. Para a maioria dos casos de uso, porém, a
compensação de desempenho não é realmente perceptível o suficiente para
fazer a diferença. Mas é algo a
ter em mente se você estiver trabalhando em algo
sensível à latência, como se você estivesse
programando laser de altíssima precisão, ou estivesse tentando construir um
negociação de ações ultrarrápida. Mas aqui está o código
usando esse vídeo. Visite o
link, clique em Fork, ripple e mexa
com o código.
10. Sudoku: Olá amigos. Parabéns por terminar todos os
vídeos instrutivos deste curso. Hoje, podemos usar o que
aprendemos para criar um jogo visual interativo que você pode compartilhar no meu
currículo e com seus amigos. Eu vinculei um documento bastante
abrangente na guia de projetos
e recursos. Vá em frente e clique neste link. E isso deve
levá-lo a este documento. Vou deixar você ler
a maior parte
deste documento em seu próprio tempo, mas vou
analisá-lo brevemente agora, que você tenha pelo menos uma ideia geral do
que está acontecendo. Eu gostaria de começar dizendo que este projeto não
foi feito para ser muito
fácil, ou concluído em 10 minutos. Eu sei que alguns dos
outros cursos
desta plataforma são muito simples, como escrever uma aula com três métodos. Mas eu realmente não acho que você
aprenderá muito
se isso é tudo o que você está fazendo depois de assistir a
esses vídeos. Portanto, esse projeto pode
exigir mais reflexão do que outros projetos se você já fez outros cursos de Java
nessa plataforma, mas não desanime. Foi projetado dessa forma. Assim, você pode ter experiência com uma tarefa real de codificação que realmente o incentiva a
entender a programação
orientada a objetos. Não deixe de ler
todo o documento. É provável que você tenha muitas perguntas sobre
o projeto que já foram respondidas aqui.
Antes de começar. Certifique-se de ter criado uma conta no repl it.com e também de
ter verificado seu e-mail. Caso contrário, você não poderá
bifurcar e
fazer alterações nos arquivos. Depois de fazer isso, visite
este link e faça o sorteio. Esse projeto que vinculamos
aqui é chamado de esqueleto. O que isso significa é que
parte do código
foi feito para você. Muitos métodos foram deixados em branco e ter um comentário para fazer blocos de código o comentário todo significa que você teve que preencher o
código dessa seção. Neste projeto, você
implementará o Sudoku caso não
esteja familiarizado. Eu escrevi uma descrição
deste jogo na seção de
visão geral aqui. Aqui, escrevi
uma breve descrição de cada um dos arquivos
deste projeto. A ordem em que
elas estão listadas é a ordem na qual você
deve concluir o projeto. Você deve fazer a si mesmo primeiro, depois remar, depois
bloquear e depois embarcar. O Main já
foi feito para você. Aqui, eu escrevi o que
acabei de dizer explicitamente. Depois de concluir cada aula, você deve executar todos
os testes unitários e garantir que os
testes unitários estejam relacionados à aula em que você
acabou de concluir nossa aprovação. Primeiro. Depois de concluir a célula, você deve se certificar de que todas as unidades estejam
relacionadas ao passe de venda. Depois de concluir a linha, você deve se certificar de
que todos os testes de unidade associados à célula e à
linha sejam aprovados, e assim por diante. A próxima seção mostra como
realmente
executar o teste. No painel esquerdo da seção de
ferramentas em repl it, você poderá acessar as ferramentas. Ferramentas. E depois de
clicar na guia Ferramentas, você poderá
ver os testes unitários. Depois de clicar em testes de unidade, você poderá
ver essa janela pop-up, que tem um botão Executar teste. Mesmo que ainda não tenhamos
começado a programar. Vamos fazer o
teste unitário e ver o que acontece. Vamos voltar ao
nosso esqueleto de Sudoku. Vamos, novamente, para
a guia Ferramentas. Clicamos em testes unitários
e clicamos em Executar testes. Depois de clicarmos em Executar testes, podemos ir até
a guia do console. Eu já o tenho aberto aqui, mas caso você não tenha, você pode encontrá-lo na seção de
ferramentas. Então, nas ferramentas, você vai para o console. E agora podemos ver a saída. Nesse caso, zero dos 20 testes foram aprovados, veja os erros acima. Então isso é bom. Isso significa que todos os nossos
testes são realmente significativos. Pense nisso. Se algum de nossos testes fosse aprovado sem nenhum código ter sido escrito, isso seria um sinal muito ruim. Isso significaria
que o teste não está realmente testando nada. Então, depois de concluir
o projeto, todos esses testes devem passar. Na próxima seção, escrevi algumas dicas de depuração para o caso de você ter algum problema. No entanto, como você
provavelmente
é novo na programação, não há problema se você não conseguir resolver o problema sozinho. Se você tiver algum problema,
você tem duas opções. A primeira opção é dar uma olhada
rápida na solução, que publiquei na
parte inferior deste documento. A segunda opção é postar uma pergunta no
curso Skillshare
sob a guia de discussão. E eu entrarei em contato com
você assim que puder. Finalmente, depois de
passar em todos os testes de unidade, você pode clicar no
grande botão verde. Jogar o jogo
deve ser assim. Aqui está minha solução. Então você clica no botão verde. Depois de concluir a compilação, ele executa o programa
e imprime esse quadro de Sudoku que tem
alguns valores preenchidos. Agora podemos jogar com este jogo. Então, digamos, por exemplo ,
que gostaríamos de
colocar o número, digamos dois em deslocamento. Então essa
será a linha número um, já que essa linha de
períodos, linha zero. Então essa é a linha um, e essa é a coluna um, porque essa
aqui é a coluna zero. Digamos que defina 11 como dois. E você pode ver que dois já foram preenchidos em deslocamento. Se quisermos desfazer isso, podemos limpar 11 porque
11 é a coordenada que estamos limpando e faremos com que ela
fique vazia novamente. Agora, vamos tentar
colocar um nove aqui, o que não deve funcionar porque
já temos um nove
neste bloco. Definimos 11 para B9. É meio que
dizer que o bloco zero tem vários nomes e
não permite que você coloque um nove lá. Se você ficar frustrado
e não quiser mais
terminar um quebra-cabeça de Sudoku, basta digitar solve. E agora ele resolverá
todo o tabuleiro para você. E ele sairá
do programa dizendo que
você precisa executar
o botão Executar novamente Se quiser um novo quebra-cabeça, existe a possibilidade de
que os
testes unitários que escrevi
não sejam abrangentes. Tenho quase certeza de que,
se você passar em um teste de unidade, poderá executar
o jogo com sucesso. No entanto, se você passar todos os testes de unidade e
ainda não conseguir executar
o jogo corretamente. Eu recomendo
que você compare sua solução com
a que eu publiquei. Quando você encontrar a discrepância, publique uma nota no curso do
Skillshare para que eu possa corrigir o esqueleto ou o teste unitário,
caso precisem ser corrigidos. Mais uma vez, lembre-se de
ler este documento na íntegra e
consultá-lo com frequência. E isso é tudo que eu tinha
a dizer sobre este vídeo. Divirta-se em sua primeira tarefa
real de codificação.
11. Transição: Olá a todos. Eu sou Derek, e obrigado por
assistir meus vídeos Tenho trabalhado arduamente
nos últimos meses e acabei de lançar uma nova
continuação, ou Citizens One. Vou colocar o link
na descrição. Eu reformulei o curso para ter slides com aparência
mais profissional e, em geral, uma melhor qualidade
de produção Eu tenho esse tripé, por exemplo,
que está segurando minha câmera. Há um novo projeto
que incorpora as lições dessa classe Mas desta vez eu incluí vídeos de
explicação
intermediários para que você não fique completamente perdido Esta aula que você
acabou de concluir aborda conhecimento
básico de Java que é essencial para escrever programas
funcionais No entanto, se você já tentou
escalar seu código à
luz de
circunstâncias imprevistas
ou devido a mudanças nos luz de
circunstâncias imprevistas requisitos, descobrirá que é muito
difícil fazer isso. Gerenciar a complexidade do
código é uma
habilidade essencial para um E abordamos
muitos conceitos com os quais você deve estar
familiarizado
se decidir seguir
uma educação formal em programação ou se
decidir procurar emprego. Espero que você tenha gostado das aulas
desta aula e que decida continuar sua jornada
comigo na próxima Nos vemos no próximo vídeo.