table des matières
1. Commentaires (une seule ligne, plusieurs lignes, document)
Deux. Principe de Identifier_Keyword_Hump
3. Solution de bogue: Welcome.java:6: Erreur: caractères non mappés encodant GBK
4. Boolean boolean _if instruction use points _ boolean occupe espace problème
Bien que je sois assez familier avec cela dans ma deuxième année, cela fait si longtemps après tout, il vaut mieux le refaire.Après tout, je dois étudier systématiquement. Bien sûr pas trop détaillé.
1. Commentaires (une seule ligne, plusieurs lignes, document)
// Commentaire sur une seule ligne
/ * Multi-lignes
Commentaire * / (Les commentaires sur plusieurs lignes peuvent également être placés entre des codes valides)
Notes de documentation:
Les commentaires de documentation commencent par "/ **" et se terminent par "* /". Les commentaires contiennent du texte descriptif et des balises JavaDoc (lors de l'écriture du projet plus tard, vous pouvez générer l'API du projet) - J'en parlerai plus tard
/**
* test 文档注释
* @author 深海鱼肝油
* @version 1.0
*/
public class Welcome {
public static void main(String[] args /*参数名称，可变*/){
//单行注释
System.out.println("hello world！");
}
}
/*
多行啊
百无聊赖啊
*/Deux. Principe de Identifier_Keyword_Hump
Règles de dénomination des identifiants:
L'identifiant doit commencer par une lettre, un trait de soulignement et le signe dollar $.
Les autres parties de l'identificateur peuvent être
n'importe quelle combinaison de lettres, de signe de soulignement dollar "$" et de chiffres.
Les identificateurs Java sont sensibles à la casse et ont une longueur illimitée.
Les identificateurs ne peuvent pas être des mots clés Java.
Java n'utilise pas le jeu de caractères ASCII utilisé par les langages ordinaires mais utilise un jeu de caractères international standard tel que Unicode. Par conséquent, la signification des lettres ici n'est pas seulement l'anglais, mais aussi les caractères chinois, etc. Mais il n'est pas recommandé d'utiliser des caractères chinois pour définir les identifiants!
Le jeu de caractères ASCII utilise un octet pour représenter les caractères, donc seulement 2 ^ 8 = 256 caractères; tandis que le jeu de caractères Unicode utilise deux octets pour représenter un caractère, donc 2 ^ 16 = 65536 caractères.
par exemple:
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！");
}
}Identifiant qui représente le nom de la classe: mettez en majuscule la première lettre de chaque mot, comme Man, GoodMan
représente l'identifiant des méthodes et des variables: le premier mot est en minuscule et la première lettre du deuxième mot est en majuscule. Nous l'appelons le " principe de cas de chameau "", tel que eat (), eatFood ()
3. Solution de bogue: Welcome.java:6: Erreur: caractères non mappés encodant GBK
Lors de la compilation avec le nom de fichier javac sur la ligne de commande, une erreur d'encodage est signalée et elle est convertie en encodage GBK sous idea, car la ligne de commande utilise l'encodage du système d'exploitation local.
Convertissez en type GBK dans le coin inférieur droit.
Bien entendu, la ligne de commande n'est généralement pas utilisée pour compiler, sauf si le code est écrit dans le bloc-notes ou le bloc-notes. .
Quatre. Constante constante
Modifié avec final devient une constante, et la valeur ne peut pas être modifiée après l'affectation, sinon une erreur sera signalée.
5. Type de données
Contrairement au C ++, le nombre d'octets de types de données correspondant aux différents compilateurs peut changer en conséquence. Java est fixe.
Lors de la définition des variables, il est recommandé de définir ligne par ligne pour améliorer la lisibilité, contrairement à int i, j ;.
1. Entier
octet1 octet, court2 octet, int4 octet, long8 octet
Numéro octal: ajoutez 0 au début, par exemple 016
Nombre hexadécimal: ajoutez 0x ou 0X au début, tel que 0x16
Nombre binaire: ajoutez 0b ou 0B au début, tel que 0b1000101
De plus, pour déclarer comme un type long doit être suivi par L ou l
par exemple:
int a=100;
int b=5030303;
int c=05;//八进制
int d=0x15;//十六进制
int e=0b101011;//二进制
long f=5555555;
long f2=55555555555555L;//将整数常量定义为long类型2. Virgule flottante
Parce que les décimales sont infinies, donc float4 octets et double8 octets ne sont certainement pas suffisants, car de nombreux chiffres ne sont pas suffisants, car les décimales sont infinies! Par conséquent, il y a une erreur dans le stockage des décimales.
La valeur du type float a un suffixe F ou f, et la valeur à virgule flottante sans le suffixe F / f prend par défaut le type double. Vous pouvez également ajouter le suffixe D ou d après la valeur à virgule flottante pour indiquer clairement qu'il s'agit d'un type double.
par exemple:
Code:
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);Résultat de sortie:
314.0
0.1
false
true3. Type de caractère
Peut être converti en type int pour afficher le numéro de série du caractère: (int) c
Unicode a un encodage de 0 à 65535, et ils sont généralement représentés par le seizième mécanisme de '\ u0000' à '\ uFFFF', et le préfixe u signifie Unicode.
Code:
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,\",\',\\");Résultat de sortie:
a
中
a
我爱中国
a
b
c
d e f g,",',\4. Boolean boolean _if instruction use points _ boolean occupe espace problème
Description de quelques octets de type booléen:
Dans la description du livre "Spécification de la machine virtuelle Java": "Bien que ce type de données booléen soit défini, il ne fournit qu'un
support non très limité pour la machine virtuelle Java. Il n'y a pas de bytecode instruction dédiée à la
valeur booléenne. La valeur booléenne manipulée par l'expression du langage Java est remplacée par le type de données int dans la machine virtuelle Java après compilation, et le tableau booléen sera encodé dans le
tableau d'octets de la machine virtuelle Java . Chaque élément de boolean l'élément occupe 8 bits ". C'est-à-dire que la spécification JVM indique que boolean est traité comme int,
soit 4 octets , et que le tableau booléen est traité comme un tableau d'octets. De cette façon, nous pouvons conclure que le type booléen occupe 4
octets pour un usage unique , et c'est un certain mot dans le tableau .
Suggérer:
N'écrivez pas comme ceci: if (flag == true), seuls les novices écrivent ça. La clé est également facile à écrire si (flag = true) est faux, donc cela devient l'affectation de flag à true au lieu de jugement! L'écriture du vétéran est if (flag) ou if (! Flag)
Exemple de code:
boolean b1=true;
boolean b2=false;
if (b1){
System.out.println("正确");
}
else{
System.out.println("错误");
}Six. Opérateur
Opération entière:
si l'un des deux opérandes est long, le résultat est également long. S'il
n'y a pas de long, le résultat est int. Même si les opérandes sont tous courts, octets, le résultat est un entier.
par exemple:
int a=5;
long b=7;
long c=a+b;//要用long类型来接受a与b的和，否则报错类型不兼容
Opérations en virgule flottante:
si l'un des deux opérandes est doubleur, le résultat est double.
Ce n'est que lorsque les deux opérandes sont flottants que le résultat est flottant.
Fonctionnement modulo:
L'opérande peut être un nombre à virgule flottante. En général, des entiers sont utilisés et le résultat est "reste". Le signe de "reste" est le même que celui de l'opérande de gauche, tel que: 7% 3 = 1, -7% 3 = -1, 7% -3 = 1.
par exemple:
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);Sortir:
true
3
10.0relation:
&&, || contraste &, | signifie que le premier est un court-circuit, c'est-à-dire que la première moitié ne remplit pas les conditions et la seconde moitié n'a pas besoin d'être lue!
Décalage:
int a=5<<2; //相当于5*2*2=20
System.out.println(a);
System.out.println(40>>3); //相当于40/2/2/2=8Concaténation de chaînes:
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);//通过加""+,将整个运算转化为字符串连接操作Sortir:
34
209
hiOpérateur conditionnel:
int score=90;
String a=score<60?"不及格":"及格";
System.out.println(a);priorité:
Il n'est pas nécessaire de se souvenir délibérément de ces priorités, les parenthèses sont préférées pour organiser les expressions !! La priorité du
ET logique, OU logique et NON logique doit être familière! (NON logique> ET logique> Prestige logique). Tels que:
le résultat de l'opération allb & c est: al (b & c), not (alb) & c
Conversion de type automatique:
La conversion automatique de type signifie qu'un type de données avec une petite capacité peut être automatiquement converti en un type de données avec une grande capacité, comme indiqué dans la figure ci-dessous:
La ligne pleine indique la conversion de type sans perte de données, et la ligne en pointillés indique que la conversion peut avoir une perte de précision!
Les constantes entières peuvent être directement affectées à des variables de type telles que byte, short, char, etc., sans nécessiter de conversion de type forcée, tant qu'elle ne dépasse pas le nombre de tables.
//从容量小的类型可以自动转化为容量大的类型
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);Sortir:
ɘConversion de type forcée:
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);Sortir:
3
a
44Problèmes courants de dépassement de capacité de conversion (problèmes L):
Int est utilisé lorsque l'entier long doit être utilisé
//溢出问题
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);Sortir:
total= -1474836480
total1=-1474836480
total2=20000000000
人的一-生心跳次数: 4204800000La valeur par défaut de la variable membre:
Intégrité: 0
Type à virgule flottante: 0,0
Type de caractère: '\ u0000'
Booléen: faux
Tous les types de référence: null
Sept. Méthode de construction
Que vous écriviez un constructeur sans paramètres ou avec des paramètres, le système ne générera plus automatiquement de constructeur.
Le constructeur est appelé par le mot-clé new !!
Bien que le constructeur ait une valeur de retour, le type de valeur de retour ne peut pas être défini (le type de la valeur de retour doit être de ce type), et vous ne pouvez pas utiliser return dans le constructeur pour renvoyer un certain valeur.
Si nous ne définissons pas de constructeur, le compilateur définira automatiquement un constructeur sans paramètre. S'il est défini, le compilateur ne l'ajoutera pas automatiquement!
Le nom de la méthode du constructeur doit être le même que le nom de la classe!
POO: Conception orientée objet d'un projet orienté objet
OOA: analyse d'objets orientés
Comprenez le module comme un sous-projet. Le module peut également être configuré avec un JDK séparé.
