1.常量和变量
程序运行期间不断发生变化的量就是变量。
程序运行期间不发生变化的量就是常亮。
2.Java的数据类型
基本数据类型
一共有8种基本数据类型
八位二进制位组成一个字节，如：
1 | 1 | 0 | 1 | 1 | 1 | 1 | 0 |
一个字节表示的范围：-128 ~ 127。
整数类型：
类型 | 占用存储空间 | 表数范围 |
byte | 1字节 | -128~127 |
short | 2字节 | -215~215-1 |
int | 4字节 | -231~231-1 |
long | 8字节 | -263~263-1 |
数值类型中最常用的就是int，其次就是long。
小数类型：
类型 | 占用存储空间 | 表数范围 |
float | 4字节 | -3.403E38~3.403E38 |
double | 8字节 | -1.798E308~1.798E308 |
Float和long比较由于存储结构不同，float比long表示的范围大。
3.局部变量的使用
局部变量定义在方法内或语句块内。
在同一个作用域内变量名不能重复。
变量的作用范围：只在当前的大括号内有效（包括子括号），大括号外无效。
有程序不能使用该变量，所以这种变量也称为局部变量。
内层的可以访问外层的，外层的不能访问内层的。
变量要先定义后使用。
4.Java数据类型的转换
自动转换：
byte→short→int→long→float→double
转换规则：
- byte,short,int,char,四种类型只要是发生计算都会自动的把结果提升成int类型。
- 字符和int类型可以自动转换。根据ACSII表。
- int，long，float，double，自身来计算的时候没有类型的提升，如果超出范围了就会出现精度的损失。
- int，long，float，double，不同类型来计算的时候会向大的表数范围提升。
- 小数的常量的默认值是double。
- 小的表数范围的常量或者变量可以自动的向大的表数范围的类型转换。
- 大的表数范围的值不能自动的赋值小的表数范围的变量。
例子：
1 class Demo{
2 public static void main(String[] args){
3
4 //定义一个byte类型
5 byte age = 127;
6 System.out.println("byte类型："+age);
7
8 //定义一个short类型
9 short personCount = 1000;
10 System.out.println("short类型："+personCount);
11
12 //定义一个int类型
13 int salary = 1000000;
14 System.out.println("int类型："+salary);
15
16 //定义一个Long类型，定义的时候数值后面可以加l
17 long starCount = 100000000;
18 System.out.println("long类型"+starCount);
19
20 //定义一个float,注意float类型后面的值要加上f
21 float price = 12.5f;
22 System.out.println("float类型："+price);
23
24 //定义一个double类型，数值后可以加上d，也可以不加
25 double totalPrice = 45.5;
26 System.out.println("double类型："+totalPrice);
27
28 //字符类型，占用2个字节
29 char c = 'a';
30 System.out.println("char类型："+c);
31
32 //布尔数据类型，只有两个值true和false
33 boolean isMarry = true;//false
34 System.out.println("boolean数据类型："+isMarry);
35
36 }
37 }Demo.java
1 class Demo2{
2 public static void main(String[] args){
3
4 //定义一个字节类型
5 byte b = 1;
6 //基本数据类型在计算的时候，数值常量默认是int
7 int b1 = b + 1;
8
9 short b2 = 12;
10 // byte, short, int, char四种类型只要是发生计算都会自动的把结果提升成int类型
11 int b3 = b + b2;
12
13 //定义一个char类型数据，字符和int类型可以自动的转换
14 char c = 'a';
15 //int i2 = c;
16 int i1 = c + 1;
17
18
19 System.out.println(i1);
20
21 //如果两个int类型计算会不会自动的提升类型呢
22 int x = 2147483647;
23 int y = 12;
24 // int, long, float, double自身来计算的时候没有类型的提升，如果超出范围了就会出现精度的损失
25 int z = x + y;
26 System.out.println(z);
27
28 // int, long, float, double 不同的类型来计算的时候没有类型的会向大的表数范围提升
29
30 float f = 1.3f;
31 // int类型和float类型计算转换成float
32 float f1 = f + y;
33 // 小数的常量的默认值是double
34 double d = f + 1.3;
35 //12.5f是表示float类型的常量，小的表数范围的常量或变量可以自动的向大的表数范围的类型转换
36 double d1 = 12.5f;
37
38 double d2 = y;
39
40 short s = 5;
41 //大的表数范围的值不能自动的赋值小的表数范围的变量
42 //s = s + 5;//此时这里会报错，因为5是int型，运算后的结果也是int型，不能存储到short类型的s中
43
44 }
45
46 }Demo2.java
强制转换：
当大容量类型的变量向小容量的类型去转换需要强制转换。
语法：
（目标类型）值
例子：
1 class Demo3{
2 public static void main(String[] args){
3
4 int i = 999;
5 //数值类型的转换的前提是精度不会损失
6 byte b = (byte)i;
7 System.out.println(b);//此输出有溢出
8
9 //定义long类型
10 long l = 10000;
11 int j = (int)l;
12 System.out.println(j);
13
14 //小数类型的强制转换
15 float f = 199.5f;
16 // 转换成int,小数转换成整数，就是把小数去掉
17 short i1 = (short)f;
18
19 System.out.println(i1);
20
21 //double向float转换
22 double d = 10.4;
23 float f1 = (float)d;
24 System.out.println(f1);
25
26 //字符的转换
27 char c = 'a';
28 int x = c;
29 System.out.println(x);
30 //字符是可以自动转换成int类型的
31
32 int y = 98;
33 char c1 = (char)y;
34 System.out.println(y);
35
36 }
37
38 }Demo3.java
5.运算符
5.1 算数运算符
+，-，*，/，%
四则运算是有类型的提升的。
例子：
1 class Demo4{
2 public static void main(String[] args){
3
4 //定义两个整数类型的变量
5 int a = 10;
6 int b = 3;
7 // +, -, *, /
8 int c = a + b;
9 System.out.println("a + b = "+ c);
10
11 int d = a - b;
12 System.out.println("a - b = "+ d);
13
14 int e = a * b;
15 System.out.println("a * b = "+ e);
16
17 //int直接做除法是整除
18 int f = a / b;
19 System.out.println("a / b = "+ f);
20
21 float f1 = 10.0f;
22 //由于f1是float类型，b是int类型，在做计算的时候类型做了提升（float>int）
23 float f2 = f1 / b;
24 System.out.println("f1 / b = "+ f2);
25
26 // 取余数
27 int g = a % b;
28 System.out.println("a % b = "+ g);
29
30 }
31
32 }Demo4.java
++、--给数值变量自身加1或减1
例子：
1 class Demo5{
2 public static void main(String[] args){
3 // 后++(i++)
4 int a = 1;
5
6 a++;
7 System.out.println("这是a++的值："+ a);//2
8
9 int b = 1;
10 //如果后++和使用这个后++在一起运算那么使用的时候加1之间的值，然后变量自身再加1
11 System.out.println("这是b++的值："+ b++);//1
12 System.out.println("这是b++后b的值："+ b);//2
13
14
15 // 前++（++i）
16 int a1 = 1;
17
18 ++a1;
19 System.out.println("这是++a1的值："+ a1);//2
20
21
22 int b1 = 1;
23 //如果++i和使用这个++i在一起运算那么使用的时候加1之后的值
24 System.out.println("这是++b1的值："+ ++b1);//2
25
26 // 后--(i--)
27 int a2 = 1;
28
29 a2--;
30 System.out.println("这是a2--的值："+ a);//0
31
32 int b2 = 1;
33 //如果后--和使用这个后--在一起运算那么使用的时候减1之间的值，然后变量自身再减1
34 System.out.println("这是b2--的值："+ b2--);//1
35 System.out.println("这是b2--之后的值："+ b);//0
36
37 // 前--（--i）
38 int a3 = 1;
39
40 --a3;
41 System.out.println("这是--a3的值："+ a3);//0
42
43
44 int b3 = 1;
45 //如果--i和使用这个--i在一起运算那么使用的时候-1之后的值
46 System.out.println("这是--b3的值："+ --b3);//0
47
48 }
49
50 }Demo5.java
小计算：
1 class Demo6{
2 public static void main(String[] args){
3
4 int a = 1;
5 int b = 2;
6 // 1 * 3 + 1 * 3
7 int c = (a++) * (++b) + (--a) * (b++);
8 // 注意按照执行顺序，先乘法后加法，
9 //在计算第一个乘法时，a = 1, b = 3,
10 //而后a = 2,b = 3,
11 //再计算第二个乘法时，--a = 1, b++ = 3
12 //而后a = 1, b = 4
13 System.out.println("a = "+ a);//1
14 System.out.println("b = "+ b);//4
15 System.out.println("c = "+ c);//6
16 }
17
18 }Demo6.java
5.2 赋值运算符
=，+=，-=，*=，/=，%=
赋值运算符不会提升数据类型。
例子：
1 class Demo7{
2 /**
3 =，+=，-=，*=，/=，%=
4 赋值运算符不会提升数据类型
5
6 */
7
8 public static void main(String[] args){
9 // 等号是赋值
10 int a = 10;
11
12 //+=, a = a + 10;
13 a +=10;
14 System.out.println(a);//20
15
16 //定义一个short类型的变量
17 short b = 10;
18
19 //b = b + 10;四则运算是有类型的提升的
20 b += 10;
21 System.out.println(b);//20
22
23 short s = 10;
24 s -= 5;
25 System.out.println(s); //5
26
27
28 short s1 = 10;
29 //把s1*5再赋值于s1
30 s1 *= 5;
31 System.out.println(s1);//50
32
33 short s2 = 10;
34 //把s2/5再赋值于s2
35 s2 /= 5;
36 System.out.println(s2);//2
37
38
39 short s3 = 10;
40 //把s3%5再赋值于s3
41 s3 %= 3;
42 System.out.println(s3);//1
43 }
44
45 }Demo7.java
5.3 比较运算符
==等于，!=不等于，>大于，>=大于等于，<小于，<=小于等于
比较数据类型的结果是Boolean类型。
例子：
1 class Demo8{
2 /** 比较运算符
3
4 ==等于，!=不等于，>大于，>=大于等于，<小于，<=小于等于
5 比较数据类型的结果是Boolean类型
6 */
7 public static void main(String[] args){
8
9 int a = 10;
10 int b = 10;
11 //判断两个变量是否相等
12 boolean result = (a == b);
13 System.out.println(result);//true
14
15 //判断两个变量是否不等
16 System.out.println(a != b);//false
17
18 //判断a是否大于b
19 System.out.println(a > b);//false
20
21 //判断a是否大于等于b
22 System.out.println(a >= b);//true
23
24 //判断a是否小于b
25 System.out.println(a < b);//false
26
27 //判断a是否小于等于b
28 System.out.println(a <= b);//true
29
30
31 }
32
33 }Demo8.java
5.4 逻辑运算符
&，|，&&，||，！
&：
多个表达式在计算的时候&与（每一个表达式的计算结果都是true的时候，结果才为True）
表达式1 | 表达式2 | 结果 |
True | True | True |
False | True | False |
True | False | False |
False | False | False |
例子：
1 class Demo9{
2 public static void main(String[] args){
3
4 int math = 55;
5 int chinese = 85;
6
7 //System.out.println((math >= 60) & (chinese >= 60));
8
9 boolean result = (math >= 60) & (chinese >= 60);
10 System.out.println(result);
11
12 }
13
14 }Demo9.java
|：
多个表达式在计算的时候 | 或（只要有一个表达式的计算结果是True，整体结果就是True）
表达式1 | 表达式2 | 结果 |
True | True | True |
False | True | True |
True | False | True |
False | False | False |
例子：
1 class Demo10{
2 public static void main(String[] args){
3
4 int math = 55;
5 int chinese = 85;
6
7 //System.out.println((math >= 60) | (chinese >= 60));
8
9 boolean result = (math >= 60) | (chinese >= 60);
10 System.out.println(result);
11
12 }
13
14 }Demo10.java
&& ：
双与号（&&）与 单与号（&）效果相同，但运行机制不同。
单与号不够智能，即使前面的表达式的计算结果能决定总体结果，后面的表达式依然要计算。
双与号（短路与），前面的表达式计算结果能决定总体结果，后面的表达式不计算。
例子：
1 class Demo11{
2 public static void main(String[] args){
3
4 int math = 55;
5 int chinese = 85;
6
7 //单&号不够智能，即使前面的表达式的计算结果能决定总体结果，后面的表达式依然要计算
8 //双&号短路与，前面的表达式计算结果能决定总体结果，后面的表达式不计算
9
10
11 //System.out.println((math >= 60) & (++chinese >= 60));
12
13
14 System.out.println((math >= 60) && (++chinese >= 60));
15
16 System.out.println(chinese);
17
18 }
19
20 }Demo11.java
|| ：
双或（ || ）和 单或（ | ）的区别：
单或不够智能，即使前面的表达式的计算结果能够决定总体结果，后面的表达式依然要计算。
双或（短路或），前面的表达式计算结果能决定总体结果，后面的表达式不计算。
! ：取反
！是布尔数据类型的取反，放在变量前或常量前都可，所有的表达式只要是最终的结果是Boolean类型都可以。
例子：
1 class Demo12{
2 public static void main(String[] args){
3
4 int math = 62;
5 int chinese = 25;
6
7 //单|号 ：不够智能，即使前面的表达式的计算结果能决定总体结果，后面的表达式依然要计算
8 // 双与号：|| 短路或，前面的表达式计算结果能决定总体结果，后面的表达式不计算
9
10 //System.out.println((math >= 60) | (++chinese >= 60));
11
12
13 System.out.println((math >= 60) || (++chinese >= 60));
14 System.out.println(chinese);
15
16 //！是布尔数据类型的取反 ，放在变量前或常量前都可，
17 // 所有的表达式只要是最终的结果是Boolean类型的都可以。
18 boolean result = !true;
19 System.out.println(result);
20 System.out.println(!((math >= 60) || (++chinese >= 60)));//加括号，对整体取反
21
22 }
23
24 }Demo12.java
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
