Comentario 03:
1, "&" y "&" Las similitudes y diferencias entre
los mismos puntos: & && resultado del cálculo es el mismo, cuando el símbolo de izquierda es verdad, ambos de los cuales se puede realizar una operación en la derecha.
Diferencias: Cuando el símbolo de la izquierda es falsa, y continuar la operación correcta de la señal. && ya no realizar la operación correcta de la señal.
2. La salida del programa.
class OperatorTest {
public static void main(String[] args) {
boolean x = true;
boolean y = false;
short z = 40;
i评((z++ == 40) 8& (y = true)) {
Z++;
}
if ((x = false) II (++z = 43)) {
Z++;
}
System. out.println("z = "+ z);
}
}
Resultados: 44
3. definir tres tipo int y asignar, mediante el operador ternario o si-else adquisición de lograr una mayor número de los tres números.
int num1 = 10,num2 = 15, num3=-20;
int max;
if(num1>=num2 && num1>=num3){
max=num1;
}else if(num2>=num1 && num2>=num3){
max=num2;
}else{
max =num3;
}
System.out.println(max);
(((n1>n2)? n1 : n2)>n3)? ((n1>n2)? n1 : n2) : n3;
4. Escribir un programa, declarar dos variables dobles y asignación. Determinar un primer número es mayor que 10,0, y el segundo número es menor que 20,0, y el número de copias dos. De lo contrario, el producto de impresión de dos números
double d1=12.3;
double d2=32.1;
if (d1>10.0 && d2<20){
}else{
}
El código de aplicación de intercambio de valores de dos variables
int a=10;
int b=20;
int c;
c=a;
a=b;
b=c;
Operadores aritméticos + positivo - negativo + Suma - Resta * multiplicación / división% módulo (resto) + (antes) + (después) - (pre) - (después) +
//除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1/num2;
System.out.println(result1);
//（前）++ ：先自增1，后运算
//（后）++ ：先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1= "+ a1 + ", b1 = " + b1);
int a2 = 10;
int b2 = a2++;
System.out.println("a2= "+ a2 + ", b2 = " + b2);
//（前）-- ：先自减1，后运算
//（后）-- ：先运算，再自减1
int a4 = 10;
int b4 = a4--;
System.out.println("a4= "+ a4 + ", b4 = " + b4);
int a5 = 10;
int b5 =--a5;
System.out.println("a5= "+ a5 + ", b5 = " + b5);
instrucciones especiales;
1 .// (frontal) +: un primer incremento, después del cálculo
// (trasera) +: primero cálculo, ya que al aumentar 1
2 .// (pre) -: Primera Decremento 1, después del cálculo
// (trasera) -: primero cálculo, y luego desde menos 1
3. conector: "+" (sólo se utiliza entre la cadena se puede utilizar con otros tipos de datos)
operador de asignación + = = - = = * / =% =
int i1 = 10;
int j1 = 10;
int i2,j2;
//连续赋值
i2 = j2 = 10;
int i3 = 10,j3 = 20;
int num1 = 10;
num1+= 2;//num1 = num1 + 2;
System.out.println(num1);
int num2=12;
num2 %= 5;//num2= num2%5
System.out.println(num2);
short s1 = 10;
//s1 = s1+2;//编译失败
s1+=2;//不会改变变量本身的数据类型；
System.out.println(s1);
Instrucciones especiales:
1. El resultado de la operación no cambia el tipo de datos de la propia variable
// desarrollo, si se desea operar variable para alcanzar 2, hay varias maneras? (Siempre que: NUM = int 10;)
// manera: num NUM + 2 =
// La segunda manera: num + = 2; (recomendado)
// desarrollo, si se quiere lograr un funcionamiento variable de 1, hay varias maneras? (premisa: NUM int = 10;)
// una manera: . + 1 = NUM NUM
// La segunda manera: = NUM + 1;.
// tres maneras: num ++; (recomendado)
operador de comparación ==! => << => = instanceOf
int i = 10;
int j = 20;
System.out.println(i==j);//false
System.out.println(i = j);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b1==b2);//false
System.out.println(b2=b1);//true
Instrucciones especiales:
1. El resultado es un operador de comparación booleana
2. <>> = <=: se puede utilizar sólo entre un tipo de datos numéricos
3 = ==:.! Puede ser utilizado solamente entre tipos de datos numéricos, más entre la variable de referencia puede ser utilizado en otros tipos
de C ONT acct1 = nueva cuenta de nuevo (1000);
de C ONT acct2 = nueva cuenta de nuevo (1000);
booleana B1 = (== acct1 acct2); // si la comparación es la misma cuenta cuenta dos
b2 boolean = (= acct1 acct2!);
Los operadores lógicos: Y && || |! ^
//区分& 与&&
//相同点：&与&&的运算结果相同，当符号左边为true，二者都会执行右边的运算。
//不同点：当符号左边为false时，&继续执行符号右边的运算。&&不再执行符号右边的运算。
//开发中，推荐使用&&
boolean b1=true;
b1 = false;
int num1=10;
if(b1 & (num1++>0)){
System.out.println("北京");
}else{
System.out.println("南京");
}
System.out.println("num1 = " + num1);
boolean b2 = true;
b2 = false;
int num2 =10;
if(b2 && (num2++>0)){
System.out.println("北京");
}else{
System.out.println("南京");
}
System.out.println("num2 = " + num2);
//区分 | 与 ||
//相同点1: | 与|| 的运算结 果相同
//相同点2:当符号左边是false时，二者都会执行符号右边的运算
//不同点3:当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
//开发中推荐使用||
boolean b3 = false;
b3 = true;
int num3 = 10;
if(b3 | (num3++>0)){
System.out.println("北京");
}else{
System.out.println("南京");
}
System.out.println("num3 = " + num3);
boolean b4 = false;
b4 =true;
int num4 = 10;
if(b4 || (num4++>0)){
System.out.println("北京");
}else{
System.out.println("南京");
}
System.out.println("num4 = " + num4);
boolean x=true;
boolean y=false;
short z=42;
//if(y == true)
if((z++==42)&&(y=true))
System.out.println("z="+z);
z++;
System.out.println("z="+z);
System.out.println("z="+z);
if((x=false) ||(++z==45))
z++;
System.out.println("z="+z);
! AB y A & B A && B ALB ALLB AA ^ B
true true true true true true false false
a true a false false false a true para verdadero a falso a verdadero
a falso a verdadero a falso como falso a verdadero a verdadero true true
false false false false false false a true a false
Instrucciones especiales:
1. Los operadores lógicos que operan es variable de tipo booleano, y el resultado es un valor booleano
operadores de bits: << >> >>> y | ^ ~
int i = 21;
System.out.println("i << 2 : " + (i << 2));//21*4
System.out.println("i << 3 : " + (i << 3));//21*8
System.out.println("i << 27 : " + (i << 27));
System.out.println("i << 26 : " + (i << 26));
System.out.println("i >> 2 : " + (i >> 2));
i = -21;
System.out.println("i >> 2 : " + (i >> 2));
System.out.println("i >>> 2 : " + (i >>>2));
int m = 12;
int n = 5;
System.out.println("m & n : " + (m & n));
System.out.println("m | n : " + (m | n));
System.out.println("m ^ n : " + (m ^ n));
[Preguntas de cara] se puede escribir la implementación más eficiente de 2 * 8?
Respuesta: 2 3 o 8 << 1 <<
1 bits son enteros operaciones sobre los datos del operador
2. <<: cierta el rango de cada uno a la izquierda, equivalente a 2 *
>>: dentro de un cierto rango, uno de cada uno a la derecha, correspondiente a / 2
sujeto típico:
1. intercambio de dos variables
2. implementar 60 binario a la conversión hexadecimal
//方式一：自动实现
String str1 = Integer.toBinaryString(60);//二进制
String str2 = Integer.toHexString(60);//十六进制
//方式二： 手动实现
int i1 = 60;
int i2 = i1&50;
String j = (i2>9)?(char)(i2-10+'A')+"":i2+"";
int temp = i1>>>4
i2 = temp&15;
String k = (i2>9)?(char)(i2-10+'A')+"":i2+"";
System.out.println(k+""""+j);
operador ternario :( expresiones condicionales)? Expresión 1: Expresión 2
// Obtener el valor de la mayor de dos números enteros
1 Descripción:
Resultados ① condición de una expresión booleana
② La expresión de verdadero o falso, decide llevar a cabo la expresión 1, la expresión 2, o
si la expresión la fórmula es cierto, la expresión 1 se ejecuta
si la expresión es falsa, la expresión 2 se lleva a cabo
2 ③ expresión 1 y la expresión es coherente
④ pueden anidarse operador ternario
2
que puede utilizar el operador ternario lugar, se puede reescribir como si-else
no viceversa
3. Si los procedimientos pueden utilizar el operador ternario, y puede ser utilizado estructura if-else, la preferencia del operador ternario. La razón: simple, de alta eficiencia,
Estructura secuencia: de arriba a abajo la ejecución del programa
estructura de ramas: si-else if SWITCH- -else caso
estructura de ciclo: pues mientras do-while
