1. 三种注释和API文档
Java注释
注释，对程序本质没有影响的内容，主要用于帮助开发者，记录一些辅助信息的内容。
单行注释： // 后面的内容就是单行注释
多行注释： /* 中间内容就是多行注释 */
文档注释 ： /** 中间内容就是文档注释*/
文档注释只有放在类定义之前、Field之前、内部类之前才有效
程序代码如下：CommentTest.java
public class CommentTest
{
/*
这里面的内容全部是多行注释
Java语言真的很有趣
*/
public static void main(String[] args)
{
// 这是一行简单的注释
System.out.println("Hello World!");
// System.out.println("这行代码被注释了，将不会被编译、执行!");
}
}Javadoc命令，可以直接提取文档注释，并根据文档注释来生成API文档。
javadoc –d [目录] Java源文件
//目录指定把生成的API文档存放到哪个目录下
API文档
开发一个大型软件时，需要定义成千上万的类，而且需要很多人参与开发。每个人都会开发一些类，并在类里面定义一些方法、成员变量提供给他人使用，但其他人怎么知道如何使用这些类和方法呢？这时候就需要提供一份说明文档，用于说明每个类、每个方法的用途。当其他人使用一个类或一个方法时，他无须关心这个类或者方法的具体实现，他只要知道这个类或方法的功能即可，然后使用这个类或方法来实现具体的目的，也就是通过调用应用程序接口（API）来编程。API文档就是用以说明这些应用程序接口的文档。对于Java语言而言，API文档通常详细说明了每个类、每个方法的功能及用法等。
API（应用程序接口）：编程，就是调用API的方法来控制系统。API文档就是API的说明书。
2. 标识符和关键字
分隔符
常见的分隔符有分号（;）、花括号（{ }）、方括号（[ ]）、圆括号( )、空格（ ）、圆点（.）
在Java语言中，每一条语句的结束必须用分号表示（;），故允许一行书写多个语句，或者语句跨行书写，但是一个字符串、变量名不能跨行书写。
标识符
类名、方法名等，只要是编程，常常需要起个合法的名字。
规则：由字母（英文字母、中文字符、日文字符等）、数字、下划线（_）、美元（$）组成,但数字不能开头，不能包含空格，不能是Java的关键字和保留字，但中间可以包含关键字和保留字。
abc_xyz 对
HelloWorld 对
abc$ 对
$中文 对
_abc 对
xyz#abc 不对
abc1 对
1abc 不对Java 的关键字加上goto、const、true、false、nulll一共有53个关键字和保留字，都不能作为Java的标识符。
关键字和保留字
关键字：对于Java程序有特殊意义的单词，一共48个。
保留字：goto、const
直接量：true、false、null
53个关键字、保留字所有字母都是小写的，TRUE、FALSE、NULL都不是Java关键字。
Java关键字和保留字
3. 八大基本数据类型
Java语言是一个强类型语言：
1、所有变量，必须先声明类型，后使用。
2、指定类型的变量，只能装对应的类型的数据。什么样的瓶子装什么样的酒。
Java 语言支持的类型分为两大类:
1、基本类型。基本数据类型包括八大数据类型。
2、引用类型。引用类型包括数组、类、接口，还有一种特殊的null类型。
所谓引用数据类型就是对一个对象的引用，对象包括实例和数组两种。实际上，引用类型变量就是一个指针，只是Java语言中不再使用指针这个说法。
空类型就是null值的类型，这种类型没有名称。因为null类型没有名称，所以不可能声明一个null类型的变量或者转换到null类型。空引用是null类型变量唯一的值。空引用可以转换为任何引用类型。
在实际开发中，程序员可以忽略null类型，假定null只是引用类型的一个特殊直接量。
Java的数据类型
1 Byte = 8 bit（bit是一个二进制位，代表0或1）= 1字节 = 8位
1 KB = 1024 B = 可表示2^10字节
1 MB = 1024 KB = 可表示2^20字节
1 GB = 1024 MB = 可表示2^30字节
1 TB = 1024 GB = 可表示2^40字节
变量
编程的本质，就是对内存中数据的访问和修改。程序所用的数据都会保存在内存中，程序员需要一种机制来访问或修改内存中数据。这种机制就是变量，每个变量都代表了某一小块内存，而且变量是有名字的，程序对变量赋值，实际上就是把数据装入该变量所代表的内存区的过程；程序读取变量的值，实际上就是从该变量所代表的内存区取值的过程。
变量就是用来记录数据的。计算机内存里数据就需要通过变量来访问。通俗来说，变量相当于一个有名称的容器，用来装各种不同类型的数据。
四个整型（不支持小数）
byte（1字节）=（2^8= 256）=可表数范围“[-128~127]”、
short（2字节）=（2^16= 65536）=可表数范围“[-32768~36767]”、
int（4字节）=（2^32= 4g）=可表数范围“[-2g~2g）”、
long（8字节）=（2^64≠8g）=可表数范围“[-2^63~2^63）” 1）当我们直接使用一个整数时，默认是int类型。
2）如果直接将一个较小的数值（在byte或short类型的表数范围内）赋给byte或short变量，系统会自动把这个整数值当成byte或short类型来处理。
3）如果直接将一个较大的数值（超出了int类型的表数范围）时，Java不会自动把这个整数值当成long类型来处理。如果想使用一个long型的整数，需要在整数后面加L/l。
整数有如下四种形式：
10进制整数： 默认。
16进制整数： 以0x开头的整数值， 0~9a~f
8进制整数： 以0开头的整数值， 0~7
2进制整数： 以0b开头的整数值， 0/1
1）当定义32位的二进制整数时，最高位是符号位（0代表正数；1代表负数）。
2）所有的数字在计算机里面都是以二进制形式存在的，原码是直接将一个数值换算成二进制数，但计算机以补码的形式保存所有的整数。
原码：数值换算出的二进制数。
反码：除最高位（符号位）不变之外，其他位按位取反。
补码：负数补码 = 反码+1；正数补码 = 原码
程序代码如下：整数Test.java
//类名可以是中文
public class 整数Test
{
public static void main(String[] args)
{
//byte（1字节）=（2^8= 256）=可表数范围“[-128~127]”
byte b1 = 56;
byte b2 = (byte)129;
System.out.println("--（表数范围内）byte类型的 b1 = 56 = "+ b1 );
System.out.println("--（表数范围外）byte类型的 b2 = (byte)129 = "+ b2 );
System.out.println();
//int（4字节）=（2^32= 4g）=可表数范围“[-2g~2g）”
int a;
//赋值语句的作用，就是把值“倒”入变量这种容器中。
a = 456;
int b;
b = a; //把a瓶子的值“倒”入b瓶子，b依然还有。
System.out.println("--int类型的 a = "+ a );
System.out.println("--int类型的 b = "+ b );
System.out.println();
int val1 = 0x2a9; //16进制的数，以0x或者0X开头的整数值
int val2 = 0X2a9; //16进制的数，以0x或者0X开头的整数值
System.out.println("--int类型（16进制）的 0x2a9 = " + val1);
System.out.println("--int类型（16进制）的 0X2a9 = " + val2);
System.out.println();
int ot = 01436; //8进制的数，以0开头的整数值
System.out.println("--int类型（8进制）的 01436 = " + ot);
System.out.print("--int类型（8进制）的 01436 与 “1 * 512 + 4 * 64 +3 * 8 + 6 * 1” 比较：");
System.out.println(ot == 1 * 512 + 4 * 64 +3 * 8 + 6 * 1);
System.out.println();
int bval = 0b11010100; //2进制的数，以0b或者0B开头的整数值，定义一个8位的2进制的数。
int bva2 = 0B01101001; //2进制的数，以0b或者0B开头的整数值，定义一个8位的2进制的数。
int bva3 = 0B00000000000000000000000000000011; //定义一个32位的2进制的数，最高位是符号位，0代表正数
int bva4 = 0B10000000000000000000000000000011; //定义一个32位的2进制的数，最高位是符号位，1代表负数
System.out.println("--int类型（2进制）的 0b100101100101 = " + bval);
System.out.println("--int类型（2进制）的 0B100101100101 = " + bva2);
System.out.println("--int类型（32位的2进制）的 0B00000000000000000000000000000011 = " + bva3);
System.out.println("--int类型（32位的2进制）的 0B10000000000000000000000000000011 = " + bva4);
System.out.println("--数字在计算机里面是以补码的形式存在，负数补码 = 反码+1，正数补码 = 原码");
System.out.println("--正数负数不能以对称的眼光来看");
System.out.println();
/*
下面代码long bigValue1是错的，系统不会把9999999999999当成long类型处理
因为当我们直接使用一个整数时，默认是int类型，取值只能在-2147483648~2147483647
但是该值超出int的表示范围，从而引起错误
如果想使用一个long型的整数，需要在整数后面加L或者l
*/
// long bigValue1 = 9999999999999;
long bigValue2 = 9999999999999L;
long bigValue3 = 9999999999999l;
System.out.println("--long bigValue2 = 9999999999999L = " + bigValue2);
System.out.println("--long bigValue3 = 9999999999999l = " + bigValue3);
System.out.println();
}
}程序代码如下：IntegerValTest.java
public class IntegerValTest
{
public static void main(String[] args)
{
// 下面代码是正确的，系统会自动把56当成byte类型处理
byte a = 56;
/*
下面代码是错的，系统不会把9999999999999当成long类型处理，
所以超出int的表数范围，从而引起错误
*/
// long bigValue = 9999999999999;
// 下面代码是正确的，在巨大的整数值后使用L后缀，强制使用long类型
long bigValue2 = 9223372036854775807L;
// 以0开头的整数值是8进制的整数
int octalValue = 013;
System.out.println(octalValue);
// 以0x或0X开头的整数值是16进制的整数
int hexValue1 = 0x13;
int hexValue2 = 0XaF;
System.out.println(hexValue1);
System.out.println(hexValue2);
// 定义二个8位的二进制数
int binVal1 = 0b11010100;
byte binVal2 = 0B01101001;
// 定义一个32位的二进制数,最高位是符号位。
int binVal3 = 0B10000000000000000000000000000011;
System.out.println(binVal1); // 输出212
System.out.println(binVal2); // 输出105
System.out.println(binVal3); // 输出-2147483645
/*
定义一个8位的二进制，该数值默认占32位，因此它是一个正数。
只是强制类型转换成byte时产生了溢出，最终导致binVal4变成了-23
*/
byte binVal4 = (byte)0b11101001;
/*
定义一个32位的二进制数,最高位是1。
但由于数值后添加了L后缀，因此该整数的实际占64位，第32位的1不是符号位。
因此binVal5的值等于2的31次方 + 2 + 1
*/
long binVal5 = 0B10000000000000000000000000000011L;
System.out.println(binVal4); // 输出-23
System.out.println(binVal5); // 输出2147483651
/* 上面程序中"long binVal5 = 0B10000000000000000000000000000011L"与"int binVal3 = 0B10000000000000000000000000000011"基本相同
* 只是在定义二进制整数时添加了"L"后缀，这就表明把它当成long类型，因此该整数实际占64位。此时的第32位不再是符号位，因此它依旧是一个正数
* 至于程序中的"byte binVal4 = (byte)0b11101001"，其中0b11101001依然是一个32位的正整数，只是程序进行强制类型转换时发生了溢出，导致它变成负数
*/
}
} int bva3 = 0B00000000000000000000000000000011;
int bva4 = 0B10000000000000000000000000000011;
bva3输出的是：3
bva4输出的是：-2147483645
数字在计算机里面是以补码的形式存在，负数补码 = 反码+1，正数补码 = 原码
正数负数不能以对称的眼光来看
二进制整数转换成十进制数
一个字符型
1）每个字符型的变量只能装一个字符。既可以是中文，也可以是英文，而且必须要用单引号括起来
2）字符型的值有3种表示方式：
1、直接通过单个字符来指定字符型值：‘a’，‘中’
2、通过转义字符表示特殊字符型值：‘\n’、‘\t’等
3、直接用Unicode的形式来表示来表示字符型值，格式是‘\uXXXX’，其中XXXX代表一个十六进制的整数。
3）每个字符占2个字节（16位）。一共2^16种状态，相当于可以表示2^16个字符。整个Java一共也就是支持2^16个字符。
字符型值也可以采用十六进制编码方式来表示，范围是‘\u0000’~‘\uFFFF’,一共可以表示65535个字符，其中前256个(‘\u0000’~‘\u00FF’)字符和ASCⅡ码中的字符完全重合。
由于计算机底层保存字符时，实际是保存该字符对应的编号，因此char类型的值也可以直接作为整数型值来使用，相当于一个16位的无符号整数，表数范围是0~65535。
字符型的变量作为“正整数”使用，最高位依然是数值。[0~2^16)
Java语言中常用的转义字符
程序代码如下：字符型Test.java
public class 字符型Test
{
public static void main(String[] args)
{
char c = 'a';
//char = '中国';
//错误，‘中国’是两个字符，char类型只能放一个字符
char c2 = '中';
System.out.println("--char类型的 c = 'a' :"+ c);
System.out.println("--char类型的 c2 = '中' :"+ c2);
System.out.println();
char rr = '\r';//相当于13
char nn = '\n';//相当于10
System.out.println("----------");
System.out.println("--char类型的 rr = '\\r' 相当于int类型的 '\\r' = "+ (int)rr);
System.out.println("--char类型的 nn = '\\n' 相当于int类型的 '\\n' = "+ (int)nn);
System.out.println("--此时的char类型的 rr + nn 相当于int类型的 '\\r' + '\\n' = "+ (rr + nn));//相当于13+10
System.out.println("==========");
System.out.println(rr);//输出转义字符\r
System.out.println(nn);//输出转义字符\n
System.out.println("----------");
char bb = '\b';//相当于键盘上的backspace
System.out.println(bb);
System.out.println(bb);
System.out.println(bb);
System.out.println("==========");
System.out.println();
System.out.println("将字符转化为整型使用");
char achar = 'a';//数值是97
char Achar = 'A';//数值是65
char zerochar = '0';//数值是48
System.out.println("--char类型的 (int)achar = "+ (int)achar);
System.out.println("--char类型的 (int)Achar = "+ (int)Achar);
System.out.println("--char类型的 (int)zerochar = "+ (int)zerochar);
System.out.println();
System.out.println("一个字符占16bit，因此可写成4位的16进制");
char ca = '\u0042'; // B
System.out.println("--char类型'\\u0042'= "+ ca);
System.out.println();
}
}
两个浮点型（支持小数）
float（4字节）、double（8字节）
1）浮点数有两种表示形式：
10进制形式： 5.12 .512（没有整数部分，0可以省略）
科学计数法： .12e4（（0.12）*10^4）
2）浮点数默认是double类型, 如果想使用一个float型的整数，需要在整数后面加F/f。故推荐使用double型浮点数。
3）浮点数有3个特殊值：
正无穷大：用正浮点数除以0就是正无穷大，所有正无穷大都相等。
负无穷大：用负浮点数除以0就是负无穷大，所有负无穷大都相等。
非数：用0.0除以0就是非数，非数与自己不相等。 double.NaN
程序代码如下：浮点数Test.java
class 浮点数Test
{
public static void main(String[] args)
{
double d = .512;
System.out.println("--double类型（10进制形式）的 d = .512 = "+ d );
double dd = .12e4; // 0.12 * 10^4 ;
System.out.println("--double类型（科学计数法形式）的 dd = .12e4 = "+ dd );
System.out.println();
float af = 5.2345556f;
System.out.println("--（值已经发生改变）float af = 5.2345556f = "+ af );
System.out.println();
//float f1 = 0.12;
//此时的0.12默认是double类型，所以会出错
//如果想使用一个float型的整数，需要在整数后面加F或者f
float f2 = 0.12f;
float f3 = 0.12F;
System.out.println("--float类型的 f2 = 0.12f = "+ f2 );
System.out.println("--float类型的 f3 = 0.12F = "+ f3 );
System.out.println();
double max1 = 0.5 / 0.0;
double max2 = 6.5 / 0.0;
System.out.println("正无穷大：用正浮点数除以0就是正无穷大，所有正无穷大都相等。");
System.out.print("max1（0.5 / 0.0）== max2 （6.5 / 0.0）：");
System.out.println(max1 == max2);
System.out.println();
double mix1 = -0.5 / 0.0;
double mix2 = -6.5 / 0.0;
System.out.println("负无穷大：用负浮点数除以0就是负无穷大，所有负无穷大都相等。");
System.out.print("mix1（-0.5 / 0.0）== mix2（-6.5 / 0.0）：");
System.out.println(mix1 == mix2);
System.out.println();
double nan1 = 0.0 / 0.0;
double nan2 = 0.0 / 0.0;
System.out.println("非数：用0.0除以0就是非数，非数与自己不相等。");
System.out.print("nan1（0.0 / 0.0）== nan2（0.0 / 0.0）：");
System.out.println(nan1 == nan2);
}
}
一个boolean型
只有两个值：true或false
8个基本类型 = 7个数值类型 + 1个boolean类型
其中7个数值类型为（4个整型、2个浮点型、char类型（字符型也是一种无符号整数类型，即正整数））
4. 基本类型的类型转换
Java是强类型的语言
1） 所有的变量，必须先声明，后使用。
2） 指定类型的变量，只能装相应类型的值。
Java的2种类型转换
1） 自动类型转换：表数范围小的，可以自动转换成表数范围大的。
直接写一个整数，默认是int型，但如果它的范围在byte、short表示范围之内，而且程序直接将该值赋给byte、short类型的变量，系统会自动把他当成byte、short用。
1、所有数值型，都可以自动转换成double类型。
2、所有数值型，除了double之外，都可以自动转换成float类型。
3、所有整型，都可以自动转换成long类型。
自动类型转换图
程序代码如下：自动转换.java
public class 自动转换
{
public static void main(String[] args)
{
double d = 34; //34默认是int型，int型可以自动转换成double型，因此是对的。
float ff = 12; //12默认是int型，int型可以自动转换成float型，因此是对的。
float f0 = '\u0078'; //'\u0078'默认是char型，char型可以自动转换成float型，因此是对的。
double dd = '\r'; //'\r'默认是char型，char型可以自动转换成double型，因此是对的。
int iVal = 'A'; //'A'默认是char型，char型可以自动转换成int型，因此是对的。
System.out.println("double d = 34；//34默认是int型，int型自动转换成double型。");
System.out.println("此时d = "+ d);
System.out.println("float ff = 12; //12默认是int型，int型可以自动转换成float型。");
System.out.println("此时ff = "+ ff);
System.out.println("float f0 = '\\u0078'; //'\\u0078'默认是char型，char型可以自动转换成float型。");
System.out.println("此时f0 = "+ f0);
System.out.println("double dd = '\\r'; //'\\r'默认是char型，char型可以自动转换成double型。");
System.out.println("此时dd = "+ dd);
System.out.println("int iVal = 'A'; //'A'默认是char型，char型可以自动转换成int型。");
System.out.println("此时iVal = "+ iVal);
}
} 2） 强制类型转换：当我们要把表数范围大的变量或值，转换成表数范围小的，就需要使用强制转换。
程序代码如下：强制转换.java
public class 强制转换
{
public static void main(String[] args)
{
double d = 34; //34默认是int型，int型可以自动转换成double型，因此是对的。
float fo = '\u0078'; //'\u0078'默认是char型，char型可以自动转换成float型，因此是对的。
double dd = '\r'; //'\r'默认是char型，char型可以自动转换成double型，因此是对的。
//相互转换
double de = fo; //由于fo是float型，float型可以自动转换为double型。
float ft = (float)d; //由于d是double型，double型不能自动转换为float型，因此需要强制转换。
char cr = (char)dd; //由于dd是double型，double型不能自动转换为char型，因此需要强制转换。
//强制转换可能丢失精度。
//short st = 33330;
//上面是错误的
short st = (short)33330; //33330默认是int型，int型不能自动转换为short型，因此需要强制转换。
byte bb = 12; // 12默认是int型，但是由于12在byte的表示范围之内，系统会自动把它当成byte处理。
int it = 233;
byte bt = (byte)it; //由于it是int型，int型不能自动转换为byte型，因此需要强制转换。
System.out.println("float fo = '\\u0078'; double de = fo; //由于fo是float型，float型可以自动转换为double型。");
System.out.println("此时de = "+ de);
System.out.println();
System.out.println("double d = 34; float ft = (float)d; //由于d是double型，double型不能自动转换为float型，因此需要强制转换。");
System.out.println("此时ft = "+ ft);
System.out.println();
System.out.println("double dd = '\\r';char cr = (char)dd; //由于dd是double型，double型不能自动转换为char型，因此需要强制转换。");
System.out.println("此时cr = "+ cr);
System.out.println();
System.out.println("short st = (short)33330; //33330默认是int型，int型不能自动转换为short型，因此需要强制转换。");
System.out.println("此时st = "+ st + "；精度丢失！");
System.out.println();
System.out.println("int it = 233; byte bt = (byte)it; //由于it是int型，int型不能自动转换为byte型，因此需要强制转换。");
System.out.println("此时bt = "+ bt);
}
}int it = 233;
byte bt = (byte)it; //由于it是int型，int型不能自动转换为byte型，因此需要强制转换。
int类型向byte类型强制类型转换
32位int类型的233在内存中如图所示，强制类型转换为8位的byte类型，则需要截断前面的24位，只保留右边8位，最左边的1是符号位，表明是一个负数，负数在计算机里是以补码的形式存在的，因此还需要换算成原码。
补码 – 1 = 反码 ， 反码取反 = 原码。
最后的二进制原码为10010111，这个byte类型的值为-（16+4+2+1） = -23
当把任何基本类型的值和字符串值进行连接运算时，基本类型的值将自动类型转换为字符串类型，虽然字符串类型不是基本类型，而是引用类型。因此，如果希望把基本类型的值转换为对应的字符串时，可以把基本类型的值和一个空字符串进行连接。
程序代码如下：PrimitiveAndString.java
public class PrimitiveAndString
{
public static void main(String[] args)
{
//下面的代码是错误的，因为5是一个整数，不能直接赋给一个字符串
//String str1 = 5;
//一个基本类型的值和字符串进行连接运算时，基本类型的值自动转换为字符串。
String str2 = 3.5f + "";
//下面输出3.5
System.out.println("String str2 = 3.5f + '' = "+ str2);
System.out.println();
//下面输出7Hello!，因为表达式先执行3 + 4得到7，然后进行7 + "Hello!"运算
//此时会把7当成字符串处理
System.out.print("3 + 4 + 'Hello!' = ");
System.out.println(3 + 4 + "Hello!" );
//下面输出Hello!34,因为"Hello!" + 3 会把3当成字符串处理
System.out.print("'Hello!' + 3 + 4 = ");
System.out.println("Hello!" + 3 + 4);
}
}程序代码如下：RangdomStr.java
import java.util.*;
public class RandomStr
{
public static void main(String[] args)
{
//控制代码循环6次
for (int i =0; i < 6 ; i ++ )
{
Random rand = new Random();//创建一个随机对象
int randNum = rand.nextInt(25);//生成0~25之间的随机数
System.out.print((char)(randNum + 65)); // 得到65~65+25之间的数值
}
}
} 易错代码：
直接把5.6赋值给float类型变量将出现错误，因为5.6默认是double
float a = 5.6;5.6默认是一个double类型的浮点数，因此将5.6赋值给一个float类型变量//将导致错误，必须使用强制类型转换才可以。
float a = (float)5.6;在通常情况下，字符串不能直接转换成基本类型，但是通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
String a = “45”; 使用Integer的方法将一个字符串转换成int类型
int iValue = Integer.parseInt(a);
boolean = > Boolean、byte = > Byte、short = > Short
int = > Integer、long = > Long、float = > Float、
double = > Double,
8个包装类都提供了一个parseXxx(String str)静态方法用于将字符串转换成基本类型
3） 表达式类型的自动提升。
规则：整个表达式的数据类型，与表达式中最高等级的的运算数的类型相同。
程序代码如下：自动提升.java
public class 自动提升
{
public static void main(String[] args)
{
byte bt = 2; //2是int型，由于2在byte范围，而且是直接赋整数值，系统会自动把他当成byte处理。
//bt = bt + 1;
//上面是错误的。1默认是int型，整个表达式的类型与1的类型相同，因此表达式的类型就提升成了int型，但是等号左边的bt依旧是byte型。
bt = (byte)(bt + 1); //需要强制转换。
System.out.println("byte bt = 2; bt = (byte)(bt + 1); ");
System.out.println("此时bt = "+ bt);
int a = 5;99
//a = (a + 20) / 2.5;
//上面是错误的。2.5默认是double型，整个表达式都被提升到double型。
a = (int)((a + 20) / 2.5); //需要强制转换。
System.out.println("int a = 5; a = (int)((a + 20) / 2.5); ");
System.out.println("此时 a = "+ a);
int it = 10;
it = 10 / 4; //it是int型，4也是int型，整个表达式依然是int型。
System.out.println("int it = 10; it = 10 / 4; //it是int型，4也是int型，整个表达式依然是int型。");
System.out.println("此时it = "+ it);
it = 10;
double du = it / 4; //it是int型，4也是int型，整个表达式依然是int型，但是du是double型。
System.out.println("int it = 10; double du = it / 4；//it是int型，4也是int型，整个表达式依然是int型，但是du是double型。");
System.out.println("此时du = "+ du);
}
}易错代码：
//输出字符串Hello!a7
System.out.println(“Hello!” + ‘a’+ 7);
//输出字符串104Hello!
System.out.println(‘a’+ 7 +“Hello!”); 对于第一个表达式，先进行“Hello!” + ‘a’运算，把‘a’转换成字符串，拼接成Heelo!a,再进行“Hello!a” + 7运算, 将变成两个字符串的拼接，得到结果是Hello!a7
第二个表达式，先进行‘a’ + 7运算,其中‘a’自动提升到int类型，变成a对应的ASCII值：97，相加等于104，然后进行107 + “Hello!”运算，104会自动转换成字符串，将变成两个字符串的拼接，得到104Hello!
直接量
8个基本数据类型，都可以指定直接量。
boolean类型，只有两个直接量：ture、false；
null直接量只能赋值给引用变量，用以表明这个引用类型变量中保存的地址为空，即还未指向任何有效对象，null直接量不能赋值给基本类型的变量。
5. 运算符
算数运算符
+、-、*、/、%、++、–（只能操作一个变量）
++、– 在变量之前：先操作变量，然后再拿来用
++、– 在变量之后：先拿来用，然后再操作变量
程序代码如下：算数运算符Test.java
public class 算数运算符Test
{
public static void main(String[] args)
{
int a = 4 + 2 / 4 + 3 * 2 - 6 % 4;
System.out.println("int a = 4 + 2 / 4 + 3 * 2 - 6 % 4 = "+ a);
int b = 3;
int c = a++ / ++b - a-- % b++ - --a / a-- * ++a / b--;
// c = 8 / 4 - 9 % 4 - 7 / 7 * 7 / 5
System.out.println("此时a = "+ a);
System.out.println("此时b = "+ b);
System.out.println("c = a++ / ++b - a-- % b++ - --a / a-- * ++a / b-- = "+ c);
System.out.println("即：c = 8 / 4 - 9 % 4 - 7 / 7 * 7 / 5 = "+ c);
}
}程序代码如下：MathTest.java
import java.util.*;
public class MathTest
{
public static void main(String[] args)
{
double a = 4;
double b = Math.pow(a , 5); //求a的5次方
double c = Math.sqrt(a); //求a的平方
double d = Math.random(); //返回一个0~1之间的随机数
double e = Math.sin(1.57); //求1.57的sin函数值
System.out.println("double a = 4;");
System.out.println("double b = Math.pow(a , 5) = "+ b);
System.out.println("double c = Math.sqrt(a) = "+ c);
System.out.println("double d = Math.random() = "+ d);
System.out.println("double e = Math.sin(1.57) = "+ e);
}
}程序代码如下：自加的陷阱Test.java
public class 自加的陷阱Test
{
public static void main(String[] args)
{
int c = 20;
c = c++;
//1、在使用变量 c 时会把c = 20 赋给临时变量 var = c = 20
//2、然后再对 c 进行 c++ = 21
//3、但最后是把临时变量的值赋值给等号左边的 c . 所以 c = 20
System.out.println("int c = 20;");
System.out.println("c = c++ = "+ c);
}
}
赋值运算符
扩展后的赋值运算符：赋值运算符可以与所有的双目运算符结合，就形成了扩展后的赋值运算符。
a+=b: 相当于 a =（a的类型）a+b；
a-=b: 相当于 a =（a的类型）a-b；
a*=b；相当于 a =（a的类型）a*b；
a/=b：相当于 a =（a的类型）a/b；
a%=b：相当于 a =（a的类型）a%b；
a&=b：相当于 a =（a的类型）a&b；
a|=b：相当于 a =（a的类型）a|b；
a~=b：相当于 a =（a的类型）a~b；
a^=b：相当于 a =（a的类型）a^b；
a<<=b：相当于 a =（a的类型）a<< b；
a>>=b：相当于 a =（a的类型）a>>b；
a>>>=b：相当于 a =（a的类型）a>>>b；
赋值语句本身有值，赋值语句的值就等于右边被赋的值
程序代码如下：扩展后的赋值运算符Test.java
public class 扩展后的赋值运算符Test
{
public static void main(String[] args)
{
byte a = 20; //20本身是int型，但由于是在-128~127之间，系统会自动把他当成byte型
//a = a + 2;
//以上错的，2是int型，表达式自动提升到int型
a += 2; //相当于 a = (byte)(a+2)
System.out.println("byte a = 20; a += 2; //相当于 a = (byte)(a+2)");
System.out.println("此时 a = "+ a);
System.out.println();
int b =3; // 相当于 b = 0b 00000011
b ^= 11; // 相当于b = b ^ 11 ，11的二进制码0b 00001011
// 计算结果等于0b 00001000
System.out.println("int b =3; b ^= 11;");
System.out.println("此时 b = "+ b);
}
}
位运算符
&：按位与。
|：按位或
~ ：按位非
^：按位异或
<< ：左移 在右边补0,。在没有数据溢出的前提下，左移N位也是乘以2的N次方
>>： 右移 在左边补符号位,。右移N位也是除以2的N次方
>>>：无符号右移
注意：
1、 对于低于int类型（如byte、short和char）的操作数总是自动类型转换成int类型后再移位的。
2、 对于int类型的整数移位a>>b，当b>32时，系统先用b对32求余（因为int类型只有32位），得到的结果才是真正移位的位数。例如：a>>33和a>>1的结果完全一样，而a>>32的结果跟a形同。
3、 对于long类型的整数移位a>>b，当b>64时，总是先用b对64求余（因为long类型是64位），得到的结果才是真正移位的位数。
4、 当进行位运算时，只要被移位的二进制码没有发生有效位的数字丢失（对于正数而言，通常被值移出的位全部都是0），可以发现，左移N位就相当于乘以2的n次方，右移N位就相当于除以2的n次方。不仅如此，进行移位位运算不会改变操作数本身，而是得到了一个新的运算结果。
程序代码如下：位运算符Test.java
public class 位运算符Test
{
public static void main(String[] args)
{
byte bt = 5;
byte be = 9;
System.out.println("byte bt = 5; byte be = 9;");
System.out.println("bt & be = "+ (bt & be));//只有上、下来两位都是1，才得到1
System.out.println("bt | be = "+ (bt | be));//只要上、下来两位有一个1，就可以得到1
System.out.println("bt ^ be = "+ (bt ^ be));//只要上、下来两位不一样，就可以得到1
System.out.println("~(-bt) = "+ ~(-bt));//按位取反（连符号位都会变掉）
System.out.println();
int a = -5;
a = -5 << 2 ; //左移N位,在没有发生数据溢出的前提下，相当于在右边补充N个0，也就是乘以2的N次方
System.out.println("int a = 5; a = 5 << 2 ;");
System.out.println("此时a = "+ a);
System.out.println();
//问：怎么把一个数，用最快的速度乘以8？
//答：左移3位即可。
//问：怎么把一个数，用最快的速度乘以128？
//答：左移7位即可。
int b = -5;
b = b >> 2;//右移N位，相当于截断右边N个位，也就是除以2的N次方
//当除不尽的情况，实际得到的整数总是比实际算数计算的值略小
System.out.println("int b = -5; b = b >> 2;");
System.out.println("此时b = "+ b);
System.out.println();
int c = -5;
c = c >>> 2; //会把负数变成正数
System.out.println("int c = -5; c = c >>> 2;");
System.out.println("此时c = "+ c);
System.out.println();
}
}
运算过程1
运算过程2
比较运算符
a>b：只有a>b，返回true，如果a< b，或a==b，返回false
a< b：只有a< b，返回true，如果a>b，或a==b，返回false
a>=b：只有a>b，或a==b，返回true，如果a< b，返回false
a<=b：只有a< b，或a==b，返回true，如果a>b，返回false
a==b：只有a==b，返回true，其他返回false
a!=b：只有a!=b，返回true，其他返回false
比较运算符的左右变量可以是：变量、直接量、表达式
程序代码如下：比较运算符Test.java
public class 比较运算符Test
{
public static void main(String[] args)
{
boolean bo = 5 >= 3;//5大于3或者5==3，都会返回true
System.out.println("boolean bo = 5 >= 3 : "+ bo);
boolean bn = 3 >= 5;//3大于5或者3==5，都会返回true
System.out.println("boolean bn = 3 >= 5 : "+ bn);
int a = 100;
int b = 20;
boolean b1 = (a = a + 2) >= (b = b * 6);
System.out.println("int a = 100; int b = 20;");
System.out.println("boolean b1 = (a = a + 2) >= (b = b * 6) = "+ b1);
System.out.println("此时 a = "+ a);
System.out.println("此时 b = "+ b);
}
}
逻辑运算符
左右变量可以是：变量、直接量、表达式
&&：两个操作数都是true时，返回true。只要一个是false，就会返回false。
&：不会短路 。
||： 只要一个操作数是true时，返回true。只要一个是true，就会返回true。
|： 不会短路。
！：取反。单目运算符，原来是true，变成false；原来是false，变成true。
^：异或。只有当两个操作数不同时，返回true。
程序代码如下：逻辑运算符Test.java
public class 逻辑运算符Test
{
public static void main(String[] args)
{
boolean bn = true && true;
System.out.println("boolean bn = true && true = "+ bn);
int a = 6;
boolean bo = (a++ >= 7) && (5 <= 20);
System.out.println("int a = 6;");
System.out.println("boolean bo = (a++ >= 7) && (5 <= 20) = "+ bo);
System.out.println("此时a = "+ a);
boolean ba = (a++ >= 7) || (5 <= 20);
System.out.println("boolean ba = (a++ >= 7) || (5 <= 20) = "+ ba);
System.out.println("此时a = "+ a);
System.out.println();
// 与运算，只要一个数是false，就直接返回false
//&&只要前一个数是false，根本不会去计算后一个操作数，直接返回false。
//但&无论前一个数是什么，依然会去算后一个操作数
int c = 10;
boolean bea = (5 <=1) && (c++ > 2);
System.out.println("int c = 10;");
System.out.println("boolean bea = (5 <= 1) && (c++ > 2) = "+ bea);
System.out.println("此时c = "+ c);
bea = (5 <=1) & (c++ > 2);
System.out.println("boolean bea = (5 <= 1) & (c++ > 2) = "+ bea);
System.out.println("此时c = "+ c);
// 或运算，只要一个数是true，就直接返回true
// || 只要前一个数是true，根本不会去计算后一个操作数，直接返回true。
// 但 | 无论前一个数是什么，依然会去算后一个操作数
int d = 5;
boolean boo = (5 <= 20) || (d++ > 100);
System.out.println("int c = 10;");
System.out.println("boolean boo = (5 <= 20) || (d++ > 100) = "+ boo);
System.out.println("此时d = "+ d);
boo = (5 <= 20) | (d++ > 100);
System.out.println("boolean boo = (5 <= 20) | (d++ > 100) = "+ boo);
System.out.println("此时d = "+ d);
System.out.println();
System.out.println("true ^ false : "+ (true ^ false));
System.out.println("true ^ true : "+ (true ^ true));
System.out.println("false ^ false : "+ (false ^ false));
System.out.println("false ^ true : "+ (false ^ true));
}
}
三目运算符
– 如果逻辑表达式返回true，整个表达式的值为表达式1的
– 如果逻辑表达式返回false，整个表达式的值为表达式2的
程序代码如下：三目运算符Test.java
public class 三目运算符Test
{
public static void main(String[] args)
{
int a = 100;
a = ((a *= 2) >= 200) ? a++ : a--;
//1、在使用变量 a 时会把a = 200 赋给临时变量 var = a = 200
//2、然后再对 a 进行 a++ = 201
//3、但最后是把临时变量的值赋值给等号左边的 a . 所以 a = 200
System.out.println("int a = 100;");
System.out.println("a = ((a *= 2) >= 200) ? a++ : a-- = "+ a);
}
}
运算符的优先级
运算符优先级
310
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
