notas de estudo Java -04

java operadores

Operador é usado para indicar o modo de operação para os operandos

De acordo com o número de operandos a ser classificadas
monocular binocular triocular
uma ++ a + b (a> b) x :? Y;
funções de operador de acordo com a classificação
1. Operadores aritméticos
- [+ - * /% (sobra modulo)]
```
int x = 5;
x/2 = 2;
x%2 = 1;
```
- [++ -]
```
int x = 1;  
x = x+1;  x空间内的值，自己增加了一个
x++;  x空间内的值 自增一个
++x;  对于x空间内的值来讲，都是一致，最终的结果都自增了一个
```
examp1 :
```
int x = 1;  在内存空间栈中划一块空间x，从存储区拷贝一份常量1赋值给x
int y = x++;  ++在后 先赋值 后自增（先进行计算，后赋值）
x==2  y==1
```
1. [atribuição] em um espaço de memória de pilha espaço designado x, uma cópia das constantes da área de armazenamento atribuído a 1 x
2. [de computação] no espaço de memória pilha para criar uma cópia temporária do x (porque o direito de x + então, de volta para cima novamente incremento),
um bom backup fazer incremento, o valor das mudanças espaciais x divindade 1-2 e, finalmente, o valor do espaço da cópia atribuição y, então x copiar o espaço será destruído.
```
x++;//x=x+1;
1. 将x变量空间的内容先取出，常量区取出1，进行计算 ，再次存回x空间
2. x在想要做值交换的时候，会产生一个临时的副本空间（备份）
3. ++在变量的前面，先自增后备份
4. ++在变量的后面，先备份后自增
5. 最终会将副本空间内的值赋给别人
```
examp2 :
```
int x = 1;
int y = ++x;
x==2  y==2
```
examp3 :
```
int a = 1;  
a = a++;   
a==1
```
examp4 :
```
int a = 1;
for(int i=1;i<=100,i++){
a = a++;
}
a=1
```
examp5 ;
```
int m = 1; //2,1,0
int n = 2; //3,2,1
int sum = m++ + ++n - n-- - --m + n-- - --m;
1   +  3  - 3   -  1  + 2   -  0
sum==2
```
1. operador de atribuição
  dentro do símbolo de atribuição = igual direito do conteúdo (valor de referência, um) no espaço deixado operando variável
  + = - = = * /% = = complexo símbolo de atribuição
  
  examp1 :
```
int x = 1;
x += 2; //3
x = x+2; //3
```
examp2 :
```
byte x = 1; //常量32bit =自动转化
x += 2; //+=算作一个运算符号，自动类型提升为3 =自动转化
x = x+2; //编译出错 类型从int转化成byte可能有损失
x变量空间的值取出，从常量区取过来2，加法运算，结果重新存回x变量空间内
x空间-->1  8bit
常量区-->2 32bit
00000001 + 00000000 00000000 00000000 00000010
+自动类型提升 8bit --32bit
00000000 00000000 00000000 00000001
00000000 00000000 00000000 00000010
+00000000 00000000 00000000 00000011 ==3
```
1. Os operadores relacionais (comparação)
```
> >= < <= != == (对象 instanceof 类)-判断对象是不是某个类型
比较运算符最终结果是true false  boolean
```
1. operação lógica
  - & Lógico AND | OR lógico
  - ^ Expressões lógicas XOR apenas antes e depois dos dois resultados não são os mesmos, o resultado é verdadeiro
  - ! NÃO lógico
  - && curto-circuito e
    - 1. Curto-circuito curto-circuito pode ocorrer em que circunstâncias?
      O valor nominal atual do resultado é falsa quando um curto-circuito ocorre
    - 2. O que, em curto-circuito no final é curto-circuito?
      O curto-circuito todo o processo de cálculo após &&
    - 3. Se um curto-circuito ocorre
      um curto-circuito e, um desempenho ligeiramente melhor do que o &
    - 4. & && E lógico curto e não há diferença do ponto de vista do resultado final da execução
    - 5. Curto-circuito e curto-circuito, não necessariamente melhorar o desempenho da superfície atual é apenas falsa quando irá ocorrer, vai melhorar o desempenho
  - || curto-circuito ou
    se a primeira condição é verdade acabará por ser verdade

60
00000000 00000000 0.000.000.000.111.100 - binário

00000000 000 trilhões de 100 000 111
0 7 4 - Oito-ary

0000 0000 0000 0000 0000 0000 0011 1100
0 X 3 C - Hex

Bit (bit) de cálculo
& Bitwise AND | OR bit a bit ^ bitwise exclusivo OR ~ bit a bit
<< bitwise deslocamento esquerda >>> >> bitwise deslocamento para a direita bit deslocamento para a direita (não assinado)

examp1:

3 & 5 ?
1. 将3和5转化成二进制表示形式
2. 竖着按照对应为止进行&|^计算（1-->true  0-->false）
3. 将计算后的二进制结果转化为十进制

            00000011   --3
            00000101   --5

    3 & 5   00000001   --1

    3 | 5   00000111   --7 
    3 ^ 5   00000110   --6

##### número binário complemento anti-code código original que representa

1-6 =? Número positivo de anti-código complementar o código original é o mesmo que
o código original 00000000 00000000 0,000,000,000,000,110
anti-código 00000000 00000000 0,000,000,000,000,110
complemento 00000000 00000000 0,000,000,000,000,110
Para -6 =?
1.000.000.000.000.000 0,000,000,000,000,110 código original - bits de código originais simbólicos muda
o invertido 1.111.111.111.111.111 1.111.111.111.111.001 - Mantenha o bit de sinal não se move, o outro o inverso
complemento 1.111.111.111.111.111 1.111.111.111.111.010 - Código trans, mais um

Resumo : computador inteiros ou negativo, são armazenados sob a forma de complemento para 2 armazenado
na representação invertida de um processo de cálculo é negada (invertido cada posição)

número positivo 按位 HidariiUtsuri <<

-3 -2 -1 <-> 0 1 2

<< 1 6 =? Corresponde a uma potência de 2 vezes multiplicadas pelo deslocamento
00000000 00000000 00000110--6
00000000 00000000 00001100--12 deixou um
00000000 00000000 00011000--24 uma então esquerda

Bitwise positivo deslocamento para a direita >>

6 >> = 1 -? 2 vezes o deslocamento equivalente dividido pelo poder de
00000000 00000000 00000011--3 direita um
00000000 00000000 00000001--1 um depois à direita

bit a bit negativo deslocamento para a direita (não assinado) >>>

-6 >> 1 =?

! >> 1 símbolos reservados preencher a posição 1

! >>> símbolo não é mantida não importa o que acaba por ser ambos e é 0
1,111,111,111,111,111 1,111,111,111,111,010
1,111,111,111,111,111 1,111,111,111,111,101 >> caminho certo
um 0.111.111.111.111.111 1.111.111.111.111.101 >>> direita