🔥常量(Constant)

在 Java 语言中，用关键字 final 来定义一个常量。常量一旦被初始化后不能再更改。

声明格式：

final type varName = value;

【eg】常量的声明及使用

	public class TestConstants {
	public static void main(String[ ] args) {
		final double PI = 3.14;
		// PI = 3.15; //编译错误，不能再被赋值！
		double r = 4;
		double area = PI * r * r;
		double circle = 2 * PI * r;
		System.out.println("area = " + area);
		System.out.println("circle = " + circle);
	}
}

为了更好的区分和表述，一般将 1、2、3、‘a’、‘b’、true、false、"helloWorld"等
称为字符常量，而使用 final 修饰的 PI 等称为符号常量。

注意:

变量和常量命名规范
🐟	所有变量、方法、类名：见名知义
🐟	类成员变量：首字母小写和驼峰原则: monthSalary
🐟	局部变量：首字母小写和驼峰原则
🐟	常量：大写字母和下划线：MAX_VALUE
🐟	类名：首字母大写和驼峰原则: Man, GoodMan
🐟	方法名：首字母小写和驼峰原则: run(), runRun()

🔥基本数据类型(primitive data type)

Java 数据类型分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。

注意：

🐟	引用数据类型的大小统一为 4 个字节，记录的是其引用对象的地址！

🔥整型

Java 语言整型常量的四种表示形式

🐟	十进制整数，如：99, -500, 0
🐟	八进制整数，要求以 0 开头，如：015
🐟	十六进制数，要求 0x 或 0X 开头，如：0x15
🐟	二进制数，要求 0b 或 0B 开头，如：0b01110011

Java 语言的整型常数默认为 int 型，声明 long 型常量可以后加‘ l ’或‘ L ’ 。

【eg】long 类型常数的写法及变量的声明

long a = 55555555; 		//编译成功，在 int 表示的范围内(21 亿内)。
long b = 55555555555;	//不加 L 编译错误，已经超过 int 表示的范围。

报错：The literal 55555555555 of type int is out of range，所以我们需要修改代
码为：

long b = 55555555555L;

🔥浮点型(Floating Point Number)

⭐ float 类型又被称作单精度类型，尾数可以精确到 7 位有效数字。

⭐ double 表示这种类型的数值精度约是 float 类型的两倍，又被称作双精度类型，绝大部分应用程序都采用 double 类型。

⭐ Java 浮点类型常量有两种表示形式

🐟	十进制数形式： 例: 3.14 314.0 0.314 
🐟	 科学记数法形式 例：3.14e0 3.14E2 3.14E-1

⭐ 浮点型不精确，不要用于比较
浮点数存在舍入误差，数字不能精确表示。浮点数适合普通的科学和工程计算，精度足够；但不适合精度要求非常高的商业计算，这时候要使用 BigDecimal 进行运算和比较。

⭐ 浮点常量默认类型是 double，要改成 float 可以后面加 F 或 f

【eg】使用科学记数法给浮点型变量赋值

double f = 314e2; //314*10^2-->31400.0
double f2 = 314e-2; //314*10^(-2)-->3.14

float类型的数值有一个后缀F或者f ，没有后缀F/f的浮点数值默认为double类型。也可以在浮点数值后添加后缀D或者d， 以明确其double类型。

【eg】float 类型常量的写法及变量的声明

float f = 3.14F;//float 类型赋值时需要添加后缀 F/f
double d1= 3.14;
double d2 = 3.14D;

【eg】浮点型数据的比较一

float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);//结果为 false

【eg】浮点型数据的比较二

	float d1 = 423432423f;
	float d2 = d1+1;
	if(d1==d2){
		System.out.println("d1==d2");//输出结果为 d1==d2
	}else{
		System.out.println("d1!=d2");
}

运行以上两个示例，发现示例一的结果是“false”，而示例二的输出结果是“d1==d2”。这是因为由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。 浮点数一般都存在舍入误差，很多数字无法精确表示(例如0.1)，其结果只能是接近， 但不等于。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。

java.math 包下面的两个有用的类：BigInteger 和 BigDecimal，这两个类可以处理任意长度的数值。BigInteger 实现了任意精度的整数运算。BigDecimal 实现了任意精度的浮点运算。

注意：

不要使用浮点数进行比较！很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误！需要比较请使用 BigDecimal 类。

🔥字符型

ASCII 字符集表示了英文字母、数字、特殊字符、控制符，所有字符集的老祖宗，大家都会兼容它。但是一个字节能够表示 256 个状态，而 ASCII 字符只用到 128 个，后面 128个一直是空的。

于是有了 ISO8859-1,别名叫 latin-1, 包含了 256 个字符。前 128 个字符与 ASCII 中完全相同。后 128 个包括了西欧语言、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。

随着我国的计算机普及，汉字的处理也有了我们自己的方案。那就是 GB2312，两个字节表示 1 个汉字。两个字节可以表示 65536 个状态，汉字再多也能全部包含。后来，又有了 GBK、GB18030。

我国的台湾地区自己搞了一套显示繁体中文的大五码 BIG5。

全世界各个地方，都有自己的文字编码。由于不互通，经常造成乱码的问题。
如果有一种统一的字符集，将世界上所有语言字符都纳入其中，每一个字符都给予一个全球独一无二的编码，那么乱码问题就会消失。于是，全球所有国家和民族使用的所有语言字符的统一字符集诞生了，这就是 Unicode 字符集。

Unicode 字符集是为了给全世界所有字符一个唯一的编码，“唯一”对应的英文为Unique，而编码的英文为 code。

Unicode 采用了字符集和编码分开的策略。Unicode 之前，Unicode 诞生之前可以将字符集和字符编码混为一谈，而在 Unicode 中必须严格区分开。

Unicode 字符集统一采用两个字节表示一个字符，包括英文字母。但是，由于英文占据互联网信息的绝大部分。真实存储和传输时，会造成极大的浪费；因此，目前主要采用 UTF-8 编码来实现具体的存储和传输。UTF-8 是变长编码，用 1-6 个字节编码 Unicode 字符。西欧字符仍然是 1 个字节，汉字 3 个字节。

字符型在内存中占 2 个字节，在 Java 中使用单引号来表示字符常量。例如’A’是一个字符，它与"A"是不同的，"A’表示含有一个字符的字符串。

char 类型用来表示在 Unicode 编码表中的字符。Unicode 编码被设计用来处理各种语言的文字，它占 2 个字节，可允许有 65536 个字符。

【eg】字符型演示

char eChar = 'a'; 
char cChar ='中';

Unicode 具有从 0 到 65535 之间的编码，他们通常用从’\u0000’到’\uFFFF’之
间的十六进制值来表示（前缀为 u 表示 Unicode）

【eg】字符型的十六进制值表示方法

char c = '\u0061';

Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的含义。常用的转
义字符及其含义和 Unicode 值如下表所示。

【eg】转义字符

char c2 = '\n'; 	//代表换行符

转义符	含义	Unicode 值
\b	退格（backspace）	\u0008
\n	换行	\u000a
\r	回车	\u000d
\t	制表符（tab）	\u0009
\ "	双引号	\u0022
\ ’	单引号	\u0027
\	反斜杠	\u005c

注意：

String 类，其实是字符序列(char sequence), 本质是 char 字符组成的数组。

🔥布尔型(boolean)

⭐ boolean 类型有两个常量值，true 和 false。
⭐ 在内存中占一个字节或 4 个字节，不可以使用 0 或非 0 的整数替代 true 和 false ，这点和 C 语言不同。

注意

JVM 规范指出 boolean 当做 int 处理，也就是 4 字节，boolean 数组当做 byte 数组处理，这样我们可以得出 boolean 类型占了单独使用是 4 个字节，在数组中是确定的 1 个字节。

【eg】boolean 类型演示

	boolean flag ;
	flag = true; //或者 flag=false;
	if(flag) {
			// true 分支
	} else {
		   // false 分支
}

个人建议

 Less is More！！请不要这样写：if ( flag = = true )，只有新手才那么写。关键也很容易写错成if(flag=true)，这样就变成赋值 flag 为 true 而不是判断！老鸟的写法是 if ( flag )或者 if ( !flag)

🔥运算符(operator)

计算机的基本用途就是执行数学运算，Java 提供了一套丰富的运算符来操作变量。

算术运算符

⭐ +，-，*，/，%属于二元运算符。%是取模运算符，就是我们常说的求余数操作。
⭐ 算术运算符中++(自增)，–(自减)属于一元运算符。

二元运算符的运算规则：

整数运算：

🐟	如果两个操作数有一个为 long, 则结果也为 long。
🐟	没有 long 时，结果为 int。即使操作数全为 short，byte，结果也是 int。

浮点运算：

🐟	如果两个操作数有一个为 double，则结果为 double。
🐟	只有两个操作数都是 float，则结果才为 float。

取模运算：

🐟	其操作数可以为浮点数,一般使用整数，结果是“余数”，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1，7%-3=1。

【eg】一元运算符++与–

		int a = 3;
		int b = a++; //执行完后,b=3。先给b赋值，再自增。
		System.out.println("a="+a+"\nb="+b);
		a = 3;
		b = ++a; //执行完后,b=4。a先自增，再给b赋值
		System.out.println("a="+a+"\nb="+b);

运行该程序，执行结果如下图所示。

赋值及其扩展赋值运算符

【eg】扩展运算符

	int a=3;
	int b=4;
	a+=b;//相当于a=a+b;
	System.out.println("a="+a+"\nb="+b);
	a=3;
	a*=b+3;//相当于a=a*(b+3)
	System.out.println("a="+a+"\nb="+b)

运行该程序，执行结果如下图所示。

关系运算符

关系运算符用来进行比较运算。关系运算的结果是布尔值：true/false；

注意

🐟	=是赋值运算符，而真正的判断两个操作数是否相等的运算符是==。
🐟	=、!= 是所有（基本和引用）数据类型都可以使用。
🐟	> 、>=、 <、 <= 仅针对数值类型（byte/short/int/long，float/double 以及char）。

🔥逻辑运算符

逻辑运算的操作数和运算结果都是 boolean 值。

短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。

【eg】短路与和逻辑与

//1>2 的结果为 false，那么整个表达式的结果即为 false，将不再计算 2>(3/0)
	boolean c = 1>2 && 2>(3/0);
	System.out.println(c);
//1>2 的结果为 false，那么整个表达式的结果即为 false，还要计算 2>(3/0)，0 不能做除数，//会输出异常信息
	boolean d = 1>2 & 2>(3/0);
	System.out.println(d);

位运算符

位运算指的是进行二进制位的运算。

【eg】左移运算和右移运算

int a = 3*2*2;
int b = 3<<2; //相当于：3*2*2;
int c = 12/2/2;
int d = 12>>2; //相当于 12/2/2;

注意：

🐟	&和|既是逻辑运算符，也是位运算符。如果两侧操作数都是 boolean 类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。
🐟	不要把“^”当做数学运算“乘方”，是“位的异或”操作。

字符串连接符

“+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

【eg】连接符“+”

int a=12;
System.out.println("a="+a);//输出结果: a=12

条件运算符

String type = score<60?“不及格”:“及格”;

x 为 boolean 类型表达式，先计算 x 的值，若为 true，则整个运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。

【eg】条件运算符

	int score = 80; 
	int x = -100;
	String type =score<60?"不及格":"及格"; 
	int flag = x > 0 ? 1 : (x == 0 ? 0 : -1);
	System.out.println("type= " + type);
	System.out.println("flag= "+ flag);

运行结果如下图所示：

运算符优先级的问题

个人建议：

🐟	大家不需要去刻意的记这些优先级，表达式里面优先使用小括号来组织！！

🔥数据类型的转换

Java共有八种基本数据类型，除了 boolean 类型之外的七种类型是可以自动转化的。

自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。如下图所示，黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

可以将整型常量直接赋值给 byte、 short、char 等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。

【eg】自动类型转换特例

short b = 12; //合法
short b = 1234567; //非法，1234567 超出了 short 的表数范围

强制类型转换

强制类型转换，又称为造型（cast），用于强制转换数值的类型，可能损失精度。

【eg】强制类型转换

double x = 3.94; 
int nx = (int)x; //值为 3
char c = 'a';
int d = c+1;
System.out.println(nx);
System.out.println(d);
System.out.println((char)d)

运行结果如下图：

当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成为一个完全不同的值。

【eg】强制类型转换特例

int x = 300;
byte bx = (byte)x; //值为 44

注意：

🐟	不能在布尔类型和任何数值类型之间做强制类型转换

基本类型转化时常见错误和问题

⭐	操作比较大的数时，要留意是否溢出，尤其是整数操作时。

⭐	L 和 l 的问题：
🐟	不要命名名字为 l 的变量，字母 l 容易和数字 1 混淆。
🐟	long 类型使用大写 L，不要用小写 l。

【eg】类型转换常见问题一

	int money = 1000000000; //10亿
	int years = 20;
	//返回的total是负数，超过了int的范围
	int total = money*years;
	System.out.println("total="+total);
	//返回的total仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失
	long total1 = money*years; 
	System.out.println("total1="+total1);
	//返回的total2正确:先将一个因子变成long，整个表达式发生提升。全部用long来计算。
	long total2 = money*((long)years); 
	System.out.println("total2="+total2);

【eg】类型转换常见问题二

int l = 2; 	//分不清是L还是1,
long a = 23451l;	//建议使用大写L
System.out.println(l+1);

🔥Scanner 处理键盘输入

【eg】使用 Scanner 获取键盘输入

import java.util.Scanner;
	public class Welcome2 {
		public static void main(String[ ] args) {
		Scanner scanner = new Scanner(System.in);
			// 将输入的一行赋给 string1
			String string1 = scanner.nextLine();
			// 将输入单词到第一个空白符为止的字符串赋给 string2
			String string2 = scanner.next();
			// 将输入的数字赋值给变量
			int a = scanner.nextInt();
	System.out.println("-----录入的信息如下-------");
	System.out.println(string1);
	System.out.println(string2);
	System.out.println(a * 10);
	}
}