1, la promotion de type automatique de Java
3, le mécanisme d'optimisation constante
4, table de code ASCII et connaissances de codage
5, en tant que caractère mosaïque +
6, les opérateurs arithmétiques
7, l'incrément, les opérateurs de décrémentation
9, les opérateurs relationnels
1, la promotion de type automatique de Java
Levage type automatique, également appelé types de données de conversion implicites.
class DataDemo
{
public static void main(String[] args)
{
//定义两个byte类型的变量
byte a = 10;
byte b = 20;
/*
byte r = a + b;
编译错误，不兼容的类型，从int转换到byte可能会有损失
Java中的一个机制：
自动类型提升：
当byte、short、char在参与运算时会自动提升为int类型，
如果还有long、float、double类型参与运算，则会相应的提升为long、float、double类型，
boolean不参与数学运算，byte、short、char之间不参与转换;
a b 提升为int类型，结果自然提升为int类型，byte不能接收int类型的结果
*/
int r = a + b;
System.out.println("r = " + r); // r = 30
long c = 1L;
//r = r + c;
//编译错误，不兼容的类型，从long转换为int可能会有损失
long res = r + c;
System.out.println("res = " + res); // res = 31
float f = 0.1f;
//res = res + f;
//编译错误，不兼容的类型，从float转换为long可能会有损失
//有float类型，long无法存小数
float result = res + f;
System.out.println("result = " + result); // result = 31.1
double d = 0.2;
//result = result + d;
//编译错误，不兼容的类型，从double转换到float可能会有损失
double num = result + d;
System.out.println("num = " + num); // num = 31.3000003814...
}
}
2, cast
class DataTypeDemo2 {
public static void main(String[] args) {
byte a = 3;
byte b = 4;
byte r = (byte) (a + b);
/*
强制类型转换：我可以把多余的字节丢弃掉，本来的结果是int类型，四个字节，
但是我用byte类型来收，那么就可以用强制类型转换，对结果只保留1个字节;
缺点：有可能发生精度损失
*/
System.out.println("r = " + r);
// r = 7
byte c = 127;
byte res = (byte) (a + c);
System.out.println("res = " + res);
//res = -126 强制类型转换发生精度损失
short result = (short) (a + c);
System.out.println("result = " + result);
//result = 130
}
}
130的二进制：
130 = 128 + 2
0000 0000 1000 0010
-126的原码：
126 = 64 + 32 + 16 + 8 + 4 + 2
1111 1110
反码：1000 0001
补码：1000 0010
130在只有一个字节的情况下(byte)130会变为-126。
Sortie caractère visuel, les élèves disent char c = 30, l'instruction de sortie et aucune sortie.
Vous pouvez consulter le tableau de code ASCII
char ch = 65;
System.out.println(ch);
//A 输出可视化字符
3, le mécanisme d'optimisation constante
class DataTypeDemo3 {
public static void main(String[] args) {
byte a = 3;
//byte r = a + 4;
//编译错误，有byte类型变量的参与，自动类型提升为int类型
byte r = 3 + 4;
//编译成功
/*
常量优化机制：当多个常量在参与运算时，它会先把这个结果计算出来，如果在这个类型的范围，
就不报错；如果不在这个类型的范围，就报错。
*/
System.out.println("r = " + r);
//r = 7
}
}
4, table de code ASCII et connaissances de codage
codage Unicode: langage Java utilise le codage Unicode, chaque caractère est de 2 octets
Encodage UTF-8: chinois a représenté trois octets de chaque
class DataTypeDemo4 {
public static void main(String[] args) {
char ch = '我';
System.out.println("ch = " + ch);
}
}
Le fichier Java dans le codage UTF-8.
Unicode是一种字符集(charset)，用两个字节就能囊括世界上所有的文字集合。
UTF-8是一种编码方式(encoding)，是Unicode的一种表现方式。
在一个Java文件(该文件为UTF-8编码)里面写上这样一句话
char a = '猿';
编译后生成的class文件会把'猿'转化成Unicode的两字节。
所以可以编译运行。`javac -encoding utf-8 DataTypeDemo4.java`
Java中的char类型采用utf-16编码，2个字节。
@Test
public void test() {
char ch = '中';
System.out.println(Arrays.toString(String.valueOf(ch).getBytes()));
//[-28, -72, -83]
}
Si la lecture est convertie en un tableau d'octets ou un utf-8 (par défaut générale du système), il deviendra 3 octets.
caractères couramment utilisés de code ASCII
class DataTypeDemo5 {
public static void main(String[] args) {
char ch = 'a';
char ch2 = ' ';
int r = ch + 1 + ch2;
System.out.println("r = " + r);
// r = 130
// 'a' = 97, 'A' = 65，'0' = 48
// ' ' = 32
//所以：r = 97 + 1 + 32 = 130
}
}
5, le connecteur +
package org.westos.demo;
public class MyDemo2 {
public static void main(String[] args) {
// + : 1、相加的运算（算术运算符）；2、连接符/拼接符（当+的两侧有任意一边是一个字符串，那么+作为连接符）
System.out.println(2+3);
//相加运算，5
System.out.println(2 + "22");
//拼接符，222
System.out.println(20 + 30 + "50");
//1、相加；2、拼接
//5050
System.out.println("100" + 20 + 30);
//1、拼接；2、拼接
//1002030
System.out.println('a' + 5);
//字符和字符串不同
//102
System.out.println("hello" + 'a' + 1);
//helloa1
System.out.println('a' + 1 + "hello");
//98hello，字符在做数学运算时转为数字
}
}
6, les opérateurs arithmétiques
Opérateur: constantes et symboles variables appelés opérateurs fonctionnent.
Opérateur Catégorie:
- opérateurs arithmétiques
- Opérateurs d'affectation
- opérateurs relationnels
- opérateurs logiques
- opérateurs de bits
- opérateur ternaires
précautions:
- Deux entiers obtiennent seulement des nombres entiers division, si les décimales de besoin, utiliser un flotteur
- / Division Business est acquise opérations, acquises% est le reste d'une opération de division
- Symbole% des résultats d'exploitation, selon le signe de l'opération impliqués gauche
package org.westos.demo;
public class MyTest {
public static void main(String[] args) {
/* 多行注释：ctrl+shift+/ */
// 单行注释：ctrl+/
int a = 20;
int b = 200;
System.out.println(a+b);
//220
System.out.println(a-b);
//-180
System.out.println(a/b);
//0
System.out.println(a%b);
//20
System.out.println(10/3);
//3
//两个整数相除只保留整数部分，舍弃小数部分
System.out.println(10.0/3);
//3.3333333333333335
//有double类型参与运算时，3自动提升为double类型
System.out.println(10%-3);
//1 10%-3=-3，余1
System.out.println(-10%3);
//-1 -10%3=-3，余-1
//%的结果的正负只与符号左边值的符号有关
System.out.println(-10%-3);
//-1
System.out.println(10%3);
//1
}
}
7, l'incrément, les opérateurs de décrémentation
package org.westos.demo;
public class MyTest2 {
public static void main(String[] args) {
int i = 1;
int j = ++i;
//先++，再赋值
System.out.println("i = " + i);
//i = 2
System.out.println("j = " + j);
//j = 2
int m = 1;
int n = m++;
//先赋值，再++
System.out.println("m = " + m);
//m = 2
System.out.println("n = " + n);
//n = 1
}
}
exercice:
package org.westos.demo1;
public class MyTest1 {
public static void main(String[] args) {
int v = 1;
int w = 2 + (v++) + 2 - (++v) - 1 - (v--) + 2 - (--v) + 3;
System.out.println(v);
//v两次自增两次自减，相当于没有变 1
System.out.println(w);
//w = 2 + 1 + 2 - 3 - 1 - 3 + 2 - 1 + 3 = 2
}
}
A:案例演示
请分别计算出a,b,c的值?
int a = 10;
int b = 10;
int c = 10;
a = b++; a=10 b=11
c = --a; c=9 a=9
b = ++a; b=10 a=10
a = c--; a=9 c=8
a=9
b=10
c=8
B:案例演示
请分别计算出x,y的值?
int x = 4;
int y = (x++) + (++x) + (x*10);
y = 4 + 6 + 60 = 70
x自增两次，x=6 , y=70
8, l'opérateur d'affectation
précautions:
- L'opérateur d'affectation de base: =
- Données = droit à la cession gauche
- L'opérateur d'affectation étendue: + =, - =, * =, / =,% =
- + =: La gauche et à droite pour faire des ajouts, puis affecté à la variable à gauche
- opérateur d'affectation des données nécessite une variable doit être laissée
package org.westos.demo;
public class MyTest3 {
public static void main(String[] args) {
//赋值运算符:=,+=,-=,*=,/=,%=
short s = 1;
//s = s + 1;
//编译会报错，short类型变量在运算时自动类型提升为int
s += 1;
//这种方式会帮你自动强制类型转换，无论运算结果是否超过short的范围
// 整数之间/结果为整数
// %的结果只与左侧运算数的符号有关
}
}
9, les opérateurs relationnels
Opérateurs relationnels:
== ,! =, <,>, <=,> =, instanceof (détermine si un type de l'objet)
précautions:
- Que votre opération soit simple ou complexe, le résultat est toujours type booléen
- « == » ne peut pas être écrit dans l'opérateur d'affectation « = »
package org.westos.demo;
public class MyTest4 {
public static void main(String[] args) {
int a = 128;
int b = 200;
System.out.println(a < b);
//true
String str = "abc";
System.out.println(str instanceof Object);
//true 判断是否是某个类型的对象
}
}