Java数据类型（修改）
定义变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。
内存管理系统根据变量的类型为变量分配存储空间，分配的空间只能用来储存该类型数据。
Java 的两大数据类型:
基本（Primitive）数据类型
引用（Reference）数据类型
基本数据类型 / 基本类型
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。
byte：byte数据类型是8位、有符号的，以二进制补码表示的整数；
short：short 数据类型是 16 位、有符号的以二进制补码表示的整数；
int：int 数据类型是32位、有符号的以二进制补码表示的整数；
long：long 数据类型是 64 位、有符号的以二进制补码表示的整数；
float：float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
double：double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
boolean：boolean数据类型表示一位的信息，只有两个取值：true 和 false；
char：char类型是一个单一的 16 位 Unicode 字符。
对于数值类型的基本类型的取值范围，我们无需强制去记忆，可以通过下面的例子了解：
public class PrimitiveTypeTest {
public static void main(String[] args) {
// byte
System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
System.out.println("包装类：java.lang.Byte");
System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();
// short
System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
System.out.println("包装类：java.lang.Short");
System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();
// int
System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
System.out.println("包装类：java.lang.Integer");
System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();
// long
System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
System.out.println("包装类：java.lang.Long");
System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();
// float
System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
System.out.println("包装类：java.lang.Float");
System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();
// double
System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
System.out.println("包装类：java.lang.Double");
System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();
// char
System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
System.out.println("包装类：java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值：Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值：Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);
}
}
运行结果如下：
Java 可运行于多个平台，Windows, Mac OS 及其他多种 UNIX 版本的系统。
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
说明：Float和Double的最小值和最大值都是以科学记数法的形式输出的，结尾的"E+数字"表示E之前的数字要乘以10的多少次方。比如3.14E3就是3.14 × 103 =3140，3.14E-3 就是 3.14 x 10-3 =0.00314。
类型默认值
下表列出了 Java 各个类型的默认值：
| 数据类型 | 默认值 |
| byte | 0 |
| short | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| char | 'u0000' |
| String (or any object) | null |
| boolean | false |
选择数据类型原则:
如果要表示整数就使用int，表示小数就使用double；
如果要描述日期时间数字或者表示文件（或内存）大小用long；
如果要实现内容传递或者编码转换使用byte；
如果要实现逻辑的控制，可以使用booleam；
如果要使用中文，使用char避免中文乱码；
如果按照保存范围：byte < int < long < double;
字面量和常量
字面量
字面量又称为字面常量（literal value：字面量、直接量），它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。
1）整型字面量
Java 的整型字面量主要有如下 3 种形式。
☆十进制数形式：如 54、-6、0。
☆八进制数形式：Java 中的八进制常数的表示以 0 开头，如 0125 表示十进制数 85，-013 表示十进制数 -11。
☆十六进制数形式：Java 中的十六进制常数的表示以 0x 或 0X 开头，如 0x100 表示十进制数 256，-0x16 表示十进制数 -22。
整型（int）常量默认在内存中占 32 位，是具有整数类型的值，当运算过程中所需值超过 32 位长度时，可以把它表示为长整型（long）数值。长整型类型则要在数字后面加 L 或 1， 如 697L，表示一个长整型数，它在内存中占 64 位。
2）实型字面量
Java 的实型字面量主要有如下两种形式。
☆十进制数形式：由数字和小数点组成，且必须有小数点，如 12.34、-98.0。
☆科学记数法形式：如 1.75e5 或 32&E3，其中 e 或 E 之前必须有数字，且 e 或 E 之后的数字必须为整数。
Java 实型常量默认在内存中占 64 位，是具有双精度型（double）的值。如果考虑到需要节省运行时的系统资源，而运算时的数据值取值范围并不大且运算精度要求不太高的情况，可以把它表示为单精度型（float）的数值。
单精度型数值一般要在该常数后面加 F 或 f，如 69.7f，表示一个 float 型实数，它在内存中占 32 位（取决于系统的版本高低）。
3）布尔型字面量
Java 的布尔型常量只有两个值，即 false（假）和 true（真）。
4）字符型和字符串字面量
char 类型的直接量有三种形式，分别是用单引号括起来的字符、转义字符和 Unicode 值表示的字符。例如‘a’，‘\n’和‘\u0061’。
需要注意的是，Java中的单引号和双引号不可混用。双引号用来表示字符串，像 "11"、"d" 等都是表示单个字符的字符串。在 Java 中，字符串实际上是对象类型。
5）null
它只有一个值：null。而且这个直接量可以赋给任何引用类型的变量，用以表示这个引用类型变量中保存的地址为空，即还未指向任何有效对象。
常量
常量就是一个固定值。它们不需要计算，直接代表相应的值。
常量不同于字面量，它可以在程序中用符号来代替字面量使用，因此在使用前必须先定义。常量与变量类似也需要初始化，即在声明常量的同时要赋予一个初始值。常量一旦初始化就不可以被修改。
Java 语言使用 final 关键字来定义一个常量，声明方式和变量类似，其语法如下所示：
final dataType variableName = value
其中，final 是定义常量的关键字，dataType 指明常量的数据类型，variableName 是变量的名称，value 是初始值。
常量有三种类型：静态常量、成员常量和局部常量。例如：
public class HelloWorld {
// 静态常量
public static final double PI = 3.14159;
// 声明成员常量
final int y = 10;
public static void main(String[] args) {
// 声明局部常量
final double x = 5.3;
}
}
在定义常量时，需要注意如下内容：
在定义常量时就需要对该常量进行初始化。
final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。
虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。
当常量被设定后，不允许再进行更改，如果更改其值将提示错误。
数学运算符
数学运算，结果为一个数值。见下表：
| 运算符 | 说明 | 举例 |
| + | 加法 | 1 + 2 等于 3 |
| - | 减法 | 4 - 3.4 等于0.6000000000000001 |
| * | 乘法 | 7 * 1.5等于 10.5 |
| / | 除法 | 3.5 / 7等于 0.5 |
| % | 取余 | 7 % 2等于 1 |
| ++ | 自增 | i = 2 则 ++i等于3 |
| -- | 自减 | J = 2则 --j等于1 |
Java的整数运算遵循四则运算规则，可以使用任意嵌套的小括号。四则运算规则和初等数学一致。
注意，Java语言中两个整数相除只能得到结果的整数部分：int x = 101 / 2; // 50
这一点和C、C++语言一样：整数除法就是整数结果，如果有浮点数才会出现浮点结果（有小数部分）。例如
public class Test {
public static void main(String[] args) {
int b = 101;
System.out.println("b / 2 = " + (b / 2) );
}
}
整数除法就是整数结果，如果有浮点数才会出现浮点结果（有小数部分）。将其中一个数改成浮点型，如上例中的 (b / 2)改为 (b/2.0) 或(b/(double)2) 得到准确结果。
自增、自减运算符的说明
操作数只能是变量，不能是常量或表达式
分前置和后置两种运算，例如：
int i=5, j=5, m, n;
m=i++; //后置++；相当于m=i; i=i+1; 结果：i的值为6，m的值为5;
n=++j; //前置++；相当于j=j+1;n=j; 结果：j的值为6，n的值为6;
赋值运算符
下面是Java语言支持的赋值运算符：
| 操作符 | 描述 | 例子 |
| = | 简单的赋值运算符，将右操作数的值赋给左侧操作数 | C = A + B将把A + B得到的值赋给C |
| + = | 加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数 | C + = A等价于C = C + A |
| - = | 减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数 | C - = A等价于C = C - A |
| * = | 乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数 | C * = A等价于C = C * A |
| / = | 除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数 | C / = A，C 与 A 同类型时等价于 C = C / A |
| （％）= | 取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数 | C％= A等价于C = C％A |
| << = | 左移位赋值运算符 | C << = 2等价于C = C << 2 |
| >> = | 右移位赋值运算符 | C >> = 2等价于C = C >> 2 |
| ＆= | 按位与赋值运算符 | C＆= 2等价于C = C＆2 |
| ^ = | 按位异或赋值操作符 | C ^ = 2等价于C = C ^ 2 |
| | = | 按位或赋值操作符 | C | = 2等价于C = C | 2 |
关系运算符
关系运算符，结果为一个布尔值。假设变量A的值为10，变量B的值为20，见下表：
| 运算符 | 描述 | 例子 |
| == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （A == B）为假。 |
| != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (A != B) 为真。 |
| > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （A> B）为假。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （A <B）为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （A> = B）为假。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （A <= B）为真。 |
位运算符
位运算符对整数的二进制形式逐位进行逻辑运算，得到一个整数。假设整数变量 A 的值为 60 （二进制为11 1100）和变量 B 的值为 13（二进制为1101），见下表：
| 操作符 | 描述 | 例子 |
| ＆ | 低位对齐，高位不足的补零，如果相对应位都是1，则结果为1，否则为0 | （A＆B），得到12，即0000 1100 |
| | | 低位对齐，高位不足的补零，如果相对应位都是 0，则结果为 0，否则为 1 | （A | B）得到61，即 0011 1101 |
| ^ | 低位对齐，高位不足的补零，如果相对应位值相同，则结果为0，否则为1 | （A ^ B）得到49，即 0011 0001 |
| 〜 | 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 | （〜A）得到-61，即1100 0011 |
| << | 按位左移运算符。左操作数按位左移右操作数指定的位数。高位移出（舍弃），低位的空位补零。 | A << 2得到240，即 1111 0000 |
| >> | 按位右移运算符。左操作数按位右移右操作数指定的位数。低位移出（舍弃），高位的空位补零。 | A >> 2得到15即 1111 |
| >>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
逻辑运算符
下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假
| 操作符 | 描述 | 例子 |
| && | 称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。 | （A && B）为假。 |
| | | | 称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。 | （A | | B）为真。 |
| ！ | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。 | ！（A && B）为真。 |
条件运算符（三目运算符）
Java中也有一个条件运算符（三目运算符）：
condition ? x1 : x2
condition为一个boolean值。根据condition，取x1或x2的值。
Java运算符优先级
说明：
1） 该表中优先级按照从高到低的顺序书写，也就是优先级为1的优先级最高，优先级14的优先级最低。
2）结合性是指运算符结合的顺序，通常都是从左到右。从右向左的运算符最典型的就是负号，例如3+-4，则意义为3加-4，符号首先和运算符右侧的内容结合。
3） instanceof作用是判断对象是否为某个类或接口类型，后续有详细介绍。
4）注意区分正负号和加减号，以及按位与和逻辑与的区别。
System.out.printf方法的格式标识符
格式化输出语法
System.out.printf(format,item1,item2,…,itemk)
这里的format是指一个由子串和格式标识符构成的字符串.
注意的问题
1.默认情况下,输出是右对齐的.可以在格式标识符中放一个符号(-),表明该条目在特定区域中的输出是左对齐的.
2.使用符号%来标记格式标识符,要在格式字符串里输出直接量%,需要使用%%
| 转换符 | 类型 | 举例 |
| d | 十进制整数 | System.out.printf("%d",159); //159 |
| x | 十六进制整数 | System.out.printf("%x",159); //9f |
| o | 八进制整数 | System.out.printf("%o",159); //237 |
| f | 定点浮点数 | System.out.printf("%.1f",15.9); //15.9 |
| e | 指数浮点数 | System.out.printf("%e",15.9); //1.590000e+01 System.out.printf("%.2e",15.9); //1.59e+01 |
| g | 通用浮点数 | System.out.printf("%g",15.9); //15.9000 |
| a | 十六进制浮点数 | System.out.printf("%.3a",15.9); //0x1.fcdp3 System.out.printf("%a",15.9); //0x1.fcccccccccccdp3 |
| s | 字符串 | System.out.printf("问候%s","Hello"); //问候Hello |
| c | 字符 | System.out.printf("字母a的大写是：%c %n", 'A'); //字母a的大写是：A |
| b | 布尔 | System.out.printf("3>7的结果是：%b %n", 3>7); //3>7的结果是：false |
| n | 换行符 | 见上两行 |
格式标识符的补充说明
① %4.2f
4为域宽度.输出的浮点数条目宽度至少为4，包括小数点和小数点后两位数字.这样，给小数点前分配了1位数字。
如果该条目小数点前的位数小于1，就在数字前面加空格。
如果该条目小数点前的位数大于7，则自动增加宽度。
2为精度().即想要输出的小数点的长度。
f为转换码。
② "%x"表示以十六进制； 输出;"%X"表示以十六进制输出，并且将字母(A、B、C、D、E、F)换成大写。
③格式为"%t"表示输出时间日期类型。"%t"之后用y表示输出日期的二位数的年份(如99)、用m 表示输出日期的月份，用d表示输出日期的日号;"%t"之后用Y表示输出日期的四位数的年份 (如1999)、用B表示输出日期的月份的完整名，用b表示输出日期的月份的简称。"%t"之后用D 表示以"%tm/%td/%ty"的格式输出日期、用F表示以"%tY-%tm-%td"的格式输出日期。
"%t"之后用H表示输出时间的时(24进制)，用I表示输出时间的时(12进制)，用M表示输出时间 分，用S表示输出时间的秒，用L表示输出时间的秒中的毫秒数、用 p 表示输出时间的是上午还是 下午。"%t"之后用R表示以"%tH:%tM"的格式输出时间、用T表示以"%tH:%tM:%tS"的格式输出 时间、用r表示以"%tI:%tM:%tS %Tp"的格式输出时间。
"%t"之后用A表示输出日期的全称，用a表示输出日期的星期简称。
下面给出具体的例子
public class Test {
public static void main(String[] args) {
System.out.printf("%d",159); //159
System.out.println();
System.out.printf("%x",159); //9f
System.out.println();
System.out.printf("%o",159); //237
System.out.println();
System.out.printf("%.1f",15.9); //15.9
System.out.println();
System.out.printf("%e",15.9); //1.590000e+01
System.out.println();
System.out.printf("%.2e",15.9); //1.59e+01
System.out.println();
System.out.printf("%g",15.9); //15.9000
System.out.println();
System.out.printf("%.3a",15.9); //0x1.fcdp3
System.out.println();
System.out.printf("%a",15.9); //0x1.fcccccccccccdp3
System.out.println();
System.out.printf("问候%s","Hello"); //问候Hello
System.out.println();
System.out.printf("字母a的大写是：%c %n", 'A'); //字母a的大写是：A
System.out.printf("3>7的结果是：%b %n", 3>7); //3>7的结果是：false
System.out.printf("%5.3f",8642.5678); //8642.568
System.out.println();
System.out.printf("%.3f",8642.5678); //8642.568
System.out.println();
System.out.printf("%8.4f",1.12); // 1.1200
System.out.println();
System.out.printf("%-8.4f",1.12); //1.1200
}
}
运行结果如下：
下面给出日期的例子
import java.util.Date;
/**关键技术点
* 使用java.io.PrintStream的printf方法实现C风格的输出
输出日期格式
*/
public class PrintfDate {
public static void main(String[] args) {
/*** 输出日期类型***/
// %t表示格式化日期时间类型，%T是时间日期的大写形式，在%t之后用特定的字母表示不同的输出格式
Date date = new Date();
long dataL = date.getTime();
// 格式化年月日
// %t之后用y表示输出日期的年份（2位数的年，如99）
// %t之后用m表示输出日期的月份，%t之后用d表示输出日期的日号
System.out.printf("%1$ty-%1$tm-%1$td; %2$ty-%2$tm-%2$td%n", date, dataL);
// %t之后用Y表示输出日期的年份（4位数的年），
// %t之后用B表示输出日期的月份的完整名， %t之后用b表示输出日期的月份的简称
System.out.printf("%1$tY-%1$tB-%1$td; %2$tY-%2$tb-%2$td%n", date, dataL);
// 以下是常见的日期组合
// %t之后用D表示以 "%tm/%td/%ty"格式化日期
System.out.printf("%1$tD%n", date);
//%t之后用F表示以"%tY-%tm-%td"格式化日期
System.out.printf("%1$tF%n", date);
/*** 输出时间类型***/
// 输出时分秒
// %t之后用H表示输出时间的时（24进制），%t之后用I表示输出时间的时（12进制），
// %t之后用M表示输出时间的分，%t之后用S表示输出时间的秒
System.out.printf("%1$tH:%1$tM:%1$tS; %2$tI:%2$tM:%2$tS%n", date, dataL);
// %t之后用L表示输出时间的秒中的毫秒
System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", date);
// %t之后p表示输出时间的上午或下午信息
System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", date);
// 以下是常见的时间组合
// %t之后用R表示以"%tH:%tM"格式化时间
System.out.printf("%1$tR%n", date);
// %t之后用T表示以"%tH:%tM:%tS"格式化时间
System.out.printf("%1$tT%n", date);
// %t之后用r表示以"%tI:%tM:%tS %Tp"格式化时间
System.out.printf("%1$tr%n", date);
/*** 输出星期***/
// %t之后用A表示得到星期几的全称
System.out.printf("%1$tF %1$tA%n", date);
// %t之后用a表示得到星期几的简称
System.out.printf("%1$tF %1$ta%n", date);
// 输出时间日期的完整信息
System.out.printf("%1$tc%n", date);
}
}
运行结果如下：
转义字符
Java定义了一种特殊的标记来表示特殊字符，这种标记称为转义序列或转义字符，转义序列由反斜杠（\）后面加上一个字符或者一些数字位组成。
| 转义字符（ASCII码值【十进制】） | 意义 |
| \b（008） | 退格（BS），将当前位置移到前一列 |
| \f（012） | 换页（FF），将当前位置一道下页开头 |
| \n（010） | 换行（LF），将当前位置移到下一行开头 |
| \r（013） | 回车（CR），将当前位置移到本行开头 |
| \t（009） | 水平制表（HT）（跳到次啊一个TAB位置） |
| \\（092） | 代表一个反斜字符\ |
| \’（039） | 代表一个单引号（撤号字符） |
| \"（034） | 代表一个双引号字符 |
| \?（063） | 代表一个问号 |
| \0（000） | 空字符（NULL） |
| \ddd（三位八进制数字） | 1到3位八进制数所代表的任意字符 |
| \xhh（二个十六进制数字） | 十六进制所代表的任意字符 |
| \uhhhh（四个十六进制数字） | 如：\u0000：NULL； \u0022 是双引号；\u0020 是半角(英文)空格；\u3000是全角(中文)空格 |
当我们需要在字符串中使用普通的反斜杠时，就需要使用双反斜杠\\来表示。
System.out.println("他说："你好！" "); //这条语句有语法错误！编译器会认为第二个引号字符就是这个字符串的结束标志，而不知道如何处理剩余的字符。应改为下句
System.out.println("他说：\" 你好！\" "); //使用转义字符
数据类型转换
注：boolean类型不能转换为其他的数据类型
默认转换：（从小到大的转换）
byte,short,char—int—long—float—double
byte,short,char相互之间补转换，他们参与运算首先转换为int类型
运算中，不同类型的数据先转化为同一类型，然后进行运算，转换规则如下：
| 操作数1类型 | 操作数2类型 | 转换后的类型 |
| byte、short、char | int | int |
| byte、short、char、int | long | long |
| byte、short、char、int、long | float | float |
| byte、short、char、int、long、float | double | double |
强制转换：
目标类型 变量名=(目标类型)(被转换的数据);
例子、
public class Demo {
public static void main(String[] args){
int x;
double y;
x = (int)34.56 + (int)11.2; // 丢失精度
y = (double)x + (double)10 + 1; // 提高精度
System.out.println("x=" + x);
System.out.println("y=" + y);
}
}
运行结果：
x=45
y=56.0
分析：由于在 34.56 前有一个 int 的强制类型转化，所以 34.56 就变成了 34。同样 11.2 就变成了 11 了，所以 x 的结果就是 45。在 x 前有一个 double 类型的强制转换，所以 x 的值变为 45.0，而 10 的前面也被强制成 double 类型，所以也变成 10.0，所以最后 y 的值变为 56。
总结：那么，我们到底用那种转换呢?
一般建议，最好不要随意使用强制类型转换，容易造成数据精度的损失。
（1）容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造成精度降低或溢出；使用时要格外注意。
（2）有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算。
变量的作用域和生存期
变量指在程序执行的过程中，在某个范围内其值可以发生改变的量。
变量定义格式：
数据类型 变量名 = 初始化值;
变量的作用域即变量的作用范围：
作用域从变量定义的位置开始，到该变量所在的那对大括号结束。
生命周期：
变量从定义的位置开始就在内存中活了；
变量到达它所在的作用域的时候就在内存中消失了。
在Java中，多行语句用{ }括起来——语句块。很多控制语句，例如条件判断和循环，都以{ }作为它们自身的范围，例如：
if (...) { // if开始
...
while (...) { while 开始
...
if (...) { // if开始
...
} // if结束
...
} // while结束
...
} // if结束
只要正确地嵌套这些{ }，编译器就能识别出语句块的开始和结束。而在语句块中定义的变量，它有一个作用域，就是从定义处开始，到语句块结束。超出了作用域引用这些变量，编译器会报错。举个例子：
{
...
int i = 0; // 变量i从这里开始定义
...
{
...
int x = 1; // 变量x从这里开始定义
...
{
...
String s = "hello"; // 变量s从这里开始定义
...
} // 变量s作用域到此结束
...
// 注意，这是一个新的变量s，它和上面的变量同名，
// 但是因为作用域不同，它们是两个不同的变量:
String s = "hi";
...
} // 变量x和s作用域到此结束
...
} // 变量i作用域到此结束
定义变量时，要遵循作用域最小化原则，尽量将变量定义在尽可能小的作用域，并且，尽量不要重复使用变量名。
关于变量的作用域和生存期以后还会结合实际情况介绍。
Java包装类、拆箱和装箱详解
Java 语言八种基本数据类型并不支持面向对象编程，基本类型的数据不具备“对象”的特性——不携带属性、没有方法可调用。
Java为每种基本数据类型分别设计了对应的类，称之为包装类(Wrapper Classes)，也有教材称为外覆类或数据类型类。
基本数据类型及对应的包装类
| 基本数据类型 | 对应的包装类 |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| char | Character |
| float | Float |
| double | Double |
| boolean | Boolean |
每个包装类的对象可以封装一个相应的基本类型的数据，并提供了其它一些有用的方法。包装类对象一经创建，其内容（所封装的基本类型数据值）不可改变。
基本类型和对应的包装类可以相互装换：
由基本类型向对应的包装类转换称为装箱，例如把 int 包装成 Integer 类的对象；
包装类向对应的基本类型转换称为拆箱，例如把 Integer 类的对象重新简化为 int。
八个包装类的使用比较相似，下面是常见的应用场景。
实现 int 和 Integer 的相互转换
可以通过 Integer 类的构造方法将 int 装箱，通过 Integer 类的 intValue 方法将 Integer 拆箱。例如：
public class Demo2A {
public static void main(String[] args) {
int m = 500;
Integer obj = new Integer(m); // 手动装箱
int n = obj.intValue(); // 手动拆箱
System.out.println("n = " + n);
Integer obj1 = new Integer(500);
System.out.println("obj 等价于 obj1？" + obj.equals(obj1));
}
}
n = 500
obj 等价于 obj1？true
使用bluej（其使用参见“Java简介与实验基础” Java简介与实验基础-CSDN博客）编译运行之参见下图：
Integer 类有一个静态的 paseInt() 方法，可以将字符串转换为整数；Integer 类有一个静态的 toString() 方法，可以将整数转换为字符串。例如：
public class Demo2B {
public static void main(String[] args) {
String str = "123";
int n = Integer.parseInt(str, 10);
System.out.println("数字字符串转换为整数：" + n); //将数字字符串转换为整数
int m = 500;
String s = Integer.toString(m); //将整数转换为字符串
System.out.println("s = " + s);
}
}
运行输出结果：
数字字符串转换为整数：123
s = 500
自动拆箱和装箱
上面的例子都需要手动实例化一个包装类，称为手动拆箱装箱。Java 1.5(5.0) 之前必须手动拆箱装箱。
Java 1.5 之后可以自动拆箱装箱，也就是在进行基本数据类型和对应的包装类转换时，系统将自动进行，这将大大方便程序员的代码书写。例如：
public class Demo2C {
public static void main(String[] args) {
int m = 500;
Integer obj = m; // 自动装箱
int n = obj; // 自动拆箱
System.out.println("n = " + n);
Integer obj1 = 500;
System.out.println("obj 等价于 obj1？" + obj.equals(obj1));
}
}
运行输出结果：
n = 500
obj 等价于 obj1？true
引用数据类型 / 引用类型
Java中的引用类型包括类（class）、接口（interface）、数组（array）等。当我们声明一个引用类型的变量时，实际上是在栈内存中分配了一个引用变量，该变量指向堆内存中的对象。
Java引用类型（Reference types）与基本类型（Primitive types）的比较：
| 引用类型 | 基本类型 |
| 引用类型的数量是无限的，因为它们可以由用户自定义。除了用户自定义的引用类型，还有一些常见的引用类型，如类、接口和数组。 | 基本类型包括：char、byte、short、int、long、float和double。 |
| 内存位置存储对数据的引用——对于引用类型的数据，内存位置存储的是对实际数据的引用。引用类型的数据本身并不直接存储在内存位置上，而是存储在另外的内存位置上，然后通过引用来指向这个实际数据的位置。 | 内存位置存储基本类型所持有的实际数据——对于基本类型的数据，内存位置直接存储的是实际的数据值。 |
| 当将一个引用类型赋值给另一个引用类型时，两者都将指向同一个对象。 | 当将一个基本类型的值赋给相同类型的另一个变量时，会进行值的复制——即值的拷贝。 |
| 当一个引用类型数据（如对象、数组）传递给一个方法时，方法可以改变引用类型数据的内容，但不能直接改变引用类型数据的地址。 | 当一个基本类型被传递给一个方法时，只会传递一个基本类型的副本。被调用的方法无法访问原始的基本类型值，因此无法改变它。被调用的方法可以改变复制的值。 |
关于引用数据类型比较复杂，在此仅概要提及，将在以后涉及到的地方介绍。
附录
Java数据的基本（原始）类型和引用类型的特点差别 https://blog.csdn.net/cnds123/article/details/134307458
511
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
