1.1 Descripción general de las variables

Hemos aprendido sobre constantes antes y ahora necesitamos aprender sobre variables. La aplicación de variables en Java es mucho más que la aplicación de constantes. ¡Así que las variables también son un punto de conocimiento particularmente importante!

¿Qué son las variables? Una variable es una pequeña caja (pequeño contenedor) en la memoria, ¿qué es un contenedor? También hay muchos recipientes en la vida: por ejemplo, un vaso de agua es un recipiente para el agua, un gran armario en casa es un recipiente para la ropa, una lonchera es un recipiente para la comida. Entonces, ¿qué carga la variable? ¡La respuesta son datos! Conclusión: una variable es un pequeño cuadro en la memoria que contiene datos y solo puede usarlo para almacenar y recuperar datos. * *

1.2 Definir variables (crear variables)

Sintaxis para definir variables:

  
          数据类型  变量名  =  数据值；
          如：int     a    =  100;

Tipos de datos Cada variable debe especificar su tipo de variable. Java es un lenguaje fuertemente tipado. En Java, los diferentes tipos de datos se almacenan en la memoria de diferentes maneras. Por lo tanto, se debe especificar el tipo de datos antes de almacenar el contenido.

El nombre de la variable es usar el identificador para darle un nombre a la variable y luego usar este nombre para participar en el cálculo al calcular. Este nombre representa el espacio para almacenar valores.

Signo "=" El signo "=" aquí es un tipo de operador, es decir, = representa la operación de asignación, no igual en el sentido matemático.

El valor es el valor almacenado en la variable real, que debe ser coherente con el tipo de datos de la variable.

Estos son los cuatro tipos de datos más utilizados:

entero entero

doble decimal

personaje de carbón

cadena de cuerda

1.3 Precauciones al usar variables

Cuando usamos variables, debemos prestar atención, solo se pueden usar si cumplen con las reglas de uso de las variables, echemos un vistazo a las precauciones.

Una vez definida la variable, no es necesario asignar un valor y luego asignar un valor cuando se usa. No se puede utilizar sin asignación .

  
  public static void main(String[] args) {
      int x;
      x = 20; //为x赋值20
      System.out.println(x);//读取x变量中的值，再打印
  }

Las variables tienen un alcance limitado.

  
  public static void main(String[] args) {
      int x = 20;
      {
          int y = 20;
      }
      System.out.println(x);//读取x变量中的值，再打印
      System.out.println(y);//读取y变量中的值失败，失败原因，找不到y变量，因为超出了y变量作用范围，所以    不能使用y变量
  }

Las variables no se pueden definir repetidamente.

  
  public static void main(String[] args){
        int x = 10;
        double x = 5.5;//编译失败，变量重复定义
  }

1.4 Unidad de almacenamiento informático

Las variables son pequeños contenedores en la memoria que almacenan datos. Entonces, ¿cómo almacena datos la memoria de la computadora? Ya sea una memoria o un disco duro, la unidad de información más pequeña de un dispositivo de almacenamiento de computadora se llama "bit" , al que también llamamos "bit", generalmente representado por una letra b minúscula. La unidad de almacenamiento básica de una computadora se llama "byte (byte)", generalmente representada por una letra B mayúscula, y un byte se compone de 8 bits consecutivos.

Cuando un programa necesita utilizar espacio de almacenamiento, el sistema operativo asignará al menos 1 byte al programa en lugar de 1 bit. Se podría decir, si el programa sólo necesita 1 bit de espacio, ¿no puede el sistema asignar sólo 1 bit? ¡La respuesta es no! Es como si solo necesitas 1 cigarrillo y vas a la tienda a comprar cigarrillos, la unidad más pequeña que te asigna la tienda es 1 caja (20 barras), y le es imposible venderte 1 cigarrillo.

Puede pensar que 1 byte (8 bits) puede almacenar un valor grande y que el valor máximo de 1 bit es 9, por lo que el valor máximo de 8 bits es 99999999. Te equivocas, porque la computadora usa dos para almacenamiento, no el sistema decimal comúnmente usado en nuestras vidas. Entonces, el número máximo de datos almacenados en 1 byte es el número binario 11111111.

Además de los bytes, existen algunas unidades de almacenamiento de uso común con las que quizás esté familiarizado.

1B (byte) = 8 bits

1KB = 1024B

1 MB = 1024 KB

1GB = 1024MB

1TB = 1024GB

1 PB = 1024 TB

1.4 4 categorías y 8 tipos de tipos básicos

No se pueden usar armarios grandes para guardar agua y no se pueden usar vasos de agua para guardar ropa. Esto significa que diferentes contenedores contienen diferentes artículos. Lo mismo ocurre con las variables: al crear una variable, debe especificar el tipo de datos de la variable, como una variable entera, una variable de punto flotante, etc. Conclusión: Las variables deben tener un tipo claro, qué tipo de variable carga qué tipo de datos.

Hay 4 tipos de tipos básicos en Java, y después de expandir estos 4 tipos, hay 8 tipos básicos en total. Usaremos estos 8 tipos básicos en lugar de 4 tipos cuando escribamos programas en el futuro, y estos 8 tipos básicos especifican el rango. El tipo predeterminado en Java: el tipo entero es int, el tipo de punto flotante es double.

Capítulo 2 Conversión de tipos de datos

Los datos necesarios para participar en el cálculo en el programa Java deben garantizar la coherencia del tipo de datos. Si el tipo de datos es inconsistente, se producirá una conversión de tipo.

2.1 Conversión automática

Al agregar una intvariable de tipo a una variable de tipo, ¿qué tipo de datos será el resultado?byte

  
  int i = 1; 
  byte b = 2;

Como resultado de la operación, el tipo de variable será intel tipo, que es el fenómeno de la conversión automática de tipos de datos.

conversión automática : 取值范围小的类型promocionará automáticamente a 取值范围大的类型.

  
  public static void main(String[] args) {
      int i = 1;
      byte b = 2;
      // byte x = b + i; // 报错
      //int类型和byte类型运算，结果是int类型
      int j = b + i;
      System.out.println(j);
  }

Diagrama del principio de conversión.

byteLa memoria de tipo ocupa 1 byte y intse promoverá a intun tipo cuando se opere con el tipo, y se agregarán automáticamente 3 bytes, por lo que el resultado calculado sigue siendo intel tipo.

Del mismo modo, cuando una intvariable de tipo doublese opera con una variable, intel tipo se promoverá automáticamente al doubletipo para operación.

  
  public static void main(String[] args) {
      int i = 1;
      double d = 2.5;
      //int类型和double类型运算，结果是double类型
      //int类型会提升为double类型
      double e = d+i;
      System.out.println(e);
  }

reglas de conversión

Un tipo con un rango pequeño se promueve a un tipo con un rango grande y byte、short、charse promueve directamente durante la operación int.

  
  byte、short、char-->int-->long-->float-->double

2.2 Conversión obligatoria

¿ Qué sucede cuando 1.5asignas un valor a una variable de tipo? intSi la compilación falla, no debe poder asignar un valor.

  
  int i = 1.5; // 错误

double8 bytes para memoria de tipo y int4 bytes para memoria de tipo. 1.5Sí double, escriba, el rango de valores es mayor que int. Se puede entender que doublese trata de una tetera de 8 litros y intuna tetera de 4. El agua de la tetera grande no se puede poner directamente en la tetera pequeña.

Si desea que la asignación se realice correctamente, solo puede asignar el valor convirtiendo doubleel tipo al tipo mediante la conversión de tipo obligatoria .int

Cast : 取值范围大的类型convierte el cast a 取值范围小的类型.

En comparación, Java realiza la conversión automática automáticamente, mientras que la conversión obligatoria requiere que la realicemos manualmente.

Formato de conversión:

  
  数据类型 变量名 = （数据类型）被转数据值；

Asignado 1.5al inttipo, el código se modifica a:

  
  // double类型数据强制转成int类型，直接去掉小数点。
  int i = (int)1.5;

De la misma manera, cuando shortse agrega un tipo 1, sabemos que el tipo será promocionado, pero si queremos asignar el resultado a una variable de tipo corto, debemos realizar una conversión.

  
  public static void main(String[] args) {
       //short类型变量，内存中2个字节
       short s = 1;
       /*
         出现编译失败
         s和1做运算的时候，1是int类型，s会被提升为int类型
         s+1后的结果是int类型，将结果在赋值会short类型时发生错误
         short内存2个字节，int类型4个字节
         必须将int强制转成short才能完成赋值
       */
       s = s + 1；//编译失败
       s = (short)(s+1);//编译成功
  }

Diagrama del principio de conversión.

fuerte atención

Al convertir punto flotante a entero, cancele el punto decimal directamente, lo que puede causar pérdida de precisión en los datos.
intLa conversión forzada shortpara cortar 2 bytes puede provocar la pérdida de datos.

  
  // 定义s为short范围内最大值
  short s = 32767;
  // 运算后，强制转换，砍掉2个字节后会出现不确定的结果
  s = (short)(s + 10);

2.3 lista de códigos ASCII

  
  public static void main(String[] args) {
    //字符类型变量
    char c = 'a';
    int i = 1;
    //字符类型和int类型计算
    System.out.println(c+i);//输出结果是98
  }

Dentro de la computadora hay todos datos binarios 0, 1. ¿Cómo hacer que la computadora pueda reconocer directamente el problema de los caracteres humanos? Acabo de producir el concepto de lista de codificación.

Tabla de codificación : Consiste en formar una tabla mediante los caracteres humanos correspondientes y un número decimal.

La gente estipula:

personaje	valor
0	48
9	57
A	sesenta y cinco
z	90
a	97
z	122

Correspondiendo todas las letras, números y símbolos ingleses al sistema decimal, produciendo así la primera tabla de codificación ASCII del mundo (

Código estándar americano para el intercambio de información (Código estándar americano para el intercambio de información).

Consejos:

En el proceso de cálculo de tipo char y tipo int, los caracteres de tipo char primero buscan en la tabla de codificación para obtener 97, luego suman 1 y el resultado es 98. El tipo char se promueve al tipo int. La memoria de tipo char es de 2 bytes y la memoria de tipo int es de 4 bytes.

2.4 Operación de constantes y variables

¿Hay algún problema con el siguiente programa?

  
  public static void main(String[] args){
    byte b1=1;
    byte b2=2;
    byte b3=1 + 2;
    byte b4=b1 + b2;
    System.out.println(b3);
    System.out.println(b4);
  }

Análisis: b3 = 1 + 2, 1y 2son constantes, que son datos fijos, al compilar (compilador javac) se ha determinado 1+2que el resultado de no excede el rango de valores del tipo de byte y se puede asignar a una variable b3, por lo b3=1 + 2que es correcto.

Por el contrario, b4 = b1 + b2b2` b1 和es una variable y el valor de la variable puede cambiar. Al compilar, el compilador javac no está seguro de cuál es el resultado de b1 + b2, por lo que procesará el resultado como un tipo int, por lo que el tipo int no se puede asignar al tipo de byte, por lo que la compilación falla.

Capítulo 3 Operadores

3.1 Operadores aritméticos

Los operadores aritméticos incluyen:	Algoritmo	ejemplo	resultado
`+`	signo positivo, más	+3、2+3	3、5
`+`	Cadena de conexión	“Chino”+“País”+2020	China 2020
-	signo menos, menos	-3、2-3	-3、-1
*	llevar	2*3	6
/	eliminar	5/2	2
%	modelo	5%2	1
++	autoincremento	++1,2++	2,3
--	Decremento	--3,5--	2,4

Cuando utilicemos operadores aritméticos, recuerde prestar atención a lo siguiente:

1. Al concatenar cadenas, se debe prestar atención al operador de suma, solo se convertirá en una cadena si se agrega directamente a la cadena.

2. Para la división "/", cuando ambos lados son números enteros, se toma la parte entera y el resto se redondea. Cuando un lado sea un flotador, divida según las reglas normales.

3. "%" es el símbolo de la división de números enteros y el resto, y el resto decimal no tiene sentido. El signo del resultado es el mismo que el signo del módulo.

4. El número entero se utiliza como dividendo y 0 no se puede utilizar como divisor; de lo contrario, se informará un error.

En Java, los números enteros utilizan los operadores anteriores; no importa cómo se calculen, no obtendrán decimales.

  
  public static void main(String[] args) {
      int i = 1234;
      System.out.println(i/1000*1000);//计算结果是1000
  }

++ Operación, la variable en sí aumenta en 1 . Por el contrario, --en operación, la variable en sí se reduce en 1 y el uso es ++consistente con.
- Operación independiente:
  - Cuando las variables se operan de forma independiente, no hay diferencia entre 前++y 后++.
  - Variables 前++: por ej ++i.
  - Variables 后++: por ej i++.
- Operaciones mixtas:
  - Combine con otras variables 前++y 后++marque la diferencia.
  - Variable 前++: la variable a se incrementa en 1 y el resultado de sumar 1 se asigna a b, es decir, a se calcula primero. El resultado de a y b es 2.
```
  
  public static void main(String[] args) {
      int a = 1;
      int b = ++a;
      System.out.println(a);//计算结果是2
      System.out.println(b);//计算结果是2
  }
```
  - Variable 后++: La variable a primero asigna su propio valor 1 a la variable b. En este momento, el valor de la variable b es 1 y la variable a se suma 1 a sí misma. El resultado de a es 2 y el resultado de b es 1.
```
  
  public static void main(String[] args) {
      int a = 1;
      int b = a++;
      System.out.println(a);//计算结果是2
      System.out.println(b);//计算结果是1
  }
```

+Operación de símbolos en cadenas:
- +Cuando un símbolo encuentra una cadena, representa el significado de conexión y empalme .
- El resultado de "a"+"b" es "ab", el significado de la conexión

  
  public static void main(String[] args){
      System.out.println("5+5="+5+5);//输出5+5=55
  }

3.2 Operadores de Asignación

operador	Algoritmo	ejemplo	resultado
`=`	asignación	int a = 2	2
`+=`	tarea posterior a la adición	int a=2,a+=2	4
`-=`	asignación después de la resta	int a=2,a-=2	0
`*=`	tarea después de la multiplicación	int a = 2, a * = 2	4
`/=`	asignación después de la divisibilidad	int a=2,a/=2	1
`%=`	Asignación después del módulo	int a = 2, a% = 2	0

El operador de asignación asigna el valor del lado derecho del símbolo a la variable del lado izquierdo.

  
  public static void main(String[] args){
      int i = 5;
      i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i
      System.out.println(i); //输出结果是10 
  }

Expansión del signo +=

¿Hay algún problema con el siguiente programa?

  
  public static void main(String[] args){
    short s = 1;
    s+=1;
    System.out.println(s);
  }

Análisis: s += 1Lógicamente, se considera que s = s + 1el resultado del cálculo se promueve al tipo int, y luego ocurre un error al asignar un valor al tipo corto, porque un tipo con un rango de valores grande no se puede asignar a un tipo con un valor pequeño rango. Sin embargo, s=s+1进行两次运算es +=un operador, que solo opera una vez, y tiene las características de conversión forzada, es decir s += 1, s = (short)(s + 1)por lo que el programa compila y pasa sin ningún problema, y el resultado de la ejecución es 2.

3.3 Operadores de comparación

operador	Algoritmo	ejemplo	resultado
`==`	igual a	4==3	FALSO
`!=`	no igual a	4!=3	verdadero
`>`	más que el	4>3	verdadero
`<`	menos que	4<3	FALSO
`<=`	Menos que o igual a	4<=3	FALSO
`>=`	mayor o igual a	4>=3	verdadero

Un operador de comparación es una operación para comparar dos datos y el resultado de la operación es un valor booleano trueo false.

  
  public static void main(String[] args) {
      System.out.println(1==1);//true
      System.out.println(1<2);//true
      System.out.println(3>4);//false
      System.out.println(3<=4);//true
      System.out.println(3>=4);//false
      System.out.println(3!=4);//true
  }

3.4 Operadores lógicos

Operadores lógicos, que se utilizan para realizar operaciones sobre valores booleanos, y el resultado final de la operación es el valor booleano verdadero o falso.

operador	Algoritmo	ejemplo	resultado
&	y	falso verdadero	FALSO
\|	o	falso\|verdadero	verdadero
^	XOR	falso^verdadero	verdadero
！	No	!FALSO	verdadero
&&	cortocircuito con	falso verdadero	FALSO
\|\|	cortocircuito o	falso\|\|verdadero	verdadero

  
  public static void main(String[] args)  {
      System.out.println(true && true);//true
      System.out.println(true && false);//false
      System.out.println(false && true);//false，右边不计算
    
      System.out.println(false || false);//falase
      System.out.println(false || true);//true
      System.out.println(true || false);//true，右边不计算
    
      System.out.println(!false);//true
  }

3.5 operadores bit a bit

Los operadores bit a bit incluyen:
<< mover a la izquierda	Desplazamiento a la izquierda es mover todos los bits hacia la izquierda unos pocos bits para completar 0
>> moverse a la derecha	El desplazamiento a la derecha consiste en mover todos los bits hacia la derecha unos pocos bits para llenar el bit más alto.

mover hacia la izquierda

12<<2 significa que 12 se mueve dos lugares a la izquierda

12的二进制 0000 1100

0000 1100 左移两位后面补0 0011 00 00 48

由此我们得出一个快速的算法 M << n 其实可以这么算 M << n = M * 2的n次方

12<<2 = 12*2的2次方

12<<3 = 12*2的3次方

右移

12>>2 意思就是12向右移动两位

0000 1100 右移两位前面补最高位 0000 0011 3

基本和左移一致不同点在于正数和负数负数补1 正数补0

-8>>2

1111 1000 右移两位补1 1111 1110 -2

由此我们得出一个快速的算法 M >>n 其实可以这么算 M >>n = M /2的n次方

-8>>2 -8/2 的 2次方

-16>>3 -16/2的3次方

3.6 三元运算符

三元运算符格式：

  
   数据类型 变量名 = 条件表达式？表达式1：表达式2

表达式：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：

3+2，使用算数运算符将操作数联系起来，这种情况，我们称为算数表达式。

3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，这种情况，我们称为条件表达式。

其他表达式，不再一一举例。

运算规则

先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。

  
  public static void main(String[] args) {
      int a = 200；
      int b = 100；
      int max = (a>b ? a : b);//max赋值为 a，b中较大的值
      System.out.println(max);//200
      int min = (a<b ? a : b);//min赋值为 a，b中较小的值
      System.out.println(min);//100
  }

3.7 运算符优先级

在学习运算符的过程中，我们发现，当多个运算符一起使用的时候，容易出现不清晰先后运算顺序的问题，那么，在这里，我们来学习下，运算符之间的运算优先级。

下图是每种运算符的优先级，按照运算先后顺序排序（优先级相同的情况下，按照从左到右的顺序依次运算）

课后练习

在控制台打印如下的信息

要求:

1.清单顶部为固定的数据，直接打印即可

2.清单中部为商品，为变化的数据，需要记录水果信息后，打印

3.清单底部包含了统计操作，需经过计算后，打印

variables, operadores

1.1 Descripción general de las variables

1.2 Definir variables (crear variables)

1.3 Precauciones al usar variables

1.4 Unidad de almacenamiento informático

1.4 4 categorías y 8 tipos de tipos básicos

Capítulo 2 Conversión de tipos de datos

2.1 Conversión automática

Diagrama del principio de conversión.

reglas de conversión

2.2 Conversión obligatoria

Diagrama del principio de conversión.

fuerte atención

2.3 lista de códigos ASCII

2.4 Operación de constantes y variables

Capítulo 3 Operadores

3.1 Operadores aritméticos

3.2 Operadores de Asignación

3.3 Operadores de comparación

3.4 Operadores lógicos

3.5 operadores bit a bit

3.6 三元运算符

3.7 运算符优先级

课后练习

Supongo que te gusta