整型变量

基本语法

int 变量名 = 初始值;

代码示例

int  a = 10;//定义一个数值为10的整型变量
System.out.println(a);

知识点：

1、int 表示变量的类型为整型
2、变量名是变量的标识。后续都是通过这个名字来使用变量。
3、java中的 =号和C语言中的一样表示赋值，目的是给变量设置一个初始值。
4、初始化的操作是可选择的，但是建议创建变量的时候都显示初始化。
5、在java中，一个int变量占4个字节，和操作系统没有直接关系
6、int的数据范围是：-2^31--> 2^32 - 1

长整型变量

基本语法格式

long 变量名 = 初始值;

代码示例

long num = 10L; 
// 定义一个长整型变量, 初始值写作 10l 也可以(小写的 L, 不是数字1).
System.out.println(num) ;

知识点：

1、基本语法与int变量基本一致，只是把类型修改成了long
2、初始化值时，数组后要加l或L，表示是一个长整型的数据
3、java中long占8个字节。
4、表示的数据范围是-2^63 -> 2^63-1

双精度浮点型变量

基本语法格式

double 变量名 = 初始值;

代码示例：

double num = 1.0;
System.out.println(num)

知识点：

1、在java中，整型除以整型的值任然是int（会直接舍弃小数部分）如果想得到小数，需要使用double类型进行计算。如下面代码：

int a = 1;
int b = 2;
System.out.println(a/b);
double c = 1.0;
double d = 2.0;
System.out.println(c/d);

运行结果：

Java 的 double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差。
如下面代码中 1.1*1.1得到的结果应该是1.2100000,但是实际结果却有所差异。

double a = 1.1;
System.out.println(a*a);

运行结果：

单精度浮点型

基本格式：

float 变量名 = 初始值;

代码示例：

float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);

知识点：

1、在初始化单精度浮点数float类型的数字时要在后加上f（F），
2、float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数都优先考虑 double, 不太推荐使用 float

字符类型

基本格式

char 变量名 = 初始值；

代码示例

char ch = 'A';

知识点：

1、计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此一个字符占用两个字节, 表示的字符种类更多, 包括中文。
2、java中使用‘’+单个字母或汉字表示字符字面值

用字符表示一个汉字：

        char ch = '六';
        System.out.println(ch);

运行上述代码结果是：

字节类型

基本语法格式：

byte 变量名 = 初始值;

代码示例：

byte value = 0;

知识点：

1.字符类型表示的是整数，只占一个字节的空间大小。
2、表示的数值范围是（-128 – 127）

短整型

基本语法格式：

short 变量名 = 初始值;

代码示例：

short value = 0;

知识点：

1、short占两个字节。
2、表示的数据范围是（-32768 – 32767）

布尔类型

基本语法格式：

boolean 变量名 = 初始值;

代码示例：

boolean value = true;

知识点：

1、布尔类型的变量只有两种取值，true表示真,false表示假。
2、布尔类型与整型不能互换，不存在0表示false，非0表示true的情况。
3、布尔类型所占空间大小没有明确规定。有占1字节，或者1比特的。

字符串类型

基本语法格式：

String 变量名 = “初始值”;

代码示例：

String name = "zhangsan";

知识点：

1、java中使用 “”+若干字符的方式表示字符串的字面值，
2、和上面类型不同的是,String不是基本类型，而是引用类型。
3、字符串中一些特定的不太方便直接表示的字符，和C语言一样需要进行转义。

4、字符串的+操作：

        String str = "加油";
        int a = 20;
        int b = 21;
        String result = str + a + b;
        System.out.println(result);

运行结果：

还可以用字符串与整数进行拼接：

 		String str = "result = ";
        int a = 10;
        int b = 20;
        String result = str + a + b;
        System.out.println(result);

运行结果：

但是如果是两个整数在前字符串在后，就会先进行整数计算。
示例如下：

        String str = "加油";
        int a = 20;
        int b = 21;
        String result =a + b +str;
        System.out.println(result);

运行结果：

变量的作用域

变量的作用域一般都是变量定义所在的代码块（大括号中）。

变量的命名规则

硬性指标:
1.、一个变量名只能包含数字, 字母, 下划线。
2、数字不能开头。
3.、变量名是大小写敏感的. 即 num 和 Num 是两个不同的变量。
注意: 虽然语法上也允许使用中文/美元符($)命名变量, 但是强烈不推荐这样做.
软性指标:
1、变量命名要具有描述性, 见名知意.
2、变量名不宜使用拼音(但是不绝对).
3、变量名的词性推荐使用名词.
4、 变量命名推荐 小驼峰命名法, 当一个变量名由多个单词构成的时候, 除了第一个单词之外, 其他单词首字母都大写.

常量

字面值常量

10 // int 字面值常量(十进制)
010 // int 字面值常量(八进制) 由数字 0 开头. 010 也就是十进制的 8
0x10 // int 字面值常量(十六进制) 由数字 0x 开头. 0x10 也就是十进制的 16
10L // long 字面值常量. 也可以写作 10l (小写的L)
1.0 // double 字面值常量. 也可以写作 1.0d 或者 1.0D
1.5e2 // double 字面值常量. 科学计数法表示. 相当于 1.5 * 10^2
1.0f // float 字面值常量, 也可以写作 1.0F
true // boolen 字面值常量, 同样的还有 false
'a' // char 字面值常量, 单引号中只能有一个字符
"abc" // String 字面值常量, 双引号中可以有多个字符

final关键字修饰的常量

final int a = 10;
a = 20; // 编译出错. 提示 无法为最终变量a分配值

常量不能再程序运行过程中发生修改。

类型转换

Java 作为一个强类型编程语言, 当不同类型之间的变量相互赋值的时候, 会有教严格的校验。

int 与long/double相互赋值

int a = 10;
long b = 20;
a = b; // 编译出错, 提示可能会损失精度.
b = a; // 编译通过.
int a = 10;
double b = 1.0;
a = b; // 编译出错, 提示可能会损失精度.
b = a; // 编译通过

long 表示的范围更大, 可以将 int 赋值给 long, 但是不能将 long 赋值给 int。
double 表示的范围更大, 可以将 int 赋值给 double, 但是不能double 赋值给 int。
结论: 不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型, 反之则不行。

int与boolean相互赋值

int a = 10;
boolean b = true;
b = a; // 编译出错, 提示不兼容的类型
a = b; // 编译出错, 提示不兼容的类型

结论: int 和 boolean 是毫不相干的两种类型, 不能相互赋值

int字面值常量给byte赋值

byte a = 100; // 编译通过
byte b = 256; // 编译报错, 提示 从int转换到byte可能会有损失

注意: byte 表示的数据范围是 -128 – +127, 256 已经超过范围, 而 100 还在范围之内。
结论:使用字面值常量赋值的时候, Java 会自动进行一些检查校验, 判定赋值是否合理。

强制类型转换

int a = 0;
double b = 10.5;
a = (int)b;
int a = 10;
boolean b = false;
b = (boolean)a; // 编译出错, 提示不兼容的类型

结论:
1、使用 (类型) 的方式可以将 double 类型强制转成 int. 但是强制类型转换可能会导致精度丢失. 如刚才的例子中, 赋值之后, 10.5 就变成 10 了, 小数点后面的部分被忽略。
2、 强制类型转换不是一定能成功, 互不相干的类型之间无法强转。

类型转换小结

1、不同数字类型的变量之间赋值, 表示范围更小的类型能隐式转换成范围较大的类型.
2.、如果需要把范围大的类型赋值给范围小的, 需要强制类型转换, 但是可能精度丢失.
3、 将一个字面值常量进行赋值的时候, Java 会自动针对数字范围进行检查

数值提升

int 与long混合运算

int a = 10;
long b = 20;
int c = a + b; // 编译出错, 提示将 long 转成 int 会丢失精度
long d = a + b; // 编译通过.

结论: 当 int 和 long 混合运算的时候, int 会提升成 long, 得到的结果仍然是 long 类型, 需要使用 long类型的变量来 接收结果. 如果非要用 int 来接收结果, 就需要使用强制类型转换。

byte 与 byte的运算

byte a = 10;
byte b = 20;
byte c = a + b;
System.out.println(c);
// 编译报错
Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
byte c = a + b;

结论: byte 和 byte 都是相同类型, 但是出现编译报错. 原因是, 虽然 a 和 b 都是 byte, 但是计算 a + b 会先将 a 和 b 都提升成 int, 再进行计算, 得到的结果也是 int, 这是赋给 c, 就会出现上述错误。
由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便, 诸如 byte 和 short 这种低于4 个字节的类型, 会先提升成 int, 再参与计算。

因此上述代码的正确写法是：

byte a = 10;
byte b = 20;
byte c = (byte)(a + b);
System.out.println(c);

类型提升小结

1、不同类型的数据混合运算, 范围小的会提升成范围大的.
2.、对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算。

int 与 String之间的相互转换

int转成String

int num = 10;
// 方法1
String str1 = num + "";
// 方法2
String str2 = String.valueOf(num);

String转成int

String str = "100";
int num = Integer.parseInt(str);

数据类型分类：