@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 运算符:运算符优先级
- 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序。如上表,上一行运算符总优先于下一行。
- 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。