Java notas de estudio -04

java operadores

Operador se utiliza para indicar el modo de funcionamiento de los operandos

De acuerdo con el número de operandos para ser clasificada
monocular binocular trinocular
a ++ a + b (a> b) x :? Y;
Funciones de manejo de acuerdo con la clasificación
1. Los operadores aritméticos
- [+ - * /% (el resto de módulo)]
```
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. [asignación] en un espacio designado espacio de memoria de pila x, una copia de las constantes del área de almacenamiento asignada a 1 x
2. [informática] en el espacio de memoria de pila para crear una copia temporal de la x (porque la derecha de x + así que de vuelta de nuevo incremento),
una copia de seguridad buena hacer incremento, el valor de las variaciones espaciales x deidad desde 1 hasta 2, y finalmente el valor de espacio de la copia de asignación y, entonces x espacio de la copia será destruido.
```
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 asignación
  dentro del símbolo de asignación = igualdad de derechos de los contenidos (valor, una referencia) en el espacio dejado operando variable de
  + = - = = * /% = = complejo símbolo de asignación
  
  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. Los operadores relacionales (comparación)
```
> >= < <= != == (对象 instanceof 类)-判断对象是不是某个类型
比较运算符最终结果是true false  boolean
```
1. operación lógica
  - Y lógica AND | OR lógico
  - ^ Expresiones lógicas XOR justo antes y después de los dos resultados no son los mismos, el resultado es verdadero
  - ! NO lógico
  - && cortocircuito y
    - 1. cortocircuito cortocircuito puede ocurrir en qué circunstancias?
      El valor nominal de corriente del resultado es falsa cuando se produce un cortocircuito
    - 2. Lo que en el cortocircuito final es corto circuito?
      El cortocircuito de todo el proceso de cálculo después de &&
    - 3. Si se produce un cortocircuito
      un cortocircuito y, un rendimiento ligeramente mejor que no sean &
    - 4. Y && Y lógico en cortocircuito y no hay ninguna diferencia desde el punto de vista del resultado final de la ejecución
    - 5. cortocircuito y cortocircuito no necesariamente mejorar el rendimiento de la superficie actual es sólo falsa cuando ocurrirá, mejorará el rendimiento
  - || cortocircuito o
    si la primera condición es verdadera, finalmente, será verdad

60
00000000 00000000 0.000.000.000.111.100 - binario

00000000 000 trillón 111 100 000
0 7 4 - Eight-ary

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

Bits (bits) de cálculo
y AND bit a bit | ^ OR bit a bit bit a bit OR exclusivo bit a bit ~
<< bit a bit de desplazamiento izquierda >>> >> bit a bit desplazamiento a la derecha mordió desplazamiento a la derecha (sin firmar)

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 binario código anti-código original complemento que representa

1-6 = número positivo de anti-código complementar el código original es el mismo que
el 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 originales simbólicos cambia
la invertida 1.111.111.111.111.111 1.111.111.111.111.001 - Mantener el bit de signo no se mueve, el otro a la inversa
complemento 1.111.111.111.111.111 1.111.111.111.111.010 - trans además de un código

Resumen : ordenador, ya sea entero o negativo, se almacenan en forma de complemento a 2 almacenada en
la representación invertida de un proceso de cálculo es negada (invertida cada posición)

número positivo 按位 HidariiUtsuri <<

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

<< 1 6 =? Corresponde a una potencia de 2 veces multiplicado por el desplazamiento
00000000 00000000 00.000.110--6
00000000 00000000 00001100 a -12 dejó un
00000000 00000000 00011000--24 uno entonces izquierda

Positivo desplazamiento a la derecha en modo bit >>

6 >> 1 = -? 2 veces el desplazamiento equivalente dividida por la potencia de
00.000.000 00.000.000 00000011--3 derecho uno
00000000 00000000 00000001--1 uno luego a la derecha

bit a bit negativo desplazamiento a la derecha (sin firmar) >>>

-6 >> 1 =?

! >> 1 símbolos reservados llenan la posición 1

! >>> símbolo no se conserva sin importar lo que resulta ser tanto y es 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 >> correcta
uno 0.111.111.111.111.111 1.111.111.111.111.101 >>> derecha