Syntaxe de base Java-B2

Grammaire de base (1)

La structure de base du programme

La forme de base des programmes Java

Le langage Java est un langage orienté objet. Les programmes Java existent principalement sous forme de classes, également appelées Class, et les classes sont également les plus petites unités de programme des programmes Java.

Les programmes Java nécessitent que toutes les instructions et méthodes d'exécution soient placées dans une classe.

Le programme Java le plus simple:

class Hello {
}

Dans la classe Hello ci-dessus, il s'agit simplement d'une définition d'une classe vide, sans aucun composant de classe, elle peut être compilée, mais elle signalera une erreur lors de son exécution.

Parce qu'il stipule que si une classe doit être directement interprétée et exécutée par l'interpréteur, elle doit inclure la méthode d'entrée du programme main (), et elle doit être décorée avec du statique public, le type de valeur de retour doit également être défini sur void, et le paramètre de cette méthode doit être String [] args Tableau de chaînes.

public static void main(String[] args) {
  System.out.println("hello");
}

À l'avenir, même si notre programme Java devient progressivement plus compliqué, pour un programme Java, il vous suffit d'avoir une méthode principale comme "entrée" dans une classe, et les autres classes seront directement ou indirectement par la méthode main (). Appelle.

Mécanisme d'exploitation du programme Java

Il existe deux types de langages informatiques de haut niveau selon les méthodes d'exécution du programme: compilés et interprétés.

Type de compilation:
Il existe des compilateurs spéciaux pour différents systèmes d'exploitation, le code source est directement compilé en code machine exécuté par le matériel du système actuel, puis conditionné dans un format de programme que le système actuel peut reconnaître et exécuter. Le programme exécutable généré peut s'exécuter sur une plate-forme système spécifique sans être limité par l'environnement de développement. Si vous souhaitez exécuter sur différentes plates-formes système, vous devez placer le code source directement dans le compilateur sur différentes plates-formes système et le recompiler avant de pouvoir l'exécuter.
Les langages compilés courants sont: C, C ++, Swift, Kotlin, Objective-C, etc.

Type d'interprétation:
un interpréteur spécial qui interprète le programme source ligne par ligne dans le code machine de la plate-forme système actuelle et l'exécute immédiatement. Un langage interprété nécessite une compilation à chaque exécution, ce qui équivaut à mélanger les processus de compilation et d'interprétation dans un langage compilé et à les terminer en même temps. Par conséquent, son efficacité est relativement faible et il ne peut pas fonctionner indépendamment de l'interpréteur. Mais son avantage est que le fonctionnement multiplateforme est particulièrement simple, tant qu'il y a un interprète pertinent sur la plate-forme correspondante.
Les langages interprétés courants sont: JavaScript, Ruby, Python, etc.

JVM

Le langage Java est très spécial et le programme source Java sera également compilé, mais après la compilation, il ne générera pas de code machine pour une plate-forme spécifique, mais générera un fichier de bytecode indépendant de la plate-forme. Cependant, le fichier de bytecode ne peut pas être exécuté. Si vous voulez l'exécuter, vous devez utiliser l'interpréteur Java pour l'interpréter. Par conséquent, le processus d'exécution du programme Java doit passer par deux étapes: d'abord compiler puis expliquer. On peut considérer que le langage Java est à la fois un langage compilé et un langage interprété.

Processus d'opération:

1. Le fichier source Java (xxx.java) est compilé via l'instruction javac pour obtenir le fichier de bytecode (xxx.class).

2. Le fichier de bytecode est interprété et exécuté par la commande java, et le bytecode est traité par la JVM (interprète) pour générer du code machine qui peut être directement exécuté par l'ordinateur, afin que le programme java puisse être correctement exécuté.

Spécification de programmation

Règles de dénomination des fichiers source Java

• L'extension du fichier source du programme Java est: xxx.java

• Si la classe est décorée avec public, le nom de fichier doit être le même que le nom de classe. Dans un fichier source Java, vous pouvez définir plusieurs classes, qui sont complètement indépendantes les unes des autres, mais il ne peut y avoir qu'une seule classe décorée publique dans une classe.

• En général, il est recommandé qu'un fichier source Java ne définisse qu'une classe Java. De plus, il est préférable que le nom du fichier source corresponde au nom de classe modifié par public.

Cas Java

Le langage Java est strictement sensible à la casse et à la casse.

Les mots "mots clés" spécifiés dans le langage Java sont tous en minuscules.

Problèmes avec les espaces sur le chemin

Lorsque vous nommez un dossier, il ne doit y avoir aucun espace dans le nom du dossier. (N'oubliez pas !!! N'oubliez pas !!! N'oubliez pas !!!)

problème de méthode main ()

Un programme Java, si vous voulez l'exécuter, doit inclure la méthode main (), le format spécifique est le suivant:

public static void main(String[] args) {
  // 需要执行的代码语句
  System.out.println("hello lucaswangdev");
}

Identifiant

Séparateurs communs:

Dans le langage Java, les séparateurs communs sont: le point-virgule, les accolades, les crochets, les parenthèses, les espaces, les points, etc.

Point-virgule

Lors de l'écriture de code, la fin de chaque phrase doit être marquée d'un point-virgule.

System.out.println("每一句代码，都是用分号来结束的");

Bretelles frisées

Les accolades sont principalement utilisées pour définir un bloc de code. Le bloc de code fait référence à l'utilisation du symbole "{" comme début et du symbole "}" comme fin.

Le code de segment est logiquement un tout.

{
  	System.out.println("I");
    System.out.println("Love");
    System.out.println("Java");
}

Crochets

Les crochets sont principalement utilisés pour accéder aux éléments du tableau, souvent suivis des noms des variables du tableau, et les valeurs d'index des éléments du tableau sont principalement spécifiées entre crochets.

String[] names = {"张三", "李四", "王五"};
System.out.println(names[1]); // 李四

Parenthèses

• Lors de la définition d'une méthode, elle peut être utilisée pour déclarer tous les paramètres formels.

  public void setName(String name){...}
  

• Lors de l'appel d'une méthode, elle peut être utilisée pour transmettre des paramètres réels.

  setName("jiajia");
  

• Lors du calcul, augmentez la priorité du calcul.

  int num = 2 * (3 + 5);
  

• Cast le type.

  int num2 = (int) 3.14;
  

L'espace

Les espaces sont principalement utilisés pour séparer différentes parties d'une phrase.

Dot

Le point, généralement utilisé comme classe / objet et ses membres (y compris le séparateur entre les variables de membre, les méthodes et les classes internes), indique qu'un membre spécifié d'une classe ou d'une instance est appelé.

Règles de dénomination des identifiants

Les identificateurs sont principalement utilisés pour nommer les variables, les classes et les méthodes dans les programmes. Les identificateurs de langage Java doivent commencer par des lettres, des traits de soulignement et des signes dollar, suivis de n'importe quel nombre de lettres, chiffres, traits de soulignement et signes dollar.

Lors de l'écriture, portez une attention particulière à la capitalisation.

Les règles d'écriture spécifiques sont les suivantes:

1. Peut être composé de lettres, de chiffres, de traits de soulignement et de signes dollar, qui ne peuvent pas commencer par un nombre.
2. Il ne peut pas s'agir de mots clés Java et de mots réservés, mais peut contenir des mots clés et des mots réservés.
3. Ne peut pas contenir d'espaces.
4. Ne peut contenir que des signes dollar, pas d' autres symboles spéciaux tels que @ , # ,%, etc.

Accord:

1. Les identifiants doivent correspondre aux informations sémantiques

2. Toutes les lettres du nom du package sont en minuscules

3. Chaque première lettre du nom de classe est en majuscules et autres minuscules

4. Variables et méthodes Premier mot en minuscule Deuxième majuscule de départ

5. Toutes les majuscules de la constante

Mot-clé

Les mots clés en Java sont des mots à des fins particulières, également appelés mots clés. Tous les mots clés sont en minuscules, alors faites particulièrement attention lors de l'écriture. De plus, true, false et null ne sont pas des mots-clés, mais des quantités directes spéciales.

Type de données

Classification des types de données

Le langage Java est un langage fortement typé, et fortement typé se réfère principalement à:

• Toutes les variables doivent être déclarées avant utilisation;

• La variable spécifiée n'est accessible qu'avec une valeur qui correspond au type.

Il a été déterminé que chaque variable et chaque expression ont un type correspondant au moment de la compilation. Les types peuvent limiter les valeurs qu'une variable peut être affectée et peuvent limiter les valeurs qu'une expression peut produire, ce qui peut limiter les opérations et la signification des opérations qui peuvent être effectuées sur ces valeurs.

Format de syntaxe:

type varName [= varValue];

int age;
String name = "lucaswangdev";

types de données Java pris en charge sont principalement deux: ** ** types de données de base et les types de données de référence .

Types de données de base

Comment utiliser

1. Lorsque vous représentez un entier, utilisez int (âge, quantité de biens, etc.), s'il s'agit d'une décimale, utilisez double (prix des marchandises, hauteur, etc.).
2. Lorsque vous indiquez la valeur de temps, le fichier et la taille de la mémoire (la taille du programme est mesurée en octets), utilisez long et utilisez long pour ces données plus volumineuses.
3. Si les opérations d'E / S et la programmation réseau impliquent un transfert de contenu ou une conversion de codage, utilisez l'octet.
4. En cas de jugement logique, vous devez utiliser la valeur booléenne comme condition de jugement, vraie ou fausse.
5. Lorsque vous devez gérer le chinois, utilisez char.

Entier

Les types entiers se réfèrent principalement aux quatre types suivants: octet, court, entier et long.

[Remarque] Lorsque vous spécifiez un entier long, vous devez ajouter la lettre L après la valeur entière, qui peut également être l minuscule.

// 100为byte类型
byte num = 100;

// 777L为long类型
long bigNumber = 777L;

Qu'est-ce qu'une variable? Quelle est l'utilisation des variables?

L'essence de la programmation est d'accéder et de modifier les données en mémoire. Les données utilisées par le programme sont stockées en mémoire, et les développeurs ont besoin d'un moyen d'accéder ou de modifier les données en mémoire.

Que se passe-t-il lorsque les données débordent?

    public static void main(String[] args) {
        // 最大值和最小值
         int max = 2147483647;
         int min = -2147483647;
        // 最大值 +1
         System.out.println(max + 1);
        // 最小值 -1
         System.out.println(min - 1);
    }

// 解决方法1：		
public static void main(String[] args) {
    // 最大值和最小值
    long max = 2147483647;
    long min = -2147483647;
    // 最大值 +1
    System.out.println(max + 1);
    // 最小值 -1
    System.out.println(min - 1);
}

// 解决方法2：		
public static void main(String[] args) {
    // 最大值和最小值
    int max = 2147483647;
    int min = -2147483647;
    // 最大值 +1
    System.out.println(max + 1L);
    // 最小值 -1
    System.out.println(min - 1L);
}

Personnage

Type de caractère, généralement utilisé pour représenter un seul caractère, et doit être entouré d'une paire de guillemets simples ('').

Trois représentations de types de caractères:

• Spécifiez un seul caractère, tel que «A», «1», «i», etc.
• Spécifiez des caractères d'échappement, tels que '\ n', '\ r', etc.
• Spécifiez la valeur Unicode, telle que '\ uXXX', etc.

Caractères d'échappement courants:

• \ b retour arrière
• \ f flux de formulaire
• \ n Envelopper
• \ r Entrez
• \ t onglet suivant
• \ 'Citations simples'
• \ "Double guillemets"

Virgule flottante

Il existe deux types de virgule flottante en Java: float et double.

Double

Le type à virgule flottante du langage Java est double par défaut. Vous pouvez également ajouter d ou D après un nombre à virgule flottante (mais ce n'est pas nécessaire).

Double est un nombre à virgule flottante double précision. Une valeur numérique de type double occupe 8 octets et 64 bits.

Valeur de type double, le premier bit est le bit de signe, les 11 bits suivants représentent l'exposant et les 52 bits suivants représentent la mantisse.

Flotte

float est un nombre à virgule flottante simple précision, et une valeur numérique de type float prend 4 octets et 32 ​​bits.

Pour les valeurs de type flottant, le premier bit est le bit de signe, les 8 bits suivants représentent l'exposant et les 23 bits suivants représentent la mantisse.

Si vous souhaitez utiliser un nombre à virgule flottante comme type flottant, vous devez ajouter f ou F après.

Booléen

Boolean, également appelé booléen, n'a que deux valeurs: true et false. La valeur ou la variable de type booléen est principalement utilisée comme indicateur pour le contrôle de processus et est couramment utilisée dans les processus suivants:

• si instruction de contrôle de flux conditionnel
• instruction de contrôle de flux en boucle
• do ... while instruction de contrôle de boucle
• pour l'instruction de contrôle de flux de boucle
• Opération trinoculaire

Conversion de type de données de base

Conversion de type automatique

Si le système prend en charge l'affectation directe de valeurs d'un type de base à des variables d'un autre type de base, cette méthode est la conversion automatique de type.

Par exemple, il y a deux bouteilles et l'eau remplie dans la petite bouteille est introduite dans la grande bouteille vide et ne débordera pas.

int ii = 88;
// int ii 转float
float ff = ii;

byte bb = 5;
// byte转char会报错
char cc = bb;

// byte可以转换成double,输出 5.0
double dd = bb;
System.out.println(dd);

Remarque:

Toute valeur de type de base + valeur de chaîne sera automatiquement convertie en type de chaîne (type de données de référence).

// 不管是什么数据类型，只要跟字符串相连，最终都变成字符串
String str = 6.66f + "";
System.out.println(str);
// 从左往右运算，打印 6Java
System.out.println(1 + 2 + 3 + "Java");
// 从左往右运算，全都转成字符串了，打印 Java123
System.out.println("Java" + 1 + 2 + 3);

Conversion automatique :

// 一个整数，默认就是 int 类型
// 一个浮点数，默认就是 double 类型

// 左边是 long 类型，右边是默认的 int 类型，左右不一样
// 等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
// int -> long，符合了数据范围从小到大的要求
// 这一行代码发生了自动类型转换。
long num1 = 100;
System.out.println(num1);
System.out.println(Utils.getType(num1)); //class java.lang.Long

// 100 // 左边是double类型，右边是float类型，左右不一样
// float -> double，符合从小到大的规则
// 也发生了自动类型转换
double num2 = 2.5F;
System.out.println(num2); // 2.5
System.out.println(Utils.getType(num2)); //class java.lang.Double

// 左边是float类型，右边是long类型，左右不一样
// long --> float，范围是float更大一些，符合从 小到大的规则
float num3 = 30L;
System.out.println(num3); // 30.0
System.out.println(Utils.getType(num3)); // class java.lang.Float

Conversion de type

La conversion forcée, semblable à diriger l'eau d'une grande bouteille vers une petite bouteille vide, provoquera un débordement et une perte de données.

Conversion obligatoire:

//左边是int类型，右边是long类型，不一样
//long --> int，不是从小到大
//不能发生自动类型转换！
//格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
int num = (int) 100L;
System.out.println(num);

// long强制转换成为int类型
int num2 = (int) 6000000000L;
System.out.println(num2);// 1705032704

// double --> int，强制类型转换
int num3 = (int) 3.99; // 3，这并不是四舍五入，所有的小数位都会被舍弃掉
System.out.println(num3);

// 这是一个字符型变量，里面是大写字母A
char c1 = 'A'; // 66，也就是大写字母A被当做65进行处理
System.out.println(c1 + 1);
// 计算机的底层会用一个数字（二进制）来代表字符A， 就是65
// 一旦char类型进行了数学运算，那么字符就会按照一 定的规则翻译成为一个数字

byte num4 = 40; // 注意！右侧的数值大小不能超过 左侧的类型范围
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5;
System.out.println(result1); // 90

short num6 = 60;
// byte + short --> int + int --> int
// int强制转换为short：注意必须保证逻辑上真实大小 本来就没有超过short范围，否则会发生数据溢出
short result2 = (short) (num4 + num6);
System.out.println(result2); // 100

Jugement de type

9 types de base prédéfinis d'objets Class, 8 types de base et void, ceux-ci sont créés par la machine virtuelle Java et portent le même nom.

//public native boolean isPrimitive();

System.out.println(byte.class.isPrimitive()); // true
System.out.println(short.class.isPrimitive());// true
System.out.println(int.class.isPrimitive());// true
System.out.println(long.class.isPrimitive());// true
System.out.println(float.class.isPrimitive());// true
System.out.println(double.class.isPrimitive());// true
System.out.println(char.class.isPrimitive());// true
System.out.println(boolean.class.isPrimitive());// true
System.out.println(void.class.isPrimitive());

Méthode de jugement de type:

//获取变量类型方法
public static String getType(Object object){
    return object.getClass().toString();
}

Opératrice

Opérateur arithmétique

Les opérateurs arithmétiques sont principalement des opérations mathématiques de base: addition, soustraction, multiplication, division et reste, etc.

// 加法
int a = 11;
int b = 12;
int sum = a + b;

//减法
int c = 15;
int d = 10;
int sub = c - d;

// 乘法
int e = 2;
int f = 3;
int multiply = e * f;

// 除法
int g = 18;
int h = 9;
int div = g / h;
System.out.println("div = " +div);

double i = 3.0;
double j = g / i;
System.out.println("j = " + j);

//如果除数是0.0，则得到正无穷大， Infinity
//如果除数是-0.0，则得到负无穷大， -Infinity
double k = g / 0.0;
System.out.println("k = " + k); // k = Infinity

// java.lang.ArithmeticException: / by zero
//int l = g / 0;
//System.out.println("l = " + l);

// 取余
// 前者除以后者，得到一个整除的结果后剩下的值就是余数
int m = 5;
int n = 2;
int o = m % n;
System.out.println("o = " + o);

// 对 0.0 求余，则得到非数
Object p = m % 0.0;
System.out.println("p = " + p);

Auto-augmentant et auto-diminuant

L'auto-addition, notée ++, est un opérateur monoculaire et ne peut fonctionner que sur un seul opérande. L'opérateur d'auto-ajout ne peut fonctionner que sur une seule variable numérique (entier, virgule flottante, etc.) et ne peut pas fonctionner sur des constantes ou des expressions.

Les opérateurs peuvent apparaître à gauche ou à droite de l'opérande, mais faites particulièrement attention à l'effet final de gauche et de droite.

Si vous mettez ++ à gauche, ajoutez d'abord 1 à l'opérande, puis placez l'opérande dans l'expression.

Si vous placez ++ à droite, vous placez d'abord l'opérande dans l'expression, puis ajoutez 1 à l'opérande.

++a
a = a + 1;
return a;

a++
temp = a;
a = a + 1;
return temp;

x++ increments the value of variable x after processing the current statement.
++x increments the value of variable x before processing the current statement.

So just decide on the logic you write.
x += ++i will increment i and add i+1 to x. 
x += i++ will add i to x, then increment i.

Exemple:

int a = 66;
// 先将 a 的值，放入表达式中进行运算，然后再给 a 加 1
int b = a++ + 10;
// 先将 a 加上 1，然后将新得到的值，再放入表达式中进行运算
int c = ++a + 10;
System.out.println("a = " + a); // 68
System.out.println("b = " + b); // 76
System.out.println("c = " + c); // 78

Opérations mathématiques complexes

Généralement, nous utilisons les méthodes d'outils de la classe java.lang.Math pour effectuer des opérations mathématiques complexes, telles que la puissance et le carré.

La classe Math contient de nombreuses méthodes statiques utilisées pour effectuer diverses opérations mathématiques complexes.

int a = 12;
// 乘方
double b = Math.pow(a, 10);
// 平方根
double c = Math.sqrt(a);
// 随机数
double d = Math.random();
// 三角函数：sin
double e = Math.sin(2.34);
System.out.println("a = " + a);
System.out.println("b = " + b);
System.out.println("c = " + c);
System.out.println("d = " + d);
System.out.println("e = " + e);
//        a = 12
//        b = 6.1917364224E10
//        c = 3.4641016151377544
//        d = 0.24282712973853993
//        e = 0.7184647930691261

Signe spécial +

En particulier, notez qu'en plus du signe plus, il peut également être utilisé comme opérateur de concaténation pour les chaînes.

int year = 2020;
String str = "年";
System.out.println(year + str);

Opérateur d'affectation

Java utilise le signe = comme symbole d'affectation pour affecter des valeurs de variable aux variables.

int a = 12; 
char b = ‘h’; 
boolean c = true; 
// 将变量 a 赋值给 d 变量 
int d = a;

En particulier, l'opérateur d'affectation effectue des calculs de droite à gauche. Le programme calcule d'abord la valeur à droite =, puis "remet" la valeur à la variable de gauche. La variable équivaut à un conteneur pouvant recevoir la valeur affectée.

Opérateur au niveau du bit

& : ET au niveau du bit, ne renvoie 1 que lorsque les deux sont 1.

| : Au niveau du bit ou, tant qu'un bit vaut 1, il peut renvoyer 1.

~ : NOT au niveau du bit, opérateur monoculaire, inverse tous les bits de l'opérande (y compris le bit de signe).

^ : XOR par bit, retourne 0 lorsque les deux bits sont identiques et retourne 1 lorsqu'ils sont différents.

<< : opérateur de décalage vers la gauche, décale le code binaire de l'opérande vers la gauche du nombre de chiffres spécifié, et le côté gauche est vide après le décalage vers la gauche

Les bits qui sortent sont remplis de 0.

>> : Opérateur de décalage vers la droite, après avoir décalé le code binaire du premier opérande vers la droite du nombre de chiffres spécifié, le côté gauche est vacant

La position entrante est remplie avec le bit de signe d'origine.

>>> : Opérateur de décalage à droite non signé. Après avoir décalé le code binaire du premier opérande vers le nombre de bits spécifié vers la droite,

Les postes libérés à gauche sont toujours remplis de 0.

Opérateur de comparaison

Il est principalement utilisé pour juger de la taille de deux variables ou constantes. Le résultat de l'opération de comparaison est une valeur booléenne (true ou false).

> : Supérieur à

> = : Supérieur ou égal à

< : Moins de

<= : Inférieur ou égal à

== : égal à.

Si les deux opérandes comparés sont tous deux de types numériques, même si leurs types de données sont différents, tant que leurs valeurs sont égales, true sera renvoyé.

Si les deux opérandes sont des types de référence, alors uniquement si les types des deux variables de référence ont un parent et un enfant

La relation peut uniquement être comparée et les deux références doivent pointer vers le même objet pour renvoyer true.

! = : Pas égal

Opérateur logique

&& : ET, les deux opérandes avant et après doivent être vrais pour retourner vrai, sinon retourner faux.

& : Pas de court-circuit et, l'effet est le même que &&, mais pas de court-circuit.

|| : Ou, tant que l'un des deux opérandes est vrai, vous pouvez retourner vrai, sinon retourner

faux.

| : Pas de court-circuit ou, le même effet que ||, mais pas de court-circuit.

! : Non, un seul opérande est requis. Si l'opérande est vrai, true est renvoyé.

^ : XOR, il retourne vrai lorsque les deux opérandes sont différents et renvoie faux quand ils sont identiques.

System.out.println(6 > 3 && '7' > 22);
System.out.println(6 >= 7 || 'h' > 'b');
System.out.println(6 >= 7 ^ 'h' > 'b');
int a = 6;
int b = 12;
if (a > 3 | b++ > 12) {
    System.out.println("a 的值：" + a);
    System.out.println("b 的值：" + b);
}
int c = 6;
int d = 12;
if (c > 3 || d++ > 12) {
    System.out.println("c 的值：" + c);
    System.out.println("d 的值：" + d);
}

Opérateur trinoculaire

Format de syntaxe:

Expression? Si la condition est remplie, la valeur ici renvoie A: Si la condition n'est pas satisfaite, la valeur ici renvoie B

Règle: évaluez d'abord l'expression. Si l'expression renvoie vrai, renvoyez la valeur en A; si l'expression renvoie faux, retournez la valeur en B.

int a = 6;
int b = 9;
System.out.println(a > b ? "a 比 b 大" : "a 比 b 小");

Commentaire

Lors de la programmation, il est recommandé d'ajouter quelques commentaires, qui peuvent être utilisés comme texte descriptif d'un morceau de code, ou le but d'une classe, quelle fonction a une méthode, etc.

Des commentaires sur une seule ligne, indiqués par des doubles barres obliques "//", peuvent être ajoutés en ajoutant au début de l'instruction qui nécessite des commentaires.

// 这是单行注释 
// System.out.println(“注释之后的语句，不能再被执行了”); 

Commentaires multi-lignes, vous pouvez commenter tout le contenu de plusieurs lignes à la fois. Commencez principalement par / * et terminez par * / , et incluez le contenu qui doit être annoté.

/*
我可以注释很多内容 System.out.println(“Hello World”); 
*/