JAVA基础知识（一）——Java语言描述、变量和运算符
@TOC(Java语言描述、变量和运算符)
一、JAVA语言描述
1.1 java语言描述
-
JDK、JRE、jVM三者之间的关系，以及JDK、JRE包含的主要结构有哪些？JDK=Jre +java的开发工具（javac.exe java.exe javadoc.exe）jre = jvm+java的核心类库
-
为什么要配置path环境变量？如何配置？
- 希望在任何目录下都可以执行java命令
cmd命令输入sysdm.cpl在path中配置JAVA_HOME:存储bin的上一层目录PATH = %JAVA_HOME%\bin
-
常用的几个命令行操作有哪些
cd md rd del cd .. cd /
-
java语言结构示意图
应用程序=算法 + 数据结构 -
java语言特点
-
面向对象性：
两个要素：类、对象三个特征：封装、继承、多态
-
健壮性 ：
- 去除了c语言中的指针
- 自动的垃圾回收机制（仍然会出现内存溢出、内存泄漏）
-
跨平台性
write once, run anywhere: 一次编译，到处运行
功劳归功于：JVM
-
-
编译过程
-
注释方式
-
java的三种注释方式
- 单行注释
- 多行注释
- 文档注释（java特有）
-
单行注释和多行注释的作用
- 对所写的程序进行解释说明，增强可读性。方便自己，方便别人。
- 调试所写的代码
-
特点
- 单行注释和多行注释，注释了的内容不参与编译。换几句话说，编译以后生成的.class结尾的字节码文件中不包含注释掉的信息。
-
文档注释的使用
- 注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
-
多行注释不可以嵌套使用
-
二、变量和运算符
1.1 关键字与保留字
- 关键字（keyword）的定义与特点
- 定义：被java语言赋予了特殊含义，用做专门用途的字符串（单词）
- 特点：关键字中所有字母都为小写
- 官方地址：https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html
| 用于定义数据类型的关键字 | ||||
|---|---|---|---|---|
| class | interface | enum | byte | short |
| int | long | float | double | char |
| boolean | void | |||
| 用于定义流程控制的关键字 | ||||
| if | else | switch | case | default |
| while | do | for | break | continue |
| return | ||||
| 用于定义访问权限修饰符的关键字 | ||||
| private | protected | public | ||
| 用于定义类、函数、变量修饰符的关键字 | ||||
| abstract | final | static | synchronized | |
| 用于定义类与类之间关系的关键字 | ||||
| extends | implements | static | ||
| 用于定义建立实例及引用实例，判断实例的关键字 | ||||
| new | this | super | instanceof | |
| 用于异常处理的关键字 | ||||
| try | catch | finally | throw | throws |
| 用于包的关键字 | ||||
| package | import | |||
| 其他修饰符的关键字 | ||||
| native | strictfp | transient | volatile | assert |
| 用于定义数据类型值的字面值 | ||||
| true | false | null | ||
true、false、null 严格意义上并不算是关键字、但是定义变量上还要避免使用它
- Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些
保留字 goto、const。
1.2 标识符（Identifier）
- 标识符：
- Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符。
- 技巧： 凡是自己可以起名字的地方都叫标识符
- 定义合法标识符规则：
由26个英文字母大小写，0-9，_或$组成。数字不可以开头。不可以使用关键字和保留字，但能包含关键字和保留字。Java中严格区分大小写，长度无限制。标识符不能包含空格
**不遵守规则编译不通过**
1.3 Java中的名称命名规范(建议)
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开发每个单词首字母大写：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
2.1 变量
- 变量的概念：
- 内存中的一个存储区域
- 该区域的数据可以在同一类型范围内不断变化
- 变量是程序中最基本的存储单元。包含
变量类型、变量名和存储的值。
- 变量的作用：
- 用于在内存中保存数据
- 使用变量注意
- Java中每个变量必须先声明，后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对{}内
- 变量只有在其作用域内才有效
- 同一个作用域内，不能定义重名的变量
- 变量的分类
- 定义：对于每一种数据都定义了明确的具体数据类型（强类型语言），在内存中分配了不同大小的内存空间。
补充：变量的分类-按声明的位置的不同
- 在方法体外，类体内声明的变量称为
成员变量 - 在方法体内部声明的变量称为
局部变量。
- 注意：二者在初始化值方面的异同
- 同：都有生命期 异：局部变量除形参外，需显示初始化。
2.2 变量整数类型
- 整数类型： byte、short、int、long
- Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
- java的整型变量默认为int型，声明long型常量须后加‘I’或‘L’
- java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| byte | 1字节=8bit位 | -128~127 |
| short | 2字节 | -2^15 ~ 2^15-1 |
| int | 4字节 | -2^31 ~ 2^31-1（约21亿） |
| long | 8字节 | -2^63 ~ 2^63-1 |
500MB 1MB = 1024KB 1KB=1024B B=byte bit
bit:计算机中的最小存储单位。 byte：计算机中基本存储单位。
- 变量在类中声明的位置
/**
* 成员变量vs局部变量
*/
class VariableTest1 {
public static void main(String[] args) {
//1.byte范围 -128~127
byte b1= 12;
byte b2 = -128;
//b2= 128;//编译失败 从int转换到byte可能会有损失
System.out.println(b1);
System.out.println(b2);
}
}
2.3 浮点类型：float、double
- 与整数类型类似，Java浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。
- 浮点型常量有两种表示形式：
- 十进制数形式：如：5.12 512.0f .512(必须有小数点)
- 科学计数法形式：如5.12e2 512E2 100E-2
- float：单精度，
尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。 - double: 双精度，精度是float的两倍。通常采用此类型。
- Java的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度float | 4字节 | -3.403E38~3.403E38 |
| 双精度double | 8字节 | -1.798E308~1.798E308 |
//2.声明long型变量，必须以"l"或"L"结尾
//3.通常，定义整型变量时，使用int型。
short s1 =128;
int i1 = 1234;
long l1 = 3114234324L;
System.out.println(l1);
//2. 浮点型：float(4字节) \double(8字节)
//1) 浮点型,表示带小数点的数值
//2) float表示数值的范围比long还大
double d1 = 123.3;
System.out.println(d1 + 1);
//3. 定义float类型变量时，变量要以"f"或"F"结尾
float f1 = 123.4F;
System.out.println(f1);
注意：通常，定义浮点型变量时，默认使用double型。
2.4 字符类型：char
-
char型数据用来表示通常意义上
“字符”(2字节) -
java中的所有字符都是用
Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。 -
字符型变量的三种表现形式
- 字符常量是用单引号（‘’）括起来的单个字符。例如：char c1 = ‘a’; char c2 = ‘中’;char c3 = ‘9’;
- Java中还允许使用转义字符’'来将其后的字符转变为特殊字符型常量。例如：char c3= ‘\n’; //‘\n’ 表示换行符
- 直接使用
Unicode值表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a表示\n。 - char类型是可以进行运算的。因为它都对应有
Unicode码。
| 转义字符 | 说明 |
|---|---|
| \b | 退格符 |
| \n | 换行符 |
| \r | 回车符 |
| \t | 制表符 |
| \" | 双引号 |
| \’ | 单引号 |
| \\ | 反斜线 |
//
char c1= 'a';
//c1 = 'AB';//编译失败 错误: 未结束的字符文字
System.out.println(c1);
char c2 = '1';
char c3 = '中';
char c4 = '@';
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
char c5 = '\n';
System.out.println(c5);
char c6 = '\t';
System.out.println(c6);
char c7 = '\u0043';
System.out.println(c7);
2.5 了解ASCII码
-
在计算机内部，所有数据都使用
二进制表示。每一个二进制位（bit）有0和1两种状态，因此8个二进制位就可以组合出256种状态，这就称为一个字节（byte）。一个字节一共可以用来表示256种不同的状态，每一个状态一应一个符号，就是256个符号，从0000000到1111111。 -
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码。ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000）,大写的字母A是65（二进制01000001）。这
128个符号(包括32个不能打印出来的控制符号)，只占用了一个字节的后面7位，最前面的1位统一规定为0。 -
缺点
- 不能表示所有字符。
- 相同的编码表示的字符不一样：比如 130在法语编码中代表了ě,在希伯来语编码中却代表了字母Gimel(λ)
2.6 Unicode编码
- 乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误方式解读，就会出现乱码。
- Unicode：一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用Unicode没有乱码的问题。
- Unicode的缺点：Unicode只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储：无法区别Unicode和ASCII;计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储空间来说是极大地浪费。
2.7 UTF-8
-
UTF-8是在互联网上使用最广的一种Unicode的实现方式。
-
UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
-
UTF-8的编码规则：
- 对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码）。
- 对于多字节的UTF-8编码，如果编码包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0，该字节剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为“10”,其余6位用来对字符进行编码。
2.8 boolean布尔型
//布尔型
//1、只能取两个值之一：true false
//2、常常在条件判断、循环结构中使用
boolean bb1 = true;
System.out.println(bb1);
boolean isMarried = true;
if (isMarried) {
System.out.println("你就不能参加\"单身\"party了！\\n很遗憾");
} else {
System.out.println("你可以多谈谈女朋友！");
}
2.9 类型装换
2.9.1 自动类型提升
byte b1 = 2;
int i1 = 129;
//byte b2 = b1 + i1; //编译不通过 错误: 不兼容的类型: 从int转换到byte可能会有损失
int i2 = b1 + i1;
long l1 = b1 + i1;
System.out.println(i2);//131
float f= b1 + i1;//float的精度大于long 131.0
System.out.println(f); //131.0
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte、char、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型。(原因可能他们之间做运算可能会超过其精度)
2.9.2 强制类型转换
- 需要使用强转符：（）
- 注意点：强制类型转换，可能导致精度损失
double d1 = 12.9;
int i1 = (int)d1;//截断操作
System.out.println(i1);
//没有精度损失
long l1 = 123;
short s2 = (short)l1;
//精度损失举例2
int i2 = 128;//1000 0000
byte b = (byte)i2;
System.out.println(b); //-128 （1000 0000 byte字节-128的补码）
2.10 字符串类型
- String不是基本数据类型，属于引用数据类型
- 使用方式与基本数据类型一致。例如：String str = “abcd”;
- 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：str = str + “xyz”; int n =100; str = str + n;
- 基本数据类型与String之间的转换
char c = 'a'; //a 97
int num =10;
String str= "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
2.11 关于进制
-
所有数字在计算机底层都以
二进制形式存在 -
对于整数，有四种表示方式
- 二进制（binary）:0,1 满2进1,以0b或0B开头。
- 十进制（decimal）:0-9 满10进1。
- 八进制（octal）: 0-7 满8进1 以数字0开头表示。
- 十六进制（hex）:0-9及A-F，满16进1。以0x或0X开头表示。此处的A-F不区分大小写。 如：0x21AF+1=0X21B0
-
进制图表
| 十进制 | 十六进制 | 八进制 | 二进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 2 | 2 | 10 |
| 3 | 3 | 3 | 11 |
| 4 | 4 | 4 | 100 |
| 5 | 5 | 5 | 101 |
| 6 | 6 | 6 | 110 |
| 7 | 7 | 7 | 111 |
| 8 | 8 | 10 | 1000 |
| 9 | 9 | 11 | 1001 |
| 10 | A | 12 | 1010 |
| 11 | B | 13 | 1011 |
| 12 | C | 14 | 1100 |
| 13 | D | 15 | 1101 |
| 14 | E | 16 | 1110 |
| 15 | F | 17 | 1111 |
| 16 | 10 | 20 | 10000 |
| 17 | 11 | 21 | 10001 |
-
进制运算
-
变量之进制
-
Java整数常量默认是int类型，当用二进制定义整数时，其第32位是符号位；当是long类型时，二进制默认为占64位，第64位是符号位。
-
二进制的整数有如下三种形式：
- 原码：直接将一个数值换成二进制数。最高位是符号位
- 负数的反码：是对原码按位取反，只是最高位（符号位）确定为1
- 负数的补码：其反码加1.
-
计算机以二进制补码的形式保存所有的整数
- 正数的原码、反码、补码都相同
- 负数的补码是其反码+1
-
3.1 运算符
-
运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
- 算数运算符
- 赋值运算符
- 比较运算符（关系运算符）
- 逻辑运算符
- 位运算符
- 三元运算符
3.1.1 运算符：算数运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| + | 正号 | +3 | 3 |
| - | 负号 | b=4;-b | -4 |
| + | 加 | 5+5 | 10 |
| - | 减 | 6-4 | 2 |
| * | 乘 | 3*4 | 12 |
| / | 除 | 5/5 | 1 |
| % | 取模（取余） | 7%5 | 2 |
| ++ | 自增（前）；先运算后取值 | a=2;b=++a; | a=3;b=3 |
| ++ | 自增（后）；先取值后运算 | a=2;b=a++; | a=3;b=2 |
| – | 自减（前）；先运算后取值 | a=2;b=–a; | a=1;b=1 |
| – | 自减（后）；先取值后运算 | a=2;b=a–; | a=1;b=2 |
| + | 字符串连接 | “He” + “llo” | “Hello” |
- 注意点
short s1 = 10;
//s1 = s1 + 1;编译失败 （自动向上转型为int）
s1 = (short)(s1+1);//正确的
s1++;//自增1不会改变本身变量的数据类型
byte bb1 = 127;
bb1++;
System.out.println("bb1= " + bb1);//127 二进制对应为01111111 增加1 为10000000 最高位为符号位所以 该二进制为-128
3.1.2 运算符：赋值运算符
-
符号：=
- 当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
- 支持连续赋值。
-
扩展赋值运算符： +=，-=， *=，/=, %=
int i2, j2;
i2 = j2 = 10;
int i3 = 10, j3 = 10;
//思考1：
short s =3;
//s = s+2;//编译失败
s +=2;//不会进行类型的变化
//思考2
int i =1;
i*=0.1;
System.out.println("i = " + i);//因为1*=0.1 没有进行自动类型提升所以 i取整为0
i++;
System.out.println("i = " + i);
//结果
// i = 0
// i = 1
//思考3
int m = 2;
int n =3;
n*=m++;
System.out.println("m = " + m);//3
System.out.println("n = " + n);//6
//结果
// m = 3
// n = 6
//思考4：
int n =10;
n += (n++) + (++n);// n = n + (n++) + (++n) ===> n = 10 + 10 + 12
System.out.println("n = " + n);//32
3.1.3 运算符：比较运算符
| 运算符 | 运算 | 范例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | false |
| != | 不等于 | 4 != 3 | true |
| < | 小于 | 4<3 | false |
| > | 大于 | 4>3 | true |
| <= | 小于等于 | 4<=3 | false |
| >= | 大于等于 | 4>=3 | true |
| instancof | 检查是否是类的对象 | “Hello" instanceof String | true |
- 比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符“==” 不能语写成“=”
int i = 10;
int j = 20;
System.out.println(i == j);//false
System.out.println(i = j);//20
3.1.4 运算符：逻辑运算符
- &——逻辑与 |——逻辑或 ！—— 逻辑非
- &&——短语与 ||——短路或 ^——逻辑异或
| a | b | a&b | a&&b | a|b | a||b | !a | a^b |
|---|---|---|---|---|---|---|---|
| true | true | true | true | true | true | false | false |
| true | false | false | false | true | true | false | true |
| false | true | false | false | true | true | true | true |
| false | false | false | false | false | false | true | false |
- 练习题
//题目一
int x =1;
int y = 1;
if (x++==2 & ++y ==2) {
x = 7;
}
System.out.println("x = " + x + ",y="+ y);//x = 2,y=2
//题目二
int x =1, y = 1;
if (x++==2 && ++y ==2) {
x = 7;
}
System.out.println("x = " + x + ",y="+ y);//x=2,y=1
//题目三
int x =1;
int y = 1;
if (x++==1 | ++y ==1) {
x = 7;
}
System.out.println("x = " + x + ",y="+ y);//x=7 y=2
//题目四
int x =1, y = 1;
if (x++==1 || ++y ==1) {
x = 7;
}
System.out.println("x = " + x + ",y="+ y);//x=7,y=1
boolean x = true;
boolean y = false;
short z = 42;
//if (y==true)
if ((z++==42) && (y=true))z++; //42 43 44
if ((x=false)||(++z==45))z++;//46
System.out.println("z = " + z);//46
}
3.1.5 运算符：位运算符
与运算 有0则0 或运算 有1 则1
/**
* 结论：
* 1、位运算符操作的都是整形的数据。
* 2、 <<：在一定范围内，每向左移动一位，相当于 *2
* >>：在一定范围内，每向右移动一位，相当于 /2
*/
public class OperatorTest {
public static void main(String[] args) {
int i = 21;
System.out.println("i << 1 : " + (i << 1));//42
System.out.println("i << 1 : " + (i << 2));//84
System.out.println("i << 27 : " + (i << 27));//-1476395008
int j = -21;
System.out.println("j << 1 : " + (j << 1));//-42
System.out.println("j << 2 : " + (j << 2));//-84
//面试题：最高效方式的计算 2 * 8？
// 2 << 3 或者 8 << 2
}
}
3.1.6 运算符：三元运算符
-
格式:
- (条件表达式)?表达式1：表达式2；
- 为true，运算后的结果是表达式1；
- 为false，运算后的结果是表达式2；
- 表达式1和表达式2为同种类型
-
三元运算符与if-else的联系与区别：
- 1）三元运算符可简化if-else语句
- 2）三元运算符要求必须返回一个结果。
- 3）if后的代码块可有多个语句
-
三元运算符的使用
/**
* 运算符之六：三元运算符
* 1、结构：(条件表达式) ? 表达式一 : 表达式二。
* 2、说明：
* （1）条件表达式的结果为boolean类型。
* （2）根据条件表达式真或假，决定执行表达式1，还是表达式2。
* 如果表达式结果为true，则执行表达式1。
* 如果表达式结果为false，则执行表达式2。
* (3)表达式1和表达式2要求是一致的。
* (4)三元运算符可以嵌套使用。
*
* 3、凡是可以使用三元运算符的地方，都可以改写为if-else。
* 反之，不成立。
*
* 4、如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符。原因：简洁、执行效率高。
*
*/
public class OperatorTest {
public static void main(String[] args) {
//获取两个整数的较大值
int a = 1;
int b = 2;
int max = (a > b) ? a : b;
System.out.println("a: " + a);
System.out.println("b: " + b);
System.out.println("较大值为: " + max);
// (a > b) ? 1 : "hello"; 编译不通过
String maxStr = (a > b) ? "a大" : ((a == b) ? "a和b相等" : "b大");
System.out.println(maxStr);
//获取三个数的较大值
int i = 1;
int j = 2;
int k = 3;
int temp = (i > j) ? i : j;
temp = (temp > k) ? temp : k;
System.out.println("最大的数为：" + temp);
}
}
3.1.7 运算符：运算符优先级
- 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如上表，上一行运算符总优先于下一行。
- 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。