[Tecnología Java Core] Gramática básica de Java

1. Palabras clave y palabras reservadas

Definición de palabra clave y características

• Una cadena (palabra) dotada de un significado especial por el lenguaje Java y utilizada para propósitos especiales
• Todas las letras de las palabras clave están en minúsculas

Definición de palabras reservadas

• No se usa en las versiones de Java existentes, pero se puede usar como palabra clave en futuras versiones. Evite estas palabras reservadas al nombrar identificadores.

Resumen: 48 palabras clave, 2 palabras reservadas, 3 valores literales

用于定义数据类型的关键字
class interface enum byte short int long float double char boolean void
用于定义流程控制的关键字
if else switch case default while do for break continue return
用于定义访问权限修饰符的关键字
private protected public
用于定义类，函数，变量修饰符的关键字
abstract final static synchronized
用于定义类与类之间关系的关键字
extends implements
用于定义建立实例及引用实例，判断实例的关键字
new this super instanceof
用于异常处理的关键字
try catch finally throw throws
用于包的关键字
package import
其他修饰符关键字
native strictfp transient volatile assert
保留字
goto const

用于定义数据类型值的字面值
true false null  true

2. Identificador

Definición de identificador

• La secuencia de caracteres utilizada por Java para nombrar elementos como variables, métodos y clases se denomina identificador.

Habilidad: cualquier lugar donde pueda nombrarlo se llama identificador

Definir reglas de identificadores legales

• Consta de 26 letras inglesas mayúsculas y minúsculas, 0-9, _ o $
• los numeros no pueden empezar por
• Las palabras clave y las palabras reservadas no están permitidas, pero pueden contener palabras clave y palabras reservadas
• Estrictamente sensible a mayúsculas y minúsculas en Java, longitud ilimitada
• Los identificadores no pueden contener espacios.

Convenciones de nomenclatura en Java

• Nombre del paquete: todas las letras están en minúsculas cuando se componen de varias palabras: xxxyyyzzz
• Nombre de clase, nombre de interfaz: cuando se compone de varias palabras, la primera letra de todas las palabras se escribe en mayúscula: XxxYyyZzz
• Nombre de variable, nombre de método: cuando se compone de varias palabras, la primera letra de la primera palabra está en minúsculas y la primera letra de cada palabra está en mayúscula al comienzo de la segunda palabra: xxxYyyZzz
• Nombre constante: todas las letras están en mayúscula y cada palabra está conectada con un guión bajo cuando hay varias palabras: XXX_YYY_ZZZ

Puntos a tener en cuenta:
1. Al elegir un nombre, para mejorar la legibilidad, debe ser lo más significativo posible, "ver el nombre y conocer el significado".
2. Java usa el conjunto de caracteres Unicode, por lo que los identificadores también se pueden declarar usando caracteres chinos, pero no se recomienda.

3. Variables

El concepto de variable

• un área de almacenamiento en la memoria
• Los datos del área pueden variar continuamente dentro del mismo rango de tipo
• Una variable es la unidad de almacenamiento más básica en un programa, incluido el tipo de variable , el nombre de la variable , el valor almacenado

El papel de las variables

• para almacenar datos en la memoria

Nota sobre el uso de variables

• Cada variable en Java debe declararse primero y luego usarse
• Use nombres de variables para acceder a los datos en esta área
• El alcance de una variable: dentro de un par de {} donde se define
• Las variables son válidas solo dentro de su alcance.
• Las variables con el mismo nombre no se pueden definir en el mismo ámbito

Clasificación de variables

Clasificados por tipo de datos

• tipo de datos básicos
  • numérico
    • Tipo entero (byte short int long)
    • Tipo de punto flotante (doble flotante)
  • Tipo de carácter (char)
  • booleano (booleano)
• tipo de datos de referencia
  • clase _
  • interfaz _
  • matriz ([])

Ordenar por ubicación de declaración

• Variables miembro
  • Variables de instancia (no modificadas con estáticas)
  • Variables de clase (decoradas con estática)
• variable local
  • Parámetros formales (variables definidas en métodos, constructores)
  • Variables locales del método (definidas dentro del método)
  • Variables locales de bloque de código (definidas dentro de un bloque de código)

Variables enteras: byte, corto, int, largo

• Cada tipo de número entero en Java tiene un rango de números de tabla y una longitud de campo fijos, que no se ven afectados por el sistema operativo específico, para garantizar la portabilidad de los programas de Java.
• Las constantes enteras de Java son de tipo int por defecto, y la declaración de constantes de tipo largo debe agregarse loL
• Las variables en los programas Java generalmente se declaran como int, y se usa long a menos que no sea suficiente para representar un número grande

tipo	ocupan espacio de almacenamiento	Rango de números de tabla
byte	1 byte = 8 bits	-128~127
corto	2 bytes	- $2^{15}$ ~$2^{15}$ -1
En t	4 bytes	- $2^{31}$ ~$2^{31}$ -1 (alrededor de 2.100 millones)
largo	8 bytes	- $2^{63}$ ~$2^{63}$ -1

bit: La unidad de almacenamiento más pequeña en una computadora. byte: La unidad básica de almacenamiento en una computadora.

Tipo de punto flotante: flotante, doble

• Al igual que el tipo entero, el tipo de coma flotante de Java también tiene un rango de números de tabla y una longitud de campo fijos, que no se ven afectados por el sistema operativo específico.
• Las constantes de punto flotante tienen dos representaciones:
  • forma decimal
  • forma de notación científica
• flotante: precisión simple, la mantisa puede tener una precisión de 7 cifras significativas. En muchos casos, la precisión es difícil de satisfacer la demanda.
• double: Doble precisión, el doble de precisión que float. Se suele utilizar este tipo.
• Las constantes de coma flotante de Java son dobles por defecto. Para declarar una constante flotante, agregue fo después de ella F.

tipo	ocupan espacio de almacenamiento	Rango de números de tabla
flotar	4 bytes	-3.403E38~3.403E38
doble	8 bytes	-1.798E308~1.798E308

Nota: float significa que el rango de valores es mayor que long

¿Cómo calcular el rango de valores flotantes?

De acuerdo con el estándar IEEE754, el bit de signo, el bit de exponente y el bit de significado se dividen para el cálculo.

tipo de carácter: carácter

• Los datos de tipo Char se utilizan para representar "caracteres" en el sentido habitual (2 bytes)
• Todos los caracteres en Java utilizan la codificación Unicode, por lo que un carácter puede almacenar una letra, un carácter chino o un carácter de otros idiomas escritos.
• Tres manifestaciones de las variables de carácter:
  • Una constante de carácter es un solo carácter encerrado entre comillas simples ''.
  • Java también permite el uso del carácter de escape '\' para convertir los caracteres subsiguientes en constantes de caracteres especiales.
  • Use valores Unicode directamente para representar constantes de caracteres.
• El tipo char es operable. Porque todo corresponde a la codificación Unicode.

char c1 = 'a'; // 编译通过
// char c2 = 'AB'; // 编译不通过
char c3 = '中'; // 编译通过
char c4 = '\n'; // 编译通过
char c5 = '\u0043'; // 编译通过
// char c6 = ''; // 编译不通过
char c7 = 97; // a, 开发中极其少见

Valores de código ASCII de uso común: 'a' == 97, 'A' == 65;

booleano: booleano

• Solo puede tomar uno de dos valores: verdadero, falso
• A menudo se usa en juicios condicionales y estructuras de bucle.

Conversión de tipos de datos básicos

• Conversión automática de tipos: un tipo con una capacidad pequeña se convierte automáticamente en un tipo de datos con una gran capacidad. Los tipos de datos se ordenan por capacidad de la siguiente manera:char、byte、short --> int --> long --> float --> double
• Cuando hay varios tipos de operaciones mixtas de datos, el sistema primero convierte automáticamente todos los tipos de datos en el tipo de datos con la mayor capacidad y luego realiza los cálculos.
• byte, short y char no se convertirán entre sí, los tres se convierten primero al tipo int durante el cálculo

Cuando Java está haciendo cálculos, si todos los operandos están en el rango de int, todas las operaciones se realizarán en el espacio de int.

• El tipo booleano no se puede operar con otros tipos de datos
• Cuando el valor de cualquier tipo de datos básico se conecta con una cadena (String) (+), el valor del tipo de datos básico se convertirá automáticamente en un tipo de cadena (String)

Explicación: La capacidad en este momento se refiere al tamaño del rango del número indicado. Por ejemplo: la capacidad flotante es mayor que la capacidad larga

elenco

• El proceso inverso de conversión automática de tipos convierte un tipo de datos con una gran capacidad en un tipo de datos con una capacidad pequeña. Al usarlo, debe agregar el carácter de conversión obligatorio: (), pero puede causar reducción de precisión o desbordamiento , así que preste especial atención.

  double d1 = 12.9;
  int i1 = (int)d1; // 12，截断操作

  int i2 = 128;
  byte b = (byte)i2; // -128

• Por lo general, las cadenas no se pueden convertir directamente en tipos básicos, pero la conversión de cadenas en tipos básicos se puede realizar a través de la clase contenedora correspondiente a los tipos básicos.

  String a = "43";
  int i = Integer.parseInt(a);

• El tipo booleano no se puede convertir a otros tipos de datos

Descripción: para constantes enteras, el tipo predeterminado es int; para constantes de punto flotante, el tipo predeterminado es doble.

  byte b = 12;
  // byte b1 = b + 1; // 编译失败
  // float f1 = b + 12.3; // 编译失败

Tipo de cadena: Cadena

• String no es un tipo de datos básico, sino un tipo de datos de referencia
• El uso es coherente con el tipo de datos básico.
• Una cadena se puede concatenar con otra cadena o directamente concatenar con otros tipos de datos.

  String str = "abcd";
  str = str + "xyz";
  int n = 100;
  str = str + n; // abcdxyz100

4. hexadecimales

• Todos los números existen en forma binaria en la parte inferior de la computadora .
• Para números enteros, hay cuatro representaciones:
  • Binario (binario): 0,1, completo 2 en 1, comienza con 0bo0B
  • Decimal (decimal): 0-9, 10 en 1
  • Octal (octal): 0-7, 8 completos en 1, 0comenzando con un número
  • Hexadecimal (hex): 0-9 y AF, 16 completos en 1, comience con 0xo . 0XAF aquí no distingue entre mayúsculas y minúsculas.
• Las constantes enteras de Java son de tipo int por defecto. Cuando un entero se define en binario, su bit 32 (bit más alto) es el bit de signo: cuando es de tipo long, el binario ocupa 64 bits por defecto, y el bit 64 es el bit de signo. poco
• Los enteros binarios vienen en tres formas:
  • Código original: reemplaza directamente un valor con un número binario. El bit más alto es el bit de signo (0 negativo 1 positivo)
  • Código inverso de número negativo: Es la inversión bit a bit del código original, solo el bit más alto (bit de signo) se confirma como 1
  • El complemento de un número negativo: sumar 1 a su complemento
• La computadora mantiene todos los números enteros en forma de complemento a dos.
  • El código original, código inverso y código complemento de números positivos son los mismos
  • El complemento de un número negativo es su complemento + 1

5. Operadores

Un operador es un símbolo especial que se utiliza para representar operaciones de datos, asignaciones y comparaciones.

• operador aritmético
• operador de asignación
• Operadores de comparación (operadores relacionales)
• Operadores logicos
• operador bit a bit
• operador ternario

operador aritmético

operador	operación	ejemplo	resultado
+	Signo de más	+3	3
-	negativo	b=4; -b	-4
+	agregar	5+5	10
-	reducir	6-4	2
*	llevar	3*4	12
/	eliminar	5/5	1
%	módulo (resto)	7%5	2
++	Incremento automático (antes), primero calcular y luego obtener valor	a=2;b=++a;	a=3;b=3
++	Incremento automático (post), valor primero y luego operación	a=2;b=a++;	a=3;b=2
–	Autodecremento (antes), primero calcular y luego tomar valor	a=2;b=–a;	a=1;b=1
–	Autodecremento (después), tomar el valor primero y luego operar	a=2;b=a–;	a=1;b=2
+	concatenación de cadenas	“He”+“llo”	"Hola"

Punto de dificultad 1: %la operación resto, el signo del resultado es el mismo que el signo del módulo

int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1); // m1 % n1 = 2
int m2 = -12;
int n2 = 5;
System.out.println("m1 % n1 = " + m2 % n2); // m1 % n1 = -2
int m3 = 12;
int n3 = -5;
System.out.println("m1 % n1 = " + m3 % n3); // m1 % n1 = 2
int m4 = -12;
int n4 = -5;
System.out.println("m1 % n1 = " + m4 % n4); // m1 % n1 = -2

Dificultad 2: ++ y – no cambie el tipo de datos de la variable en sí

short s = 10;
//s = s + 1; //编译失败
s = (short) (s + 1); //正确
s++; //正确

byte b = 127;
b++;
System.out.println(b); //-128

operador de asignación

Símbolos: =Operadores de asignación extendida: +=, -=, *=, /=,%=

• Cuando =los tipos de datos en ambos lados son inconsistentes, puede usar la conversión de tipo automática o usar el principio de conversión de tipo obligatoria para el procesamiento
• Soporte para asignación continua

int i, j;
//连续赋值
i = j = 10;

Dificultades: el operador de asignación extendida no cambia el tipo de datos de la variable en sí

short s = 10;
//s = s + 2; //编译失败
s += 2;
System.out.println(s); //12
int i = 1;
i *= 0.1;
System.out.println(i); // 0

operador de comparación

operador	operación	ejemplo	resultado
==	igual a	4==3	FALSO
!=	no igual a	4!=3	verdadero
<	menos que	4<3	FALSO
>	más que el	4>3	verdadero
<=	Menos que o igual a	4<=3	FALSO
>=	mayor o igual a	4>=3	verdadero
en vez de	Comprobar si es un objeto de clase.	Instancia "Hola" de String	verdadero

• Los resultados de los operadores de comparación son todos booleanos, es decir, verdaderos o falsos.
• Los operadores de comparación ==no pueden escribirse erróneamente como=
• > < >= <=: Solo se puede utilizar entre datos de tipo numérico
• ==: Puede utilizarse no solo entre datos de tipo numérico, sino también entre otras variables de tipo referencial.

Operadores logicos

&- Lógico Y
|- Lógico O
!- Lógico NO
&&- Cortocircuito Y
||- Cortocircuito O
^- Lógico XOR

a	b	a&b	a&b	a|b	a||b	!a	a ^ b
verdadero	verdadero	verdadero	verdadero	verdadero	verdadero	FALSO	FALSO
verdadero	FALSO	FALSO	FALSO	verdadero	verdadero	FALSO	verdadero
FALSO	verdadero	FALSO	FALSO	verdadero	verdadero	verdadero	verdadero
FALSO	FALSO	FALSO	FALSO	FALSO	FALSO	verdadero	FALSO

distinguir entre & y &&

• Similitud 1: los resultados de operación de & y && son los mismos
• Mismo punto 2: cuando el lado izquierdo del símbolo es verdadero, ambos realizarán la operación en el lado derecho del símbolo
• La diferencia: cuando el lado izquierdo del símbolo es falso, & continúa realizando la operación en el lado derecho del símbolo, y && ya no realiza la operación en el lado derecho del símbolo

Distinguir entre | y ||

• Similitud 1: | y || tienen el mismo resultado de operación
• Mismo punto 2: Cuando el lado izquierdo del símbolo es falso, ambos realizarán la operación en el lado derecho del símbolo
• 不同点1：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算

位运算符

运算符	运算	范例
<<	左移	3 << 2 = 12 --> 3*2*2=12
>>	右移	3 >> 1 = 1 --> 3/2=1
>>>	无符号右移	3 >>> 1 = 1 --> 3/2=1
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 7
^	异或运算	6 ^ 3 = 5
~	取反运算	~6 = -7

位运算时直接对整数的二进制进行的运算

运算符	描述
<<	空位补0，被移除的高位丢弃，空缺位补0
>>	被移除的二进制最高位是0，右移后，空缺位补0，若最高位是1，空缺位补1
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补
&	二进制位进行&运算，只有1&1时结果是1，否则是0
|	二进制位进行|运算，只有0|0时结果是0，否则是1
^	相同二进制进行^运算结果是0：1^1=0,0^0=0；不相同二进制位^运算结果是1：1^0=1，0^1=1
~	各二进制码按补码各位取反

m = k ^ n = (m ^ n) ^ n

三元运算符

• 格式：(条件表达式) ? 表达式1 : 表达式2;
• 表达式1和表达式2为同种类型

三元运算符与if-else的联系与区别

• 三元运算符可简化if-else语句
• 三元运算符要求必须返回一个结果
• if后的代码块可有多个语句

附加：运算符的优先级

	. () {} ; ,
R–>L	++ -- ~ !(data type)
L–>R	* / %
L–>R	+ -
L–>R	<< >> >>>
L–>R	< > <= >= instanceof
L–>R	== !=
L–>R	&
L–>R	^
L–>R	|
L–>R	&&
L–>R	||
R–>L	? :
R–>L	= *= /= %=
	+= -= <<= >>=
	>>>= &= ^= |=

6、程序流程控制

• 程序控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结果，即：顺序结构、分支结构、循环结构

分支结构

if-else结构

• else 结构是可选的
• 针对与条件表达式：
  • 如果多个条件表达式之间是“互斥”关系（或没有交集的关系），哪个判断和执行语句声明在上面还是下面，无所谓。
  • 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
  • 如果多个条件表达式之间有包含关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没有机会执行
• if-else 结构是可以互相嵌套的。
• 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
• 多个if-else时，if-else的配对方式采用就近原则进行配对

switch-case结构

switch(表达式){
  case 常量1:
    语句1;
    // break;
  case 常量2:
    语句2;
    // break;
  ... ...
  case 常量N:
    语句N;
    // break;
  default:
    语句;
    // break;
}

• 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应的case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
• break，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构
• switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）
• case 之后只能声明常量，不能声明范围。
• break 关键字是可选的
• default：相当于if-else结构中的else。default结构是可选的，而且位置是灵活的。

int number = 0;
// Console: zero
switch(number) {
  default:
    System.out.println("other");
  case 0:
    System.out.println("zero");
    break;
  case 1:
    System.out.println("one");
    break;
}

• 凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立。
• 当发现既可以使用switch-case且switch中表达式的取值情况不太多，又可以使用if-else时，我们优先选择使用switch-case。原因：switch-case执行效率稍高。

循环结构

循环语句的四个组成部分

• 初始化部分
• 循环条件部分
• 循环体部分
• 迭代部分

for循环结构

for(初始化部分;循环条件部分;迭代部分) {
  循环体部分
}

执行过程：初始化部分-循环条件部分-循环体部分-迭代部分-循环条件部分-循环体部分-迭代部分- ... - 循环条件部分

while循环结构

初始化部分
while(循环条件部分) {
  循环体部分
  迭代部分
}

执行过程：初始化部分-循环条件部分-循环体部分-迭代部分-循环条件部分-循环体部分-迭代部分- ... - 循环条件部分

• 写while循环千万小心不要丢了迭代条件。一旦丢了，就可能导致死循环！
• 写程序需要避免出现死循环。
• for循环和while循环是可以相互转换的。区别在于for循环和while循环的初始化条件部分的作用范围不同。

do-while循环结构

初始化部分
do{
  循环体部分
  迭代部分
}while(循环条件部分);

执行过程：初始化部分-循环体部分-迭代部分-循环条件部分-循环体部分-迭代部分- ... - 循环条件部分

• do-while循环至少会执行一次循环体！
• 开发中，使用for和while更多一些。较少使用do-while

特殊关键字的使用

	适用范围	不同点	相同点
break	switch-case和循环结构中	结束当前循环	关键字后面不能声明执行语句
continue	循环结构中	结束当次循环	关键字后面不能声明执行语句

label: for(int i = 1; i <= 4; i++) {
          for(int j = 1; j <= 10; j++) {
            if (j % 4 == 0) {
              //break; //默认跳出包裹此关键字最近的一层循环
              //continue;
              
              //break label; //结束指定标识的一层循环结构
              continue label; //结束指定标识的一层循环结构当次循环
            }
          }
        }

• return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。
• 与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

7、数组

• 数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。
• 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。
• 数组的长度一旦确定，就不能修改。

//1.一维数组的声明和初始化		
int[] ids;//声明
//1.1静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{1001,1002,1003,1004};
//1.2动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];

数组元素的默认初始化值

• 数组元素是整型：0
• 数组元素是浮点型：0.0
• 数组元素是char型：0或者’\u0000’，而非’0’
• 数组元素是boolean型：false
• 数组元素是引用数据类型：null

对于二维数组的理解：我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。其实，从数组底层的运行机制来看，其实没有多维数组。

//一些错误的写法
//int[] ids;
//ids = {1,2,2}; //编译错误
//一些正确但是不标准的写法
int[] arr1 = {1,2,2,3}; //类型推断
int[] arr2[] = new int[][]{
   
   {1,2,2},{4,5},{6,7,8}}; // 数组[]位置可以随意
int[] arr3[] = {
   
   {1,2,2},{4,5},{6,7,8}};
String[] strArray1[] = {
   
   {"222", "2222"},{"111", "3333", "5555"}};

附加：Arrays工具类的使用

• java.util.Arrays类即为操作数组的工具类，包含了用来操作数组的各种方法

方法	作用
boolean equals(int[] a,int[] b)	判断两个数组是否相等
String toString(int[] a)	输出数组信息
void fill(int[] a,int val)	将指定值填充到数组之中
void sort(int[] a)	对数组进行排序
int binarySearch(int[] a,int key)	对排列后的数组进行二分法检索指定的值