Comment utiliser les annotations, les types de données, les constantes et les variables en Java

1. Commentaires

1. Introduction

Les commentaires sont du texte qui explique le programme, améliore la lisibilité du code, nous aide à trouver les erreurs et n'affectera pas le fonctionnement du programme. vous soucier du code exécutable Devenez plus.

2. Tapez

1. Commentaires sur une seule ligne

Les commentaires sur une seule ligne sont les plus couramment utilisés, format : //Contenu du commentaire. //注释的内容。

用法如下：

package day1;
public class Demo01 {
public static void main(String[] args) {
	System.out.println("hello word");  //输出hello word
	System.out.println(3-1);           //输出结果为2
}
}

2.多行注释

当注释过多时可以用多行注释 ，格式：/注释的内容/

用法如下：

package day1;
public class Demo01 {
public static void main(String[] args) {
	System.out.println("yuema");
	System.out.println(3-1);
	/*System.out.println("yuema");
	System.out.println(3-1);*/   //这就是多行注释用法
}
}

3.文档注释

自动生成文档的注释，格式：/*注释的内容/

L'utilisation est la suivante :

package day1;
public class Demo01 {
/**public static void main(String[] args) {
	System.out.println("yuema");
	System.out.println(3-1);
	System.out.println("yuema");
	System.out.println(3-1);
}*/                    //这就是文档注释用法
}

2. Commentaires multi-lignes

Lorsqu'il y a trop de commentaires, vous pouvez utiliser des commentaires multi-lignes, format : /contenu des commentaires/

Utilisation est la suivante :

System.out.println(2.0-1.1);  //系统将打印出0.8999999999999999而不是0.9。

3. Commentaire de documentation

Générer automatiquement les commentaires du document, format : /*Contenu du commentaire/

L'utilisation est la suivante :

package com;
public class Demo05 {
	public static void main(String[] args) {
		//System.out.println();//输出语句，能够在控制台上输出内容
		//在控制台上输出整数常量
		System.out.println(1);
		System.out.println(12);
		System.out.println(-12);
		//在控制台上输出小数常量
		System.out.println(3.14);
		System.out.println(12.5);
		System.out.println(1.0);
		//在控制台上输出字符常量
		System.out.println('a');
		System.out.println('在');
		System.out.println('$');
		//字符常量单引号之内有且仅有一个字符，不能是空字符，以下为例
		//System.out.println('');//错误的
		//System.out.println('abc');//错误的
		//在控制台上输出字符串常量 
		System.out.println("a");  //字符串常量必须用双引号括起来，里面可以是一个、一串、空数据。
		System.out.println("abc");
		System.out.println("123");
		System.out.println("");
		//在控制台上输出布尔常量
		System.out.println(true);  //只有两个值。
		System.out.println(false);
		//在控制台上输出空常量
		//System.out.println(null);//空常量不能放在输出语句的里面
	}
}

3. les commentaires ne peuvent pas être imbriqués en Java, c'est-à-dire/ * */ L'imbrication ne peut pas être utilisée, ce code lui-même peut également contenir un délimiteur /*.

2. Types de données

1. Introduction

Java est un langage fortement typé, ce qui signifie qu'un type doit être déclaré pour chaque variable.

Java a huit types de base : quatre types entiers, deux types à virgule flottante, un type char et un type booléen

2 Les types entiers

Les types entiers sont utilisés pour représenter des valeurs sans décimales, et les nombres négatifs sont autorisés.

Java propose quatre types d'entiers : int, short, long et byte.

Type Exigences de stockage Plage de valeurs

int 4 octets -2147483648 ~ 2147483647

short 2 octets -32768 ~ 32768

long 8 octets -9223372036854775808 ~ 9223372036854775808

octet 1 octet -128 ~ 127

int est le plus couramment utilisé. Si une valeur est relativement grande, utilisez long. De plus, short et byte sont utilisés pour des applications spécifiques, telles que le traitement de fichiers sous-jacents ou des tableaux avec un espace de stockage précieux.

Il n'existe pas de formes non signées (non signées) de types int, short, long ou byte en Java.

3.Type à virgule flottante

• Le type à virgule flottante représente une valeur avec une virgule décimale. Il existe deux types à virgule flottante en Java.

Type Exigences de stockage Plage de valeurs
• float 4 octets Environ +-3.40282347E+38F (les chiffres significatifs sont 6~7)

  double 8 octets Environ +-1.79769313486231570E+308 (15 chiffres significatifs)

• Le numérique la précision du type double est le double de celle du type flottant, et le type double est le plus couramment utilisé.

Le type float est utilisé dans des situations spécifiques, telles que les bibliothèques simple précision ou lors du stockage de grandes quantités de données.

La valeur de type float est suivie d'un suffixe F ou f, par exemple : 3.14F/f. S'il n'y a pas de suffixe F/f, le système utilisera par défaut le type double.

Attention : les valeurs à virgule flottante ne conviennent pas aux calculs financiers qui ne peuvent pas accepter les erreurs d'arrondi

package decom1;

public class changliang {
	public static void main(String[] args) {
		
		final double a=2.50;  //final一旦被定义变量，该变量的值就不能改变。
		double b=2.0;
		double c=3.0;
		
		System.out.println("输出结果："+a*b+"与"+a*c);
	}

}

4.char type

char est utilisé pour représenter des caractères

les littéraux char sont représentés par des guillemets simples, par exemple : « Remarque : N'utilisez pas de guillemets doubles.

char représente la plage : u0000 à uFFFF

5. type booléen

Le type booléen (Boolean) a deux valeurs : false et true, qui sont utilisées pour déterminer les conditions logiques.

Les valeurs entières ne peuvent pas être converties en valeurs booléennes.

3. Constantes et variables

1. Constantes

Une constante est une quantité qui ne peut pas être modifiée. C'est une constante et reste inchangée pour toujours.

Classification des constantes : constantes entières, constantes décimales, constantes de caractères, constantes de chaîne, constantes booléennes et constantes vides.

package decom1;
public class bianliang {
	public static void main(String[] args) {
		//定义一个byte变量
		byte a =12;
		System.out.println(a);
		//定义一个short变量
		short b;
		b=13;
		System.out.println(b);
		//定义一个int变量
		int c=14;
		System.out.println(c);
		//定义一个long变量
		long d=2;
		System.out.println(d);
		//定义一个float变量
		float e=12.04F;
		System.out.println(e);
		//定义一个double变量
		double f=1.0;
		System.out.println(f);
		//定义一个char变量
		char g = 'A';
		System.out.println(g);
		//定义一个boolean类型的变量
		boolean h = true;
		System.out.println(h);
		boolean i = false;
		System.out.println(i);
		//定义2个int类型变量a,b
		//int a = 12, b = 13;
		/*int a, b;
		a = 12;
		b = 13;*/
		//定义一个int类型的变量，初始值为12
		int k = 12;
		System.out.println(a);//12
		//将变量a的值修改为13
		k = 13;
		System.out.println(a);//13				
	}
}

En Java, vous pouvez utiliser le mot-clé final pour indiquer une constante :

package decom1;
public class cuowu {
	public static void main(String[] args) {
		byte i = (byte)130;
		System.out.println(i);
	}

}

Résultats de sortie : 5.0 et 7.5

2 Variables

Les variables qui changent au fil du temps sont appelées variables.

Les noms de variables doivent commencer par une lettre et être constitués d'une séquence de lettres ou de chiffres, et sont sensibles à la casse.

Vous ne pouvez pas utiliser de mots-clés en Java comme variables.

Après avoir déclaré une variable, la variable déclarée doit être initialisée.

Format de la variable :

Variable directe :

nom de la variable de type de données ; (définition directe) int i = 0 ;

• Variable indirecte :

nom de la variable de type de données ; Définition) int i;=1;

• rrreee

  Notes

• Lorsque nous attribuons une valeur à une variable de type float, nous devons ajouter F ou f après les données.

• Lorsque nous attribuons une valeur à une variable de type long, il est recommandé d'ajouter L ou l après celle-ci. 🎜🎜🎜🎜Lorsque nous voulons utiliser une variable, nous devons d'abord attribuer une valeur puis l'utiliser, sinon une erreur sera signalée. 🎜🎜🎜🎜Lorsque nous voulons attribuer une valeur à une variable, nous devons considérer la portée de la variable, sinon une erreur sera signalée. 🎜

• 在同一对花括号内，不能定义同名变量。

第四条实例：

package decom1;
public class cuowu {
	public static void main(String[] args) {
		byte i = (byte)130;
		System.out.println(i);
	}

}

输出结果为：-126

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!