Descritor
Os descritores são palavras -chave que você adiciona a essas definições para mudar seu significado. A língua Java tem muitos descritores, incluindo o seguinte:
classe pública classe classe nome {// ...} private boolean myflag; estático final duplo semanas = 9,5; lwidth de caixa final estática protegida = 42; public static void main (string [] argumentos) {// Body of Method} Descritores acessíveis
O Java fornece uma série de descritores acessíveis para definir os níveis de acesso de classes, variáveis, métodos e construtores. Os quatro níveis de acesso são os seguintes:
Por padrão, visível para encapsulamento. Nenhum descritor é necessário.
Descritor inacessível
O Java fornece alguns descritores inacessíveis para satisfazer outras funções.
Operadores básicos
O Java fornece um rico conjunto de operadores para manipular variáveis. Podemos dividir todos os operadores de Java nos seguintes grupos:
O uso de operadores aritméticos em expressões matemáticas é o mesmo que seu uso na álgebra. A tabela a seguir lista os operadores aritméticos:
Supondo que existam 10 variáveis gerais A e 20 variáveis B, então:
Exemplo
| Operadores | descrever | exemplo |
|---|---|---|
| + | A adição é adicionada na outra extremidade do operador | A+B é 30 |
| - | Subtração subtrai o operando à direita do operando à esquerda | A - B é -10 |
| * | Multiplicação multiplica os valores nas duas extremidades do operador | A * b é 200 |
| / | Divida o operando esquerdo pelo operando direito | B/A é 2 |
| % | Coeficiente - Divida o operando esquerdo com o operando direito e devolva o restante | B % A é 0 |
| ++ | Incremento aumenta o valor do operando em 1 | B ++ é 21 |
| - | Diminuir subtraia 1 ao valor do operando | B-IS 19 |
Exemplo
| Operadores | descrever | exemplo |
|---|---|---|
| == | Verifique se os valores dos operando de ambos os lados são iguais. Se forem iguais, a condição é verdadeira. | (A == b) Não é verdade. |
| ! = | Verifique se os valores dos operando de ambos os lados são iguais. Se não for igual, a condição é verdadeira. | (A! = B) é verdadeiro. |
| > | Verifique se o operando à esquerda é maior que o operando à direita. Se for maior, a condição é verdadeira | (A> b) Não é verdade. |
| < | Verifique se o operando à esquerda é menor que o operando à direita. Se for menor, a condição é verdadeira | (A <b) é verdadeiro. |
| > = | Verifique se o operando à esquerda é maior ou igual ao operando à direita. Nesse caso, a condição é verdadeira | (A> = b) Não é verdade. |
| <= | Verifique se o operando à esquerda é menor ou igual ao operando à direita. Nesse caso, a condição é verdadeira | (A <= b) é verdadeiro. |
O operador de bits atua nos padrões de transmissão entre os sistemas binários e executa operações bitwise. Suponha se A for igual a 60; B é igual a 13; Agora, na forma binária, eles são os seguintes:
A = 0011 1100B = 0000 1101 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
A tabela a seguir lista os operadores de bits:
Suponha que haja 60 variáveis inteiras A e 13 B, então:
Exemplo
| Operadores | descrever | exemplo |
|---|---|---|
| & | Binário e operador copiar um no resultado se ambos os operandos existirem ao mesmo tempo | (A&B) é 12, ou seja, 0000 1100 |
| | | O binário ou operador copia um pouco o resultado se houver em qualquer operando | (A | b) é 61, ou seja, 0011 1101 |
| ^ | O operador XOR binário copia o bit se estiver definido em um operando em vez de dois. | (A ^ b) é 49, isto é, 0011 0001 |
| ~ | O operador de suplementos binários é unário e B tem o efeito de bits "flip" | (~ A) é -61. Como é um número binário assinado, a forma de complemento de 2 é 1100 0011 |
| << | Operador de turno esquerdo binário. O valor do operando à esquerda se move para a esquerda de acordo com o número de bits especificados pelo operando à direita. | A << 2 é 240, ou seja, 1111 0000 |
| >> | Operador de turno direito binário. O valor do operando à esquerda se move para a direita, de acordo com o número de bits especificados pelo operando à direita. | A >> 2 é 15, ou seja, 1111 |
| >>> | Mova -se para a direita para preencher o operador zero. O valor do operando esquerdo é movido para a direita de acordo com o número de bits especificados pelo operando direito e o valor transferido é preenchido com zero. | A >>> 2 é 15, ou seja, 0000 1111 |
Supondo que a variável do sistema matemático booleano A seja verdadeiro e B é falso, então:
Exemplo
| Operadores | descrever | exemplo |
|---|---|---|
| && | É chamado de lógica e operadora. Se ambos os operandos não forem zero, a condição será verdadeira. | (A && b) é verdadeiro. |
| || | Chamado de lógica ou operador. Se nenhum dos operandos for zero, a condição será verdadeira. | (A || b) é verdadeiro. |
| ! | Chamado de não operador lógico. É usado como um estado lógico de operandos de flip. Se uma condição for verdadeira, o não operador lógico será falso. | ! (A && b) é verdadeiro. |
Exemplo
| Operadores | descrever | exemplo |
|---|---|---|
| = | Simples e operador, atribua o valor do operando à direita ao operando à esquerda | C = A + B atribuirá o valor de A + B a C |
| += | Adicione e atribua operador, o que aumenta o operando à direita ao operando à esquerda e atribui o resultado ao operando à esquerda | C + = a é igual a C = C + A |
| -= | O operador de subtração e atribuição, que subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo | C - = A é igual a C = C - A |
| *= | Operador de multiplicação e atribuição, que multiplica o operando direito com a esquerda e atribui o resultado ao operando esquerdo | C = A é igual a C = C A |
| /= | Dividir e operador de atribuição, que divide o operando direito à esquerda e atribui o resultado ao operando esquerdo | C / = a é igual a c = c / a |
| %= | O coeficiente e operador de atribuição exigem que o coeficiente use dois operandos e atribua o resultado ao operando à esquerda. | C % = a é igual a C = C % A |
| << = | Operadores de turno e tarefas à esquerda | C << = 2 é igual a c = c << 2 |
| >> = | Operadores de turno e tarefas à direita | C >> = 2 é igual a c = c >> 2 |
| & = | Operadores de bit a bit e tarefas | C & = 2 é igual a C = C & 2 |
| ^= | Bitwise XOR e operadores de atribuição | C ^ = 2 é igual a C = C ^ 2 |
| | = | Bit nessa ou atribui operadores | C | = 2 é igual a C = C | 2 |
Operador condicional (? :)
Os operadores condicionais também são chamados de operadores ternários. Este operador consiste em três operandos e é usado para avaliar expressões matemáticas booleanas. O objetivo deste operador é determinar quais valores devem ser atribuídos à variável. Este operador está escrito da seguinte forma:
variável x = (expressão)? valor se verdadeiro: valor se false
Aqui está um exemplo:
public class Test {public static void main (string args []) {int a, b; a = 10; b = (a == 1)? 20: 30; System.out.println ("O valor de B é:" + b); b = (a == 10)? 20: 30; System.out.println ("O valor de B é:" + b); }}Isso resultará no seguinte:
O valor de B é: 30Value de B é: 20
Instância de símbolo
Este operador é usado apenas para variáveis de referência de objetos. Este operador verifica se um objeto é um tipo exclusivo (tipo ou tipo de interface). A instância do operador é escrita como:
(Variável de referência do objeto) Instância do (tipo de classe/interface)
Se o objeto à esquerda do operador referido pela variável for o tipo ou tipo de interface à direita, passando um cheque, o resultado será verdadeiro. Aqui está um exemplo:
public class Test {public static void main (string args []) {string name = "James"; // a seguir retornará true, pois o nome é o tipo de string boolean resultado = nome da string; System.out.println (resultado); }}Isso produzirá os seguintes resultados:
Copie o código da seguinte maneira: true
Esse operador ainda retornará ao TRUE se o objeto comparado for uma atribuição compatível com o tipo certo. Aqui está outro exemplo: classe veículo {} public class Car estende o veículo {public static void main (string args []) {veículo a = novo car (); resultado booleano = uma instância do carro; System.out.println (resultado); }}Isso produzirá os seguintes resultados:
verdadeiro
Prioridade do operador Java
A prioridade do operador determina o agrupamento de termos em uma expressão. Afeta como uma expressão é avaliada. Um determinado operador tem uma prioridade mais alta do que outros operadores; Por exemplo: o operador de multiplicação tem uma prioridade mais alta que o operador de adição:
Por exemplo, x = 7+3 2; Aqui X é atribuído a 13, não 20, porque o operador é maior prioridade que o operador +, por isso opera primeiro a multiplicação 3*2 e depois adiciona 7.
Aqui, os operadores com a maior prioridade estão no nível mais alto desta tabela, e aqueles com a prioridade mais baixa aparecem na parte inferior. Em uma expressão, quanto maior o operador prioritário é avaliado primeiro.
| tipo | Operadores | Relevância |
|---|---|---|
| sufixo | () []. (Operador de pontos) | Da esquerda para a direita |
| Um dólar | ++ - -! ~ | Da direita para a esquerda |
| Multiplicação | */ % | Da esquerda para a direita |
| Aditivo | + - | Da esquerda para a direita |
| Mudança | >> >>> << | Da esquerda para a direita |
| Relação | >> = <<= | Da esquerda para a direita |
| igual | ==! = | Da esquerda para a direita |
| bit e | & | Da esquerda para a direita |
| Posição extraordinária ou | ^ | Da esquerda para a direita |
| bit ou | | | Da esquerda para a direita |
| Lógica e | && | Da esquerda para a direita |
| Lógico ou | || | Da esquerda para a direita |
| Condicional | ?: | Da direita para a esquerda |
| Atribuição | = += -= *= /= %= >> = << = & = ^== | Da direita para a esquerda |
| vírgula | , Assim, | Da esquerda para a direita |