Transcrições
1. Apresentação: Olá pessoal e bem-vindos. Meu nome é Michael.
Sou fotógrafo ,
diretor de fotografia
e físico. E neste curso,
vou explorar com vocês algumas dicas e
truques que você
definitivamente pode usar para melhorar sua codificação ou sua
programação. Nível. Rise
lidará principalmente com Java. E este curso é destinado a grupos
intermediários de pessoas. Isso significa que você tem
alguma compreensão básica do que é Java. Mas ainda estamos desenvolvendo
alguns fundamentos com isso. Acabei de fazer um estágio intermediário. Portanto, há um pouco de experiência que
você precisa ter. E espero ver você
na próxima lição.
2. Declarações condicionais: Tudo bem pessoal, estou feliz por
ter vocês aqui. E apenas um lembrete de que
este curso presume que você já tem algumas noções básicas
de codificação em Java, certo? E o que vamos fazer é
começar
aqui com
declarações condicionais, bem aqui, acima, declaração condicional. E lembre-se de que esse é um
comentário bem ali. E
começaremos particularmente com a declaração if else. Se dadadadada significa que colocamos uma
condição bem ali, e depois diremos
outra coisa ali. E então também colocamos uma condição do que deveria acontecer, certo? E, inerentemente, o Java
é bem capaz de
suportar várias condições lógicas
da matemática, certo? Sejam
condições lógicas como talvez algo como menos do que, digamos menos do que. E lembre-se de que nós, mostramos, matematicamente
falando, mostramos menos feito por algo
do seguinte cenário. Dizemos que a é menor que
b, por exemplo, certo? E então poderíamos
ter outro cenário em que temos
menos ou igual a, certo? E esse
obviamente teria que ser
da seguinte forma, onde teríamos que dizer que talvez
a seja menor ou igual a b. Então também poderíamos ter
um cenário em que
falássemos sobre maior que, maior que, que
seria então referido como um
ser maior que b. E você pode definitivamente ser
capaz de rastrear em cima o que eu
vou dizer um x
maior ou igual a, que seria então
referido ou mostrado da seguinte
maneira, onde dizemos o mesmo padrão é
maior ou igual a b. Então também poderíamos
ter um cenário em que você fala sobre ser igual a algo e como nos
referimos a isso, como dizemos, é igual a fato, deixe-me fazer isso. Bem, eu digo que a é igual
a a a b,
não, e repito que não. A é igual a b.
A codificação a é igual a b significa que você
está dizendo que a deve ser substituído por b. Significa igual,
literalmente significa inserir. Você vê, mas quando você
diz igual, igual, significa
que você
realmente está se referindo
à notação matemática
ou igual a, certo? Que é o que você
gostaria de colocar talvez no cenário
das condições. Então você poderia
mostrar que algo
não é igual a algo
dizendo não é igual a. E então vamos ter isso
e dizer que a é igual a b. Então, definitivamente, há um
grande número de condições
que você definitivamente pode usar. E com base no que
você quer para
você, você pode sair com diferentes performances ou
ações para alcançar, certo? E outra coisa que você pode querer saber
é que o
próprio Java tem as seguintes instruções
condicionais. Então, aqui estão as declarações
condicionais. Do próprio Java. Temos condição if. Temos a
condição if, condição. E isso é para fazer o quê? Isso é para especificar um
código a ser executado. É tão simples quanto isso. Se uma
condição especificada for verdadeira, se a condição for verdadeira, certo? Então, essencialmente, seria capaz ter essa condição if, certo? E deixe-me apenas
colocá-lo nesses dois colchetes aqui apenas para que
ele se destaque como uma condição em si. Você não é capaz de
confundir como se
fosse apenas uma frase
contínua. Não. Usamos if para ser capaz de fazer isso. Eu poderia até colocar esse uso aqui. Usamos f para fazer isso e, em seguida, também
podemos usar
else, else para especificar um código
a ser executado também. Tudo bem, deixe-me fazer isso. Mas se uma condição é
falsa, você vê isso? Então aqui isso é perfeito. Se a condição for verdadeira, nada mais significa que se
a condição for falsa. Então é assim que você usa. E então também poderíamos
falar sobre else if, que também é uma condição. Portanto, eu deveria
colocar um suporte. Caso contrário, se usarmos else if. E com a condição
sendo condição. E é aí que queremos especificar uma condição
a ser testada. Para ser testado. Isso se a condição
for falsa, certo? Então, essencialmente, o que
geralmente acontece é que provavelmente
teria algo
como essa condição primeiro, que é a condição if. E então o próximo
teria else-if. E então, finalmente,
teríamos esse outro. Isso se todas as condições
estiverem acontecendo, então vamos finalmente para o outro. Normalmente, essa é a ordem em
que teria uma preocupação. Definitivamente, estaremos investigando isso logo depois disso. Isso é apenas uma apresentação
desses métodos. E então também temos uma condição de
troca que é usada para especificar que há uma
condição ali, certo? Typo, que é
definitivamente usado para especificar quantos, muitos, muitos blocos alternativos de código a serem executados. Isso é muito útil, especialmente em aprendizado de
máquina ou ciência de dados ou
qualquer coisa disso. Você se verá usando
isso muitas vezes,
apenas para se aprofundar em toda
a ideia
da declaração if. Deixe-me dar um
pouco , algo
interessante, Garrett. Vamos dar uma
olhada no seguinte. Vamos apenas dizer que estamos
olhando para a condição if now if. E com essa condição if, o que vamos
fazer é escrever isso.
3. Se declarações condicionais: O que vamos fazer é
colocar uma condição
aqui e dizer se. E então colocamos nossa
condição se, por exemplo três for maior que um. Isso é um exemplo. A questão é, agora, se for esse
o caso, o que deve acontecer? O que deve acontecer
se for esse o caso? Então você poderia dizer isso misturado,
por exemplo, sistema. Lembre-se de colocá-lo
corretamente no sistema. Dot out, dot, print, LN, print. Vamos imprimir uma string que diz o primeiro número maior que o
segundo número. Certo? Então, essencialmente, o que estou
dizendo ao meu, meu, meu Java aqui para fazer é
se o primeiro número, que é três, é
maior que o segundo número, se essa condição for verdadeira, então isso deve ser impresso. Isso é o que eu deveria ver. E se for falso, a questão é se é falso,
então o que deve acontecer? Bem, nada porque
eu não disse o
que deveria
acontecer se nada, se essa condição for falsa. Então, vamos tentar
executar isso e ver com java será capaz de imprimir o que esperamos que ele imprima. Há um primeiro número
maior que o segundo número. Agora, não se deixe levar
por este HelloWorld. Isso é por causa
disso aqui. Eu poderia facilmente
excluir isso. Nós realmente não precisamos disso. Honestamente. Eu poderia executá-lo novamente
apenas para que estejamos convencidos de que
apenas temos isso como primeiro número maior que o
segundo número. Muito bom. Portanto, considere o
seguinte cenário. Eu, eu coloquei o meu aqui
e coloquei meu 3M. Agora, vamos prever
o que deve acontecer. Inerentemente, sabemos que um não
é maior que três. E, portanto, isso significa que essa
primeira condição não é verdadeira. E lembre-se de que, se a
condição for usada para especificar um código verdadeiro, se essa condição for verdadeira, o código será executado. Mas então, no nosso
cenário aqui, essa condição
não é verdadeira, certo? Então, não vamos ver nada. Por que nada? Isso porque a condição é falsa.
Definitivamente falso. Mas então Java está se perguntando,
agora, se for falso,
o que devo fazer a seguir? Como não especificamos o que ele deveria fazer a seguir, apenas
resumimos nada. O que devemos fazer é
dizer outra coisa. Poderíamos dizer outra coisa, se,
ou poderíamos dizer outra coisa. Mas vou começar com outra coisa. Significa que se a primeira
condição não for verdadeira, se for falsa, então,
o que deve acontecer? É aí que mais entra. E então eu digo system, out, dot, dot, out, dot, print LN. E temos o primeiro número, menor que o segundo número. Então, vamos ver agora, vamos executá-lo. Essencialmente, estamos
dizendo que se isso é falso, então isso deve ser mantido. Agora, se essa condição não
for verdadeira, então obviamente
significa que é falsa. E, portanto, se for falso, isso aqui deve
ser testado, certo? Isso significa que se não
fizermos o primeiro, caso
contrário, faremos o seguinte. Então, vamos analisá-lo e
ver o que obtemos. Walla, primeiro número,
menor que o segundo número. Isso é definitivamente verdade, de
acordo com o que vemos aqui, o primeiro número é
menor que o segundo número. E podemos brincar com
quantos valores quisermos. Poderíamos até
brincar com 100. E vamos ver 103,
qual é o maior? Definitivamente são centenas, então significa que o
primeiro número deve ser maior que
o segundo número. Vamos ver. Voila, aí está. Primeiro número maior que
o segundo número, certo? Então essa é definitivamente a
declaração if ali, certo.
4. Erros associados a declarações condicionais: Em seguida, basta tomar nota, porém que existem alguns erros
que as pessoas cometerão. Às vezes, tome o modo
que, se você usar letras maiúsculas, se assim for,
isso significa
outra coisa de maneira diferente, então nós lhe daremos um erro. É muito importante
notar isso, certo? Então você pode pensar nisso, ou melhor, até mesmo Teslas que
acabamos de fazer aqui. Não apenas para números, você pode até testar
variáveis. E se você adicionar variáveis
como, por exemplo, digamos que eu diga que int x
é igual a 25, assim. E eu digo int y é igual a 79. Então, ao contrário da direita,
ponto e vírgula ali. E então eu
coloquei a condição if. Agora eu só abro o
colchete e eu apenas digo que x é menor que y, por exemplo. Tudo bem? Se for esse o caso, então o que deve acontecer?
Isso deve acontecer. Sistema. Então eu digo
dot out dot print LN. E, portanto, apenas
dizemos que x é maior. Digamos que x é menor que, x é menor que y. Por exemplo, se isso
for, se for verdade, se for
verdade, então esse é o caso. Agora, o que
prevemos que aconteça? Bem, são inerentemente, podemos
ver que x é definitivamente menor que y porque
x é 25 e y é 79. E, portanto, o que esperamos
ver é que vemos lá, é, isso deve ser
considerado verdade. Isso é verdade. Se essa condição for verdadeira,
então é isso que
será impresso e é verdade. E, portanto, o que esperamos
ver é que x é menor
que y. Isso é o que esperamos
ver. Agora, o que queremos fazer aqui, lembre-se, é colocar isso nos
comentários apenas para garantir que não recebamos respostas da
coisa anterior exibida também. Só queremos essa
parte e o X
dos dados da viola é menor que y, certo? Incrível. Espero que esteja fazendo
sentido para vocês. Está escrito a coisa mais
importante.
5. Outra declaração: E logo em seguida,
vamos seguir
em frente rapidamente e ver se podemos simplesmente ativar a instrução L. Tudo bem, estamos
apenas entendendo a declaração else ainda mais. O foco tem sido principalmente
no F. Agora vamos nos concentrar principalmente
na declaração else. Como já mencionei,
a instrução else é usada apenas para especificar um bloco de código a ser executado se a
condição for falsa, certo? Então você pode pensar
nisso como, digamos, por exemplo, dizer fim
e depois falamos sobre o tempo. Isso equivale a talvez
40 minutos, talvez, certo? E então dizemos, se o tempo for inferior a 60
minutos, uma hora, certo? Se, se o tempo for inferior 60 minutos, o que deve acontecer? Bem, se for esse o
caso, estou adiantado. O aluno é LE talvez se este fosse um
caso em que um aluno chegasse
atrasado para um exame, seja 40 minutos mais cedo, ou melhor, 40 minutos
atrasado ou 60 minutos. 60 minutos além do tempo. Obviamente, o aluno
é retirado, mas é apenas uma questão de qual é o melhor entre os dois. Então, provavelmente imprimiremos
algo como, ei, se o tempo for
inferior a 60 minutos, então o aluno não
está tão atrasado. Saiba se isso é aconselhável, mas espero que o aluno
não se atrase. Estudante não está tão atrasado. Isso se for
menos de 60 minutos. E vamos ver. Lembre-se, isso é porque
o primeiro aqui está aparecendo porque
não colocamos comentários nele. Então, deixe-me colocar comentários
lá e então podemos nos
concentrar no segundo sem
nenhuma distração. Então lá está escondido e o aluno não está tão
deitado aqui como podemos ver. Isso porque, novamente,
a variável aqui, o que o Java faz é
entender. Lembre-se de que falamos sobre
como o sinal de igual e essencialmente significa apenas
inserir o que eu vejo tempo, eu inseri 40 no tempo sempre que o tempo é
mencionado para Java, java rapidamente entende
que isso não Na verdade, não há tempo. Este não é realmente o
momento que estamos
falando é 40 se o inteiro, todos os números inteiros para t. E, portanto, de acordo com uma condição que temos aqui, o aluno não está morto. E então nós o ajustamos. Nós ajustamos isso. Como nós ajustamos isso? Dizemos outra coisa agora, dizemos outra coisa Agora. Else. Isso significa que, se
essa condição
não for mantida, o aluno está atrasado. Amiga, Ellen, a estudante está atrasada. Isso se aplicaria no cenário a
seguir. Imagine que eu diria, qual deles Alia está sendo impressa minutos atrasada
ou 40 minutos atrasada? Qual deles relativamente como Ellie, obviamente 20 minutos, certo? Portanto, o aluno agora é o líder se ele estiver
40 minutos atrasado. Por exemplo, em nosso
cenário aqui significa que em portanto é para t menos de 20, nenhum, Isso é o que
estamos dizendo aqui. A condição é se para
t for menor que 2040, representado pelo tempo,
a variável de tempo. Se for esse o caso, então é isso que
vai ser impresso. Mas isso não é verdade. O que é verdade agora é que
para t é maior que 20,
e, portanto, isso cai
na declaração else
porque aqui é falso,
e, portanto, o que for falso aqui será executado aqui embaixo. Então, vamos ver se
prevemos que o aluno está atrasado, voila. Aí está. Aí está. O aluno está atrasado. Lindo. Espero que esteja fazendo ainda
mais sentido para vocês.
6. Eles..se Declaração Condicional: Vá rapidamente para o outro. Deixe-me colocar
isso como algo comum. O outro, se for o
ELF, a condição else-if. E com a condição else-if, o que
realmente
está acontecendo aqui é que o que realmente
está acontecendo aqui é que temos o
seguinte cenário certo? Lá. Temos isso, por exemplo, vamos aplicar exatamente
o que acabamos de fazer aqui. Basta levá-la
conosco até aqui para entender muito melhor. Então, deixe-me colocar isso nos comentários porque
não precisamos mais dele. Eu sempre poderia
literalmente apenas consolar isso e
sim, está tudo bem. Portanto, não
seguimos o cenário. Agora, pense nisso. E se, se o tempo
for menor que dez, então é isso que imprimirá LE ou talvez Bom dia.
Vamos mudar isso um pouco. Só para entender. Melhor. Tarde, por exemplo. Ou outro aqui é noite. Tarde. Significa que seja qual for o
tempo que tenho aqui, é uma situação bastante binária. Se for menos de dez, o tempo é menor que
dez, é hora da manhã. Se for maior que dez, mesmo em apuros automaticamente. Certo? Mas então o outro
se vier e disser:
Ei, e se eu quiser dizer outra coisa? se? Vamos dizer else-if. E então colocamos nossa
condição e nós células se o tempo for menor
que, e se for apenas
menos de 30 minutos? Bem, neste caso, o que vai acontecer é que você me
deixe copiar esta linha aqui para que não tenhamos que continuar escrevendo toda
vez que a virmos. Então aqui seria
apenas a tarde. Tarde. Então, literalmente, o que
realmente está acontecendo aqui é que estamos dizendo que se o tempo for menor que
dez, é de manhã. Se for menos de 30
da tarde. E se for maior do que o quê? Do que T, o que significa que não é menos de dez e
não é menos de 30, então definitivamente significa que é
maior que Theta, certo? E você provavelmente está se
perguntando por que precisaríamos do LCF? Bem, você vê quando você
faz isso apenas se então, é uma situação muito arbitrária ou melhor
, muito
binária, isso limita você muito
porque é realmente uma opção, a, eu serei. Mas então a beleza
do else-if é que ele permite que você adicione
mais condições. Portanto, você pode
adicionar opções a, B ,
C, D, E quantas quiser. Você pode adicionar quantos
outros se quiser. Agora, se eu tiver um tempo,
digamos que eu tive um
tempo que foi o quê? Literalmente cinco. Talvez. Se eu tiver cinco, significa que é
menos de dez, certo? A primeira condição
está satisfeita. Significa o que em Java executa
que você pode me dizer, mas cinco também é
menor que 30, E13. Imprima esta mensagem. Bem, quando o Java o executa, ele está começando outras coisas literalmente
daqui, verifica aqui. Isso é verdade ou não? E então, se não for
verdade, ele segue em frente. Mas se for verdade, então o Java apenas executará qualquer código que
esteja lá que esteja definitivamente aqui, certo? Mas então, se for maior do
que isso, ele virá aqui. Então, nesse cenário,
previmos estar
no primeiro cenário. Portanto, esperamos que
ele nos fale sobre o dinheiro e os dados da manhã. Isso porque ele rodou
este primeiro é, observe que ei, cinco é
menos que dez, portanto, dinheiro. Mas e se eu adicionar mais dez? Faça 15 agora? Agora é maior que dez. Isso significa que ele verificará o
primeiro ano e dirá:
Ei, isso é falso,
isso não é verdade. E uma vez que ele faz isso,
o que ele faz? Ele pula e vai aqui e
verifica se as galinhas estão aqui. E quanto a essa área? Caso contrário, se o tempo for menor que 30, 15 será menor que 30. E diz: Sim, é. E, portanto, vai imprimir
à tarde. Então, vamos analisá-lo e ver. Lá é tarde. E definitivamente verdade, capaz ver a tendência se eu
fosse aumentar isso imprimindo aqui e
apenas torná-lo melhor cinco agora, isso significa que você vai verificar
aqui primeiro e dizer, Isso
é um cinco a menos que virar? Ele dirá que é possível
que isso seja falso. E então siga em frente e verifique se cinco a menos de 13 também
não é verdade. E então você também
agora apenas diz falso. Então ele finalmente chegará
ao outro aqui e dirá, se este não estiver satisfeito e
este não estiver satisfeito, então definitivamente será solidificado aqui. Portanto, isso aqui
será verdade e prevemos, portanto, que nosso
código aqui seja executado, nossa string seja mostrada aqui, nosso texto seja mostrado
aqui para ser o quê? Tarde. Então, vamos
analisá-lo e ver. E pronto, aí está. Espero que isso tenha ajudado vocês e eu vou
passar para outra coisa agora.
7. O operador ternário: Certo? Então, a próxima que
analisaremos ainda é uma declaração
incondicional, mas eu só quero mostrar a vocês maneira
mais rápida de lidar com todas as declarações
condicionais if else. E isso aqui
nos leva ao que chamamos, vou fazer uso
do operador ternário. E não se preocupe. Vamos
explicar isso em breve, mas é chamado de Java. Deixe-me colocar isso
em taquigrafia davon. Se outra coisa. Tudo bem, então esse é o tiro e o mal de
Java. Portanto, é mais como uma abreviatura que é essencialmente um
operador ternário. E você provavelmente está
se perguntando
o que o operador ouve. Veja como soletramos isso. É um operador ternário. E um operador ternário realmente é apenas um
operador ternário porque consiste em três operandos. Operandos são, você os
verá em breve como eu, como eu vou mandar mensagens para eles. Então, pense no cenário a
seguir, que é o que tivemos. Pense nisso assim. Digamos que você tenha algo
como fim e tempo, como fizemos no primeiro
cenário e
demos a isso um valor
de 30, por exemplo. E então digamos que se o tempo
for menor do que Twain t, então o que deve acontecer é, o que deve acontecer é que
devemos imprimi-lo, certo? Deve imprimir o quê? Talvez algo como um bom dia. Ou se não for esse o
caso, o que deve acontecer? Então escrevemos outra coisa
e depois dizemos, isso é literalmente
o que acabamos de fazer. Poderíamos imprimir a impressão e agora podemos imprimir
talvez uma boa noite. Sim, este está bem, já
falamos sobre isso e nada está
incomodado agora pelo
menos porque
já fizemos isso antes. E eu definitivamente vou
ser uma boa noite porque 30 é maior que 20. Essa é uma longa maneira de
escrever dessa maneira. Usando operadores ternários, ou realmente essa regra abreviada
que estamos prestes a usar. Você pode simplesmente substituir tudo isso em vez de
escrever dessa maneira, o que você poderia fazer é escrever literalmente assim e dizer que o tempo do fim
é uma ferramenta equivalente. Deixe-me colocá-los no operador aqui e dizer que o
horário final é igual a três, como dissemos no caso anterior. E então mudamos
a tensão de cisalhamento da cama. E então dizemos resultado. E então dizemos, é equivalente
ao tempo, tudo bem, que é menor que t. Então literalmente, a partir daí colocamos um ponto de
interrogação ali. Assim mesmo. E
colocamos o ponto de interrogação. Nós até temos isso aqui
onde dizemos, bom dia. Assim mesmo, até ponha um ponto. E não precisamos de um cachorro
necessariamente, é só que o meio
estava colocando um ponto. E então também poderíamos ter algo como
boa noite aqui. Mas apenas como uma string, porque é assim que
definimos isso. É uma corda. Tarde. Tudo bem? Depois
fechamos assim. Como você pode ver, não
há erro. Então isso significa a vida de Darwin. Eu entendo o que você está dizendo. E então eu coloquei uma impressão e um resultado
estranhos. Então, em vez de escrever
esse longo caminho, como você pode ver, isso
leva quantas linhas? 12345 aqui, três linhas. Provavelmente se perguntando por que nós, de
que adianta se ele faz a mesma coisa com o ponto? Bem, quanto mais você realmente
se
aprofundar em toda a codificação, verá que
às vezes é que você verá que
às vezes é que você cria milhares
de linhas que vê. Então,
às vezes é mais fácil se você puder encontrar formas
abreviadas dessas
linhas ou códigos, certo? Então, vamos ver de novo,
boa noite. Você vê isso? Então
aí está uma aplicação
da regra abreviada ou do operador ternário, certo?
8. Altere as declarações condicionais: Isso nos leva então
ao próximo ponto. Deixe-me colocar alguns comentários. Nosso próximo ponto
tem a ver com a
declaração condicional de switch. Alternar declaração condicional. Portanto, para essas
declarações condicionais, nós as usamos para selecionar um dos muitos blocos de código
a serem expressos. Como funciona é assim. Como funciona essencialmente
é assim. Aqui está um erro porque esse
cara deveria estar aqui embaixo. Sim. Sim, bom. Casa de assalto, que funciona
essencialmente. É assim, certo? O código de troca,
deixe-me colocar isso. Vamos fazer
alguns comentários aqui. O código de pesquisa. Em vez disso, a expressão switch
é avaliada, certo? Qual é o valor
da expressão é comparado
com os valores de cada caso. Tudo bem, então comparação dos
valores de cada caso
está feita, certo? Então também temos
se houver uma correspondência, por exemplo, se houver uma correspondência, teremos o terceiro estágio, que é se houver uma correspondência, o código será executado. E há algumas palavras,
palavras-chave como break. A pausa, usamos palavras-chave
como esta aqui, a quebra e o padrão. Essas são algumas palavras-chave que
usamos, essa é opcional, certo? E isso tem algumas
palavras-chave a serem observadas. E vou elaborá-los úmidos. Continuamos, certo? E a coisa chave a se notar
aqui é realmente, como veremos, particularmente agora
com um exemplo, isso
é realmente, essa é
realmente a veia principal. Então, um exemplo,
digamos que falemos sobre, ei,
eles são padrão, por exemplo,
ou melhor, o cinco e, de
preferência, cinco sobre quatro. E então falamos sobre um
switch e depois dizemos, dia, é assim
que fazemos a propósito. E vamos apenas abrir nossa declaração de que há declaração
condicional, nós a examinamos no
caso número um. E no caso número um, o que fazemos é
olhar para o caso número um. Podemos descer e
depois dizemos: Ei, este é o primeiro caso, depois imprimir segunda-feira, por
exemplo, os dias da semana. E se esse não for o caso, se, se o quê, nossa
condição não for uma,
portanto, você
não imprimirá segunda-feira. Vamos dizer ao Java
para sair desse loop
ou dessa condição no
caso aqui e chegar ao caso número dois e verificar um dois. Então, levando com
esses valores aqui, é tentar combinar esses valores aqui com o que
inicialmente temos ali. Então, ele virá aqui e me permitirá copiar e usar
isso para que eu possa fazer isso muito mais rápido e dizer que
será terça-feira, o segundo dia da semana. E no número do caso, quero dizer, definitivamente
vamos dar um tempo. Então, se você não fizer uma pausa, isso atingirá o diabo não entenderá
corretamente como
fazer corretamente ou o que
fazer nesse cenário. Você vê? Portanto, é sempre aconselhável usá-lo da seguinte maneira. Tudo bem, então temos um
ponto aqui esgotado. Temos um dia selvagem e
temos uma pausa. E temos kaizen antes
dado até quinta-feira. Com pausa. Sim. Então, como você pode ver
, definitivamente mais linhas
aqui Isso é muco com a especificação de um
monte de condições. Lloyd, caso número cinco, acho que provavelmente vou parar
no Kids número sete. Então, tenha paciência comigo aqui. Sexta-feira. É sexta-feira lá. E apenas
uma pausa para o café aqui também e caso, deixe-me copiar
tudo isso deve ser muito, muito mais rápido assim. Caso número seis e
caso número sete. E aqui é sábado
e domingo. domingo. Certo. Então, o que esperamos disso, já que estamos
verificando o dia ali, o que vai acontecer
é que o Java vai percorrer, verificar, pegar o número cinco e
examiná-lo com todos essas condições aqui,
é a condição 1234. E quando chega a
uma partida de cinco, como você pode ver, já está recebendo
um Metro cinco. Há cinco aqui
e há um cinco, se já está
destacado. Vai ser impresso na sexta-feira. Então, vamos executá-lo na sexta-feira. Tudo bem, tão lindo. Geralmente, é assim
que trabalhamos em torno de todo o código Java. Código Java inteiro quando se
trata de declarações condicionais, ou seja, declarações condicionais.
9. Loops Java: Tudo bem, então a próxima coisa
que vamos analisar é
o que chamamos de loops Java. Este é um loop Java, especialmente vamos
começar com os loops while, o que
significa que um grande
número de loops. Mas vamos nos concentrar
no ciclo while. E se repetem. Molécula como definimos
o loop em inglês, é algo que é quase, você poderia dizer, taxa repetitiva. Eles podem executar um
bloco de código
desde que a
condição especificada seja atingida. Eles são muito úteis
porque economizam tempo, reduzem os erros no código
principal mais legíveis. E o código Java
, seus mesmos textos podem ser vistos
da seguinte maneira. Então, deixe-me colocar
o comentário
aqui apenas para que
possamos incluir um comentário aqui. Veja, bom. Tudo bem. A sintaxe para isso
seria dada por, deixe-me tê-la
aqui embaixo para nós, a sintaxe será dada
pela condição while. Como você sabe, eu adoro colocar condições
entre parênteses assim. É meio que evitado e você sabe como usá-los
melhor. E, obviamente, vamos
abrir algo lá e depois temos
um código a ser executado aqui. E então vamos
fechar com esse cara aqui. Portanto,
isso significa que provavelmente é tudo o que você precisa e
basta fechá-lo ali. Tudo bem. Então, um exemplo disso
seria algo assim. Então, deixe-me dizer, por exemplo, int I é equivalente a um. E eu digo, eu dou uma
condição enquanto eu tenho menos de cinco
ou cinco anos, por que não? Isso é o que deveria acontecer. Sistema. Dot out, dot, print, print I. Tudo bem. Então, o que está acontecendo aqui? O que está acontecendo até agora é que
estamos dizendo ao nosso código que embora eu tenha menos de cinco anos, continue fazendo o seguinte. Continue mostrando o valor de I. E não pare por aí. Aumentar. E isso sou eu
colocando o aumento. Eu digo e plus plus. Eu digo um armário como esse. Continue subindo. Faça um incremento de
mais um a cada vez. Então Java pegará um, comparará com
cinco e verá que, ei, é menos de cinco,
então o que você fará, você pega o valor de
11 e imprime como um, e então desce e adiciona um a novamente e
depois voltar a dizer, agora eu tenho um mais um. Agora são dois. E é assim que demonstrar
que será um, depois um. Então você terá um mais um. E então você terá
um mais um mais um. E então você terá um
mais um mais um mais um. E então, finalmente, ele
vai parar por aí. Portanto, os valores que
você obtém essencialmente serão um mais dois mais
três mais quatro. Você vê isso? Então, vamos fazer isso para
nós e ver o que obtemos. Então aí está, 1234. Esses são os
valores que obtemos. E lembre-se de que a razão pela qual
paramos às quatro e não
vamos além ou gostamos de um cinco ou
algo assim. É simplesmente porque é simplesmente porque
dissemos menos de cinco. Se tivéssemos dito menos
ou igual a cinco, isso teria sido
diferente porque significa que cinco estão incluídos. Mas neste caso,
cinco não estão incluídos. Então, agora que é verdade, isso nos
permite ver a diferença. Você verá que chega a cinco. Vamos ver, dados
de um a cinco. Agora, você vê isso. Portanto, é apenas uma forma de contornar isso. Só um pouco de
cuidado aqui, por favor, lembre-se disso. Deixe-me colocar para você. Não se esqueça de
aumentar a variável usada
na condição. Não presuma, certo,
não assuma isso. Só isso por si só é suficiente para fazer com que o olho
continue subindo. Não, não é. Realmente não é.
E ele nem vai saber quando parar é o
seu risco de fazer um loop de fim, interminável, realmente me
deixe remover isso e
apenas encolher alguma coisa. Sim. Se eu executar desta forma, vamos ver o que está acontecendo aqui. Ele continua indo 111111. Por que ele faz isso? Ele continua fazendo
isso porque vai
se manter em um nível
infinito disso. É por isso que meu computador
está literalmente lutando para ver que
ele continua caindo. Eu posso até rolar para baixo ou para cima. Sinceramente, não posso. A única coisa que tenho que fazer
neste estágio é que agora posso fazer
isso de novo. E eu vou parar com isso
aqui também. Parei e executei novamente. A razão pela qual isso
estava ocorrendo, é porque está
pegando o valor de um e depois repetindo para verificar novamente contra
a vontade de um. E toda vez que ele fica pegando a Villa de um e
pegando aquele botão cinco, mas um é menos de cinco. Então, o que devo fazer? Eu deveria imprimir I, que é um. E isso me dá isso de
novo e de novo. Portanto, é um loop infinito. Ele continuará fazendo
isso. Isso simplesmente não vai parar. Então você precisa ter algumas
dessas condições
abaixo dela para dar, quando deve parar? Como ele deveria saber
que deveria parar? Espere. Então, quando você
dá esse incremento, você está dizendo para continuar subindo, continue subindo até
chegar à espinha, a afirmação aqui,
e isso é verdade. É quando você para. Você vê que é muito
valioso e muito importante entender
isso também, certo? E apenas junto com a condição
while é o que
chamamos de condição padrão. E apenas as quatro condições. Deixe-me apenas movê-los, colocá-los aqui. Linda. Portanto, a condição de quatro é silenciosa. Uma daquelas condições
que são
muito usadas e como elas
realmente funcionam, é assim. Deixe-me largar para você. Nós o chamamos de loop Java for. E usamos esse quando
você sabe exatamente quantas vezes você quer
passar por um bloco de código. Em vez de um loop while. While loop, se você não sabe, quando isso pararia, certo? Então, é como se você estivesse
colocando uma restrição. Mas para, você definitivamente
sabe o que é o começo, você sabe qual é o fim. E a sintaxe que usamos para
este é a seguinte. Realmente a sintaxe é a seguinte. Dizemos para mim, basta rolar
para baixo, vemos quatro. Colocamos a declaração um, declaração dois. E então colocamos a
declaração três também. Lembre-se de que,
no meio, estamos colocando
ponto-e-vírgula em vez de apenas vírgulas como essa. Colocamos ponto e vírgula. E então, como você sabe, nós sempre abrimos aqui e você
quer fechar também. E aqui só temos
um código a ser executado. Executado. Você provavelmente está
se perguntando, neste estágio o que é chamado de declaração1. O que significa a declaração dois, o
que faz
, o que significa tudo isso? Bem, o que se
trata realmente é
essa declaração um, o que ela faz é que é uma declaração que
realmente é executada uma vez antes da execução
do código de bloco ser executada. Uma vez antes da execução do código. Em seguida, declaração dois. Por outro lado, define o que
define a condição. Condição, define a condição
para executar o código. E então, finalmente, a
declaração três. declaração três é sobre, realmente é apenas o
último estágio que você poderia dizer executado após o frio significa
depois que o código foi
executado, é claro, certo? Então, um exemplo disso provavelmente seria
algo assim. Vamos ver se podemos
encontrar aqui e dizer,
pois x é igual a 0. Então dizemos a declaração dois. Dizemos que eu sou menor
ou melhor, não I, x é menor que sete. E então, finalmente,
ficamos tipo, Ei. Eu sou o x continua aumentando
da seguinte maneira, o que
significa que tem um incremento. E nós apenas abrimos
parênteses ali. E nós imprimimos, nós apenas imprimimos x. Então, apenas na previsão do que vai
acontecer aqui é que estamos essencialmente definindo
o valor de x começando de, de, de 0. Definimos que x é 0. Em seguida, damos a condição dizer enquanto x é menor que 0. E então continue
fazendo o seguinte. O que deve continuar acontecendo? Simplesmente continue adicionando um
porque é x mais mais, o que significa um incremento de um. Então, cupons passando, um
de novo, de novo, de novo. Então, o que Java fará é pegar o primeiro valor, verificar contra sete e ver
que temos apenas 0, certo? Então, a partir daí, ele
vai apenas de 0. Haverá um incremento
de 0 mais um. Então, novamente, continue
fazendo isso de novo, 0 mais um mais um. E então novamente 0
mais um mais um, mais um mais um, e assim por
diante e assim por diante até que vá vá até seis porque é menor que sete, não
deve chegar a sete. Então, é de 0 até seis. Então, isso significa que quando
executamos isso, devemos apenas ver valores
fazendo isso até seis. Lindo, aí está. Isso é exatamente o que
esperávamos que ele fizesse, e isso é exatamente o que
ele fez, certo? Então isso é simplesmente incrível,
isso é simplesmente incrível. Um exemplo em que você pode
definitivamente pensar ou apenas encontrar um valor
seria este aqui. Deixe-me comentar
isso e mas,
mas , mas, uh, certo. Basta comentar sobre isso e vamos considerar o
seguinte cenário. E se você tivesse, por exemplo, para o fim, eu definitivamente é hora. Adoro francês de mim. Muito bom. Eu digo que é menor ou
igual a talvez dez. E então eu dou
para o ato final de simplesmente subir por dois
em vez de explodir um. Você vê isso? Então agora eu estou subindo dois
e então eu digo saída do sistema, impressão LN e os gerentes
dizem, Ei, imprima i. E o que vai acontecer aqui é que você
provavelmente pode prever, é que vamos
ter o seguindo. Teremos 0 e depois teremos
um incremento de mais dois. Então, será 0 mais dois. Tudo bem? Espero que você já esteja
vendo onde isso vai dar. Vamos ser 0. E depois mais dois,
mais dois, tudo bem? O incremento é verdadeiro, não
é um, certo? Então isso significa nosso incremento. Cada passo será apenas por dois. Então, agora temos às seis. Ainda não é maior que dez. Então, finalmente, vai
parar aqui também, como dois mais dois mais dois. E descobrir que isso
é oito, certo? E o que ele
realmente vai fazer é
isso, é assim que vai realmente fazer. Agora, eu estou apenas dizendo a
vocês, em retrospectiva já não fiz
isso muitas vezes. Ele verificará e dirá 0
e, em seguida, verificará e definirá agora para registrar o valor de
true, imprimi-lo. Ele imprimirá um valor de 0,
imprimirá o valor de dois. Aqui ele imprimirá o
valor de dois mais dois, que é quatro aqui ele imprimirá o valor de dois mais dois
mais dois, que é seis. Aqui ele imprimirá o
valor de dois mais dois mais dois mais dois,
que é oito. E quando chega aqui, diz
que são dez. Ele executará a
varredura e dirá, espere, dez é dez menor
ou igual a dez. E então a resposta é sim. Na verdade é,
porque é igual a dois. Você vê isso? Portanto, ele também deve ser
capaz de assumir esse valor. Na verdade, eu não tinha visto que
coloquei um sinal de igual aqui, mas porque há
um sinal de igual, sim, ele
definitivamente se registrará. Isso é dez, então ele
mostrará 0246810. Então, vamos executá-lo e ver por
nós mesmos, há 0248610. E tenha em mente que
se eu remover o sinal de igual, ele vai parar em oito
vai ser 0 até oito. Lei var, isso é dados. É simplesmente incrível. Linda. O próximo que
definitivamente gostaria de examinar é chamado de Java each loop. Java cada loop, certo? E para
este, é assim que o temos como Java em cada loop,
é assim
que escrevemos cada um,
cada um a partir do inglês, na
verdade. Para cada grupo. Isso é para cada um, para cada um, não apenas
para cada um, pois cada um deve ser para
cada um o tempo todo. Tudo bem, então para este aqui, a sintaxe para isso é
realmente a seguinte natureza. Dizemos quatro e depois colocamos
o tipo de uma variável. E colocamos o nome da
variável aqui. E bem ali
colocamos um nome de matriz. E nós abrimos assim. E então simplesmente
temos nosso código. Aqui. Esse é um código a ser
executado como sempre. código a ser executado
está bem ali. E sim, só para ter em mente que você
precisa fechar isso, certo? Então lembre-se, você provavelmente
gostaria de ter algo
assim aqui. Tudo bem, muito importante. E, assim mesmo, vamos tentar ver
um exemplo disso. Digamos que tivéssemos uma string contendo nomes
de custos, certo? E deixe-me fazer isso porque meu teclado não tem isso
inerentemente, então eu sempre tenho que mudar meus votos principais
para fazer isso. Se você estiver em um computador ou em um Mac que não tem o, o lugar de muitos botões, você sempre pode simplesmente trocar de
teclado aqui. Lembra disso? Então? Sempre podemos ir
até os carros aqui. E só temos,
por exemplo, a Volvo. Poderíamos ter, por exemplo, BMW. Sim, você mencionou que
poderia ser VW, Volkswagen. Pode ser que os americanos
definitivamente adorassem este. Definitivamente poderia ser
talvez Honda, Japão. Então você também pode
ter isso. E então bem aqui, o que fazemos, o que fazemos? Bem, nós realmente não
abrimos isso nesta fase. É quando começamos a
usar os quatro que começamos a abrir
as coisas por enquanto, isso é apenas uma lista de ints, uma matriz contendo
uma lista de dados. Então é corda, corda I. Então dizemos cos. Sim. Em seguida, abrimos. Agora. Agora é definitivamente
a hora de abrir. E então dizemos system out dot print, por
exemplo, certo? Então, vamos apenas, isso significa,
portanto, neste cenário, vamos apenas executá-lo e
vemos lá o belo. Então isso significa que para cada uma
das coisas que
vemos em uma lista, listas
contínuas como essa, fomos capazes de
apresentar cada uma delas. Isso significa que o Java foi capaz de
passar por cada um deles. Como o java interpreta
isso é assim. É quase como se isso fosse
representado por um valor de 0. E então o valor
um, valor dois aqui. Mas se três valem quatro, e simplesmente fazendo isso, estamos dizendo
que é uma string. Imprima o valor um
e, em seguida, ele entenderá. Então, um é na verdade uma
corda e representa
, representa uma cadeia de Volvo. Então ele imprimirá Volvo, representado pelo valor de 0, e depois virá para um
e c1 é BMW e depois vem para dois e c2 como vw, e então C vem para
três e depois S3, S4, e depois vem para quatro. E C4 é um Honda, certo? Ben meu que eu comecei com
0 e é assim que em Java sempre a contagem começa
a partir de 0 e sobe. Isso não para por aqui e
o vê como um necessariamente
, ele o vê como um 0. Então, isso é apenas
outra coisa para se ter em mente e ver seu valor, assim como
ainda estamos neste tópico muito
interessante. Tópico interessante.
10. Java Break e Continue, arrays: Tudo bem pessoal, então a próxima
coisa que definitivamente
vamos querer abordar
terá a ver
com o que chamamos quebra e continuação do
Java. Então o Java quebra e continua, ainda faz parte do que ainda
estamos fazendo agora. Definitivamente, ainda faz parte disso. E o que
vamos fazer com isso, e você também verá. Para isso, já
vimos a declaração break usada em uma situação alienígena do que estamos
falando. E nós o usamos obviamente para saltar de uma
declaração de troca, certo? Podemos usar a instrução break para saltar de um loop também. Pule para fora do loop. E, obviamente, isso
vai ser um comentário. Tudo bem? E a melhor maneira de
demonstrar isso seria, digamos que você tenha algo
da seguinte natureza. Você deveria dizer “outono”.
E então você diria fim. I é equivalente a, digamos que seja equivalente a 0. E como você se lembra, sempre que você tem quatro, você
precisa ter três declarações. Então, deixe-me definir
mais algumas afirmações para mim aqui e ver o que posso
inventar. Tudo bem? Tudo bem, e assim por diante. E então dizemos, se E é
equivalente a quatro, certo? Quatro assim,
o que deveria acontecer? Então, deve haver um
salto para fora desse loop. Então, aí está. E então o que eu faço a seguir? Eu só digo system dot out, dot print LN, e
eu estou de olho ali. Tudo bem, então
vamos passar por aqui e ver o que
obtemos com isso. E pronto, aí está. Temos os valores
de 0 a três. E a razão pela qual isso
é, é porque simplesmente
dissemos nosso código aqui, nosso software, java para
fazer isso, comece do 0. E desde que
essa condição seja satisfeita por ter
um número menor que dez com
incrementos de um por vez. O que deveria acontecer? O
seguinte deve acontecer se eu for equivalente a
no momento em que eu chegar ao valor
de quatro e depois parar. Você vê o que o Java faz. Começa em 0, faz
isso e percebe que, hey, nós somos 0 é
definitivamente menor que dez. E então ele
imprime o valor de todos os cheques aqui também. Definitivamente ele vai verificar aqui e verificar e dizer que, Ei, eu sou 00 não é igual a quatro. Portanto, não há necessidade de
chegar a esse intervalo. Ele pulará e virá aqui
e imprimirá o valor de 0, e depois aumentará um e, em
seguida, pegará o valor de um, verificará com a tag e verá
se é maior ou menor que, e verá que é menor que. Aqui novamente, verifique
contra quatro e verifique se um é igual a quatro. E descobrirá, obviamente,
que não é igual a quatro. Então, o que ele fará,
ele saltará novamente, imprimirá o valor de um, e assim por diante, até chegar ao local
de, de, até chegar
ao valor de quatro. Quando chega
ao valor de quatro, seguir ainda está
satisfeito, certo? Mas quando ficar odioso, veja que quatro é igual
a quatro e depois neutro. Então, portanto, eu vou quebrar. Ele vai parar aqui e um virá imprimir
esse valor aqui. Você vê isso? Portanto, não haverá necessidade de imprimir esse
valor aqui. Mas se eu
dissesse, por exemplo, se eu fosse remover ou se eu
tivesse essa impressão aqui e apenas dissesse se
deixe-me imprimir isso aqui. Se eu fosse imprimir isso
e defini-lo em quatro aqui, ele deveria imprimir o valor de I. Definitivamente registraria o valor de quatro que
estava lá, certo? Mas sim, definitivamente
faz sentido. Espero que agora. Então
vamos continuar e depois falar sobre isso. Aí está nosso comentário ali. Então, a próxima coisa sobre a
qual queremos falar é definitivamente a continuação do Java. Eles andam de mãos dadas. É uma pausa e continua. Portanto, a
instrução contínua quebra uma iteração no loop. Se uma condição especificada
ocorrer e continuar com a próxima
iteração no loop. Então, é quase como se estivéssemos
pulando aquela área que talvez estivéssemos procurando obter. Por exemplo, no próprio
problema que temos aqui, as várias situações
que temos aqui. Vamos apenas copiar e
colar aqui. Em vez de eu fazer
uma pausa aqui, se eu tivesse colocado
talvez continue? Qual é o efeito? Foi o efeito de
definitivamente continuar por lá. E há um pequeno problema, como você pode ver com
meu código aqui. Está tudo bem agora que executamos isso. E agora não 0123, não
há falso. Nós pulamos para 56789.
Você vê isso? Isso porque dissemos que quando quatro é
igual a quatro, contíguo, significando ignorá-lo, não
há necessidade de imprimi-lo. Basta pular e
voltar a isso também. É por isso que ele pula o
valor de quatro ali. Então, essencialmente, é
assim que o continue funciona. Pessoas incríveis. Então, a próxima coisa que
queremos ver é provavelmente uma das mais essenciais quando
se trata codificação que tem
tudo a ver com o que chamamos de matrizes, matrizes java. Então deixe-me
largar isso para você. Matriz Java. É isso, certo? E com matrizes Java, usamos matrizes
para várias coisas. Honestamente. Podemos usá-los para,
por exemplo, armazenar, armazenar vários valores
em uma única variável. Essa é a beleza disso. Renderizar pode parar. Por exemplo, ele pode armazenar
uma coleção de carros, coleção de diferentes
pessoas, alturas, todos os tipos de estatísticas,
realmente você pode
mantê-los e armazená-los
em uma categoria, talvez a altura das pessoas. e cores
diferentes que você vê. Portanto, a principal coisa a saber é que quando você deseja declarar uma matriz, você precisa primeiro definir o tipo de variável
com colchetes. E como você faz isso? Bem, essencialmente, você
apenas faz assim. Obviamente, vou
dar um exemplo, mas só quero ajudá-lo a se
familiarizar com a sintaxe. Eu tenho meu quadrado aqui. Deixe-me trocar o teclado
e ele está aqui. Deixe-me abrir. Isso
eu posso copiar e colar de alguma forma que eu sei porque
eu já tinha usado isso, acredito que hoje em algum momento. Não, eu não usei ainda. Não tem problema. Vamos
dar assim. E deixe-me ver no meu teclado onde posso encontrar uma
maneira de fechar isso. Então, sim, esse é
o que está bem aqui. Tudo bem. Lindo. Tudo bem. Então,
vamos assim também. Excelente, excelente. Então, se você estiver em uma
situação como a minha que não tem muito o que
explorar no teclado. Você sempre pode usar esse fundo de sinalização
visual com ele. E então você tem carros, certo? E é uma série de carros. E com essa série de carros, na
verdade, você pode armazenar quantos carros
quiser lá. Porque quando fizemos isso, agora
declaramos
uma variável que contém uma matriz de strings
para ints adicionar valores a ela. Podemos apenas usar um literal de
matriz e reproduzir os valores em uma
lista separada por vírgulas dentro de colchetes. Como fazemos isso? Bem, agora
vem o exemplo. Então deixe-me gritar
e dizemos corda. Deixe-me literalmente pegar este exemplo, deve ser
mais fácil de fazer com o que eu já tenho carros de tensão e depois não mudei
meu teclado. Incrível. Então, screencasts e depois
dizemos que é uma ferramenta equivalente. E então vamos colocar
nossos carros ali. Poderíamos ter, por exemplo, Toyota, Ford dos meus amigos
americanos. Mas, como você pode ver, está em vermelho. Por que está em vermelho? Porque não está identificando como uma string. Então, precisamos colocar essas
aspas ali. Incrível. Então aí está. Aí está. E então
poderíamos ter Toyota, poderíamos ter FADH, poderíamos ter Ferrari,
nossos italianos. Poderíamos ter um Mercedes Benz. Poderíamos ter quantos
carros quisermos, mas acho que isso será
suficiente por enquanto, na verdade. E pronto, é tão
simples quanto isso. E isso funciona não
apenas para objetos
orientados a cordas , é claro,
ou assuntos de cordas. Também poderíamos fazer isso
um pouco para números inteiros, ou seja, para valores
também, certo? E como fazemos isso é simplesmente
fazendo isso, apenas indo para a string, vamos apenas copiar isso. E nós temos int. Agora temos isso e
depois dizemos meu número. Podemos declarar a
variável Nino assim. Em seguida, abrimos e começamos a
armazenar valores de dez a 20 a 30 a 40. Cabe a nós sermos tão livres e exploradores quanto
quisermos ser, certo? Então isso é uma coisa legal. Começamos todos esses valores em um só lugar, meus números, certo? Então, digamos que, por exemplo, você queira acessar elementos
dessa matriz, certo? Deixe-me escrever
isso para nós. Acessar elementos da matriz. Como faríamos isso? Bem, fazer isso, ou teria que fazer
é, por exemplo, digamos que eu quisesse
acessar elementos
dessa matriz aqui,
essa é essa área. Como eu faria isso? Bem, tudo que
eu tenho que fazer é
apenas dizer system out dot print LN, preferência como
imprimi-los dessa maneira. E depois
selecioná-los como custos com nossos elementos aqui e n aqui. Entre meus dois
quadrados ali. O que eu faço é escolher
o que mostrar, certo? Lembre-se de que quando Java sabe disso, ele conhece este S. Este
S corresponde a 0, o conjunto S corresponde a dois como um em vez disso
corresponde a, isso corresponde a três, e assim por diante e assim por diante. Você vê que se eu
dissesse, por exemplo, 0, o que o Java obtém disso é, eu preciso imprimir o primeiro
cartão que eu encontrar, certo? Porque começa a contar do oral para começar a
mostrar as saídas de 0. Então, vamos lá. Deveríamos ver um Toyota voila. Ou seja, temos
um Toyota, certo? Se eu dissesse três, por
exemplo, três
significa que se isso é 0, este é um, isso é dois,
isso é 33 deve ser curvas. Então, vamos executá-lo e ver se conseguimos dobrar, de
fato, vencimentos. Sim, incrível. Mercedes Benz De fato, certo? Então, digamos que talvez
você queira fazer isso. Você quer mudar, digamos que você queira talvez
mudar um elemento de matriz. Um elemento de matriz. Como você faria isso? Bem, para alterar
um elemento de matriz, você só precisa especificar o elemento que
deseja alterar, certo? Então, por exemplo,
digamos que eu queria
mudar a Ford, tendo
muito por hoje. Então, vamos mudar isso
apenas para o empréstimo. Então, digamos carros e
depois selecione lutado, qual deles está em 123 ou quatro. Na verdade, não há força
10123. Então, vamos escolher o
primeiro, que é 01,
que representa
lutado, e depois dizer Carros 01 e depois
substituí-los por. Que tal o Aston Martin? Quanto ao Martin? Aston Martin, a ideia benigna e
desviante de
um pouco fã de carros,
realmente carros esportivos. Ou seja, poderíamos ter um replays à frente com
um Aston Martin, certo? Então, no momento em que
temos isso, tudo o que temos que fazer é simplesmente
imprimir o câncer novamente. Então, poderíamos apenas dizer,
em vez de imprimir tonelada número três, que
tal isso? Que tal eu pegar esse cara de novo e colocá-lo aqui agora depois a mudança aconteceu e
apenas registrar isso como kirwan. Isso porque
costumava ser combatido lá. Mas isso mudou. Tornou-se uma montanha de pedra. Portanto, devemos ter
nossos estômatos agora, Aston Martin DB nove. Então essa é a beleza disso. Agora você provavelmente está se perguntando
por que eu tive que mudar isso. Bem, vamos dizer que
foi y t Na verdade, digamos que alguém está bem aqui. Vamos executá-lo e depois
veremos o que vai
acontecer lá. Ele lutou de novo. Por que isso? Isso porque é Java. Está lendo o código aqui. Começa linha por linha. Isso é de 187188. Então, na medida em que 188
ou 1921 são encontrados, quando eu digo a ele para lançar e me dar o
valor que um tem aqui,
ele está avançando
porque ainda não foi compreendido ou melhor, recebeu informações que
isso deveria mudar. Essa mudança só
acontece na linha 194. Então é por isso que eu tive que
fazer o que fiz e apenas colocar
isso aqui em baixo para que, quando eu executá-lo, agora ele
entendesse que em 1 antes
havia uma mudança. Agora Cao Huan significa e Aston
Martin de ser nove, certo? Então é assim que fazemos se quisermos
mudar no elemento ROE. Mas e se quisermos
determinar, o quê? E se quisermos
determinar o comprimento de uma matriz, por exemplo, por um
motivo ou outro, é
possível quando é possível que você
queira descobrir quantos elementos
existem em uma matriz. E para isso, tudo o que você
precisa fazer 3D é usar a propriedade length. E como usamos
a propriedade length? Bem, faça isso. Então, deixe-me usar a mesma
coisa que estamos usando aqui, o sistema que pensava. Então, eu vou apenas vir aqui. Em vez de imprimir
carros assim, vou dizer carros
e o comprimento, certo? Então, quando eu faço
isso, ele deve me dizer quantos elementos existem. Tenha em mente. Não está contando a partir de 0123. Não, não, não. É contar quantos valores estão
em primeiro lugar. Está contando 0 e x1, passou para um, S2, S3 para S3, e seu
conteúdo três é quatro. Então, portanto, ele deve produzir quatro elementos estão
na matriz, certo? Porque eu estou perguntando
quantos elementos existem nas áreas onde diz
quatro elementos em diarréia, o que é verdade, é
1234, portanto, certo? Então é isso que eu
espero que isso definitivamente ajude.
11. Loop de matriz Java: Então, a próxima coisa que
queremos ver é o que chamamos de Java. O loop de array Java é definitivamente algo
que queremos analisar agora. E podemos percorrer nossos elementos de matriz com
um ciclo de custos. E podemos até usar a propriedade length para especificar quantas vezes
o loop deve ser executado. Certo? Então, vamos pensar, por exemplo, na mesma, mesma situação em que
temos nossa corda aqui. Digamos que, por exemplo, queríamos apenas fazer um pequeno
loop por lá, certo? Apenas tente ficar sem
um pouco de loop. Então, o que poderíamos fazer é isso. Poderíamos pegar isso aqui e colocá-lo onde eu
possa acessá-lo facilmente, especialmente este, este
primeiro sobre os carros, S1 sobre a causa. Tudo bem, deixe-me tentar escrever de novo. Eu mesmo. Logo aqui. Tudo bem. Aqui, o braço, a causa. Então aqui está o nosso Novamente, deixe-me reescrever isso de novo. Eu acho que ele
se excluiu java array loop. Então, digamos que eu tenha
o seguinte. Digamos que eu tenha uma corda e também tenha
o seguinte. Este treinamento ao lado disso, eu tenho a seguinte
sequência com carros e deixe-me colocar este agora entre parênteses porque eu não
preciso mais disso realmente. Então, eu vou descer
daqui e mover este. Agora. Mova isso um
pouco do trabalho que está acontecendo aqui, mas deve ser feito em um minuto. Tudo bem? Então, o que eu faço agora é apresentar um
pouco de um loop aqui. Eu digo int I é igual a 0. E aí eu
digo que tenho menos custo. E então eles são
longos, é claro. E então, eu
só digo que eu mais, mais. E eu abro isso
para usarmos. E quando eu abrir,
bem assim, vou
imprimir e colocar
esse método de impressão aqui
apenas para esse método de impressão aqui que eu possa
descobrir o que realmente está
acontecendo aqui. Agora, desta vez,
definitivamente não vou imprimir em termos de comprimento do carro e em vez usar o E que já
foi colocado ali. Mas eu definitivamente vou
querer colocá-lo
também em meus quadrados porque é uma matriz da qual
estamos falando aqui. É uma matriz, então não
queremos perder isso de vista. Então esse é o meu olho
e está pronto. Vamos analisar isso e ver
o que inventamos. E eles são, temos os seguintes elementos. Temos Toyota, temos Ford, temos, temos bandas, certo? Então, em essência, o que
dissemos aqui é que
usamos essa técnica
dessa propriedade length para
poder imprimir
tudo o que está lá, desde que
não exceda o seu próprio eu, como contanto que não
saia de sua lista de matrizes , isso deve
continuar acontecendo. Certo? Então, por outro lado, também
poderíamos falar
sobre como usar R at, como olhar através, um,
através de um array com quatro cada, com um para cada declaração, se você quiser escrever o para cada loop, se
você quiser, certo. A sintaxe para isso definitivamente ocorre
da seguinte maneira. Simplesmente fazemos isso. Poderíamos dizer que, com
letras maiúsculas, cancele quatro. Em seguida, escrevemos o tipo de qualquer variável com a qual
estamos trabalhando. E depois há uma
variável aqui. E então nós apenas
mantemos o nome do
array, o nome do array também. Bem aqui, sem espaço no meio. E abrimos o que quer que
queiramos lidar. Você vê isso? Obviamente, não
precisaremos fechá-lo também. Então, um exemplo disso
seria perguntado fazendo o que, por exemplo, ainda usando
exatamente a mesma coisa. Deixe-me colocá-los no Commons. Coloque isso em comum. Certo? Então deixe-me pegar
isso, tudo isso. Definitivamente, vamos
usá-lo aqui novamente. Então, digamos que temos a mesma
sequência de custos aqui. Então, o que poderíamos dizer
é que poderíamos dizer para este trem eu sendo a sintaxe dos custos
com a causa lá também. E também
abrindo nossos colchetes, temos sistema dot out, dot, print LN, print LN. Então podemos simplesmente
imprimi-lo, por exemplo. Podemos simplesmente imprimir
eu assim mesmo. Em seguida, tentamos executá-lo. E vamos ver o que obtemos. Nós inventamos a
mesma coisa, certo? Então, é realmente apenas um método de, você poderia dizer que eu sou uma questão
de técnica, se você quiser. Definitivamente, você pode
usá-los tão livremente quanto
quiser, é apenas uma questão de técnica
e preferência sobre como você
prefere que seu código se pareça. Então, a próxima coisa que
vamos ver, deixe-me colocar isso no Commons. A próxima coisa que definitivamente
estamos
analisando é chamada de matriz
multidimensional e
multidimensional Java multidimensional . Array multidimensional Java, certo? E para este, você só precisa
ter em mente que para criar uma matriz
bidimensional, você precisa adicionar
cada matriz dentro seu próprio conjunto de chaves. A sintaxe disso
seria algo como int. E então deixe-me pegar
esse aparelho também aqui. Deixe-me fazer isso. Ótimo. Sim. Meu ônibus numérico, por exemplo. Então nós dizemos, nós igualamos
isso e depois colocamos isso em suas próprias chaves. Portanto, seja muito
cauteloso, pois isso
terá dois eventos, seja 1234. Então, há quatro aqui. Vamos parar aqui às quatro. Então, deixe-me copiar esse cara
e colá-los aqui. E depois dizemos coma porque ainda
continuamos. E nós abrimos. E então você diz
567, por exemplo. E então
fechamos assim. E não apenas uma vez
, mas na verdade duas vezes. E então nós trancamos
assim, certo. Então, esse é um exemplo disso. Se eu fosse
tirar isso dos seus comentários só para que você pudesse ver se ele é reconhecido pelo java. Vamos,
deixe-me tentar fazer isso
e você pode
conferir por si mesmo. Então aqui está, Aqui está bem aqui. E nós terminamos aqui. E nosso aparelho aqui, A2, B2. É por isso que estamos tendo
uma flecha ali. Então, lá estão eles. Cada um, você poderia dizer que cada
um representa sua própria coisa e ver que
este representa esse. Este aqui representa esse
aqui. Você vê isso? Então, essa é essencialmente a
sintaxe. Essencialmente, essa é a sintaxe.
12. arrays multidimensionais: Portanto, vale a pena notar que agora que está dessa
forma,
isso significa que os números desta mina aqui são agora uma matriz com duas matrizes como
seus elementos, certo? Para acessar os elementos
da minha matriz de números, você precisa especificar dois índices, um para a matriz e outro para o elemento dentro da matriz. Então, o exemplo que eu poderia dar para isso
seria algo assim. Por exemplo, digamos que
usamos exatamente a mesma coisa
que usamos aqui. E então nós deveríamos dizer int
x é igual a dois meus números. E eu deveria dizer,
por exemplo, um. Deixe-me tentar copiar
isso para que eu possa ser
muito, muito mais rápido. Eu quero colocar isso
nessa pergunta? Em vez disso, vou copiar
isso é o que eu quero. Isso é o que
eu sou porque preciso especificar. O primeiro que estou
especificando é o array. E então o segundo que estou especificando é a
posição na matriz. Você vê que a
matriz e, em seguida, a posição na
matriz, é ela mesma. Então, digamos que eu deveria
especificar algo como 12. Sim. Então, ao especificar 12, o que realmente está acontecendo aqui? O que eu sou? O que estou
realmente dizendo aqui, certo? Então, ao especificar um aqui, este é o que
esta primeira chave aqui, ou melhor, quadrado aqui, contém informações que nos
dizem sobre qual, em que área estamos, estamos na matriz 0? Lembre-se, esta é uma
matriz 0. Lembre-se de que este é o nosso a 0, ou estamos na matriz um. Você vê isso? Então este é o nosso a 0,
este já é um. Isso é no que diz respeito a
isso. O segundo quadrado
aqui contém informações sobre agora que estamos
nessa matriz. que posição exatamente
estamos nos
referindo para extrair nosso
elemento do mar?
13. Loop “for”: Então nós
continuamos assim e dizemos system dot
out, dot, print n. E imprimimos o valor de x porque é apenas avaliar, é apenas um valor fora disso, apenas verificando se não
tem mais alguma coisa lá em cima. E nós imprimimos aqui. Portanto, prevemos
que se eu vender 12, isso significa 01. Prevemos
que estaremos aqui. A posição dois por
centróide é 012. Prevemos que isso
nos dará um valor de sete. Então, vamos analisá-lo e ver que
sete dias é lindo. Ou seja, então são
sete ali. E também podemos usar um loop for dentro de outro loop for para obter os elementos de uma matriz
bidimensional. E, claro,
ainda temos que
apontar para os índices do 2x. Definitivamente, ainda
preciso fazer isso. Um exemplo disso seria,
digamos, usar for-loop,
usar acompanhamento, certo? Então, um exemplo disso provavelmente
seria, teria que especificar e criar um método aqui e
dizer, chamá-lo de público. Eu só quero verificar em
que método estamos. Já estamos no vazio
estático público. Então, isso já está bom. Exceto que o que
vamos fazer é vir
até aqui de novo. E, simplesmente, não
precisamos especificar o método porque
já o temos lá em cima. Então, só vai ser o fim. E copiamos nosso final aqui novamente. E em vez de
escrever tudo isso, eu poderia simplesmente copiar isso. Deixe-me copiar e colar ali mesmo e dizer meus números. E em vez de apenas meus números
ou colocá-los como um aqui, apenas para diferenciá-lo
do cenário anterior
que tínhamos. E o que vou fazer
também é dizer que para int eu é igual a 0, eu sou menor que o meu
número um, certo? Porque esse é o
particular ao
qual estou me referindo. O comprimento deles.
Lembra desse comprimento? Significa exatamente isso. É com o comprimento. E então fazemos
um incremento de I. Então aí está. Temos um incremento de Iowa. E abrimos nosso loop
for aqui. Em seguida, adicionamos outro
loop for bem aqui. E dizemos que int j é igual a começar de 0 também. E dizer 0 em vez de diferente de zero. Eu prefiro usar j diferente de zero. Meus números de novo,
comprimento de ponto. Na verdade, não terminei. Comprimento do ponto. Deixe-me colocá-lo
assim em vez disso. Vamos voltar. E eu vou pegar isso aqui menos dois quadrados aqui
e colocá-los aqui. Então eu tenho meus dois, meu quadrado, apenas um deles e por favor, meus olhos bem ali. E esse é o comprimento
que estou procurando. Esse é o comprimento
que estou procurando. E continue
subindo com j de verdade, continue subindo com j de verdade. E para cada um desses cenários, preciso
imprimir valores aqui. E, em particular,
imprimir aqui meus números e
tê-los em termos de I e j, normalmente deve
funcionar assim. Então, vamos analisá-lo e
ver o que obtemos isso e
entender melhor o que está
acontecendo aqui, certo? Portanto, é realmente apenas uma
situação em que estamos tentando deduzir ou criar todos
esses valores daqui. Então temos um int e
depois guardamos para o fim, pelo que é porque
essencialmente o que estou dizendo? Estou dizendo, contanto que i, que representa a média da área, Lembre-se da matriz 0, da matriz um. Desde que seja
menor que seu próprio comprimento, seja, ele tem um comprimento de
um de 0 a um, certo? Então isso significa que ele pegará
o primeiro 0 e virá aqui. Como 0 é permitido aqui, definitivamente
é menos de um. Então ele virá aqui e imprimirá o que está
acontecendo aqui. Imprima o que está acontecendo aqui. Na verdade, o comprimento aqui, mente
urbana É na verdade dois porque é o
comprimento disso, é 12. Então vai levar 0, verificar e ver que 0 é
definitivamente menor que dois. E siga em frente para dizer
isso e quanto a j? J é igual a 0. E então digamos que j é menor que, j é menor que três,
como você pode ver lá. Para j, quantos elementos? Eles no dia em primeiro lugar. Então, para j, na
verdade, não são três elementos. Vai ser 1234567. Então, serão
sete elementos lá. Então, ele vai apenas pegar
e armazenar esse valor de 0. Então, deixe-me colocar um
comentário aqui só para que você possa ver melhor. Então, vai demorar, como eu disse, apenas pegue o valor de 0. Em primeiro lugar,
teremos um 0, certo? Então contra esse 0, ele vai
rodar e pegar outro 0, certo? E então ele virá. E deixe-me copiar isso. Imprima o valor
que corresponde a
isso e 0 vírgula 0. Obviamente, isso
vai nos dar um. Então ele virá e
causará um aumento de forma. Isso causará um aumento na
medida em que J for consentimento, certo? Portanto, isso só
causará um aumento consentimento
dos salários, então será 01. E, portanto, 01, como
você pode ver,
é 0, está nesta matriz, um, significa verdadeiro aqui,
então vai ser dois. E então chegamos aqui, dizemos: “E quanto a três? Aqui? Agora serão dois, o que aqui fará três, como podemos ver aqui, e assim por diante e assim por diante. Provavelmente posso presumir que
você já viu um pouco de um padrão aqui que está
definitivamente surgindo. Então, deixe-me mudar
esses valores para nós. Então vai ser três aqui, vai ser quatro aqui. Vai ser quatro aqui, vai ser cinco aqui. Então aqui
vai ser cinco aqui, levando a seis aqui. E então aqui
vai ser seis aqui, levando a sete aqui. Agora, por que isso acabará,
e a propósito, quando ele se levantar para me
deixar ver 0123 aqui, normalmente aqui
vai mudar. Vai ser bastante um. E então,
porque agora está neste conjunto, e então ele vai procurar
a posição aqui e começar de novo a partir de 0, certo? Então, vai ser assim. E então aqui
vai ser um. E então aqui
vai ser novamente um. Então aqui vai
ser agora um, e então aqui agora
vai ser dois, certo? Então, essencialmente, isso é o que acabará por
nos dar todos esses valores. Se você tentar
localizá-los você mesmo, precisaremos de uma caneta ou
lápis e papel. E tente localizar 00. Você verá que é um
01, é 2023034105116127. Você vê isso? Então,
essencialmente, é assim que está realmente dando sentido
ao que está acontecendo. Certo, bem aqui, certo, certo, bem aqui, certo? Então, o que vamos fazer a seguir é apenas
passar para a próxima área, passar para a
próxima coisa realmente.
14. Métodos: Tudo bem, então a próxima coisa que definitivamente
examinaria é, tem a ver com métodos Java. Provavelmente a coisa mais
importante que você
encontrará ao fazer Java. E para entender corretamente este, vamos
definir o método de água doce é um método simplesmente é um método
é apenas um bloco de cadeia. Esse bloco de cadeia, ou um bloco de código que só é executado quando está frio, certo? Então você chama isso, então você
definitivamente pode fazer uso disso. Assim, você pode passar dados conhecidos
como parâmetros para um método. E os métodos são usados para realizar determinadas ações e também são
conhecidos como funções, certo? Certo. Sim. E por que
quereríamos usar métodos? Você provavelmente está perguntando por quê. Bem, a verdade é que é só
para reutilizar o código, na verdade. Reutilize o código. Defina
o código uma vez. E você o usará
quantas vezes quiser. Quantas vezes você quiser. Tudo bem? Então é isso, certo? E a principal coisa que você provavelmente está se perguntando
agora é, portanto, como criamos um método? Para que um metal
seja criado, ele deve primeiro ser
declarado dentro de uma classe. E é definido com
o nome do método, seguido pelo
parêntese, é claro. E, claro, o java fornecerá alguns métodos predefinidos, como system.out.print,
line como você conhece. E, mas você também pode criar seu próprio método para
realizar determinadas ações. Um exemplo disso seria, digamos que você quisesse
criar um método dentro do main. Então, o que você faz é
apenas dizer,
vamos ver, vamos até aqui
e colocar tudo aqui nos comentários
porque não precisamos disso. Certo, certo, bem aqui. Em nossa classe pública, nós apenas, em vez
de torná-la pública, vamos apenas torná-la
uma classe estática
da seguinte maneira e
depois chamá-la, chamá-la. Vamos chamá-lo de MyMethod. É mais fácil chamá-lo
assim como o método principal do MyMathLab. E meu método,
isso é o que é. É apenas nosso próprio método, certo? E com isso, nosso próprio método, o que eu vou fazer é que eu preciso disso, porque deixe-me colocar
esse cara bem aqui. Certifique-se de que tudo
esteja sob comentários e que não haja erros que
coletamos aqui,
especialmente aqui. E aqui. Não precisamos
de nada disso, certo? Certo. Excelente. Então, agora que
o temos dessa forma, vamos chamá-lo de nosso método. E então, literalmente, aqui poderíamos ter puxado para ser
executado, certo? Isso é o que precisamos executar. Então, um exemplo disso seria, digamos que você quisesse escrever algo
transbordando da natureza. Por exemplo, digamos que
você queira dizer, hey, system dot out, dot print LN. E então você disse: “
Ei, isso é divertido.
Esse é um, certo? Então ele continuou dizendo isso. Então deixe-me diminuir
essa distância aqui. Eu geralmente prefiro
assim para que eu possa saber exatamente o que
estou fazendo certo? Então eu poderia, alternativamente,
apenas pub, public, static ,
void, main, e definir
minha string aqui. Minha corda bem ali. Deixe-me só, eu preciso de alguns
quadrados ou pegá-los daqui. E pegue meus quadrados aqui
e coloque meu barbante assim. E eu sou assim, vou chamar isso de RGS. Você sempre pode colocar isso
na frente ou atrás. Na verdade, não é grande coisa. Defina o que quer que
eu esteja tentando executar. Então eu vou dizer. Meu método termina. Aqui. Como você pode ver, o Java
realmente reconhece que eu posso executar isso, e quando eu o executo, ele deve
apenas dizer, este é um. Esse é um. Por que os suecos estavam executando isso e é essencialmente justo, ele entendeu que
isso é um método. Quando ligo para isso, estou pedindo que isso
seja feito, certo? Então imagine que eu fosse
apenas fazer isso e colocar
isso aqui mais isso, mais isso, mais isso aqui. E é como literalmente usar a mesma coisa de novo
e de novo e de novo. Então, cada vez que
ele liga de novo. Este é um, este
aqui, este não. Então eu posso usá-lo
quantas vezes eu quiser. E, obviamente, este é
um exemplo muito Lee, mas ajuda a
provar a você que um método pode ser chamado várias vezes sem
nenhum problema, certo? O que é muito útil. Mais adiante, vamos em todo
o aspecto dos
métodos e tudo o que você vê. Então, apenas informações
podem ser passadas. Dois métodos como parâmetros, e parâmetros atuam como variáveis
dentro do método, na verdade. E os parâmetros são
especificados após o nome do método e
dentro dos parênteses. E você pode adicionar quantos
parâmetros quiser. Basta separá-los com uma vírgula. Essa é a coisa mais importante. E então este exemplo que
estou prestes a mostrar a vocês tem um método que usa uma string chamada Eu sou F9 como parâmetro. Por exemplo, quando o
método é chamado, passamos um
nome que é usado dentro de um método para
imprimir o nome completo. Então, vamos direto ao assunto
e ver nós mesmos, certo? Então, digamos que
temos um vazio estático público
e, em seguida, temos uma string aqui. Nós o chamamos de fname,
como eu acabei de dizer, nome
F
significa literalmente o primeiro nome, certo? Então aqui vamos apenas dizer fname. Vamos ligar de novo. E mais execuções de
referência. Quando eu fizer isso, eu
posso vir para o meu vazio estático público aqui. E agora ainda especifique-o porque eu deveria especificar o que está
acontecendo, o que aconteceu aqui. Então eu preciso dar
nomes, por exemplo, Tom, Tom lá dentro. Mas lembre-se de que Tom é uma corda. Então eu deveria tê-lo.
Tom como uma corda. E aí está, já o está identificando como uma corda. E então aqui também, Lindy. Lindy, sim. Então aqui eu tenho o Sam. E então aqui eu tenho Rob. E então aqui eu tenho Lincoln. E sim. Então, se eu executar isso e
digamos que isso é uma maldade, literalmente mencionando tudo
isso para uma família. Então, deixe-me dizer que é uma família de
Thompson enviando Thompson. Eu tenho, portanto, Tom Thompson, Linda Thompson,
Sam's, Thomson's, Rob Thomson's e
lamber Thomson's. Agora você provavelmente está dizendo, ei, o que eu queria adicionar espaço
entre eles, sem problemas. Você sempre pode
fazer isso colocando, colocando isso aqui. E quando você faz
isso, deve ter um
pouco de espaço entre eles. Deixe-me colocar assim. E voila aqui. Tom Thompson era Linda Thompson. E às vezes é
tudo uma família se você quiser uma grande família. Tudo bem? Portanto, tenha em mente que quando um parâmetro é passado
para o método, ele é chamado de argumento. Então, a partir do exemplo que
acabei de dar aqui, fname é um parâmetro, enquanto esse nome é Tom Lindy, Sam Rob Lincoln, ou argumentos, você vê que eles são
apenas argumentos. Tem o mesmo mesmo
mesmo em matemática, o que quer que esteja entre parênteses,
chamamos isso de argumento. E lembre-se de
que você pode ter quantos parâmetros quiser. E apenas diga que
para cada um deles, eu queria especificar
também que ei, eu quero saber a idade deles para que
eu pudesse até colocar a idade aqui. E pela primeira vez que eu fizer isso, eu preciso colocar uma vírgula
e dizer que Tom tem 12 anos. Por exemplo. Lind é a mais antiga. Ela tem 28 anos. Sam tem 20 anos. Rob está em algum lugar entre 25. E Lincoln é só para sim. Então, se eu executar
isso, agora
também vai mostrar a idade deles. Tudo bem. Agora
também vai mostrar as idades. Agora, como você pode ver, ainda não está mostrando que
é por isso? Por que isso? É porque eu não
especifiquei aqui isso, Ei. Eu também quero os agentes, certo? Então deixe-me dizer isso mais,
mais e H dias de idade. Então eu poderia até dizer que talvez adicione uma string que diga
algo como os dados são. Então eu digo isso h, Então vamos executá-lo. Aí está. Tom
Thompson está instalado. Então isso é alto, 828 frases são 20. Rob Thompson tem 25 e Lincoln Thompson
tem quatro anos. Então essa é a beleza disso. E você só precisa ter em mente que quando você está trabalhando
com vários parâmetros, o método carvão deve ter o mesmo número de argumentos
que eles são parâmetros. Os argumentos devem ser
passados na mesma ordem. Portanto, também podemos ter
alguns valores de retorno. Portanto, tenha em mente que quando falamos sobre valores de
retorno aqui, usamos o teclado vazio , usamos em, usamos nos exemplos acima. Isso indica que o método não
deve retornar um valor. Se você quiser que o método
retorne um valor, você pode usar um tipo de
dados primitivo, como um final ou um chuveiro
em vez de vazio, e usar a palavra-chave return
dentro do MathLab, certo? Um exemplo disso seria, digamos que temos
algo assim. Deixe-me ver. Vamos colocar isso nos comentários aqui. Não precisamos desse. Então, em vez de vazio estático, o que eu vou fazer é
apenas dizer static int. Você vê isso? Então, quando digo static int, significa que tenho certeza de
que quero trabalhar com ints, se você
entende o que quero dizer. Então eu posso apenas fazer isso
e apenas dizer int age. E aqui ao fazer isso, o que estou dizendo é
que estou dizendo que, Ei, eu também quero que você
retorne minha idade. Tudo bem? Então eu quero que você retorne a idade. Poderia até dizer que a idade mais um número de exemplos
é mais sete. E pode, pode
definitivamente funcionar. E então eu definitivamente
não vou precisar disso por enquanto. Então, deixe-me removê-lo. E
então, quando se trata de estática, remova esse erro. Sim, quando se trata
desse vazio aqui, o que eu vou fazer
é dizer sistema dot out, dot print. E vou
imprimir meu método de idade. E eu dou meu valor de idade, eu dou como cinco, por exemplo. E ao dar cinco, significa que quando ele
detecta que todas as idades de cinco anos e vai
dizer cinco mais sete e obter, qualquer artista deve
ficar em 12º normalmente, deve ter 12,
normalmente. Lindo. Então aí está. Recebeu 12, certo? Este exemplo definitivamente retorna a soma dos métodos,
dois parâmetros. Você pode ser tão criativo
quanto quiser definitivamente,
contornando isso. E apenas um exemplo
mais
elaborado disso seria o que aconteceria se eu tivesse dito e por que
também está lá? Em vez disso, não apenas na idade, deixe-me chamá-lo de H1 e H2. Seja mais prático. Dois anos de idade devem fazer sentido. Agora. H1 e H2, H1 é então muito melhor, deixe-me colocá-lo como H12. Mas o que faz apenas
como dois,
na verdade , isso é
tudo o que eu preciso. E, essencialmente, fazendo isso, o que estou fazendo é dizer que o
retorno é um mais j2, por exemplo, que
deve ser cinco mais dois, que deve ser um sete. Então, vamos ver o que
obtemos. Recebemos um sete. Eu ainda poderia até adicionar um valor, sete mais três, que
deveria ser dez agora. Então lá vamos nós, é dez agora, certo? Então é assim que
realmente somos capazes de fazer
uso dos dois parâmetros. Sim, você também pode simplesmente armazenar
o resultado em uma variável, que é recomendado, é claro, pois é mais fácil de
ler e manter, mais fácil de ler e manter. Então, apenas um exemplo
mais elaborado disso que eu estou
falando seria, digamos que você
tivesse, por exemplo, x aqui e y aqui e o mais
curto e o mais, aqueles que
mais amamos quando falamos sobre matemática é y aqui, e há um x aqui. E o que queremos fazer
é simplesmente
especificar quando um z aqui se quisermos e z aqui vamos
chamá-lo de nosso método. E ligue para o 54. Então nós apenas imprimimos z. Certo, não é apenas imprimir todas essas coisas que serão
impressas em primeiro lugar,
onde tudo o que queremos fazer é
agora podemos simplesmente imprimir z. E deixe-me fechar isso
corretamente também aqui. E meu pai. Sim. Portanto, deve funcionar
imediatamente aqui. Então, vamos ver. Deveria ser sem o meu
método apenas dizer x0, realmente, isso é tudo que precisamos. Então, vamos apenas
executá-lo e obtemos nove, isso é quatro mais cinco, que deve
ser simplesmente nove. Então esse é o outro
valor para isso bem ali. O outro local
definitivamente para isso. Certo? Certo. Então, o próximo com o qual estamos lidando
definitivamente é o que chamamos de sobrecarga do
método Java. Tudo bem? Portanto, a
sobrecarga do método Java funciona assim. Com a sobrecarga, você pode
ter vários métodos que podem ter o mesmo nome com
parâmetros diferentes, certo? Exemplo disso seria talvez se eu dissesse algo como,
ei, e se eu tiver um fim? Meu método? Em vez disso, deixe-me chamá-lo de medicina, um é igual a, não é igual a ou
melhor, acabou de conhecer um. E então eu digo int x. E sim, em vez de usar x, talvez eu tenha usado muitas
vezes em T é melhor. Eu acho que entidades, mas
definitivamente eu também poderia ter um carro alegórico e
chamá-lo de louco também. E eu sou colorido flutuador e tenho o dobro também. Três loucos com um duplo
dentro das chamadas. Um a e um duplo de B. Sim, definitivamente, isso definitivamente
deveria ser embora, onde agora também podemos fazer isso. O que podemos fazer é
ter um exemplo disso. Um exemplo disso seria, deixe-me apenas me livrar
disso, porque há algumas coisas lá que eu quero esclarecer e
melhorar com um exemplo. Então, vamos fazer isso. Vamos dizer isso. Vamos voltar ao nosso método
estático aqui. E dizemos que é o fim mais. Vamos chamá-lo de método positivo. Então, com esse método plus, o que temos é que temos
int x e y definitivamente, e retornamos x mais y. E então dizemos static, static, double, static double. Portanto, temos um PFAD estático
duplo Plus Math com duplo aqui. E isso é com um int aqui. Muito importante. Aqui está dobrado
aqui, entre parênteses. Vou colocar meus dois
duplos e chamá-lo de x
duplo, duplo y. E só tenho esse
retorno x mais y. Novamente, certo? E apenas tenha essa estática
pública. Deixe-me remover tudo
isso. Eu não preciso disso. Apenas volte a
dizer Deixe-me ter
certeza de que
é aqui que pertence. Sim. Sim. Então, poderíamos ter aqui método estático
público que sempre
usamos public
static, void main. E pegue esse trem. E em cima dessa
corda, teremos nossos quadrados também. Então, deixe-me pegá-los. Como você sabe, com meu teclado. Eu tenho que levá-los
até o fim. Como aqui. Definitivamente aqui. Então nós pegamos cordas e RGS. Então, aí mesmo, abrimos
isso e abrimos. O que dizemos? Dizemos int num. Por exemplo. Meu número um é igual
a um método positivo. E nós agradamos locais como
sete vírgula nove, por exemplo. Por que não? Em seguida, seguimos em frente para dizer o dobro. E dizemos meu número dois, que é equivalente ao método
plus double. E aqui vamos
apenas colocar algo que
é um pouco de uma fração,
talvez cinco pontos, vamos ver, talvez 5,4 com 6,9, por exemplo. Isso. E então vamos apenas dizer um
sistema dot out dot print LN. E o que queremos é
imprimir nosso local inteiro assim com uma string que é, e apenas reproduz todo o nosso valor r que queremos imprimir aqui, que
será mais um. Certo? Então vamos fazer uma
coisa semelhante aqui, diz system dot out, dot print LN. E bem aqui, vamos ter um duplo em formato de string com alarme, alarme num dois ali, certo? Então, vamos analisá-lo e
ver o que obtemos. Normalmente, ele deve nos dar
somas desses dois valores. Aqui. Vai ser sete
mais nove, que é 16. E um duplo aqui
vai nos dar, deixe-me colocar isso
também para que seja relevante. Um duplo aqui nos
dará 5,4 mais seis por nove, o que seria apenas 12,3. Tudo bem? Então, definitivamente, é
assim que podemos usar a sobrecarga, se você quiser. Tudo bem.
15. Escopo: Tudo bem pessoal, então
a próxima coisa que definitivamente
queremos analisar é o que chamamos de escopo
Java, certo? Então aí está, escopo Java. E sempre que falamos
sobre o escopo Java, essencialmente o que estamos
falando realmente é apenas a região que
é acessível, certo? É aí que as variáveis
são encontradas, certo? Então, deixe-me anotar. Estamos falando
de algo da seguinte natureza. Em Java, sabemos que as próprias variáveis
só são acessíveis, acessíveis apenas dentro, e
não dentro de uma região. Eles são criados. Deixe-me ter certeza de colocar esse lado
direito da região. Criado é um S duplo sobre
Matt disse originalmente criado. E isso em si é o que
chamamos de escopo. Esse é o nosso escopo.
Então, aquela região que os torna disponíveis, esse é o escopo
essencialmente, certo? Portanto, as variáveis podem ser declaradas
diretamente dentro de um método
e, portanto, podem estar disponíveis em
qualquer lugar do método seguindo a linha de código
em que a forma declarada. Um exemplo disso seria literalmente o que eu
escrevi aqui. Acabei de dar uma olhada no que estávamos fazendo aqui com
nosso método anterior. Então temos uma classe pública main, então temos um método aqui. Nós chamamos isso de talvez,
deixe-me falar sobre este, especialmente estático duplo
mais método duplo e depois temos isso
e então aqui
temos o interesse em um. Vamos colocar nosso foco bem aqui. Concentre-se aqui. Temos estática pública,
vazio principal, certo? Então, lá dentro, o que temos? Colocamos o que
você quiser colocar lá. Certo. E, portanto, é acessível. Tudo, mesmo o que
declaramos lá fora, se puder ser chamado
aqui, certo? E se isso não fizer sentido, posso sempre fazer
isso por você apenas para esclarecer melhor do
que estamos falando. Consigo pensar nisso assim. Deixe-me esclarecer
tudo isso. Na verdade, não precisamos
mais disso. Todo o caminho até
aqui e exclua. E vamos
direto e dizer público. Não é uma tampa superior, uma tampa, um vazio estático público. Na verdade, eu deveria apenas
excluir a coisa toda, em vez de apenas remover essa
parte superior aqui. Tudo isso. Sim, isso é o que eu não
preciso e eu não preciso disso. Mas isso eu preciso
absolutamente apenas para provar meu ponto aqui
do que estou falando. E, portanto, o que
estamos dizendo aqui? Estamos dizendo que poderíamos ter algo assim aqui. O código que pode estar aqui
não pode usar x, certo? Essa é a área. É assim que o definimos. E então poderíamos
especificar que inteiro de x é equivalente a 100, certo? E com isso, podemos dizer, podemos criar algo
que pode usar X. código aqui pode usar x.
E pedimos esse
código que pode usar x ou dizemos um sistema
dot out dot print LN e então lembramos,
e imprimimos x. Neste caso aqui não
tínhamos nada, Não
fomos declarados. O que significa exit solve, você vê, então precisamos
chamá-lo primeiro e declarar essa variável de x e , portanto, ser capaz de
chamá-la e imprimi-la. Então, se fôssemos executar isso agora, ele deveria ser
capaz de nos dar o que x é essencialmente, certo? E o que eu vou fazer
é apenas para garantir que tudo está bem, deixe-me colocar isso aqui e colocá-lo bem
aqui. Lindo. Então, deixe-me fazer isso para você e ver por si mesmo
o que ganhamos com isso. Então, estamos executando isso no momento. E um 100. Isso porque x,
declaramos x como 100. E esse é apenas um escopo de método que ainda estamos
fazendo aqui, bem
ali em algo também chamado de escopo de bloco. E um escopo de bloco, você pode pensar nisso mais
assim, certo? Então, um bloco de código se refere todo o código entre
as chaves, essa outra cor de chaves de que
estamos falando. Então, qualquer coisa que seja
encontrada entre essas duas chaves coloridas, isso e isso aqui é
apenas um bloco de código, certo? Agora, variáveis declaradas
dentro de um bloco de código
acessível apenas pelo código
entre as chaves, que segue a linha na qual a variável foi declarada. Para elaborar muito mais, vamos fazer um exemplo. Vamos dizer aqui com o mesmo exemplo
que temos aqui. Digamos que façamos
algo assim. Digamos que deveríamos, em vez de ter x aqui, digamos que fôssemos fazer
algo assim aqui,
sabemos que um código aqui
não pode usar x definitivamente. Mas então e se eu fizesse algo do
seguinte tipo para dizer e colocar aparelho
encaracolado, depois abrir o site. Então você percebe
que o que quer que esteja entre essas duas chaves encaracoladas
aqui seria um bloqueio. Isso é um bloco de código. O que quer que eu colocasse lá seria
apenas um bloco de código. E esse bloco de
código ali mesmo. Ele não pode usar x também. A luz
também não pode usar x. Não é possível usar x. No entanto, se
fôssemos, por exemplo, apenas especificar e dizer que
x é igual a 100. Novamente, talvez nada de
especial sobre um 100, assim como usá-lo. Podemos ver que o próximo código que implementamos
pode definitivamente levar em consideração qual código de
acesso aqui pode usar x. E, assim, podemos simplesmente acessá-lo e é
um ponto de saída do sistema, dot print LN X. Não
há erro, como podemos ver. Então vemos, portanto,
que esse bloco de código termina bem aqui. Deixe-me fazer isso. Rolo. Então o é igual a n aqui. Coloque um blog e aqui. Então o código aqui
também estará fora
das chaves encaracoladas. Código aqui, não pode usar x. Então você vê que, Você vê
que o efeito que está dentro dessas chaves
permite que você acesse x. Mas no momento em que ele sai, você não pode mais acessar nenhum
x e dados, Temos nossos 100 lá que acabamos de
especificar, certo? Então, essencialmente, isso
é realmente sobre o escopo do bloco e tenha em mente que o bloco de código pode existir por conta própria ou pode pertencer a um FYI
de declaração falsa. No caso de qualquer caso desligado. Para instruções lembre-se de que as variáveis declaradas
na própria instrução também estão disponíveis dentro
do escopo do bloco. É apenas
outra coisa que você deve ter em
mente sempre que estiver
fazendo sua codificação, certo? Tudo bem, então a próxima
coisa em que quero que nos concentremos é no que é
chamado e tudo isso. Deixe-me apenas excluí-lo. Nós não precisamos disso. A próxima coisa sobre
a qual queremos falar é o que chamamos de recursões Java. Escreva recursão Java. Então, deixe-me colocar
para nós aqui. Deixe-me fazer isso. Sim, java. Às vezes, quando você segura
o Shift por um tempo, isso
é o que acontece. Recursões Java. Incrível. Então, o que é uma recursão? A recursão é inerentemente, é apenas a técnica de fazer com que a função IF se chame. Então, se você tem uma função
que continua chamando a si mesma, então o que você
acabou de fazer lá é o que chamamos de recursão, certo? Então aí está, chame a si mesmo. Essa técnica definitivamente
fornece uma maneira de dividir problemas
complicados problemas
simples que
são mais fáceis de resolver. E é claro que isso pode ser um pouco difícil de entender, mas a melhor maneira de
descobrir como sempre, apenas codificando,
você tem que fazer isso. Você tem que
sujar as mãos e fazer isso sozinho. Você vê isso? Então, vamos dar uma olhada
neste exemplo aqui. Digamos que queremos usar,
use recursão para adicionar todos os números. Até dez. Quer adicionar todos os números? Bem, uma coisa é a palavra correta
em inglês aqui. Todos os números. Até dez, certo? Então, como você faria isso? Bem, você provavelmente
quer começar primeiro declarando o método que
você vai usar. Então, vamos
usar static, void, main e call string. Aqui, o ARG está aqui. E bem com a nossa
corda ali. O que queremos fazer é usar os quadrados aqui. Então, deixe-me chamá-los assim. E volte aqui e mude meu teclado de volta para
o modo padrão normal. E então int resulta definitivamente dentro do nosso
bloco de código que é, e dizemos soma de dez. É isso que estamos
investigando com frequência. E em breve
vamos definir o que é a soma de
dez. O que isso significa? O que o Java deve entender levando em
consideração o que é chamado de soma de dez, certo? Então, imprimimos o resultado aqui. Então o que queremos fazer é, logo depois de tirar
isso assim, queremos criar
outro método aqui, aquele que vai definir
o que alguns em si significam. Então, diremos int sum. E então vamos apenas chamar o valor inteiro de k.
Sim, então aí está. Agora nós reconhecemos isso. Então Java é capaz de interpretar
e dizer, oh, ok, então o valor de alguns,
há um método que é capaz de
chamar o sol. Então, ainda não entendemos
o que esse método realmente salva e como
ele deve se comportar, certo? Tudo bem? E então dizemos que se k, se k for maior que 0, o que deve acontecer
é o seguinte. Devemos retornar k e adicionar a soma porque queremos que seja k
recursivo menos um. Sim, então é aí que entra a habilidade
recursiva. E eu vou interpretar
isso sobre você acabou de resolver, agora
você pode
entender completamente o que exatamente
está acontecendo aqui. Caso contrário, deve fazer isso. significado da condição
é ser como não sendo atendida, basta simplesmente retornar
o valor de 0. E é só isso. Isso é realmente sobre
isso. É sobre isso. Deixe-me fazer
isso para que eu
sempre possa nos perder aqui. Esse cara, eu vou
pegá-los e arrastá-los e colocá-los
até aqui. Só para que você se lembre desse
cara lá embaixo, aqui embaixo. Sims, há um pequeno
erro em algum lugar aqui
neste bloco de um bloco de código com o qual
estamos lidando. Sim, basta fazer isso. Todo o erro desapareceu. Tudo bem, então, essencialmente,
o que estamos dizendo aqui? O que estamos dizendo
essencialmente aqui, e vou
colocar
alguns comentários aqui apenas para
que você possa entender melhor o que está acontecendo. Estamos somando valores e, a propósito,
vamos executá-lo mais rápido. Podemos ver se funciona ou não, e agora podemos passar
para a próxima coisa. Então, aí
está. São 55 anos. Você sempre pode fazer isso sozinho. Apenas tente e diga 0 mais um mais dois mais três
mais quatro mais cinco mais seis mais sete
mais oito mais nove mais dez, você obtém 55. Agora, como isso
ocorre na verdade? Bem, o que vai
acontecer é isso. Vou pegar nosso valor,
nosso valor de resultado aqui. E normalmente sobre
isso, é uma aula obviamente. E então o que Java
vai fazer é verificar o
valor do resultado,
a soma e dizer, Oh, a soma é despejo é na verdade
um valor de dez. E então diga, o que
esse método de alguns faz?
16. Condições de interrupção: Como isso faz na verdade? Então, ele virá aqui e tentará entender
o que Sam é. E ele registrará um
valor de dez aqui, certo? Porque escolhemos
ser dez e depois dizemos que dez é maior que 0. Isso é verdade? E então você
diz: Sim, isso é verdade. Se for esse o caso,
retorne k, que no nosso caso é dez. Então, ele retornará
o valor de dez. E depois mais a
soma de k menos um. No nosso caso, k é dez. Então, dez, essencialmente
é 1010 menos um. Essencialmente, é isso que
vai acontecer, certo? E o que é dez menos um? Na verdade, são nove. Então, essencialmente, estamos
falando sobre a soma da minha, algumas das minhas. E vai ter
o mesmo valor de nove. Faça todo o caminho de volta. E ainda estamos nesse ciclo. Não vamos sair ainda. Então ele vai
subir aqui e dizer, nove é maior que, é nove maior que x4 e
dizer, sim, isso é verdade. Então, tendemos a
valorizar nove, viu isso? Essencialmente, ele
só vai te dar, agora não é mais
uma soma lá. Só vai ser o
valor de nove em si. Além da soma de, será nove menos um, que é a soma de oito. Viu isso? Com a soma de oito, a mesma coisa
vai acontecer. Ele vai contra
o oito é maior que 0 e depois retorna
o valor de oito. Então, agora temos o
valor de oito em si. Não é um, não é um método de oito, mas é um valor de oito em si. E então ele
dirá soma de sete. Então, o mesmo processo
continua acontecendo. E é isso que
torna recursivo. Lembre-se, a repressão
por natureza está repetindo uma função que
continua chamando a si mesma. Isso é o que estamos fazendo aqui. Estamos fazendo essa
função de algum cupom chamando a si mesmo de novo e de
novo e de novo e de novo. Então, ele continuará fazendo isso. E isso significa que teremos
mais sete mais seis, mais cinco, mais quatro, mais três mais dois. Eu vou
espaçá-los mais um, certo? E então, quando chegar a um,
o que ele vai dizer? Basicamente,
só vai dizer que um é maior que
0. Isso é verdade? Retorna um mais soma de um
menos um, é 0, certo? Então, vai dizer mais
soma de 0 aqui. A soma dos zeros. Então o que ele vai fazer é
pegar a soma de 0, digamos o valor de k
que agora está definido como 0. Então você dirá que 0
é maior que 0 e percebemos
que isso não é verdade. Isso é falso. E sal, porque isso é, essa condição não está
mais sendo atendida, agora
vai pular. Ignore esta
declaração condicional e venha aqui e diga outra coisa que tendemos
0, o que é verdade. Então, isso acabará apenas adicionando um
0 adicional. Você vê isso? Então, como você pode ver, eles
continuam se somando. Então aqui vai dizer apenas
dez mais 919 mais oito. Trinta e sete, cinquenta e quatro. E como na
verdade, vai ser 19, 27 para 40, quarenta e cinco, quarenta e nove, cinquenta para 5455. Você vê isso? Então é assim
que ele continua resumindo esses
valores em si. Você os adicionará. Não vai gravá-los. Só estou gravando
assim para o seu bem. Mas o que ele vai fazer na verdade é que cada vez ele continuará fazendo e fazendo algo como dez mais nove recuos em 19
e depois enviará 19 mais oito. E então te dar, como
eu disse, 2727 mais sete. E então ele lhe dará 34. E então ele
adicionará 34 mais seis, e nós damos 4040 mais cinco. Dê 45, e então ele
dirá 45 mais quatro, e então ele dará 49
e depois 4949 mais três. E
isso lhe dará 5252 mais dois. E nós damos 54.
E dirá que cinco a quatro mais
um lhe dará 55. Viu isso? Então é assim que ele está
crescendo e, na verdade,
cresce até um valor final de 55, certo? Portanto, lembre-se de que, quando a função SUM é chamada, ela adiciona o parâmetro
k à soma de todos os números menores que
k e retorna o resultado. Então, quando K se torna 0, a função apenas retorna 0
quando executado no programa segue os passos que
acabei de mostrar logo acima, aqui, certo? Então, é claro que poderia
ser um pouco mais criativo e talvez até dar como
uma condição de parada, uma condição de parada de quando
ele deveria saber quando parar, sob quais circunstâncias sob as quais cenário não deve parar. Falando sobre isso, falando
sobre a condição de parada. Condição de parada. Quando você fala sobre isso,
sabemos que, assim como loops podem se deparar com um problema
de loop infinito, funções
recursivas podem ser
executadas, eliminar um problema de recursões
infinitas se
a condição de parada não for. taxa devidamente declarada. Então, por que
precisamos aprender sobre o coração e condicionar a condição de parada,
como
eu gosto de dizer, eu vou apenas colocar essa
força aqui neste caminho e colocá-la assim. Certo? Incrível. Ótimo. Ok, está tudo bem agora,
então nós o levamos sobre a condição de parada e recursão
infinita ou cuidados, ou melhor, é quando
a função nunca para de se chamar.
Basta colocar os mortos. recursão infinita é quando uma função nunca para de chamar a si mesma. Certo? Toda função recursiva deve ter a condição de parada, que é a condição em que
a função para de
chamar a si mesma. No exemplo anterior. Por exemplo, a
condição Holton é quando o parâmetro k, como vimos, quando k se tornou 0, foi assim que
Java tinha que saber que, oh, paramos
bem aqui, certo? Portanto, é útil
ver uma variedade de exemplos
diferentes para
entender melhor o conceito. E neste exemplo, a função adiciona um intervalo de números entre
um início e um fim. Então, a condição final quente para essa função de Lucas é quando n não é
maior que stat, certo? Então, vamos dar
um exemplo aqui e tentar ver se
podemos usar a regressão. Então, vamos usar a recursão e vamos
colocá-la para baixo para nós. Temos uma concussão para adicionar
todos os números entre 510. Então, todos os números entre 510. Então, vamos fazer isso e ver como nossa coisa
toda evolui. Então vamos voltar
aqui, certo, bem aqui, e modificar a mesma
coisa que estamos usando. Então, só o resultado final. E então, para alguns aqui,
vamos torná-lo um pouco interessante em vez
de apenas dizer dez. Já que queremos que comece das cinco, vou dizer 510. Sim. Então fica vermelho porque até onde o método de alguns já
havia sido definido, ele tinha apenas um
parâmetro lá, então é um pouco confuso sobre
o que realmente
está acontecendo aqui. Então, vamos mudar isso
quando isso for permanente. Teremos uma permanente
inicial de int e, em seguida, terminando a Paramount
of India bem aqui. Agora está tudo bem porque
nós o definimos como dois parâmetros que
foram reconhecidos como cinco como um início e
tendões o fim. E tenha em mente que
decide apenas nomes de variáveis para eu saber que esta está iniciando
os outros finais. Porque estudar e ter funções
particulares que são Java é capaz de reconhecer que começar significa
um conhecimento repentino do endossomo, eu apenas os chamei dessa forma. Eu poderia tê-los chamado de x, y, z, o que eu quiser, certo? Mas o que vou fazer é
dizer se,
se o fim for
maior do que o meu começo, assim como fizemos
em um caso anterior. O fim é maior
do que o meu começo. Então, o que eu quero fazer
é retornar
ao final e fazer com que minha estatística faça o seguinte. Vai começar
e terminar menos um. Então, ele vai
continuar fazendo isso e outra
vez e outra vez. E então ele deve
retornar ao final. Agora, literalmente, quase como a outra pergunta que
estávamos fazendo. Se você prestar atenção, poderá ver que
realmente é quase como o que acabamos de fazer há
alguns minutos. E então vamos
continuar e executá-lo e ver o que vai sair dele. E aí está. Temos um vale
lá de Eu acredito
que deveria ser o quê? Quarenta e cinco. É isso aí? Sim. Acho que é 45. Então isso só diz
que um mais dois mais três mais quatro
são simplesmente fazer o quê? Eles somam dez porque é a diferença
entre os outros. Mas cinco mais seis mais
sete mais oito mais nove. Até dez, isso realmente
dá a você exatamente o que? Isso te dá 45 em si, certo? Então, lá temos
pessoas incríveis do que nós.
17. Programação orientada a objetos: Tudo bem, então a próxima
coisa que queremos
analisar é o que é chamado. E essa é provavelmente uma
das principais coisas que
definitivamente queremos saber em Java. É Java, OOP,
programação orientada a objetos, certo? E é isso que
tudo P representa. O P significa essencialmente
apenas objeto. Para baixo para você. A programação
orientada a objetos . Isso é algo com o qual
você entrará em contato muitas vezes. Portanto, lembre-se de que procedimento ou
programação é sobre escrever procedimentos ou métodos que executam operações
nos dados. Enquanto a
programação orientada a objetos trata de
criar, criar objetos que contenham dados
e métodos. Mas abra o tipo sobre isso, dados
e métodos, certo? Então, orientado a objetos, há
um indicado a hífen sobre isso. programação orientada a objetos tem várias vantagens sobre a programação
processual, certo? Portanto, essas vantagens
são vantagens de 00 p sobre o procedimento. Toda a programação. Programação de papéis. primeiro é que o p é
realmente mais rápido no buraco. É capaz de ser
feito e executado rapidamente também. E então essa é a
definição e o
vento que você quer fazer se estiver trabalhando em prazos e tudo mais. E outra coisa é que
tudo P in simplesmente fornece uma estrutura
clara para problemas para programas. Portanto, há uma
estrutura clara para os programas. E também OOP, ajuda a
manter o código Java seco. E por seco, o que queremos dizer é que você não
precisa se repetir. Não repita. Isso é o que impulsiona você a resolver. Deixe-me escrever isso
corretamente para corretamente que
possamos tê-lo. Você não precisa se
repetir. E, portanto, torna
o código mais
fácil de manter e modificar,
se você quiser. E, claro, depure
porque há código. Especialmente de acordo com
muitas coisas que você encontra os bugs eventualmente
entram no código e você quer ter o valor de todos os p's que
ele permite que você facilmente, sem muita agitação,
realmente depure ou removeu bugs do seu código e de
todos os p também. E torna possível
criar
aplicativos reutilizáveis reutilizáveis e
reutilizáveis com menos código e menor tempo de desenvolvimento. Essa é a beleza
disso bem ali. Essa é a beleza disso, certo? Portanto, tenha em mente
que o princípio DRY ou o princípio de não
se repetir é sobre reduzir a
repetição de código. Você deve extrair as chamadas que são comuns
para o aplicativo, colocá-las em
um único local e reutilizá-las em vez
de colocá-las. Você vê isso? Então
essa é a beleza da programação
orientada a objetos bem ali. Quando falamos sobre O P, não
podemos falar sobre OOP, não
podemos falar sobre
OOP sem falar sobre algum entendimento ou uma compreensão completa
de classes e objetos. Mas é a diferença
entre esses dois e o que exatamente adultos. Basta entender que
os próprios clusters, essencialmente um
objeto, em vez dos dois aspectos principais da programação orientada a
objetos. Classes e objetos são
dois aspectos principais de o p. E você pode pensar
em uma aula realmente como um conjunto de alimentos,
por exemplo, frutas. Os objetos dessa
aula serão o quê? Os objetos serão. As diferentes frutas lá dentro. Você vê que
poderíamos ter uma maçã. Você poderia ter uma manga, você poderia ter um par. Você poderia comer uma banana. Pode ser todas essas coisas. Você pode pensar em uma aula realmente mais como
algo que contém outras
coisas dentro dela. Mais parecido com o que você
tem ouvido ver aqui é um cluster e, em seguida, dentro da aula, temos diferentes objetos sobre os quais
podemos falar. Você vê que todas
as classes da mesma
classe, você vê isso. Outro exemplo
provavelmente seria uma classe de carros. Classe de carros. E dentro dos carros, podemos falar sobre a Volvo, podemos falar sobre curvas. Poderíamos falar sobre como a Honda, sim, no final, Audi, certo? Então, eles são todos os custos
no final do dia, mas a aula é o
que contém a linha deles. Assim, você pode pensar na
classe como um modelo para objetos e um objeto como
uma instância de uma classe. Tudo bem? Esse é o termo que você ouvirá muitos exemplos
de um peso de classe. Então isso é importante. E então, quando os
objetos individuais são criados, eles herdam todas as variáveis e métodos da classe. E nós definitivamente
entraremos nisso um pouco mais tarde com mais profundidade. Mas, por enquanto, é
só isso por enquanto. Tudo bem, então a
próxima coisa que eu quero que analisemos é o que chamamos de
classes e objetos Java. Quero dizer, nós já
os começamos um pouco aqui, mas vamos nos
aprofundar um pouco mais agora. Portanto, sabendo que o Java em si é uma linguagem de
programação orientada a objetos, tudo em Java
está associado classes e objetos, juntamente com seus atributos e métodos. Por exemplo, na
vida real, objeto Kaizen, o chi tem atributos
como peso, cor e métodos como Dr e
quebrar quase um método de surf ou C. Assim, uma classe é um construtor de objeto ou um plano para criar
objetos, certo? Então, para criar uma classe, geralmente
usamos, usamos o quê? Usamos a classe de palavras-chave. Então, um exemplo disso
provavelmente seria algo parecido com isso. Por exemplo, eu poderia dizer público. Isso acabou um pouco. Só para você
entender como você faz isso. Classe pública, como você já nos
viu fazer muitas vezes. maio. Então, obviamente, vamos
ter esse aparelho encaracolado aqui. Ninguém poderia dizer que x é
igual a phi, certo? Então, isso é algo que temos
visto tantas vezes. Ele geralmente já fazia
isso por você na maioria das vezes. Mas então, à medida que você avança nos cenários
deles, você pode
querer fazer isso sozinho. Mas, por enquanto, isso é tudo o que você pode precisar. Isso está bem por
enquanto, faz sentido. E, obviamente,
teremos uma brisa aqui para fechá-lo. Mas só
porque é um exemplo, não
vou tão longe
para mostrar isso, certo? Mas então, para
criar isso para criar uma classe,
é realmente isso. Que tal criar um objeto? E objeto? O que criar um objeto? O que queremos fazer isso. Em Java, precisamos
começar primeiro,
um não ordenado e, em Java, um objeto é criado
a partir de uma classe. Nós já criamos
a classe chamada main aqui. Esse é o nome da
turma, é chamado de principal. Agora podemos usar isso
para criar objetos. Para criar um objeto de main, especifique o nome da classe
seguido pelo nome do objeto e use a palavra-chave. Novo. exemplo seria exatamente aqui na
mesma classe aqui, Digamos que deveríamos
criar um objeto em, digamos, public static, void, main, estamos afirmando que recrutaremos
nesta string de objeto. E eu vou apenas fazer
essa parte aqui. Literalmente a mesma
coisa que queremos. Corda. E então vamos
apenas dizer no principal e dois pontos meu objeto. Então, chamando um método
aqui e estamos pegando todo o nosso objeto e dizemos novo, pode ver novo principal e
ali também
dizemos sistema dot
out, dot print LN. E então acabamos de ver tudo de
mim e fechamos isso. Então poderíamos ter
sido subtraídos de x se não estivéssemos
realmente consumindo. Você já tinha um
valor de x lá. E podemos executar isso. Você vê. Então, deixe-me copiar e colar
exatamente o que fizemos aqui. E vamos colocar bem aqui. Não está mais nos comentários, mas na coisa real
que ainda está
em execução no momento. Então, vamos dizer fechá-lo aqui. Então aqui já
temos uma aula, então não precisamos
fazer isso de novo. Então vamos ver, aqui já
temos um
vazio estático público feito para nós, então não precisamos fazer isso novamente. Podemos literalmente
pegar a mesma coisa aqui e
colocá-la lá embaixo. E console esse console mal. Tudo bem. E podemos pegar isso, colocar acima aqui, porque é uma
aula online, a geral. E já temos
tudo no lugar. Tudo bem, então aqui estão
os desafios que Bain considera que
temos o nome da nossa classe como
Hello World, certo? Desde a nossa aula, a saber, já a
declaramos como Olá. Olá Mundo, o que
vamos fazer é chamá-lo de mundo. E quando ele
também, Olá Mundo, Esse é o nome padrão
que temos aqui. Do que estamos falando. Este é pequeno m, meu gene OB. E vai ler x. Não é menos.
18. Classe e objetos: Tudo bem, então a próxima coisa
que queremos
analisar é focar mais na classe
e nos objetos Java, certo? Então, vamos nos concentrar
mais nisso, especialmente. E tenha em mente que Java, sendo uma linguagem de
programação orientada a objetos, tudo o que fazemos em
Java está associado a essas duas coisas aqui
na classe ou a um objeto, junto com sua
atributos e métodos. Então, por exemplo, na vida real, um carro é um objeto
e o chi é o quê? Tem atributos
como peso e cor. E métodos
como Dr. e break. Você pode pensar em métodos
como atos. O que fazer. Você vê isso? Atributos como
sua aparência. Você vê que eu posso
descrever o certo? Portanto, o I plus é como um construtor de objetos ou um modelo para
criar objetos. Então, para criarmos uma classe
, tudo o que precisamos é
simplesmente declarar algo assim e dizer HelloWorld de
classe pública, certo? Então, já nomeamos por todos os
anos de classe hello world. Normalmente, o Java
faria isso por você, mas pode haver
cenários em que talvez você não, você pode querer
fazer isso sozinho. Mas, por enquanto, está tudo bem. E então poderíamos até dizer que x é igual a cinco, por exemplo. E, hum, sim, isso definitivamente
poderia funcionar. E então, se quisermos talvez criar um objeto que fosse o inicial, era
como criar uma classe. Mas neste, queremos
criar um objeto. Para criar um objeto, você deve ter em
mente que em Java, um objeto é criado
a partir de uma classe, e nós já criamos a classe chamada
HelloWorld force, como você pode claramente
veja aqui, certo? Agora podemos usar isso
para criar objetos. Então, para criar um objeto
de Hello World, o que vamos fazer
é especificar o nome da classe
seguido pelo nome
e, em seguida, usar a palavra-chave new. Então, um exemplo de madeira, isso seria o seguinte. Digamos que público, estático, vazio. Vazio estático público. Vamos experimentar e dizer
apenas a string principal. Deixe-me mudar o mais rápido possível. Insira isso, volte e ergs. E bem aqui,
apenas olá mundo. Meu objeto OBJ, realmente
abreviatura de objetos, novo, hello-world e voila. Então também poderíamos
dizer, Ei, queremos as dúvidas do sprint
ou o sistema do nosso LN impresso. E então imprimimos
meu OBJ ponto x ponto x. Então, qualquer que seja o objeto
multiplicado por x realmente, certo? Então, o que inventamos? Essencialmente, chegamos
com apenas cinco, certo? Então, obtemos o valor
de cinco por lá. E então pode haver um
cenário em que talvez queiramos
criar vários
objetos de uma classe. E para fazer
isso, ainda vai ser
muito, muito simples. Nada complicado em tudo. O que queremos fazer
é que você realmente é apenas queríamos dizer
olá mundo, e então agora especificamos
e dizemos meu OBJ. Digamos que o primeiro
fosse religioso como um ou apenas o começo uma vez ou especificado em dois
e apenas diga novo. Então dizemos olá, mundo. E tenha em mente
que aqui temos número
do objeto para,
objetar a isso. Aqui temos o objeto um. Objeto um, certo? Então o que queremos fazer, bem
como talvez pudéssemos imprimir
os dois realmente, por que não? Você pode escolher
o mesmo sistema. Dot out, dot, print. E então meu OBJ, o primeiro. O segundo
porque já
temos o primeiro ou com a. E depois dizemos por x, e normalmente deveríamos fazer com que
os dois saíssem. Isso é 55. Então essa é a beleza
disso bem ali. Essa é a beleza
disso bem ali. Essencialmente, estamos
dizendo a ele para
imprimir o que
encontrar nesta classe, especialmente o perímetro de X, como
dissemos bem ali. Pode haver cenários
em que talvez você precise. Então, sim, espero que isso
definitivamente
te ajude com isso
definitivamente te ajude. Então, a próxima coisa que
queremos analisar é o que é chamado de atributos de classe Java. Certo? Aqui estão eles. Em atributos de classe Java,
atributos , o que eles fazem. E então, em inglês,
é apenas algo que define as características
de algo, certo? No cenário anterior ou
menos do que estávamos falando sobre classes e objetos. E ainda mais cedo, até
definimos o que significa invariável. Portanto, uma variável é
na verdade um atributo de uma classe que realmente vale
a pena anotar. Variável é um
atributo da classe. E então, para dar um exemplo, digamos que temos uma classe
chamada remover tudo isso. Temos uma aula
aqui, chamada Hello World, por exemplo. Portanto, com isso em mente,
vamos criar atributos. Então será x. E x está perto de cinco,
como tínhamos antes. Poderíamos até criar
outro em y é igual a
sete, por exemplo. Então, essas duas coisas, x e y ,
nossos dois atributos, é
isso que temos visto até agora que
existem variáveis. Agora você está entendendo que
elas não são apenas variáveis, mas também são atributos. Isso é o que eles são,
isso é o que, e. Então, outro termo para
atributos de classe é campos. Então, em vez de
chamá-los de atributos, você sempre pode
chamá-los de campos também. Para acessar
esses atributos, você pode acessá-los
criando um objeto
da classe e
usando a sintaxe de ponto. Este exemplo que estou
prestes a mostrar
agora ajudará você a
criar um objeto de nossa classe com o nome meu OBJ como eu
os tenho usado, todo meu objeto. E usamos o tributo
e o objeto exatos para imprimir seu valor. Então, só para
te ajudar a entender mais do que
exatamente estou falando, vamos apenas chamar o público
static, void, main, string. Basta ter esse RGS e
soltar esse memorando. E sim, vamos ter aula HelloWorld
e dois pontos, nosso OBJ. Lembre-se de que não precisa
necessariamente ser tudo. Você sempre pode
chamá-lo de outra coisa. Então, convocamos uma nova turma agora. Então nós apenas imprimimos
isso. Você imprime. E vamos ver o que ganhamos
com essa linda, que é linda, linda. Então é assim que nós definitivamente
acessamos os atributos deles. Então, também podemos modificar
os atributos que já
definimos. Um exemplo seria, vamos falar sobre o
que eu fiz aqui. Digamos que eu chame x, apenas x nos
minutos seguintes em vez de cinco, eu apenas digo x e x. Eu poderia modificá-lo aqui
e apenas dizer meu objeto aqui, e assim mesmo. Mas meu objeto de x é
equivalente a cinco. Deixa-me só largar isso. Portanto, é
equivalente a cinco dias. E então eu corro meu objeto de x. E eu recebo cinco. Se eu mudar isso para um 124, eu deveria receber 124
porque eu o modifiquei. Você vê, inicialmente
era apenas x. E eu o
modifiquei bem ali. Tudo bem, se foi, por exemplo, outono, estamos aqui. Vamos apenas executá-lo e
tentar entender. Ainda chega a ser um 124. Isso porque o valor
inicial que ele obtém é realmente o que vemos. Mas então ele chega a esse
estágio e diz que todo o novo valor de x
que eu deveria inserir, deveria ser 124. Como ele sempre
leva até Java, sempre leva as
informações mais recentes fornecidas a ele. Essa é a que sobrescreve as informações
existentes. Isso é, isso é realmente o
que você pode dizer sobre isso. Então eu posso simplesmente colocar
o comentário CN e dizer que x agora é 124. Isso é o que é, certo? Então, se você não quiser a capacidade de substituir valores
existentes, declare, você sempre pode
declarar o atributo como um exemplo final aqui. Você poderia dizer, se você não quiser mudar em nenhum estágio, você poderia dizer um x final. Então, como você pode ver agora, é um
erro para mim mudar isso. Não tenho permissão para
transformá-lo em nada. Então, por si só, Isso é porque não está permitindo que eu assuma nenhum valor. Nem um pouco, nem uma
nova contribuição. Eu vejo. Então eu preciso me livrar disso e é aí que
tudo ficará bem. E se eu fosse imprimir isso, eu deveria obter o valor
de apenas para si mesmo. Então, Betas que não temos. Outro cenário com o
qual você pode se encontrar trabalhando é talvez
trabalhar com vários objetos. E isso acontece difícil é que se você quiser criar vários
objetos em uma classe, você pode alterar os
valores de atributo em um objeto sem afetar os valores de
atributo no outro. Exemplo, se você quiser alterar
o valor de 25 extra e objeto número dois e deixar x no objeto número
um e alterado. Você poderia fazer algo
da seguinte natureza. Digamos que eles tenham isso. Não precisamos do
último aqui por enquanto. Temos dois objetos, então deixe-me criar
meu segundo objeto. O segundo objeto é o
novo mundo olá e dados. E então meu, meu segundo objeto pode ser especificado
da seguinte maneira. Meu OBJ ponto x, é 24, o que significa que, no que diz respeito ao valor da
face, ele será impresso
apenas no que diz respeito ao segundo objeto,
ele imprimirá 24. Então, vou
imprimir os dois só para que possamos ver melhor. Então copie e cole e imprima
os dois para que você possa ver a diferença
entre os dois. Portanto, o primeiro deve ser para o segundo intervalo.
Então aí está. Somente o primeiro foi alterado. O segundo, desde
que foi modificado. Isso mudou. Você vê que o
primeiro permanece o mesmo, o segundo muda. Então é isso que acontece
se você quiser apenas ter vários objetos em operação. Você também pode ter vários
atributos em operação. Assim, você pode especificar quantos
atributos quiser. E para que você faça isso, realmente envolveria você fazer algo
transbordando a natureza. Digamos que eu fosse
remover tudo isso. E não estamos falando sobre deixe-me mover isso
também porque eu não preciso disso. Então vamos dizer que eu diria string FirstName
F9, dada por Tom. Então eu preciso de sintaxe
também, esforço. Este é meu sobrenome aqui. Sheppard do
jogo mass effect. Então aí está. E então falamos sobre a idade, e digamos que ele tenha 26 anos. E então o que vamos fazer
é não precisarmos mais. Sim, realmente,
não é importante. Então eu poderia ter e criar
meu próprio objeto, certo? Como você provavelmente já
viu muitas vezes. Agora, o que eu vou fazer
é isso, no entanto. O que vou fazer é aqui, só quero que
imprimemos algo interessante. Vamos dizer
apenas um nome, um nome. E depois com o nome. Também entraremos em apenas dois pontos ou nome do
ponto F do objeto, certo? E então nós também vamos
falar, tudo
bem, eu dou algum espaço entre eles, não
realmente clavícula. E depois temos nosso segundo objeto, que é nosso sobrenome. L para L name e depois
li delete isso. E bem aqui também. O que eu vou fazer é que eu vou
apenas chamar
a idade aqui para que
nós tenhamos a idade. E chamamos esse objeto e
telefone para a era bem aqui. E vamos analisá-lo e
ver o que obtemos. Quando o executamos. Aí está. Chamamos Tom
shepherd, 260 anos. Então isso é definitivamente muito
valioso, muito valioso, especialmente quando você lida com pilhas de código e
tanta informação que você precisa processar e apenas
ter tudo isso . ao todo,
tê-lo completamente. Essas são algumas
informações valiosas que você definitivamente
deseja ter em mente. Definitivamente, quero ter em mente. Tudo bem, então a próxima coisa a qual definitivamente falaremos é
apenas sobre métodos de
classe Java, certo? Então, você aprendeu com capítulo
de métodos Java ou qualquer outra coisa, a lição sobre a qual
estamos falando, que os métodos são
declarados dentro de uma classe, que eles são usados para
executar certas ações. Então,
para você criar um método, para
criar um método, você sabe que
você definitivamente quer
ter o seguinte. Você quer realizar as
seguintes ações, certo? Então, digamos que
eu queira criar um método, chame meu método. Sim, deixe-me
chamá-lo de meu método. Então, o que eu posso fazer é
dizer estático, vazio, minha matemática para frente, abrir isso e abrir assim. Isso é método. Sim. Então escreva assim. Bem, eu não preciso mais
desse cara. Realmente. Veja, deixe-me arrastar
esse cara todo o caminho só para que possamos
sempre lembrar que tudo está bem ali. Então, criamos um método antigo, realmente vimos que um sistema
que imprime pontos LN. Então poderíamos dizer, ei, pessoal, você quer. E vamos ver. Certo, ok, claro, há
um pequeno erro aqui. Método principal não encontrado na classe
HelloWorld, isso acontece, defina o
método principal public, static, void, main
method, certo? Então, essencialmente, sim, isso diz a você que
definitivamente há um problema aqui. Então, o que vamos fazer é dizer público,
estático, vazio, principal. E convocamos esse
trem e
mudamos nossa coisa aqui e
criamos essas cotas e ARDS. E aqui, invocamos
nosso método, meu método. Agora, vamos executá-lo e ver
o que acontece quando o executamos. Lindo, isso é
MyMethod, MyMethod, certo? Então, o erro foi
corrigido e é definitivamente assim que
lidamos com o metil. Então, sempre que você chama um
método de recrutamento de métodos, você quer colocá-los em
seu vazio estático público e , em seguida, executá-lo em qualquer
método que seja. Isso mostrará que definitivamente
funcionará ao seu gosto. Isso levanta a questão de
entender que a
coisa toda está aqui. O público obviamente
significa que é acessível a todos, hum, pode ser modificado e alterado em
formas de capa dura necessariamente. Mas a estática em si
é um pouco interessante. O que significa static? Bem, estática para
chegarmos ao tópico de algo ser estático ou
não ser estático, precisamos realmente entender
o que está acontecendo, certo? Então, estático versus não estático, é nisso
que estamos
nos concentrando agora.
19. Vs estáticos não estático: Tudo bem, então passamos para
as naturezas estática e não estática de nossos programas Java. E você costuma ver que
em programas Java, poderíamos ter nossa geografia. Os programas Java são estáticos
ou públicos em seus atributos
e métodos, certo? Então, no exemplo anterior
que fizemos aqui, criamos um
método estático, certo? Como você pode ver, existe
um método estático. Isso significava que ele só poderia ser acessado sem criar
um objeto da classe, ao contrário do público,
que só pode ser acessado por objetos, certo? Então, vamos dar uma olhada no exemplo
a seguir apenas para
demonstrar as diferenças entre os métodos estáticos e
públicos, certo? Então, deixe-me
deletar tudo isso. Não precisamos mais disso. Pelo menos essa parte
até a nossa classe pública
ali, certo? Então, logo após a aula pública, vamos apenas
nomear isso e colocá-lo como um comentário e manter o método
estático. E nosso método estático será
o seguinte tipo dirá vazio
estático e o
chamará de meu método estático. Vai ser muito
melhor assim. Um pequeno erro de digitação por lá. E então nos certificamos de
que temos isso entre parênteses. E nós abrimos assim. Então diremos Just system
dot out, dot print LN. E tudo o que temos que provar aqui é
apenas dizer que algo como métodos estáticos
podem ser chamados, podem ser chamados sem
criar objetos. Sem criar objetos. Simples assim, certo? E então, por outro lado, o que
vamos fazer
também é que também
mostraremos uma diferença
aqui com um método público. Vou colocar isso como
um comentário. E com nosso
método público direi apenas vazio
público, meu método público. E apenas
abra isso assim. E nós apenas dizemos sistema
fora, ponto print LN. E então acabamos de mencionar que os métodos
públicos devem ser chamados pela criação de objetos. Então, precisamos de objetos
com métodos públicos. Essa é essencialmente a diferença
entre os dois, certo? Essa é essencialmente a
diferença entre os dois. Então o que vou fazer é chamar isso de meu método principal, se
você quiser, certo? Esse é o meu método principal. O principal, certo? Então, vou apenas dizer algo
como público, estático, vazio. Quer dizer, como sempre dizemos. E então, à direita
em nossa coisa aqui, nós vamos apenas
chamar uma string. E como você sabe, eu preciso colocá-lo
lá porque eu não tenho esse
ERG S
inerentemente lá. E apenas venha até aqui. E chamamos isso de meu método
estático, certo? E, essencialmente, ao fazer
isso, o que estamos fazendo? Estamos chamando o método estático. Isso é o que realmente está
acontecendo aqui. Então aqui está com caudal
são método estático. Então, se nós, se
talvez chamássemos nosso método público, vamos ver o que aconteceria. Método público. Portanto, há um
método público lá. Há um pequeno
erro por lá. Por que isso? Tem uma flecha ali? Porque a maneira que precisamos
chamar um método público
é que precisamos chamar. Precisamos criar um objeto, antes de tudo,
para que possamos acessá-lo. Você vê isso para acessar
os métodos públicos. Então isso é claramente
um erro aqui. Vamos chamá-lo, vamos apenas dizer, vamos compilar uma flecha. Essas compilações e erros, o que significa que, com isso, o que experimentamos é um erro. Mas então vamos
chamá-lo na classe principal, que se chama HelloWorld. E apenas diga meu objeto. Então nós apenas dizemos
novo olá mundo e fechamos isso. E então chamamos isso de
meu objeto novamente. E então, com esse tempo, acabamos dizer ponto meu método público. Já está sendo, você poderia
dizer idiota, falso, certo? Isso. E como você pode ver, não
há erro. E essencialmente o que estamos
fazendo aqui é que estamos criando um objeto de Um objeto de Hello World, Essa é uma classe principal, certo? E aqui,
essencialmente, o que estamos
fazendo é chamar
o método público
no objeto que o método público
no acabamos de criar. Então, se fôssemos executar isso, vamos ver o que basicamente
obtemos. Normalmente, como você pode ver, não
há nenhum erro. Então, devemos ter o primeiro mostrando que métodos
estáticos podem ser chamados sem
criar objetos. Voila. Então também temos métodos públicos que devem ser chamados
criando objetos. Como podemos ver, tivemos que criar um objeto para montar o dia, certo? Então, essencialmente, essa é a diferença entre
os dois, certo? E só para
elaborar mais isso, poderíamos até falar sobre como
acessamos métodos dentro de
um objeto, certo? Então, digamos que você crie, deixe-me colocar os métodos de
acesso downforce com um objeto. Então, vamos usá-lo para criar um carro. Um objeto de carro chamado meu carro. Você poderia simplesmente ligar para o MF muito
acelerador de aceleração total e
velocidade excessiva direto no meu carro. um objeto e, em seguida,
simplesmente execute o programa. E se isso não fizer sentido, vamos escolher
um exemplo disso. Então, deixe-me
remover tudo isso. Não precisamos de nada disso por enquanto. Provavelmente só isso
poderia dizer que isso
sempre me faz voltar para o
meu segundo teclado. Mas então, por enquanto, vamos fazer isso. Vamos criar aceleração total. Crie um erro
de digitação a todo vapor, onde há comida jogada com um
grande T ali. E estamos criando um método de aceleração total
aqui, certo? Então, essencialmente, é isso. Então, vamos apenas dizer público, vazio, foo, acelerador. E nós temos isso, fechamos assim. Então, dentro desse método, tudo o que esse método faz
é imprimir pontos do sistema, imprimir
pontos LN, imprimir
a seguinte declaração. O carro está indo
o mais rápido que pode. Sim, porque indo
o mais rápido possível. Tudo bem. Então, o que queremos fazer a
seguir é
criar um método de velocidade também. Tudo bem? E adicione um parâmetro. Então, vamos chamá-lo de velocidade do vazio
público. O primeiro
vazio mais público, a todo vapor. Este usa a velocidade do vazio público. E então neste trecho aqui, que vai
colocar nosso parâmetro e chamá-lo de velocidade máxima. Esse é o nome do
nosso valor inteiro que deveria estar lá. Ele deve representar
a velocidade máxima. Então, vamos apenas dizer
sistema fora, imprimir LN. E aí mesmo
chamaremos a velocidade máxima. E a velocidade máxima é, e lá fora
chamará a velocidade máxima. Esse é o valor inteiro
que queremos, certo? Então a próxima coisa
que queremos fazer é apenas, hum, isso está dentro, claro, letras maiúsculas. Por dentro do Hello World. O que queremos fazer é chamar os métodos no objeto do meu carro, certo? Então, lá temos, dirá
público, estático, vazio agora. E então temos todas as cordas aqui com um RGS aqui e
ali, nós temos. E vamos ligar para Hello World. Olá Mundo, e
diga meu carro, por exemplo. E depois dizemos novo
e “Olá, mundo” de novo. Então, essencialmente aqui, como você sabe, estamos apenas criando
meu objeto de carro. Isso é o que está acontecendo.
Então, o objeto existe. Agora, se quiséssemos
ir a público sobre isso, poderíamos definitivamente
fazer uso do objeto. Então, nós apenas vinculamos isso ao
nosso método de aceleração. Então, essencialmente, o que
estamos fazendo é chamar o método de aceleração total. Então dizemos de novo, meu carro, e então alocamos
ou aceleramos em talvez 25. Então, ao sombrear, estamos
chamando a matemática da velocidade de PFAD. Isso é o que está acontecendo aqui. Certo? Então. Você só quer ter certeza de que não
há espaço aqui. Deve ser apenas vazio estático
público. Deve haver um principal
aqui que eu deixei de fora. Principal. Sim, bom. E nós executamos isso e devemos nos dizer
que o carro está indo mais rápido
possível primeiro e depois nos dizer a velocidade
máxima também. Então aí está. O carro está indo
o mais rápido que podemos ter. E o mx b é 25, certo? Então, só para elaborar o que está
acontecendo mais aqui. Em primeiro lugar, criamos um hello de classe mundial
personalizado. Isso é o que está acontecendo
com a palavra-chave class. E, em segundo lugar, criamos o método de aceleração total aqui. Não apenas essa aceleração total, mas também o método da velocidade. Exceto no método speed, nós tínhamos um parâmetro
que é um inteiro, é um inteiro, o
que quer que esteja dentro
disso como um parâmetro. Mas nosso inteiro aqui
ou em nosso parâmetro é um inteiro e é chamado
de parâmetro de velocidade máxima. Então nós simplesmente dissemos
para que usássemos nossa média,
nossa classe Hello,
HelloWorld. E a culpa é minha.
Precisamos criar um objeto da classe mundial hello, que é exatamente o que fizemos. Criamos um objeto
aqui, certo? Então, a próxima coisa
que fizemos foi dizer que criamos um objeto , obviamente, usando a nova
palavra-chave ali. E então chamamos
os métodos de aceleração total e velocidade no
objeto mica e executamos o programa. E nomeie o objeto
seguido pelo ponto, seguido pelo
nome do método qual estamos interessados. E vale a pena
notar que podemos adicionar um parâmetro int de mesmo que 200 dentro do método de
velocidade, certo.
20. Construtores: Então, lembre-se, algo que
vale a pena notar é exatamente isso. Lembre-se de que o ponto é usado para acessar os
objetos, objetos, atributos
e métodos. Portanto, vale a pena
notar que, porque isso é muito
útil à medida que você progride, especialmente
em todo o aspecto do que ainda estamos fazendo
no momento, certo? Incrível. Então, a próxima coisa
que eu quero que analisemos é o que é chamado de construtores. Construtores. E isso é algo que
será muito útil à medida que você avança
cada vez mais. Então, basta ter em mente que
um construtor em si. O construtor é um método especial, um método especial que é usado para inicializar objetos
tão simples quanto isso. Viola. Simplesmente, chamamos o construtor quando
um objeto de uma classe é criado e ele pode
ser usado para definir valores
iniciais para atributos de
objeto. Tudo bem? Então, um exemplo disso
provavelmente seria algo como, vamos até aqui e ver se eu posso dar
um exemplo disso. Então, agora estamos falando
sobre um construtor. Então, digamos que
temos algo como int x sendo assim. Em essência, estamos criando
um atributo de classe. Apenas certifique-se de que este é um comentário criado na árvore de classes Butte. Criamos um
atributo de classe lá. Então, a próxima coisa que fazemos é
criar um construtor de classe. Agora, o foco principal do que
estamos fazendo agora. Para a nossa turma, que é
a classe HelloWorld. Incrível. Então, nós apenas dizemos público. E então dizemos olá, mundo. E então vamos fazer isso
e fechar aquela luz aquilo. E sim, vamos ter certeza de que está
aberto assim. E aqui nós apenas nomeamos nosso atributo e damos
a ele um sete, por exemplo. Ao dar-lhe um sete, o que fazemos a seguir é que
apenas temos nosso método comum, public void, main, string ou NGS. E nós criamos um objeto essencialmente que
vai ser hello world. E basta enviar meu OBJ. E então dizemos novo olá
mundo e fechamos isso. Isso significa o que fizemos? Criamos um
objeto da nossa classe, que será usado para chamar
um construtor, certo? Então, criamos
um objeto que chamará a estrutura. O objeto
da nossa BU de cluster definitivamente chama um construtor? Então, bem aqui, o que eu
vou fazer é definir meu, então temos x sobre o, essencialmente estamos imprimindo o valor, valor de x. Então vamos ver se podemos
obter um sete ali . Isso é perfeito. Temos nossos sete. Portanto, vale a pena notar que o nome do construtor deve
corresponder ao nome da classe e não pode ter um tipo de retorno como
int void, por exemplo. E observe também que o
construtor é chamado quando o objeto é criado e todas as classes
são construídas por padrão. E se você não criar um construtor de
classe sozinho, Java criará um para você. No entanto, você
não poderá definir valores
iniciais para
atributos de objeto, certo? Então, outra coisa que
vale a pena
examinar definitivamente é o que é
chamado de construtor. Param do construtor. Então, um parâmetro de construtor. Parâmetros do construtor,
essencialmente eles podem, os próprios construtores podem pegar parâmetros que são usados para qualquer atributo de
mentira. Tudo bem, então aqui está
um exemplo que
podemos definitivamente usar como uma aplicação do que
estamos falando aqui. Vamos apenas consolar
tudo o que fizemos até agora. Em vez disso, até
pelo menos alguns quebra-cabeças, dizemos que x é igual a y. E então ainda
não definimos y. Mas, em vez disso, o que vamos
fazer é
defini-lo ali mesmo
e chamá-lo de int y. E, em seguida, bem aqui também. O que vamos fazer é dizer “objeto”. E então aqui, vamos colocar um número
correspondente ao valor de y, porque é assim que
mencionamos que hello world tem um parâmetro. É um número inteiro de y. E sempre que vejo Hello World, preciso ter certeza
de tê-lo como um inteiro y sempre que
vejo isso como uma classe. Então, o que eu vou
fazer é dizer a minha parte. E então x e eu
executamos normalmente deve ser oito, porque x é igual a y. Então aí está,
apenas oito, certo? Acabei de comer e você pode ter
quantos parâmetros quiser. Então, por exemplo, aqui pode
ser um número inteiro chamado ano. Por exemplo, apenas
um exemplo, na verdade. E em que, por exemplo, teria que modificar isso
definitivamente. Digamos que isso foi
como modelo, sim, em termos de talvez estejamos
falando de custos, talvez. Então isso seria como o
seu modelo aqui. E então, abaixo, você provavelmente vai querer
olhar para a corda. Não preciso desse
comentário por enquanto. E então tenha uma string
que nos diga qual é o nome do modelo
desse carro. E então, porque os
temos assim sugerimos
que um
número inteiro aqui
seria o fluxo de ar apenas
chamando o nome. Sim. Então, essencialmente,
o que vamos fazer é dar a eles nome do
modelo
seria essencialmente equivalente a alguém que lhe
pediu o nome. E então modelo
seria equivalente a mim. Basta dizer qual é o sim. Associado ao carro de que
estamos falando. E então eu vou apenas dizer aqui,
principal, aqui está o
Hello World. Aqui. Definitivamente,
daremos o nome Primeiro. Vamos chamá-lo de exemplo da Ford. Então, neste
vau , vamos
começar com o ano primeiro. Então, vai ser 1967. E colocamos o nome
que seria combatido, por exemplo, placa de 1967. E é só uma questão de garantir que
imprimimos bem agora. Então, como vamos imprimir isso? Bem, não é mais
apenas um objeto, então vou
chamá-lo de meu carro aqui. Eu chamo isso de ponto do meu carro. Então é só uma questão de
escolhermos exatamente o que queremos. Portanto, temos isso da
seguinte maneira. Em seguida,
invocamos não apenas o ano, mas também
o nome modal. Então, deveria dizer 1967, Ford também. Então aí está. 1967. Ford faz a saída
que obtemos, certo? Então, essencialmente, é
sobre isso quando
se trata de construir isso. Isso é o
incômodo quando se trata construtores em ação, certo?
21. Modificadores: Tudo bem pessoal, então
a próxima coisa que eu definitivamente quero que
analisemos
é o que é chamado de
modificadores, certo? Então, deixe-me colocar isso aqui,
porque há alguns comentários que acontecerão aqui. Então nós os chamamos de Phi é, certo. E eles se importaram com modificadores, algo que
já estamos usando. Tenha em mente que, por exemplo, sempre que dizemos
classe pública HelloWorld, público é um modificador, certo? Então, nós digitamos ou outros
grupos de modificadores. Os modificadores podem ser nomeados em termos de ou melhor, agrupados em termos de modificadores de acesso, que é um exemplo
do nosso público. Podemos ter
modificadores de acesso ou não podemos ter modificadores de acesso. Tudo bem? Então, o que são modificadores de acesso? Os próprios modificadores de acesso são inerentemente aqueles que controlam acesso, assim como o nome diz, Realmente acesse qualquer
codificação que você tenha, certo? E então este não é. Eles não controlam o acesso. Mas eles fornecem provide. Outras funcionalidades. Sim, incrível. Então, esses são os modificadores de não
acesso. Público, por exemplo, público, como falamos, público é um exemplo
de modificador de acesso. É. E só com isso
que estou prestes a mostrar a vocês, porque é um pouco
de algum comentário que definitivamente
faria aqui,
apenas para que você possa
entender exatamente o que estamos fazendo aqui. E vou dar um exemplo
começando com o público. Então, essencialmente, o que
é público é permitido ou melhor, o que
isso significa é que estamos falando de uma classe que é acessível por outras classes. É uma aula acessível por outro copo, se você quiser. Então, também podemos falar sobre um modificador chamado modificador
padrão. Tudo isso são
modificadores de acesso, a propósito, provavelmente
devem apenas
deixar claro que são modificadores de acesso. Também temos padrão
e padrão. O que isso significa é que
a classe só pode ser acessada por classes
no mesmo pacote. Turma. Aulas simples de tchau
no mesmo pacote. Agora, se você está se perguntando
quais são os
mesmos pacotes que poderíamos estar falando
sobre isso, por exemplo, este é um pacote do qual
estamos falando. Então, poderíamos ter
vários pacotes e, na verdade, é um contêiner
contendo classes. Você pode pensar
nisso mais assim. E usamos isso quando
não especificamos um modificador. Então isso significa que isso é usado. Java usa isso automaticamente. Isso é usado quando você não especifica por modificador, é o padrão. Se você quisesse, com
certeza poderia dizer isso. Sim. Tudo bem, e então
quatro atributos, métodos e construtores
que você pode usar. Tudo isso realmente poderia ser
útil, não apenas público. E como sabemos, P
tem que ser pequeno t. E depois quatro atributos, atributos, métodos e construtores. Poderíamos ter o seguinte. Ainda podemos usar o público. Aqui. Isso significaria
que nosso código é acessível para todos os clusters. Então, se for privado. Se for privado, é
uma coisa diferente. É só o código que
só pode ser acessado. Em seguida, declaramos classe,
então é particular. E então, se for padrão, significa que estamos
falando sobre isso. Mesmo pacote. A soja ainda é a mesma coisa que já
mencionamos aqui. Então, vou fazer isso apenas para referir ou autotrophs mostrar
que é a mesma coisa, mas sim aqui apenas
para o mesmo código
de pacote acessível na
mesma base de pacote. Então também poderíamos
ter protegido. E quando um código ou o que você deseja modificar é protegido, isso significa que o código também pode
ser acessado no
mesmo pacote. E subclasses. Isso vai ver muito mais
e ajudar muito, especialmente quando começamos a
falar sobre herança, superclasses e subclasses, é muito valioso
que você saiba disso. Sim. Certo. Então, a próxima coisa que eu quero que
analisemos é o que
chamamos de modificadores sem acesso. Sim. Com um modificador
sem acesso deixe-me
colocá-los para baixo para nós. Estamos falando sobre modificadores de acesso
Nan. E com os
modificadores sem acesso, certo? Realmente, você pode
usar final ou abstrato. Esse é o, esse é o k
é pelo menos quatro classes. Aulas. Você só pode usar Final
it all up struct. E se estamos falando de
algo ser final, o que estamos dizendo é
que a classe não pode,
a classe não pode ser herdada, não
pode ser herdada
pelo processo. Então, novamente, isso é muito útil, ou melhor, você entende
isso ainda mais à medida fazemos herança,
o que ainda estamos para fazer. Sou só eu.
Construindo para isso. Estou aqui com abstração
significa que a classe não pode ser usada para criar objetos. Portanto, para que você possa
acessar uma classe abstrata, ela deve ser herdada
de outra classe. Tudo bem? Então, para, esse foi o
caso das aulas. Mas então, se estamos falando
sobre atributos e métodos, quando estamos nos referindo a algo ser
definitivo, isso significa o quê? Isso significa que aquela
coisa ou esse atributo ou esse método não podem
ser substituídos. Substituído. Mostre que você ainda se lembra do
exemplo que fizemos acima. Isso não pode ser escrito em excesso por mais
uma hora ou se algumas pessoas
até mesmo modificariam. Então, se for estático, também
temos estática. Se algo é estático de atributos e
métodos são estáticos, isso significa que nossos atributos e métodos pertencem à classe. Dan, em vez de um objeto. Pertence a. Eles pertencem à classe. Em vez de objetar. Sim. E se for abstrato, significa o que significa
que só pode ser usado, só
pode ser usado em
uma classe abstrata. E
só N só
pode só N só ser usado em métodos, não em qualquer outra coisa. Portanto, tenha em mente que o método não tem incorporação. Por exemplo, algo como o vazio
abstrato corre para que o próprio corpo seja fornecido
pela subclasse herdada
de, certo. Portanto, é apenas algumas informações
extras que você precisa ter
em mente, suponha. Também poderíamos falar sobre como também
existe transitório, o que não é muito comum de usar, mas ainda existe. Então, isso significa que
atributos e métodos são ignorados ao serializar
o objeto que os contém? Envie ignorado. Usando o objeto
contido neles. Em seguida, também sincronizamos. Então, o que significa
essencialmente sincronizado? Quando algo está sincronizado, essencialmente o que estamos dizendo é que eu acho que deixei
algo aqui. Pecado colonizado. Sim. Essa é a grafia correta. Sincronizado. Isso significa que nossos
métodos só podem ser acessados por um thread
por vez, certo? Portanto, é importante que
eu afirme que aqui, esse é um método ao qual estou
apenas me referindo. Os métodos só podem ser acessados por um encadeamento por vez. Então, se for volatilidade ou
melhor, volátil, se você quiser. Se eu usar volatilidade significa que o valor de
um atributo
não é encadeado localmente e isso é sempre lido
na memória principal, certo? Então, novamente, definitivamente não é algo que você veria muitas vezes. Mas se os custos, a programação
é tão grande com Java, desculpe, no final das contas
dependerá do que
você está citando. Esses conceitos incríveis
que progressivamente nos
encontraremos fazendo localmente e sempre são lidos na memória principal. Isso em si não
estava aqui na segunda-feira. Sim, então este é o eixo n nenhum modificador de acesso que você definitivamente
quer ter em mente. E agora vamos
apenas dar alguns exemplos, explorando
isso muito mais. Então, um exemplo disso
seria algo assim. Deixe-me deletar tudo isso. Não precisamos mais disso. Então diz final. Há um modificador em x em um atributo aqui
e dê talvez 19. E então dizemos o
Pi duplo final e o próprio Pi, como sabemos, é dado por 3,14. Sim, 3,14 é, na verdade, 3,1428. Então, deixe-me apenas ajudar e progressivamente,
e assim por diante. Então, estamos afirmando que nossos
modificadores estão sendo finitos. Isso significa que eles não podem
ser substituídos ou modificados. Não podemos começar a definir o
novo valor de X ou o novo valor de pi, certo? E aí vem o método. Dizemos public, static, void, main e,
em seguida, essa string. E nós apenas nos certificamos de
que temos tudo bem, teclado sobre o RGS deles e
nós ingerimos abrir isso. E aí mesmo
nós criamos um objeto. Então dizemos olá, mundo. E então meu J é igual ao novo
nome hello-world da minha classe. Eu simplesmente desço e depois começo a explorar outra
coisa. Então, vamos começar assim. Vamos apenas dizer meu OBJ
e depois eu digo x. E então vamos ver o que
obtemos com isso
vai ser interessante. Coisas erradas. Eles, por que então é erro? Bem, como podemos ver, erro. Tudo bem, por quê? Porque ele não pode
atribuir valor de x, y porque o
declaramos como final. Isso significa que não pode ser modificado ou alterado de
forma alguma. Mesmo se tentássemos a torta e tentássemos modificar
nosso Pi também. Uma coisa semelhante definitivamente
aconteceria com cinco para dizer,
Oh, o novo valor de pi é
apenas 3,14, por exemplo. Nada de errado com isso,
mas eles ainda são um erro. Por que então o erro é
um erro porque estamos modificando o valor que foi
declarado como sendo final. Isso não deveria estar mudando. Não é possível atribuir um
valor de Pi seno, tudo bem, Yeah,
Yeah, Yeah, certo. Então, deixe-me tentar imprimir
e dizer, Ei,
sistema, ponto fora, impressão de pontos. E então
imprimimos x, por exemplo. E vemos o que vai acontecer. Então, se imprimirmos x, apenas um aqui, lembre-se que
imprimimos com objeto. Então aí está o meu objeto. Vamos ver o que, o que obtemos. Agora. Obviamente, este aqui, vamos
colocá-lo em um comentário porque sabemos que
há um erro lá. Não precisamos disso.
E nós o administramos. E vamos ver. Tirando um pouco de
tempo aqui para carregar. Ainda carregando. Isto é maintain faz porque
definimos x como 19, objeto é x. E se eu fosse mudar
isso por exemplo, e apenas fazer isso tudo pi, então vamos ver o que
vem disso. Agora. Vamos ver se isso nos dá 3,148. Isso é 3.1428, certo? Então esse é um exemplo de como
usamos o modificador final. Modificador final, que sabemos
estar no modificador sem acesso. Agora vamos usar outro modificador
sem acesso, que é um modificador estático. Então, ou eles entendem
muito mais, certo? Então, com isso, é
um metal de nós apenas entendermos, mesmo sempre que temos algo
chamado estática. Método estático significa que ele pode ser acessado sem criar
um objeto de uma classe. Ao contrário do público em que
já falamos sobre isso, estamos falando sobre
estática versus não estática. Espere. Só para colocar isso em perspectiva, deixe-me remover
tudo aqui. Provavelmente vou dar esse cara aqui porque sei que
não tenho um teclado. E basta criar um método estático. Eu digo apenas estático, vazio, meu método
estático. E está definitivamente aberto. E basta chamá-lo de
sistema, pontilhar, imprimir e escrever lá. Provavelmente escreva
algo como estática. Os métodos podem ser chamados
sem criar objetos. Sim.
22. Modificadores de acesso e não acesso: Em seguida, basta olhar para o método
público e
olhar para um vazio público. Basta criar algo como vazio
público e depois
chamá-lo de meu vazio público. Agora, método público, que está aqui, vamos imprimir algo
como sistema que é podado. Então, digamos que os métodos públicos
devem ser frios. Ao criar objetos. Então temos muito. Algumas pessoas
diriam o método principal, mas vamos chamá-lo de
nosso método HelloWorld. E este
será apenas algo como este público, estático, vazio principal. E falaremos sobre
esse trem G S e simplesmente desceremos e
chamaremos nosso método estático. Apenas certifique-se de que eu tenha esse aparelho
encaracolado lá. Sim, meu método estático, essencialmente estou chamando
esse método estático colin, o método estático. Ao fazer isso. Então, se eu
olhar para o meu método público, se eu tentar chamar
isso, vamos ver. Isso já é uma indicação que algo estava
errado, pois não foi sugerido para mim,
que há um erro. Por quê? Porque eu preciso criar um objeto para começar
a usar esse direito. Aqui está um erro aqui. Então eu preciso colocar isso como um comentário e apenas criar meu objeto Hello World. Olá. Tudo bem, acho que é
hora de mudar. Agora. Meu Deus, por enquanto. Eu tenho ligado para o meu OBJ por muito tempo, por
muito tempo ou outro. E olá mundo e meu OH, e esse método
público de homem de cor que
foi sugerido para mim. E, essencialmente, estou
chamando o método agora. Se eu executar isso, normalmente
deve funcionar. Agora eu deveria ser capaz imprimir o
método público também, bem
como o estático. Portanto, eu deveria ver as duas
declarações fumando, apenas uma
delas deveria ver métodos estáticos podem ser chamados sem
criar objetos. E eu deveria ser
capaz de ver que métodos públicos devem ser chamados
criando objetos também. Vamos ver. Também está carregando. Aí está. Nós temos
os dois. Métodos estáticos podem ser chamados sem
criar objetos. E temos
métodos públicos que podem ser chamados de devem ser chamados
criando objetos. Sim, lindo. Então aí está. Aí está. Então, a última modificação
que analisaremos é o que chamamos de modificador
abstrato. Como sabemos, o modificador
abstrato também
pertence
ao modificador sem acesso. Sim. E pode funcionar para classes
e quatro atributos, certo? Tão abstrato. Só vou
remover tudo isso de novo. E nós apenas nos
certificamos de que temos tudo no lugar. Ok, lindo. Tudo bem. Então, em vez de
chamar isso de público, vamos chamá-lo de obstrução
abstrata. Há aula abstrata. E com o Officer plus,
vamos apenas chamar, eu não preciso mais desse método
estático. E então eu vou apenas
dizer algo como talvez public String fname, que é para o meu FirstName, e chamá-lo de Will. E público final. Idade também, que
tem 24 anos. E também há um abstrato
público vazio abstrato
público. Estudar. Isso significa que esse
é um método abstrato. Sim. Esse é um método abstrato. Sim, definitivamente. E nós apenas nos certificamos de que
isso seja fechado assim. Definitivamente assim. Bom. Logo abaixo dela, o que faremos é ter
algo como uma subclasse, que realmente herdamos
do Hello World. E com todas as subclasses
diremos apenas clusters, o que significa que é
padrão
se você quiser, se fôssemos
deixá-lo como apenas o custo. Então, se eles atacarem o
aluno grande S e dissermos que estende a
herança agora, olá mundo. E abrimos isso. As possibilidades são infinitas. Agora ,
isso para que
tenhamos o comando público e
clique em Fechar e
clique em Fechar. Tudo bem, então a próxima coisa que eu quero que analisemos é
o que é chamado de encapsulamento Java. Então, vamos ter
isso aqui. Isso é encapsulamento Java. Então, o que significa encapsulamento Java é para nós realmente
entendermos o que realmente significa é que
precisamos entender o que é encapsulamento de
encapsulamento. Significa garantir que os dados
confidenciais estejam
ocultos dos usuários. E
para conseguirmos isso, devemos declarar variáveis de
classe. Atributos de barra, é claro, na verdade superam como privados. Em segundo lugar, fornecer,
queremos ter certeza que fornecemos o eixo dos métodos públicos get e set e o valor da variável privada. Sim, então isso é algo
muito importante também. Então você, nós já fizemos isso
que variáveis privadas
só podem ser acessadas dentro da mesma classe e a
classe externa não tem acesso a ela. No entanto, sabemos que
é possível
acessá-los se fornecermos métodos públicos de
obtenção e definição, certo? Então, o método GET retorna o valor da variável e o método
set define a variável. Portanto, a sintaxe para
ambos é que eles começam com
get all set seguido pelo nome da variável com a primeira letra em maiúscula. Um exemplo disso seria,
digamos, classe pública. Como eles
já estavam sugerindo aqui. Olá, mundo. Incrível. E então escrever lá, o que queremos fazer é colocar algo como uma string privada e
depois chamá-la de nome. E apenas certifique-se de que
fechamos isso. Então Ben, lembre-se de que
quando é privado, privado significa acesso restrito. Então, por razões de segurança, nós definitivamente queremos
ter essas coisas no lugar. Não queremos que todos tenham
acesso a tudo no seu código, pois eles
podem definitivamente hackear seus arquivos e apenas obter muitas informações
de você. Então temos getName. E abrimos isso. E dizemos nome de retorno. Nome do retorno. Então isso é um getter. Agora também temos nossas cerdas. E com toda a configuração, diremos apenas
public void setName. E basta chamar esse
treinamento para um novo nome. E abra isso e
diga esse nome como equivalente. Novo nome. Excelente. Excelente. Então, se executarmos isso, vamos ver o que obtemos.
23. Projeto de classe: Muito bem, então obrigado por
se juntarem a mim neste curso e no
seu projeto de aula. O que eu quero que você
faça é que eu quero que você, com todo o
trivalente agora, eu anexarei um arquivo aqui. Eu quero que você vá
direto para o arquivo. Eu quero ler isso. E há alguns exercícios que eu anexei
também que eu
gostaria que você fizesse
e se submetesse para mim. Tudo bem, saúde, e estou
ansioso para ver você
no painel de custos.