Como entender declarações java

A maioria dos resumos de sintaxe listar os detalhes de cada tipo de instrução usando, descrições esotéricas formais. No entanto, estes exemplos de cada tipo de instrução dar uma breve descrição, informal do propósito do tipo de instrução. Esta descrição da sintaxe Java está longe de ser completa, mas você deve encontrá-lo para ser legível e útil.

Uma classe Java:

classe PreIncrementDemo {}

O que significa: “As coisas entre as chaves pertence a uma classe chamada PreIncrementDemo. Esta classe é um modelo para a criação de objetos (instâncias da PreIncrementDemo classe)."

declarações de importação:

importação java.util.Scanner-import java.lang.System.out- estática

O que eles querem dizer: “Quando eu usar o nome Scanner em outras partes deste .Java arquivo, levá-la a ser uma abreviação para java.util.Scanner. Ou seja, levar o nome Scanner para representar o Scanner classe que está no java.util pacote.

“Quando eu usar o nome em outro lugar neste arquivo .java, levá-la a ser uma abreviação para java.lang.System.out. Ou seja, levar o nome Fora para representar a estática Fora campo que está no Sistema classe que, por sua vez, está na java.lang pacote."

declarações de variáveis:

int numberOfBunnies = 27-Jframe myFrame-

"O nome numberOfBunnies armazena um int valor (um valor do número inteiro, tal como 42, 0, -289) e o valor a partir de numberOfBunnies é 27. O nome MyFrame irá se referir a um objeto criado a partir da JFrame classe. (Isso é, MyFrame vai se referir a um instância do JFrame classe. o JFrame classe é pré-declarado em um pacote chamado javax.swing.) “

instruções de atribuição:

amountInAccount = 50,22-amountInAccount * = 1.05-amountInAccount = amountInAccount + 1000000.00-

“Para a variável amountInAccount atribuir o valor 50,22. Em seguida, multiplicar o valor de amountInAccount por 1,05. Em seguida, adicione 1.000.000,00 para o valor de amountInAccount.”

A declaração de método:

int incrementBy (quantidade int) {}

“Eu estou introduzindo (que é‘declarar’) um método chamado incrementBy. o incrementBy método leva, como sua entrada (é “parâmetro”) um int valor. Dentro do corpo do método (isto é, entre as chaves) que o valor do parâmetro é conhecido pelo nome quantidade variável. Execução do incrementBy método retorna um valor (possivelmente diferente), também de tipo int.”

Chamadas de método:

n = incrementBy (6) -System.out.println (incrementBy (10)) -

"Ligar para incrementBy método (isto é, executar as instruções no corpo do incrementBy método) dando parâmetro do método do valor 6. Pegue o valor retornado pela chamada para incrementBy, e atribuir esse valor retornado para a variável n.

“Além disso, chamar a incrementBy método que dê parâmetro do método do valor 10. Em seguida, tomar o valor retornado pela chamada para incrementBy, e alimentação que retornou valor para outro método - de Java pré-declarados System.out.println método."

Um método principal:

void main (args String []) public static {}

“Comece a executar o programa Java executando as instruções no corpo do método chamado a Principal.”

A chamada do construtor:

JFrame MyFrame = new JFrame ("Este é o meu quadro!") -

“Criar um novo objeto usando a definição do JFrame classe. (UMA JFrame é o que você normalmente chamam de “janela”.) Na barra de título do novo objeto, exibir as palavras Este é o meu quadro! Deixe a variável MyFrame referem-se ao novo objecto (a nova instância da JFrame classe)."

Uma instrução if:

if (entraNumero == randomNumber) {} else {}

“Se o entraNumero é igual ao número aleatório, em seguida, executar um grupo de instruções (os comandos dentro do primeiro par de chaves). Mas, se o entraNumero não é igual ao número aleatório, executar um grupo diferente de instruções (os comandos dentro do segundo par de chaves - as instruções após a palavra outro).”

A instrução switch:

switch (verso) {case 1: break-case 2: quebrar-case 3: quebrar-default: break}

“Se o valor de versículo é 1, executar as instruções depois caso 1: e, em seguida, romper fora do inteiro interruptor declaração. Se o valor de versículo é 2, depois de executar as instruções Caso 2: e, em seguida, romper fora do inteiro interruptor declaração. Blá-blá-blá de versículo sendo igual a 3. Se, por algum motivo, o valor do verso não é qualquer um dos valores 1, 2 ou 3, executar as instruções depois padrão: e, em seguida, romper fora do inteiro interruptor declaração."

A instrução while:

while (entraNumero! = randomNumber) {}

“Verifique se o entraNumero não é igual ao número aleatório. Se assim for (isto é, se os dois números não são iguais), em seguida, executar as instruções entre as chaves. Depois de executar as instruções entre as chaves, em seguida, repita a coisa toda. (Verifique se os números não são iguais, e assim por diante). Se, durante uma das repetições, você acha que entraNumero! = randomNumber não é verdade (isto é, você achar que o entraNumero é igual ao número aleatório), Em seguida, parar de repetir coisas e seguir em frente para executar o que quer declaração vem imediatamente após este enquanto declaração em seu código “.

Video: Curso de Java - Aula 22 - O problema dos Loopings - eXcript

A instrução for:

para (int count = 1- contagem lt; = 10- contagem ++) {}

“Comece com 1 para o valor de contagem. Certifique-se de que contagem é inferior a 10. (É claro que, neste exemplo, contagem começa sendo inferior a 10.) Porque contagem é inferior a 10, executar as instruções no interior das chaves. Quando você terminar de executar os comandos dentro das chaves, faça o contar ++ negócios (isto é, adicionar 1 ao valor de contagem).

“Volte e verificar para ver se contagem ainda é inferior a 10. (Sim, neste exemplo, contagem é agora 2.) Como contagem é inferior a 10, executar as instruções dentro das chaves, e em seguida, adicione 1 ao valor de contagem.

“Se, no início de uma repetição, você acha que contagem lt; = 10 não é verdade, então parar de repetir coisas e seguir em frente para executar o que quer declaração vem imediatamente após este para declaração em seu código “.

Um do ... while:

do {} while (responder! = `y` && Resposta = `n`)! -

“No começo, não marque nada. Comece por executar as instruções entre as chaves, em seguida, verificar para ver se resposta não é igual a ‘Y’ e resposta não é igual a ‘N’. (Ou seja, verificar para ver se resposta não é nem ‘Y’ nem ‘N’.) E se resposta não é nem ‘Y’ nem ‘N’, em seguida, repita a coisa toda. (Execute as instruções entre as chaves, em seguida, clique aqui.) Se, no final de uma das repetições, você achar que o resposta é também ‘Y’ ou ‘N’, em seguida, parar de repetir e executar a instrução imediatamente após este fazer enquanto declaração."

Uma declaração enum:

Quarto enum {salão, cozinha, sala de jantar, sala, hall, estudo, biblioteca, billiardRoom, conservatório} -Room sceneOfTheCrime = Room.study-

“Qualquer variável que é declarada como sendo do tipo Quarto armazenará um dos seguintes valores: Room.ballroom, Room.kitchen, Room.diningRoom, Room.lounge, e assim por diante. Neste exemplo, a variável Cena do crime é declarado como sendo do tipo Quarto. a variável Cena do crime começa armazenar o valor Room.study.”

Uma instrução for aprimorada:

for (Quarto MyRoom: Room.values ​​()) {}

“Execute as declarações dentro do encaracolados chaves várias vezes - uma vez para cada um dos Quarto Os valores da enumeração. Executar as instruções uma vez com meu quarto igual a Room.ballroom. Em seguida, executar as instruções novamente com meu quarto igual a Room.kitchen. E assim por diante."

Estendendo uma classe existente:

classe FullTimeEmployee estende empregado {}

"UMA Empregado em tempo integral é um Empregado com certeza Features- adicional ou seja, as características descritas entre as chaves “.

Neste exemplo Empregado em tempo integral é um subclasse (A.K.A. classe criança) do Empregado classe, eo Empregado classe é um superclasse (A.K.A. classe pai) do Empregado em tempo integral classe.

A cláusula throws:

vazio doStuff () throws IOException {Scanner diskScanner = new Scanner (new File ("EmployeeInfo.txt")) -

“A execução de algum código dentro do Fazer coisas método pode lançar uma IOException.”

Quando você tenta criar uma nova instância do Arquivo classe, as coisas podem dar errado. Java insiste que você reconhece a possível calamidade, ao anunciar que seu método pode / pode lançar uma IOException. Sempre que você executar um código que pode lançar uma IOException, você deve reconhecer a exceção em seu código. Uma exceção que deve ser reconhecido (como IOException) É chamado de exceção verificada.

construtores:

Classe de temperatura {ScaleName Temperatura scale-público-privada número duplo privado () {number = 0,0-scale = ScaleName.fahrenheit-} Temperatura público (número duplo, escala ScaleName) {this.number = número-this.scale = Scale}

“Você pode criar um Temperatura objecto (um exemplo do Temperatura classe) chamando novo Temperatura () com nada entre os parênteses. Você também pode criar um Temperatura objeto chamando novo Temperatura (70,0, ScaleName.fahrenheit), ou Temperatura novo (0,0, ScaleName.celsius), ou com algum outro número e algum outro nome escala.

A declaração do construtor se parece com uma declaração de método, mas o nome de um construtor é o mesmo que o nome da classe correspondente, e uma declaração construtor tem nenhum tipo de retorno (nem mesmo vazio).

Chamar o construtor de uma superclasse:

classe TemperatureNice estende Temperatura {TemperatureNice pública () {super () -} TemperatureNice público (número duplo) {super (número) -}

“Sempre que o programa executa nova TemperatureNice () (Chamando o parameterless TemperatureNice construtor), têm a chamada do programa super(). Neste exemplo, chamando super() significa chamando novo Temperatura () (Chamando o parameterless Temperatura construtor.)

“Sempre que o programa executa novo TemperatureNice (70,0) (Chamando um a um parâmetro TemperatureNice construtor), têm a chamada do programa super (70,0). Neste exemplo, chamando super (70,0) significa chamando novo Temperatura (70,0) (Chamando um a um parâmetro Temperatura construtor.)"

Video: Aprenda Java Rápido! Aula01 Hello World

Trabalhando com matrizes (parte 1):

convidados int [] = new int [10] -

“Criar uma variável chamada convidados. a variável convidados irá referir-se a uma matriz de int valores. Abrir espaço para uma série de dez int valores. Deixei convidados referem-se a que o espaço gama “.

Trabalhando com matrizes (Parte 2):

para (int roomNum = 0- roomNum lt; 10- roomNum ++) {convidados [roomNum] = 0-}

“Loja 0 em cada um dos dez convidado localizações matriz.”

Trabalhando com matrizes (parte 3):

capacidades int [] = {4, 4, 2, 4, 2, 2, 4, 2, 0, 2} -

“Criar uma variável chamada capacities. a variável capacities irá referir-se a uma matriz de int valores. Abrir espaço para uma série de int valores. Armazenar os números 4, 4, 2 (e assim por diante) nos locais da matriz. Deixei capacities referem-se a que o espaço gama “.

Trabalhando com matrizes (Parte 4):

Quarto quartos [] = new quarto [10] -

“Criar uma variável chamada quartos. Os quartos variáveis ​​irá se referir a uma variedade de quartos. Abrir espaço para uma série de quartos. Deixei quartos referem-se a que o espaço gama “.

Trabalho com matrizes (Parte 5):

para (int roomNum = 0- roomNum lt; 10- roomNum ++) {quartos [roomNum] = new quarto () -}

“Faça espaço para dez Quarto objetos. Faça com que cada elemento do quartos referem-se a matriz de um desses Quarto objetos “.

Usando genéricos:

ArrayList pessoas = new ArrayList() -

“Criar uma variável chamada pessoas. a variável pessoas irá se referir a uma coleção de Cordas (Isto é, uma ArrayList do Cordas). Abrir espaço para uma ArrayList do Cordas. Deixei pessoas se referir a esse ArrayList.”

A instrução try ... catch:

try {} catch (NumberFormatException e) {} finally {}

“Tentativa de executar as instruções dentro do primeiro par de chaves. Se nada der errado (isto é, se a execução não lançar quaisquer excepções), em seguida, ignorar o pegar cláusula (os comandos dentro do segundo par de chaves).

“Mas se algo der errado (isto é, se a execução lança uma exceção), em seguida, saltar imediatamente a partir da declaração de ofensa à pegar cláusula. Cruze os dedos e esperar que a declaração agressor jogou uma NumberFormatException. Se assim for, então executar as instruções dentro do pegar cláusula, e depois passar para executar as instruções que vêm após a pegar cláusula.

“Ai de mim, se a instrução agressor lançou uma exceção que não é um NumberFormatException, em seguida, retornar prematuramente do método que você está executando atualmente (o método que contém este tente ... catch declaração). Retornar para qualquer método chamado este método atual, e espero que o método de chamada pode lidar de forma sensata com exceção desagradável.

“De uma forma ou de outra (exceção ou nenhuma exceção, retornando prematuramente ou não), executar as instruções dentro do finalmente cláusula (o terceiro conjunto de chaves).”

Usando modificadores de acesso (parte 1):

com.allmycode.utilities-pública de pacotes de primeira classe {} class Segundo {}

“O código neste arquivo pertence a um pacote chamado com.allmycode.utilities. A classe Primeiro está disponível para qualquer código Java. A classe Segundo está disponível para código Java somente se que o código também está no com.allmycode.utilities pacote."

Usando modificadores de acesso (Parte 2):

pacote com.allmycode.utilities classe Terceiro {amountInAccount pública = 50,22-int numOfThings = 22-privada coisas int =-protegido 10 int x = 40-

“O código neste arquivo pertence a um pacote chamado com.allmycode.utilities. a variável amountInAccount está disponível para qualquer código Java. (Qualquer código Java pode fazer referência ao nome amountInAccount.) A variável numOfThings está disponível para código Java somente se que o código também está no com.allmycode.utilities pacote. a variável coisa não está disponível para qualquer código fora do Terceiro classe. a variável X está disponível para código Java somente se esse código é ou na com.allmycode.utilities pacote ou que o código está em uma subclasse da Terceiro classe."

Implementação de uma interface:

classe Gameframe estende JFrameimplements ActionListener, ItemListener {}

“Eu (o Gameframe programador) concorda em fornecer corpos (implementações) para quaisquer métodos sem corpo declaradas no ActionListener e ItemListener interfaces.”

Uma expressão lambda:

(Cliente) -gt; customer.name.equals ("Burd")

"Retorna verdade se o nome do cliente é “Burd”- Retorna falso de outra forma."

. CustomerList.stream () filtro ((cliente) -gt; customer.name.equals ("Burd"))

“Tire os objetos no Lista de clientes. usando o corrente método, enviar esses objetos, um por um, a um filtro método. o filtro método se aplica a expressão lambda para cada objeto, ficando verdade para os clientes cujo nome é “Burd”, e falso para todos os outros clientes. Como resultado, o filtro método envia todos e somente os clientes cujo nome é “Burd” para qualquer método que vem a seguir na linha de montagem “.

Um método de referência:

Cliente :: isBurd

“Execute as instruções no corpo do Cliente classe de isBurd método."

class Cliente {boolean isBurd String O nome-pública () {name.equals de retorno ("Burd") -.} // Mais código vai aqui} customerList.stream () filtrar (Customer :: isBurd)

“Tire os objetos no Lista de clientes. usando o corrente método, enviar esses objetos, um por um, a um filtro método. o filtro método aplica-se a Cliente classe de isBurd método para cada objeto, ficando verdade para os clientes cujo nome é “Burd”, e falso para todos os outros clientes. Como resultado, o filtro método envia todos e somente os clientes cujo nome é “Burd” para qualquer método que vem a seguir na linha de montagem “.