Como compreender instruçõ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: "O material entre as chaves pertence a uma classe chamada PreIncrementDemo. Essa 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 outros lugares no presente .Java arquivo, levá-la a ser uma abreviatura 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 outra parte deste arquivo .java, levá-la a ser uma abreviatura 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á no java.lang pacote."

declarações de variáveis:

int numberOfBunnies = 27-Jframe myFrame-

"O nome numberOfBunnies armazena um int valor (um valor-número inteiro, tal como 42, 0, -289) e o valor de partida de numberOfBunnies é 27. O nome MyFrame irá se referir a um objeto criado a partir da JFrame classe. (Isso é, MyFrame irá referir-se 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, adicionar 1000000.00 para o valor de amountInAccount."

A declaração de método:

int incrementBy (valor 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 diferentes), também do tipo int."

Chamadas de método:

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

"Ligar para incrementBy método (ou seja, 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 alimentos para animais que retornou valor para outro método - de Java pré-declarados System.out.println método."

A principal método:

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 chamar uma "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 objeto (a nova instância do JFrame classe)."

Uma instrução if:

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

"Se o entraNumero é igual a número aleatório, então execute um monte de declarações (as declarações dentro do primeiro par de chaves). Mas, se o entraNumero não é igual ao número aleatório, executar um grupo diferente de declarações (as declarações dentro do segundo par de chaves - as declarações após a palavra outro). "

A instrução switch:

switch (verso) {case 1: break-case 2: break-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, executar as instruções depois case 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, depois de executar as instruções padrão: e, em seguida, romper fora do inteiro interruptor declaração."

A instrução while:

while (entraNumero! = randomNumber) {}

"Verifique para ver 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 ".

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. (Evidentemente, neste exemplo, contagem começa a ser menor do que 10.) Porque contagem é inferior a 10, executar as instruções dentro das chaves. Quando você terminar de executar os comandos dentro das chaves, faça o contar ++ negócios (ou seja, adicionar 1 para o valor de contagem).

"Volte e verificar para ver se contagem é ainda inferior a 10. (Sim, neste exemplo, contagem é agora 2.) Devido contagem é inferior a 10, executar as instruções dentro das chaves, e depois adicionar 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 executando as instruções entre as chaves, em seguida, verificar para ver se resposta não é igual 'Y' e resposta não é igual 'N'. (Isto é, 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 # 133 enquanto declaração."

Uma declaração enum:

Quarto enum {salão de festas, 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 vai 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 é declarada 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 Employee {}

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

Neste exemplo Empregado em tempo integral é uma subclasse (A.k.a. classe filha) 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 () lança 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."

Ao tentar criar uma nova instância do Arquivo classe, as coisas podem dar errado. Java insiste em que você reconhece a possível calamidade, anunciando que o 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 excepção de que tem de ser reconhecida (tal como IOException) É chamado um 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ública (número duplo, escala ScaleName) {this.number = número-this.scale = Scale}

"Você pode criar um Temperatura objeto (uma instância da Temperatura classe) chamando nova Temperatura () com nada entre os parênteses. Você também pode criar um Temperatura objeto chamando nova Temperatura (70,0, ScaleName.fahrenheit), ou nova Temperatura (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ública (número duplo) {super (número) -}

"Sempre que o programa é executado nova TemperatureNice () (Chamando o parameterless TemperatureNice construtor), têm a chamada do programa super(). Neste exemplo, chamar super() significa chamando nova Temperatura () (Chamando o parameterless Temperatura construtor.)

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

Trabalho 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. Adicione espaço para uma disposição de dez int valores. Deixei convidados referem-se a esse espaço array ".

Trabalho com matrizes (parte 2):

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

"Loja 0 em cada um dos dez convidado locais matriz. "

Trabalho 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. Adicione espaço para uma disposição de int valores. Armazenar os números 4, 4, 2 (e assim por diante) nos locais da matriz. Deixei capacities referem-se a esse espaço array ".

Trabalho com matrizes (Parte 4):

Quarto quartos [] = new quarto [10] -

"Criar uma variável chamada quartos. Os quartos variável irá referir-se a uma matriz de quartos. Adicione espaço para uma disposição de quartos. Deixei quartos referem-se a esse espaço array ".

Trabalho com matrizes (Parte 5):

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

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

Usando os genéricos:

ArrayList pessoas = new ArrayList() -

"Criar uma variável chamada pessoas. a variável pessoas irá referir-se a um conjunto de Cordas (Isto é, uma ArrayList do Cordas). Abrir espaço para uma ArrayList do Cordas. Deixei pessoas referem-se 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 (ou seja, 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 (ou seja, se a execução lança uma exceção), em seguida, saltar imediatamente a partir da declaração de ofensa ao 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 nº 133-catch declaração). Retornar para qualquer método chamado esse 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). "

modificadores usando o Access (Parte 1):

com.allmycode.utilities-públicas do pacote 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 o código Java apenas se o código que é também na com.allmycode.utilities pacote."

modificadores usando o Access (parte 2):

pacote com.allmycode.utilities classe Terceiro {amountInAccount pública = 50,22-int numOfThings = 22-privadas 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 o código Java apenas se o código que é também na com.allmycode.utilities pacote. a variável material não está disponível para qualquer código fora do Terceiro classe. a variável x está disponível para o código Java apenas se o código que está ou na configuração- com.allmycode.utilities pacote ou esse código é 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) -> customer.name.equals ( "Burd")

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

. CustomerList.stream () filtro ((clientes) -> customer.name.equals ( "Burd"))

"Tire os objetos no customerList. usando o corrente método, enviar esses objetos, um por um, a um filtro método. o filtro método aplica-se a expressão lambda para cada objeto, obtendo 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" a qualquer método que vem a seguir na linha de montagem ".

A referência de método:

Cliente :: isBurd

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

classe Customer. {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 customerList. 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, obtendo 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" a qualquer método que vem a seguir na linha de montagem ".