Tabla de contenido
1. Comentarios (una sola línea, varias líneas, documento)
Dos. Principio Identifier_Keyword_Hump
3. Solución de error: Welcome.java:6: Error: caracteres no asignados que codifican GBK
4. Booleano booleano _if declaración use puntos _ problema booleano ocupa espacio
Aunque estaba bastante familiarizado con él en mi segundo año, ha pasado tanto tiempo después de todo, es mejor volver a hacerlo. Después de todo, tengo que estudiar sistemáticamente. Por supuesto que no es demasiado detallado.
1. Comentarios (una sola línea, varias líneas, documento)
// Comentario de una sola línea
/ * Multilínea
Comentario * / (Los comentarios de varias líneas también se pueden colocar entre códigos válidos)
Notas de documentación:
Los comentarios de la documentación comienzan con "/ **" y terminan con "* /". Los comentarios contienen texto descriptivo y algunas etiquetas JavaDoc (cuando escribas el proyecto más tarde, puedes generar la API del proyecto). Hablaré de ello más adelante.
/**
* test 文档注释
* @author 深海鱼肝油
* @version 1.0
*/
public class Welcome {
public static void main(String[] args /*参数名称，可变*/){
//单行注释
System.out.println("hello world！");
}
}
/*
多行啊
百无聊赖啊
*/Dos. Principio Identifier_Keyword_Hump
Reglas de nomenclatura de identificadores:
El identificador debe comenzar con una letra, un guión bajo y un signo de dólar $.
Las otras partes del identificador pueden ser
cualquier combinación de letras, signo de dólar de subrayado "$" y números.
Los identificadores de Java distinguen entre mayúsculas y minúsculas y tienen una longitud ilimitada.
Los identificadores no pueden ser palabras clave de Java.
Java no usa el juego de caracteres ASCII que usan los lenguajes ordinarios, pero usa un juego de caracteres internacional estándar como Unicode. Por lo tanto, el significado de las letras aquí no es solo en inglés, sino también en caracteres chinos, etc. ¡Pero no se recomienda que utilice caracteres chinos para definir identificadores!
El juego de caracteres ASCII usa un byte para representar caracteres, por lo que solo 2 ^ 8 = 256 caracteres; mientras que el juego de caracteres Unicode usa dos bytes para representar un carácter, por lo que 2 ^ 16 = 65536 caracteres.
p.ej:
public class Welcome {
public static void main(String[] args /*参数名称，可变*/){
int 随便=123;//java用的是Unicode字符集，所以汉字可以作为变量名称
int abc=12;
int $salary=3500;
int _year=2021;
System.out.println("hello world！");
}
}Identificador que representa el nombre de la clase: escriba en mayúscula la primera letra de cada palabra, como Man, GoodMan
representa el identificador de métodos y variables: la primera palabra está en minúsculas y la primera letra de la segunda palabra está en mayúscula. La llamamos " principio de caso de camello "”, como eat (), eatFood ()
3. Solución de error: Welcome.java:6: Error: caracteres no asignados que codifican GBK
Al compilar con el nombre de archivo javac en la línea de comando, se informa un error de codificación y se convierte a la codificación GBK bajo idea, porque la línea de comando usa la codificación del sistema operativo local.
Convierta a tipo GBK en la esquina inferior derecha.
Por supuesto, la línea de comando generalmente no se usa para compilar, a menos que el código esté escrito en el bloc de notas o en el bloc de notas. .
Cuatro. Constante constante
Modificado con final se convierte en una constante y el valor no se puede cambiar después de la asignación; de lo contrario, se informará un error.
Cinco. Tipo de datos
A diferencia de C ++, el número de bytes de tipos de datos correspondientes a diferentes compiladores puede cambiar en consecuencia. Java es fijo.
Al definir variables, se recomienda definir línea por línea para mejorar la legibilidad, no como int i, j ;.
1. Entero
byte1 byte, short2 byte, int4 byte, long8 byte
Número octal: agregue 0 al principio, como 016
Número hexadecimal: agregue 0x o 0X al principio, como 0x16
Número binario: agregue 0b o 0B al principio, como 0b1000101
Además, para declarar como tipo largo debe ir seguido de L o l
p.ej:
int a=100;
int b=5030303;
int c=05;//八进制
int d=0x15;//十六进制
int e=0b101011;//二进制
long f=5555555;
long f2=55555555555555L;//将整数常量定义为long类型2. Punto flotante
Debido a que los decimales son infinitos, float4 bytes y double8 bytes definitivamente no son suficientes, ya que muchos dígitos no son suficientes, ¡porque los decimales son infinitos! Por tanto, existe un error en el almacenamiento de decimales.
El valor del tipo flotante tiene un sufijo F o f, y el valor de punto flotante sin el sufijo F / f toma por defecto el tipo doble. También puede agregar el sufijo D od después del valor de punto flotante para dejar en claro que es un tipo doble.
p.ej:
Código:
double d1=3.14;
double d2=3.14e2;//科学计数法表示小数
System.out.println(d2);
//浮点数是不精确的，尽量不要直接进行比较
float d3=0.1F;
double d4=1.0/10;
System.out.println(d4);
System.out.println(d3==d4);
float f5=1234567412356L;//long转float
float f6=f5+1;//如果f5和f6都是整型性的话肯定不相等
System.out.println(f5==f6);Resultado de salida:
314.0
0.1
false
true3. Tipo de personaje
Se puede convertir a tipo int para ver el número de serie del carácter: (int) c
Unicode tiene una codificación de 0 a 65535, y generalmente están representados por el decimosexto mecanismo de '\ u0000' a '\ uFFFF', y el prefijo u significa Unicode.
Código:
char c1='a';
char c2='中';
//也可以通过每个字符对应的编码来输出字符
char c3='\u0061';//0061的十六进制就是97
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
//java中的字符串不是基本数据类型，而是一个独立定义的类
String str ="我爱中国";
System.out.println(str);
//转义字符
System.out.println("a\nb\nc\nd\te\tf\tg,\",\',\\");Resultado de salida:
a
中
a
我爱中国
a
b
c
d e f g,",',\4. Booleano booleano _if declaración use puntos _ problema booleano ocupa espacio
Descripción de unos pocos bytes de tipo booleano:
En la descripción del libro "Java Virtual Machine Specification": "Aunque este tipo de datos booleano está definido, solo proporciona un
soporte no muy limitado para la máquina virtual Java. No hay código de bytes instrucción dedicada al
valor booleano. El valor booleano manipulado por la expresión del lenguaje Java se reemplaza por el tipo de datos int en la máquina virtual Java después de la compilación, y la matriz booleana se codificará en la
matriz de bytes de la máquina virtual Java . Cada elemento de boolean el elemento ocupa 8 bits ". Es decir, la especificación JVM señala que boolean se trata como int,
que es de 4 bytes , y la matriz booleana se trata como matriz de bytes. De esta forma, podemos concluir que el tipo booleano ocupa 4
bytes para un solo uso , y es una palabra determinada en la matriz .
Sugerir:
No escribas así: si (flag == true), solo los novatos escriben eso. La clave también es fácil de escribir if (flag = true) incorrecto, por lo que se convierte en la asignación de flag a true en lugar de juicio. La escritura del veterano es if (flag) o if (! Flag)
Código de muestra:
boolean b1=true;
boolean b2=false;
if (b1){
System.out.println("正确");
}
else{
System.out.println("错误");
}Seis. Operador
Operación entera:
si uno de los dos operandos es largo, el resultado también es largo, si
no hay largo, el resultado es int. Incluso si los operandos son todos cortos, byte, el resultado es un int.
p.ej:
int a=5;
long b=7;
long c=a+b;//要用long类型来接受a与b的和，否则报错类型不兼容
Operaciones de coma flotante:
Si uno de los dos operandos es doblador, el resultado es doble,
solo cuando ambos operandos son flotantes, el resultado es flotante.
Operación de módulo:
El operando puede ser un número de coma flotante. En general, se utilizan enteros y el resultado es "resto". El signo de "resto" es el mismo que el del operando izquierdo, como: 7% 3 = 1, -7% 3 = -1, 7% -3 = 1.
p.ej:
int a=1;
Long b=2L;
boolean flag=b instanceof Long;//注意是Long(包装类)
System.out.println(flag);
long c=a+b;
System.out.println(c);
double d=31/3;//先31/3=10（整型运算），之后，再将10赋给double型
System.out.println(d);Producción:
true
3
10.0relación:
&&, || contrast &, | significa que el primero es un cortocircuito, es decir, la primera mitad no cumple las condiciones y la segunda mitad no necesita ser leída.
Cambio:
int a=5<<2; //相当于5*2*2=20
System.out.println(a);
System.out.println(40>>3); //相当于40/2/2/2=8Concatenación de cadenas:
String a="3";
int b=4;
System.out.println(a+b);
//条件是String，不是char，为char时，仍然是加号。不是连接符
char c1='h';
char c2='i';
System.out.println(c1+c2);
System.out.println(""+c1+c2);//通过加""+,将整个运算转化为字符串连接操作Producción:
34
209
hiOperador condicional:
int score=90;
String a=score<60?"不及格":"及格";
System.out.println(a);prioridad:
No hay necesidad de recordar deliberadamente estas prioridades, se prefieren los paréntesis para organizar expresiones !! La prioridad de
AND lógico, OR lógico y NOT lógico debe ser familiar (NOT lógico> Y lógico> Prestigio lógico). Tales como:
el resultado de la operación de allb & c es: al (b & c), no (alb) & c
Conversión automática de tipos:
La conversión automática de tipos significa que un tipo de datos con poca capacidad se puede convertir automáticamente en un tipo de datos con una gran capacidad, como se muestra en la siguiente figura:
La línea continua indica la conversión de tipo sin pérdida de datos y la línea discontinua indica que la conversión puede tener una pérdida de precisión.
Las constantes enteras se pueden asignar directamente a variables de tipo como byte, short, char, etc., sin la necesidad de una conversión de tipo forzada, siempre que no exceda el número de tablas.
//从容量小的类型可以自动转化为容量大的类型
int a = 2345;
long b=a;
//int c= b; //long类型不能自动转为int
double d = b;
float f= b;
//特例:整型常量是int类型,但是可以自动转为: byte,short,char。只要不超过对应类型的表数范围。
byte h1 = 123;
//byte h2 = 1234; //1234超过 了byte的表数范围[-128,127]。
char h3 = 600;
//char[0,65535]之间
System.out.println(h3);Producción:
ɘConversión de tipo forzada:
double a = 3.9415;
int b = (int)a;//b:3.浮点数强制转成整数,则直接丢失小数部分(不会四舍五入)
System.out.println(b);
int c=97;
System.out.println((char)c);
//强制转型，超过了表数范围，则会转成一个完全不同的值。
byte d = (byte)300;
System.out.println(d);Producción:
3
a
44Problemas comunes de desbordamiento de conversión (problemas L):
Int se usa cuando se debe usar el entero largo
//溢出问题
int money = 1000000000; //10亿
int years = 20;
//返回的total是负数,超过了int的范围
int total = money*years;
System.out.println(" total= " + total);
//返回的total仍然是负数。默认是int ,因此结果会转成int值,再转成long。但是已经发生了数据丢失
long total1 = money*years;
System.out.println(" total1="+ total1);
//返回的total2正确:先将一个因子变成long ,整个表达式发生提升。全部用long来计算。
long total2 = (money*(long)years);
//long total2 = 1L*money*years;
System.out.println(" total2=" + total2);
//人的寿命是80岁，经历了多少次心跳
long num = 100L *60*24*365*80; //注意这里100L是长整型
System.out.println("人的一-生心跳次数: " +num);Producción:
total= -1474836480
total1=-1474836480
total2=20000000000
人的一-生心跳次数: 4204800000El valor predeterminado de la variable miembro:
Integridad: 0
Tipo de punto flotante: 0.0
Tipo de carácter: '\ u0000'
Booleano: falso
Todos los tipos de referencia: nulo
Siete. Método de construcción
Independientemente de si escribe un constructor sin parámetros o con parámetros, el sistema ya no generará automáticamente un constructor.
¡El constructor es llamado por la nueva palabra clave!
Aunque el constructor tiene un valor de retorno, el tipo de valor de retorno no se puede definir (el tipo de valor de retorno debe ser este tipo), y no se puede usar retorno en el constructor para devolver un determinado valor.
Si no definimos un constructor, el compilador definirá automáticamente un constructor sin parámetros. ¡Si está definido, el compilador no lo agregará automáticamente! ¡
El nombre del método del constructor debe ser el mismo que el nombre de la clase!
POO: diseño orientado a objetos de proyectos de objetos orientados
OOA: análisis de objetos orientados
Entender el módulo como un subproyecto. El módulo también se puede configurar con un JDK separado.
