【Java】——数据类型和变量

个人主页：User_芊芊君子
🎉欢迎大家点赞👍评论📝收藏⭐文章

1.Java中的注释

和C语言一样，注释的作用是为了让代码更容易被理解，虽然不被编译运行，但却不可或缺。为了方便你我他，请重视注释

1.1.基本规则

• 单行注释：//注释内容
• 多行注释：/*注释内容 */
• 文档注释：/** 文档注释 */（常见于方法和类之上描述方法和类的作用），可以被javadoc⼯具解
  析，⽣成⼀套以⽹⻚⽂件形式体现的程序说明⽂档

注：多行注释不能嵌套使用

1.2.注释规范

1. 内容准确: 注释内容要和代码⼀致, 匹配, 并在代码修改时及时更新
2. 篇幅合理: 注释既不应该太精简, 也不应该⻓篇⼤论
3. 使⽤中⽂: ⼀般中国公司都要求使⽤中⽂写注释, 外企另当别论
4. 积极向上: 注释中不要包含负能量(例如 领导 SB 等)

2.标识符

标识符是程序中用户给类名，方法名，或者变量所取的名字。

• 标识符中可以包含：字母，数字，下划线及＄符号（合法但不合理）…
• 注意：标识符不能以数字开头，也不可能是关键字，且严格区分大小写

• 类名：每个单词的首字母大写（大驼峰）
• 方法名：首字母小写，后面每个单词的首字母大写（小驼峰）
• 变量名：与方法名规则相同

3.关键字

我们在写程序时可以发现，public、class以及static等颜⾊会发⽣变化，将这些具有特殊含义的标识符称为关键字。即：关键字是由Java语⾔提前定义好的，有特殊含义的标识符，或者保留字

4.字面常量

public class Test {public static void main(String[] args) {System.out.println("Hello World");}
}

在这串代码中，“Hello World”就是字面常量。
常量即程序运行期间，固定不变的量. eg:⼀个礼拜七天，⼀年12个⽉等。

public class Test {public static void main(String[] args) {System.out.println("Hello World");System.out.println(100);System.out.println(3.14);System.out.println('A');System.out.println(true);System.out.println(false);}
}

其中，100，3.14，‘A’，true/false都是常量，将其称为字面常量

• 字符串常量：由 “” 括起来的，⽐如"12345"、“hello”、“你好”。
• 整型常量：程序中直接写的数字(注意没有⼩数点)，⽐如：100、1000
• 浮点数常量：程序中直接写的⼩数，⽐如：3.14、0.49
• 字符常量：由 单引号 括起来的当个字符，⽐如：‘A’、‘1’
• 布尔常量：只有两种true和false
  字符串、整型、浮点型、字符型以及布尔型，在Java中都称为数据类型。

5.数据类型

Java中数据类型分为两类：基本数据类型和引用数据类型。
基本数据类型有四类八种：

• 四类：整型，浮点型，字符型，及布尔型
• 八种：

注：

• 不论是在16位系统还是32位系统，int都占4个字节，long都占8个字节
• 整型和浮点型都是带有符号的
• 整型默认是int 型，浮点型默认是double
• 字符串属于引用类型

6.变量

6.1变量的概念

在Java中，经常改变的量，称为变量，数据类型就是用来定义不同种类的变量的

6.2语法

数据类型 变量名 = 初始值；

public class Test {public static void main(String[] args) {int a = 10;//变量a,也叫标识符double b =3.14;char c = 'A';boolean d = true;System.out.println(a);System.out.println(b);System.out.println(c);System.out.println(d);a = 100;//和C语言引用，这里是将100赋值给aSystem.out.println(a);int a1 = 10, a2 = 20, a3= 30;//一行可以定义多个相同类型的变量System.out.println(a1);System.out.println(a2);System.out.println(3);}
}

6.3整型变量

6.3.1整型变量

public class Test {public static void main(String[] args) {//定义方法一：定义时给出初始值int a = 10;System.out.println(a);//定义方法二：赋值（使用前没有赋值的话会报错）int b;b = 20;System.out.println(b);//int型变量所能表示的范围：System.out.println(Integer.MIN_VALUE);System.out.println(Integer.MAX_VALUE);//赋值不能超过int范围}
}

int的包装类型为Integer

6.3.2长整型变量

public class Test {public static void main(String[] args) {int a = 10;long b = 10;//为了区分int和long类型，一般long类型变量的初始值后加上Llong c = 10L;}
}

注：

• ⻓整型变量的初始值后加L或者l，推荐加L
• ⻓整型不论在那个系统下都占8个字节
• ⻓整型的表⽰范围为：-2^63 ~ (2^63)-1
• long的包装类型为Long

6.3.3短整型变量

public class Test {public static void main(String[] args) {short a = 10;System.out.println(a);//范围：System.out.println(Short.MIN_VALUE);System.out.println(Short.MAX_VALUE);}
}

注意事项：

1. short在任何系统下都占2个字节
2. short的表⽰范围为：-32768 ~ 32767
3. 使⽤时注意不要超过范围(⼀般使⽤⽐较少)
4. short的包装类型为Short

6.3.4字节型变量

public class Test {public static void main(String[] args) {byte a = 10;System.out.println(a);// byte型变量所能表⽰的范围：System.out.println(Byte.MIN_VALUE);System.out.println(Byte.MAX_VALUE);}
}

注意事项：

1. byte在任何系统下都占1个字节
2. byte的范围是：-128 ~ 127
3. 字节的包装类型为Byte

6.4浮点型变量

6.4.1双精度浮点型

public class Test {public static void main(String[] args) {double a = 3.14;System.out.println(a);int b = 1;int c = 2;System.out.println(b / c);//在 Java 中, int 除以 int 的值仍然是 int(会直接舍弃⼩数部分)double m = 1.0;double n = 2.0;System.out.println(m / n);//输出0.5double x = 1.1;System.out.println(x*x);//输出1.2100000000000002}
}

注意事项：

1. double在任何系统下都占8个字节
2. 浮点数与整数在内存中的存储⽅式不同，不能单纯使⽤的形式来计算
3. double的包装类型为Double
4. double 类型的内存布局遵守 IEEE 754 标准(和C语⾔⼀样), 尝试使⽤有限的内存空间表⽰可能⽆限的⼩数, 势必会存在⼀定的精度误差，因此浮点数是个近似值，并不是精确值。

6.4.2单精度浮点型

public class Test {public static void main(String[] args) {float num = 1.0f;System.out.println(num);}
}

在Java中占4个字节， 不常使用

6.5字符型变量

public class Test {public static void main(String[] args) {char c1 = 'A';char c2 = '1';System.out.println(c1);System.out.println(c2);char c3 = '乾';System.out.println(c3);}
}

注意事项:

1. Java 中使⽤ 单引号 + 单个字⺟ 的形式表⽰字符字⾯值.
2. 计算机中的字符本质上是⼀个整数. 在 C 语⾔中使⽤ ASCII 表⽰字符, ⽽ Java 中使⽤ Unicode 表⽰字符. 因此⼀个字符占⽤两个字节, 表⽰的字符种类更多, 包括中⽂.
3. char的包装类型为Character

6.6布尔型变量

布尔类型常⽤来表⽰真假

public class Test {public static void main(String[] args) {boolean a = true;//System.out.println(a);a = false;System.out.println(a);}
}

注意事项：

1. boolean 类型的变量只有两种取值, true 表⽰真, false 表⽰假.
2. Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表⽰ true, 0 表⽰ false 这样的⽤法.

6.7类型转换

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

public class Test {public static void main(String[] args) {int a = 10;long b = 100L;b = a;a = b;//编译失败}
}

在Java中，当参与运算数据类型不⼀致时，就会进⾏类型转换。Java中类型转换主要分为两类：⾃动类型转换(隐式) 和 强制类型转换(显式)。

6.7.1⾃动类型转换(隐式)

⾃动类型转换：代码不需要经过任何处理，在代码编译时，编译器会⾃动进⾏处理。特点：数据范围⼩的转为数据范围⼤的时会⾃动进⾏。

public class Test {public static void main(String[] args) {System.out.println(1024);//默认intSystem.out.println(3.14);//默认doubleint a = 100;long b = 10L;b = a;//int 类型的值⾃动转换为了long类型float m =3.14F;double n = 5.12;n = m;//float 类型的值 ⾃动转换为了double 类型}
}

6.7.2强制类型转换（显式）

强制类型转换：当进⾏操作时，代码需要经过⼀定的格式处理，不能⾃动完成。特点：数据范围⼤的到数据范围⼩的。

```java
public class Test {public static void main(String[] args) {int a = 10;long b = 100L;b = a;//int--long,数据范围由小到大，隐式转换a = (int)b;//long--int, 数据范围由⼤到⼩，需要强转，否则编译失败float f = 3.14F;double d = 1.21;d = f;// float-->double，数据范围由⼩到⼤，隐式转换f = (float)d;// double-->float, 数据范围由⼤到⼩，需要强转，否则编译失败byte m = 100;// 100默认为int，没有超过byte范围，隐式转换byte n = (byte)200;// 200默认为int，超过byte范围，需要显⽰转换，否则报错}
}

注意事项：

1. 不同数字类型的变量之间赋值, 表⽰范围更⼩的类型能隐式转换成范围较⼤的类型
2. 如果需要把范围⼤的类型赋值给范围⼩的, 需要强制类型转换, 但是可能精度丢失
3. 将⼀个字⾯值常量进⾏赋值的时候, Java 会⾃动针对数字范围进⾏检查
4. 强制类型转换不⼀定能成功，不相⼲的类型不能互相转换

6.8类型提升

不同类型的数据之间相互运算时，数据类型⼩的会被提升到数据类型⼤的。

int被提升为long

public class Test {public static void main(String[] args) {int a = 10;long b = 20;int c = a + b;//编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据long d = a + b;// 编译成功：a + b==>int + long--->long + long 赋值给long}
}

byte与byte之间运算

public class Test {public static void main(String[] args) {byte a = 10;byte b = 20;//byte c = a + b;//编译错误byte d = (byte)(a + b);//正确书写System.out.println(d);}
}

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

6.8字符串类型

public class Test {public static void main(String[] args) {String s1 = " hello";String s2 = " world";System.out.println(s1);System.out.println(s2);System.out.println(s1+s2);//将s1和s2拼接而不是进行计算}
}

• int转String

public class Test {public static void main(String[] args) {int num = 10;String str1 = num + "";//方法一String str2 = String.valueOf(num);//方法二}
}

• String转int

public class Test {public static void main(String[] args) {String str = "100";int num =Integer.parseInt(str);}
}