Java 学习笔记：第二章 数据类型和运算符
Java 学习笔记：第二章 数据类型和运算符
- 2.1 注释
- 2.2 标识符
- 标识符的使用规范
- 2.3 Java中的关键字/保留字
- 2.4.1 变量的本质
- 变量的声明
- 2.4.2 变量的分类
- 局部变量（local variable）
- 成员变量（也叫实例变量 member variable）
- 静态变量（类变量 static variable）
- 2.5 常量
- 2.6 基本数据类型（primitive data type）
- Java中定义了3类8种基本数据类型
- 2.6.1 整型变量/常量
- Java 语言整型常量的四中表示形式
- 2.6.2 浮点变量/常量
- Java 浮点类型常量有两种表示形式
- 浮点数使用总结
- 2.6.3 字符型变量/常量
- 2.6.4 boolean 类型变量/常量
- 2.7 运算符
- 运算符分类
- 2.7.1 算术运算符
- 二元运算符的运算规则：
- 2.7.2 赋值及其扩展赋值运算符
- 2.7.3 关系运算符
- 2.7.4 逻辑运算符
- 2.7.5 位运算
- 2.7.6 字符串连接符
- 2.7.7 条件运算符
- 2.7.8 运算符的优先级问题
- 2.8.1 自动类型转化
- 2.8.2 强制类型转化
- 2.8.3 基本类型转换常见错误和问题
- 2.9 简单的键盘输入和输出
- 总结
2.1 注释
为了方便程序的阅读，Java语言允许程序员在程序中写上一些说明性的文字，用来提高程序的可读性，这些文字性的说明就称为注释。注释不会在字节码文件中，即Java 编译器编译时会跳过注释语句。在Java中根据注释的功能不同，主要分为单行注释、多行注释和文档注释。
- 单行注释：使用“//”开头，“//”后面的单行内容均为注释。
- 多行注释：以“/*”开头以“/”结尾，在“/”和“*/”之间的内容为注释，我们也可以使用多行注释作为行内注释，但是在使用时要注意，多行注释不能嵌套使用。
- 文档注释： 以“/**”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc标签(后期写项目时，可以生成项目的API)
【示例2-1】认识Java的三种注释类型
/**
* Welcome类（我是文档注释）
* @author 高淇
* @version 1.0
*/
public class Welcome {
//我是单行注释
public static void main(String[] args/*我是行内注释 */) {
System.out.println("Hello World!");
}
/*
我是多行注释！
我是多行注释！
*/
}
2.2 标识符
标识符是用来给变量、类、方法以及包进行命名的，如Welcome、main、System、age、name、gender等。标识符需要遵守一定的规则。
- 标识符必须以字母、下划线、美元符号开头。
- 标识符其他部分可以是字母、下划线、美元符号和数字的任意组合。
- Java标识符大小写敏感，且长度无限制。
- 标识符不可以是Java的关键字。
标识符的使用规范
- 表示类名的标识符：单个单词的首字母大写，如：Man、GoodMan
- 表示方法和变量的标识符：第一个单词大小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如 eat(),eatFood()
注意；Java 不采用永昌语言使用的ASCII字符集，而是采用Unicode这样标准的国际字符集。因此，这里的字母的含义不仅仅是英文，好包括汉字等等。但是不建议大家使用汉字来定义标识符！
【示例2-2】合法的标识符
int _123 = 3;
int $12aa = 3;
int 变量1 = 55; //合法，但是不建议使用中文命名的标识符
【示例2-3】不适合的标识符
int 1a = 3; //不能用数字开头
int a# = 3; //不能包含#这样的特殊字符
int int = 3; //不能使用关键字
课堂代码：
/**
* 测试标识符的用法
* @author 高淇
*
*/
public class TestIdentifer {
//能力是练出来的，不是看书看出来的。对于初学者来说，再简单的代码也一定要敲一下！
public static void main(String[] args) {
int a123 = 1;
//int 123abc = 2; //数字不能开头
int $a = 3;
int _abc = 4;
//int #abc = 5;
int 年龄 = 18; //可以使用汉字，但是一般不建议
//int class = 2; //关键字不能作为标识符
}
}
2.3 Java中的关键字/保留字
Java关键字是Java语言保留供内部使用的，如 class 用于定义类。关键字也可以成为保留字，它们 的意思是一样的，我们不能使用关键字作为变量名或方法名。
表2-1 Java中的关键字/保留字 |
|||||
abstract |
assert |
boolean |
break |
byte |
case |
catch |
char |
class |
const |
continue |
default |
do |
double |
else |
extends |
final |
finally |
float |
for |
goto |
if |
implements |
import |
instanceof |
int |
interface |
long |
native |
new |
null |
package |
private |
protected |
public |
return |
short |
static |
strictfp |
super |
switch |
synchronized |
this |
throw |
throws |
transient |
try |
void |
volatile |
while |
||||
菜鸟雷区
出于应试教育的惯性思维，很多新手很可能去呗上面的单词，从实战思维出发，我们不需要刻意去记！随着学习的深入，自然就非常熟悉了。
2.4.1 变量的本质
变量的本质上就是代表一个“可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。
Java 是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据 存储空间的大小。比如，int a=3；表示a 变量的空间大小为4个字节。
变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明，只有在变量声明以后，才能为其分配相应长度的存储空间。
变量的声明
格式为：
type varName [=value][,varName[=value]...];
//[]中的内容为可选项，即可有可无
数据类型 变量名 [=初始值] [,变量名 [=初始值]…];
【示例2-4】 声明变量：
double salary;
long earthPopulation;
int age;
不同数据类型的变量会在内存中分配不同的空间，如图所示。
注意事项
- 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
- 变量名必须是合法的标识符
- 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
【示例2-5】在一行中声明多个变量
int i ,j; // 两个变量的数据类型都是int
老鸟建议
不提倡这种“一行声明多个变量”风格，逐一声明每一个变量可以提高程序可读性。
【示例2-6】 可以将变量的声明和初始化放在同一行中
int age = 18;
double e = 2.718281828;
2.4.2 变量的分类
从整体上可将变量划分为局部变量、成员变量（也称为实例变量）和静态变量。
表2-2 局部变量、成员变量、静态变量的区别 |
|||
类型 |
声明位置 |
从属于 |
生命周期 |
局部变量 |
方法或语句块内部 |
方法/语句块 |
从声明位置开始，直到方法或语句块执行完毕，局部变量消失 |
成员变量 (实例变量) |
类内部，方法外部 |
对象 |
对象创建，成员变量也跟着创建。对象消失，成员变量也跟着消失； |
静态变量 (类变量) |
类内部，static修饰 |
类 |
类被加载，静态变量就有效；类被卸载，静态变量消失。 |
老鸟建议
成员变量和静态变量不是目前重点，不要过多纠结理解与否。我们学习面向对象时，在重点讲解成员变量和静态变量
局部变量（local variable）
方法或语句块内部定义的变量。生命周期是从声明位置开始到方法或语句块执行完毕为止。局部变量在使用必须先声明、初始化（赋初值）再使用。
【示例2-7】 局部变量
public void test() {
int i;
int j = i+5 ; // 编译出错，变量i还未被初始化
}
public void test() {
int i;
i=10;
int j = i+5 ; // 编译正确
}
成员变量（也叫实例变量 member variable）
方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会自动初始化成该类型的默认初始值。
表2-3 实例变量的默认初始值 |
|
数据类型 |
实始值 |
int |
0 |
double |
0.0 |
char |
‘\u0000’ |
boolean |
false |
【示例2-8】实例变量的声明
public class Test {
int i;
}
静态变量（类变量 static variable）
使用static 定义。从属于类，生命周期伴随类 始终，从类加载到卸载。如果不自行初始化，与成员变量相同会自动初始化该类型的默认初始值，如表2-3所示：
课堂练习1：变量的声明并赋值
public class LocalVariableTest {
public static void main(String[ ] args) {
boolean flag = true; // 声明boolean型变量并赋值
char c1, c2; // 声明char型变量
c1 = '\u0041'; // 为char型变量赋值
c2 = 'B'; // 为char型变量赋值
int x; // 声明int型变量
x = 9; //为int型变量赋值
int y = x; // 声明并初始化int型变量
float f = 3.15f; // 声明float型变量并赋值
double d = 3.1415926; //声明double型变量并赋值
}
}
课堂代码：
/**
* 测试变量
*
* @author 高淇
*
*/
public class TestVariable {
int a; //成员变量, 从属于对象； 成员变量会自动被初始化
static int size; //静态变量，从属于类
public static void main(String[] args) {
{
int age; //局部变量，从属于语句块；
age = 18;
}
int salary = 3000; //局部变量，从属于方法
int gao = 13;
System.out.println(gao);
int i;
// int j = i + 5; // 编译出错，变量i还未被初始化
}
}
2.5 常量
常量通常指的是一个固定的值，例如：1、2、3、‘a’、‘b’、true、false、“helloworld”等.
Java 语言中，主要是利用关键字final 来定义一个常量。常量一旦被初始化后不能再更改其值。
声明格式为：
final type varName = value;
【示例2-9】 常量的声明及使用
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()
2.6 基本数据类型（primitive data type）
Java 是一张强类型语言，每个变量都必须声明其数据类型。Java 的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）
Java中定义了3类8种基本数据类型
- 数值型 - byte、short、int、long、float、double
- 字符型 - char
- 布尔型 - boolean
注意事项
- 引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！
- 本章只讲解基本数据类型。引用数据类型在后续数组和面向对象章节讲解。
2.6.1 整型变量/常量
整型用于表示没有小数部分的数值，它允许是负数。整型的范围与运行Java 代码的机器无关，这正是 Java 程序员具有很强移植能力的原因之一。与此相反，C 和 C++ 程序需要针对不同的处理器选择有效的整型。
表2-4 整型数据类型 |
||
类型 |
占用存储空间 |
表数范围 |
byte |
1字节 |
-27 ~ 27-1（-128~127） |
short |
2字节 |
-215 ~ 215-1 （-32768~32767） |
int |
4字节 |
-231 ~ 231-1 (-2147483648~2147483647) 约21亿 |
long |
8字节 |
-263 ~ 263-1 |
Java 语言整型常量的四中表示形式
- 十进制整数：99，-500,0
- 八进制整数：要以0开头，015
- 十六进制整数，要求 0x 或0X 开头，0x15
- 二进制数，要求0b或0B开头，0b01110011
Java语言的整型常熟默认为int 型，声明long型常量可以在后面加 ‘l’或‘L’。
【示例2-10】长整型常数的声明
long a = 55555555; //编译成功，在int表示的范围内(21亿内)。
long b = 55555555555;//不加L编译错误，已经超过int表示的范围。
我们修改成 long类型的常量即可
long b = 55555555555L;
2.6.2 浮点变量/常量
带小数的数据在Java 中称为浮点型。浮点型可分为 float 类型和double 类型。
表2-5 浮点型数据类型 |
||
类型 |
占用存储空间 |
表数范围 |
float |
4字节 |
-3.403E38~3.403E38 |
double |
8字节 |
-1.798E308~1.798E308 |
float 类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。而double表示这种类型的数值精度约是float类型的两倍，又被称为双精度类型，绝大部分应用程序采用double类型。浮点型常量默认类型也是 double。
Java 浮点类型常量有两种表示形式
- 十进制数形式，例如：3.14、314.0 、0.314
- 科学计数法形式，例如：314e2、314E2、314E-2
【示例2-11】 使用科学计数法给浮点型变量赋值
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 类型。
【示例2-12】float类型赋值时需要添加后缀F/f
float f = 3.14F;
double d1 = 3.14;
double d2 = 3.14D;
老鸟建议
- 浮点类型 float、double 的数据不适合在不容许舍入误差的金融计算领域。如果需要进行不产生舍入误差的精确数字计算，需要使用 BIgDecimal 类。
【示例2-13】浮点数的比较一
float f = 0.1f;
double d = 1.0/10;
System.out.println(f==d);//结果为false
【示例2-14】 浮点数比较二
float d1 = 423432423f;
float d2 = d1+1;
if(d1==d2){
System.out.println("d1==d2");//输出结果为d1==d2
}else{
System.out.println("d1!=d2");
}
运行以上两个例子，发现示例2-13的结果是“false”，而示例2-14的输出结果是“d1==d2”。这是因为由于字长有限，浮点数一般都存在舍入误差，很多数字无法精确表示（例如0.1），其结果只能是接近，但不等于。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。
java.math 包下面的练个有用的类：BigInteger 和 BigDecimal，这两个类可以处理任意长度的数值。BigInteger 实现了任意精度的整数运算。BigDecimal 实现了任意精确的浮点运算。
菜鸟雷区
- 不要使用浮点数进行比较！很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误！需要比较请使用 BigDecimal 类
【示例2-15】使用BigDecimal 进行浮点数的比较
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
BigDecimal bd = BigDecimal.valueOf(1.0);
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
bd = bd.subtract(BigDecimal.valueOf(0.1));
System.out.println(bd);//0.5
System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1);//0.5000000000000001
}
}
浮点数使用总结
- 默认是 double 类型
- 浮点数存在舍入误差，数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用 BigDecimal 类。
- 避免比较中使用浮点数，需要比较请使用 BigDecimal 类
2.6.3 字符型变量/常量
字符型在内存中占2个字节，在Java中使用单引号来表示字符常量。例如‘A’ 是一个字符，它与“A”是不同的，“A”表示一个字符的字符串。
char 类型用来表示在Unicode 编码表中的字符。Unicode 编码被设计用来处理各种语言的文字，它占2个字节，可允许有 65536 个字符。
【示例2-16】 字符型举例
char eChar = 'a';
char cChar ='中';
Unicode 具有从0到65535之间的编码，他们通常用从‘\u0000’到‘\uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）
【示例2-17】 字符型的十六进制值表示方法
char c = '\u0061';
Java语言中好允许使用转义字符‘\’来将其后的字符转变为其它的含义。常用的转义字符及其含义和Unicode值如表所示。
【示例2-18】转义字符
char c2 = '\n'; //代表换行符
表2-6 转义字符 |
||
转义符 |
含义 |
Unicode值 |
\b |
退格（backspace） |
\u0008 |
\n |
换行 |
\u000a |
\r |
回车 |
\u000d |
\t |
制表符（tab） |
\u0009 |
\“ |
双引号 |
\u0022 |
\‘ |
单引号 |
\u0027 |
\\ |
反斜杠 |
\u005c |
注意事项
- 以后我们学的String 类，其实是字符序列（char sequence）。
课堂代码
/**
* 测试字符类型
* @author 高淇
*
*/
public class TestPrimitiveDataType3 {
public static void main(String[] args) {
char a = 'T';
char b = '尚';
char c = '\u0061';
System.out.println(c);
//转义字符
System.out.println(""+'a'+'\n'+'b');
System.out.println(""+'a'+'\t'+'b');
System.out.println(""+'a'+'\''+'b'); //a'b
//String就是字符序列
String d = "abc";
}
}
2.6.4 boolean 类型变量/常量
boolean 类型有两个常量值，true 和 false ，在内存中占一位（不是一个字节），不可以使用 0 或 非0 的整数替代 true 和 false，这点和C语言不同。boolean 类型用来判断逻辑条件，一般用于程序流程控制。
【示例2-19】 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）
2.7 运算符
计算机的最基本用途之一就执行数学运算，作为一门计算机语言，Java 也提供了一套丰富的运算符来操作变量。
运算符分类
| 算术运算符 | 二元运算符 | +，-，*，/，% |
| 一元运算符 | ++，-- | |
| 赋值运算符 | = | |
| 扩展运算符 | +=，-=，*=，/= | |
| 关系运算符 | >，<，>=，<=，==，!= instanceof | |
| 逻辑运算符 | &&，||，!，^ | |
| 位运算符 | &，|，^，~ ， >>，<<，>>> | |
| 条件运算符 | ? : | |
| 字符串连接符 | + | |
2.7.1 算术运算符
算术运算符中 +，-，*，/，% 属于二元运算符，二元运算符指的是需要两个操作数才能完成运算的运算符。其中的%是取模运算符，就是我们常说的求余数操作。
二元运算符的运算规则：
整数运算：
- 如果两个操作数有一个为long，则结果也为long。
- 没有long 时，结果为 int。即使操作数全为short，byte，结果也是int。
浮点运算
- 如果两个操作数有一个为double，则结果为double。
- 只有两个操作数都是float，则结果才为float。
取模运算
- 其操作数可以为浮点数，一般使用整数，结果是“余数”，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1,7%-3=1。算术运算符中++，–属于一元运算符，该类运算符只需要一个操作数。
【示例2-20】 一元运算符 ++ 与 –
int a = 3;
int b = a++; //执行完后,b=3。先给b赋值，再自增。
System.out.println("a="+a+"\nb="+b);
a = 3;
b = ++a; //执行完后,c=5。a先自增，再给c赋值
System.out.println("a="+a+"\nb="+b);
运行该程序，执行结果如图所示。
2.7.2 赋值及其扩展赋值运算符
表2-8 赋值及其扩展运算符
| 运算符 | 用法举例 | 等效的表达式 |
| += | a += b | a = a+b |
| -= | a -= b | a = a-b |
| *= | a *= b | a = a*b |
| /= | a *= b | a = a/b |
| %= | a *= b | a = a%b |
【示例2-21】 扩展运算符
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);
运行该程序，执行结果如图所示
2.7.3 关系运算符
关系运算符用来进行比较运算，如表所示。关系运算的结果是布尔值：true/false；
| 运算符 | 含义 | 示例 |
| == | 等于 | a==b |
| != | 不等于 | a!=b |
| > | 大于 | a>b |
| < | 小于 | a |
| >= | 大于或等于 | a>=b |
| <= | 小于或等于 | a<=b |
注意事项
- =是赋值运算符，而真正的判断两个操作数是否相等的运算符 == 。
- ==、！= 是所有（基本和引用）数据类型都可以使用
- >、>=、<、<= 仅针对数值类型（byte/short/int/long，float/double。以及char）
2.7.4 逻辑运算符
Java 中的逻辑运算符如表所示。逻辑运算符的操作数和运算结果都是 bolean 值
| 运算符 | 说明 | |
| 逻辑与 | &( 与) | 两个操作数为true，结果才是true，否则是false |
| 逻辑或 | |(或) | 两个操作数有一个是true，结果就是true |
| 短路与 | &&( 与) | 只要有一个为false，则直接返回false |
| 短路或 | ||(或) | 只要有一个为true， 则直接返回true |
| 逻辑非 | !（非） | 取反：!false为true，!true为false |
| 逻辑异或 | ^（异或） | 相同为false，不同为true |
短路与 和 短路或 采用的短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符的右边的操作数，提高效率。
【示例 2-22】短路与 和 逻辑与
//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);
2.7.5 位运算
位运算指的是进行二进制位的运算，常用的位运算符如表所示
| 位运算符 | 说明 |
| ~ | 取反 |
| & | 按位与 |
| | | 按位或 |
| ^ | 按位异或 |
| << | 左移运算符，左移1位相当于乘2 |
| >> | 右移运算符，右移1位相当于除2取商 |
【示例2-23】左移运算和右移运算
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 类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。
- 不要把 “^” 当做数学运算 “乘方”，是 “位的异或”操作。
2.7.6 字符串连接符
“+” 运算符两侧的操作数中只有有一个是字符串（String）类型，系统会自动将另一个操作数转换为字符串然后进行连接。
【示例2-24】连接符 “+”
int a=12;
System.out.println("a="+a);//输出结果: a=12
2.7.7 条件运算符
语法格式：
x ? y : z
其中 x 为 boolean 类型表达式，先计算 x 的值， 若为true，则整个运算的结果为表达式 y 的值，否则整个运算符结果为表达式 z 的值。
【示例2-25】三目条件运算符
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);
运行结果如图所示：
2.7.8 运算符的优先级问题
| 优先级 | 运算符 | 类 | 结合性 |
| 1 | () | 括号运算符 | 由左至右 |
| 2 | !、+（正号）、-（负号） | 一元运算符 | 由左至右 |
| 2 | ~ | 位逻辑运算符 | 由右至左 |
| 2 | ++、-- | 递增与递减运算符 | 由右至左 |
| 3 | *、/、% | 算术运算符 | 由左至右 |
| 4 | +、- | 算术运算符 | 由左至右 |
| 5 | <<、>> | 位左移、右移运算符 | 由左至右 |
| 6 | >、>=、<、<= | 关系运算符 | 由左至右 |
| 7 | ==、!= | 关系运算符 | 由左至右 |
| 8 | & | 位运算符、逻辑运算符 | 由左至右 |
| 9 | ^ | 位运算符、逻辑运算符 | 由左至右 |
| 10 | | | 位运算符、逻辑运算符 | 由左至右 |
| 11 | && | 逻辑运算符 | 由左至右 |
| 12 | || | 逻辑运算符 | 由左至右 |
| 13 |
? : | 条件运算符 | 由右至左 |
| 14 | =、+=、-=、*=、/=、%= | 赋值运算符、扩展运算符 | 由右至左 |
老鸟建议
- 大家不需要去刻意的记这些优先级，表达式里面优先使用小括号来组织！！
- 逻辑与、逻辑或、逻辑非 的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）
2.8.1 自动类型转化
自动类型转换指的是小的数据类型可以自动转换为容量大的数据类型。如图所示，黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。
可以将整型常量复制给 byte、short、char 等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。
【示例2-26】自动类型转换特例
short b = 12; //合法
short b = 1234567; //非法，超出了short 的表数范围l
2.8.2 强制类型转化
强制类型转化，又被称为造型，用于显式的转换一个数值的类型。在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
语法格式：
(type)var
运算符 “()” 中的type 表示将值 var 想要转换成的目标数据类型。
【示例2-27】强制类型转换
double x = 3.14;
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);
运行结果如图所示：
当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成为一个完全不同的值。
【示例2-28】强制类型转换特例
int x = 300;
byte bx = (byte)x; //值为44
新手雷区
不能在布尔类型和任何数值类型之间做强制类型转换
2.8.3 基本类型转换常见错误和问题
操作比较大的数时，要留意是否溢出，尤其是证书操作时。
【示例2-29】常见问题一
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);
运行结果如图所示
L 和 l 的问题：
不要命名名字为 l 的变量， l 容易和 1 混淆。long 类型使用大写L 不要使用小写。
【示例 2-30】 常见问题二
int l = 2; //分不清是L还是1,
long a = 23451l;//建议使用大写L
System.out.println(l+1);
2.9 简单的键盘输入和输出
为了我们能写出更加fuza 的程序，可以让我们的程序和用户可以用过键盘交互，我们先学习一下简单的键盘输入和输出。
【示例2-31】使用 Scanner 获取键盘输入
在import java.util.Scanner;
/**
* 测试获得键盘输入
* @author 高淇
*
*/
public class TestScanner {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入名字：");
String name = scanner.nextLine();
System.out.println("请输入你的爱好：");
String favor = scanner.nextLine();
System.out.println("请输入你的年龄：");
int age = scanner.nextInt();
System.out.println("###############");
System.out.println(name);
System.out.println(favor);
System.out.println("来到地球的天数："+age*365);
System.out.println("离开地球的天数："+(72-age)*365);
}
}
运行结果如图所示：
总结
-
注释可以提高程序的可读性。可划分为
-
单行注释 //
-
多行注释 /…/
-
文档注释 /**…*/
-
标识符的命名规则：
-
标识符必须以字母、下划线_、美元符号$开头。
-
标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
-
Java 标识符大小写敏感，且长度无限制。
-
标识符不可以是Java的关键字。
-
标识符的命名规范
-
表示类名的标识符：每个单词的首字母大写，如Man, GoodMan
-
表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(), eatFood()
-
变量的声明格式：
type varName [=value] [,varName[=value]…];
-
变量的分类：局部变量、实例变量、静态变量
-
常量的声明格式
final type varName = value ;
-
Java的数据类型可分为基本数据类型和引用数据类，基本数据类型的分类如下：
-
整型变量：byte、short、int、long
-
浮点型：float、double
-
字符型：char
-
布尔型:boolean，值为true或者false
-
Java语言支持的运算符可分为：
-
算术运算符: +，-，*，/，%，++，–
-
赋值运算符 =
-
扩展赋值运算符:+=，-=，*=，/=
-
关系运算符: >，<，>=，<=，==，!= ，instanceof
-
逻辑运算符: &&，||，!
-
位运算符: &，|，^，~ ， >>，<<，>>>
-
字符串连接符：+
-
条件运算符 ？：
-
基本数据类型的类型转换可分为：
-
自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型
-
强制类型转换：用于显式的转换一个数值的类型，语法格式：(type)var
-
键盘的输入：Scanner类的使用