1. Regras de nomenclatura
Em Java, existe um padrão unificado para nomear vários identificadores (nomes de classes, nomes de pacotes, nomes de métodos, nomes de variáveis)
- Só pode ser composto por números, letras, _ e $ e não pode começar com um número.
- Não pode ser uma palavra-chave
- Tente ver o nome e saber o significado tanto quanto possível
- Todos os nomes de classes devem começar com letras maiúsculas
- Todos os nomes de pacotes devem estar em letras minúsculas
- Todos os nomes de constantes devem estar em letras maiúsculas e podem ser separados por sublinhados.
- Siga a nomenclatura em camel case (a primeira letra da palavra é maiúscula e o nome pode começar em minúscula)
2. Comentários
Existem três tipos de anotações no arquivo Java
1. Comentários de linha única
Geralmente usado em locais com menos conteúdo de comentários, como comentários de lógica de código
// 注释内容
2. Comentários multilinhas
Usado onde há muitas anotações
/*
注释内容
*/
3. Comentários do documento
Comentários de documentação geralmente são usados em classes, métodos e variáveis para descrever suas funções.
/**
* 注释内容
*/
3. Tipos básicos de dados
Java tem oito tipos básicos , exceto esses oito tipos básicos, outros tipos são tipos de referência e o valor padrão de todos os tipos de referência é nulo. Os oito tipos básicos são divididos em tipos inteiro, ponto flutuante, caractere e booleano .
1. Tipo inteiro
| tipo | byte | faixa de tamanho | Padrões |
|---|---|---|---|
| byte | 1 | -2 7 a 2 7 -1 (-2 (1*8-1) a 2 (1*8-1) -1) | 0 |
| curto | 2 | -2 15 a 2 15 -1 (-2 (2*8-1) a 2 (2*8-1) -1) | 0 |
| interno | 4 | -2 31 a 2 31 -1 (-2 (4*8-1) a 2 (4*8-1) -1) | 0 |
| longo | 8 | -2 63 a 2 63 -1 (-2 (8*8-1) a 2 (8*8-1) -1) | 0 |
2. Tipo de ponto flutuante
| tipo | byte | faixa de tamanho | Padrões |
|---|---|---|---|
| float (precisão única) | 4 | 1.4E-45 a 3.4028235E38 | 0,0 |
| duplo (precisão dupla) | 8 | 4.9E-324 a 1.7976931348623157E308 | 0,0 |
3. Tipo de personagem
| tipo | byte | faixa de tamanho | Padrões |
|---|---|---|---|
| Caracteres | 2 | Unicode(0~2^16-1) | Unicode(0) |
4. Tipo booleano
| tipo | byte | faixa de tamanho | Padrões |
|---|---|---|---|
| boleano | 1 | falso e verdadeiro | falso |
5. Conversão hexadecimal do tipo int
a. Binário
Em Java, você pode usar prefixos diretamente 0bpara representar entradas binárias, como
int a = 0b111; // 结果：7
b. Sistema octal
Você pode usar um prefixo 0para representar um int octal, como
int a = 011; // 结果：9
c. Hexadecimal
0xInts hexadecimais podem ser representados por um prefixo , como
int a = 0x11; // 结果：17
6. Conversão básica
A conversão de um tipo com um intervalo de valores grande para um tipo com um intervalo de valores pequeno requer conversão forçada , como
int age = (int)3.5; // 通过(int)把浮点型数据强转为int类型
Tipos com um intervalo de valores pequeno podem ser convertidos diretamente em tipos com um intervalo de valores grande, como
double price = 2; // 2明显是int类型，但是可以直接赋值为浮点型
4. Operadores
1. Operadores aritméticos
para operações numéricas
| símbolo | nome |
|---|---|
| + | adicionar |
| - | reduzir |
| * | pegar |
| / | remover |
| % | Pegue o resto |
2. Operadores de comparação
Usado para comparação numérica, o resultado é do tipo booleano
| símbolo | nome |
|---|---|
| > | mais do que o |
| < | menor que |
| >= | maior ou igual a |
| <= | menos que ou igual a |
| == | igual |
| != | não é igual a |
3. Operadores lógicos
| símbolo | nome | lógica |
|---|---|---|
| && | lógico E | Antes e depois são verdadeiros e o resultado é verdadeiro |
| || | lógico ou | Contanto que um dos dois seja verdadeiro, o resultado é verdadeiro. |
| ！ | negação lógica | Mude verdadeiro para falso e falso para verdadeiro |
fenômeno de curto-circuito
A&&B, quando A é falso, o resultado é falso e B não precisa julgar novamente.
A||B, o resultado é verdadeiro quando A é verdadeiro, B não precisa mais ser julgado
4. Operadores unários
| símbolo | lógica |
|---|---|
| ++ | eu mais um |
| – | Subtraia um de si mesmo |
como
int a = 12;
++a; // 结果：13
a++; // 结果：14
--a; // 结果：13
a--; // 结果：12
5. 赋值运算符
| 符号 | 逻辑 |
|---|---|
| = | 等于 |
| += | 在自身上加… |
| -= | 在自身上减… |
如
int a = 12;
a+=3; // 结果：15。与a = a + 3;不同，a = a + 3是先运算a + 3再赋值给a，而a+=3则是直接在a上加3
a-=4; // 结果：11。与a = a - 4;不同，a = a - 4是先运算a - 4再赋值给a，而a-=4则是直接在a上减4
6. 按位运算符
| 符号 | 名称 | 逻辑 |
|---|---|---|
| >> | 按位右移 | A>>B，将A转为二进制，然后二进制数字向右移动B位数，超出的部分截取掉，剩余的部分转为十进制就是结果 |
| << | 按位左移 | A<<B，将A转为二进制，然后二进制数字向左移动B位数，空出来的位置补0，然后转为十进制 |
| >>> | 按位带符号位右移 | 与按位右移不同的是该运算符会带符号位位移 |
| & | 按位与 | A&B，将A和B转为二进制，右对齐上下比较，两者都为1则为1，否则为0，再转为十进制 |
| | | 按位或 | A|B，将A和B转为二进制，右对齐上下比较，两者有一个为1则为1，再转为十进制 |
| ^ | 按位异或 | A^B，将A和B转为二进制，右对齐上下比较，两者不同则为1，相同则为0，再转为十进制 |
如
7 >> 2; // 结果：1
7 << 2; // 结果：28
-1 >>> 1; // 结果：2147483647
7 & 8; // 结果：0
6 | 7; // 结果：7
7 ^ 8; // 结果：15
7. 三元运算符
A?B:C，判断A的结果，如果A为true，表达式就取B的值，如果是false，就取C的值
如
1>2?12:23; // 结果：23
注意
System.out.println(1>2?1.2:2);
// 直接输出时，后面两个值属性可以不同，类型取范围大的，结果为2.0
// 赋值的时候后面两个值类型必须相同
int a = 1>2?1.2:2//报错
8. 优先级
| 优先级 | 运算符 | 结合性 |
|---|---|---|
| 1 | ()、[]、{} | 从左向右 |
| 2 | !、+、-（正负）、~、++、– | 从右向左 |
| 3 | *、/、% | 从左向右 |
| 4 | +、-（加减） | 从左向右 |
| 5 | <<、>>、>>> | 从左向右 |
| 6 | <、<=、>、>=、instanceof | 从左向右 |
| 7 | ==、!= | 从左向右 |
| 8 | & | 从左向右 |
| 9 | ^ | 从左向右 |
| 10 | | | 从左向右 |
| 11 | && | 从左向右 |
| 12 | || | 从左向右 |
| 13 | ?: | 从右向左 |
| 14 | =、+=、-=、*=、/=、&=、|=、^=、~=、<<=、>>=、>>>= | 从右向左 |
五、转义符
| 转义字符 | 意义 |
|---|---|
| \n | 换行 |
| \t | 横向跳格 |
| \r | 回车 |
| \ | \ |
| " | " |
| ’ | ’ |