本章目标：
● IDE的使用
● 注释
● 关键字
● 标识符
● Java变量
● Java 数据类型
● 条件运算符
● 控制语句
● 循环
● Java中的方法
IDE的使用
●
IDE(Integrated Development Environment )
集成开发环境
,
是用于提
供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器 和图
形用户界面等工具。
●
常用的
java
开发工具有
:
● IntelliJ IDEA
● Eclipse
注释
●
以某种特定符号作为标记
,
对程序功能的说明
,
程序在运行过程中不会执行注
释
.
● Java
语言有三种注释方式：
//
用于单行注释
,
快捷键
ctrl+/
/* */
用于多行注释
,
快捷键
ctrl+shift+/ ctrl+shift+\
取消注释
/** */
文档注释，用于为类
,
方法
,
属性 功能进行说明
,
可在调用时提示
,
以及
使用
javadoc
命令生成说明文档
关键字
●
关键字的定义和特点
●
定义：被
Java
语言赋予了特殊含义，用做专门用途的单词
●
特点：关键字中所有字母都为小写
●
关键字比较多，不需要死记硬背，学到哪里记到哪里即可
下面是现阶段我们需要认识和了解的关键字：
| 用于定义数据类型的关键字 | ||||
| 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 | |||
| 用于定义建立实例和引用实例，判断实例的关键字 | ||||
| new | this | super | instanceof | |
| 用于处理异常的关键字 | ||||
| try | catch | finally | throws | throw |
| 用于包的关键字 | ||||
| package | import | |||
| 其他修饰符关键字 | ||||
| native | strictfp | transient | volatile | assert |
| 用于定义数据类型值的字面值 | ||||
| ture | false | null | ||
说明：
关键字一共50个，其中const和goto是保留字。
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。
标识符
●
标识符： Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符.
●
技巧：凡是自己可以起名字的名称都可以叫标识符。
●
定义合法标识符规则(必须遵守的语法规则)：
●
由26个英文字母大小写，0-9 ，_或 $ 组成
●
数字不可以开头
●
不可以使用关键字和保留字，但能包含关键字和保留字
●
Java中严格区分大小写
●
长度无限制。
●
标识符不能包含空格
标识符的命名规范（建议遵守的`软性要求`，否则工作时容易被鄙视）:
注意：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”
●
类名、接口名：多单词组成时，所有单词的首字母大写： XxxYyyZzz
例如: HelloWorld String
●
变量名、方法名：多单词组成时，第一个单词首字母小写，第二 个单词开始每个单词首字母大
写：xxxYyyZzz
String userName = "Kobe";
int age = "20";
Java变量
●
变量是程序中最基本的存储单元，程序执行中数值是可变的
.
●
变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个 变量使
用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用
.
●
变量是通过使用变量名来访问这块区域的
.
●
其要素包括变量名，变量类型。
● Java
程序中每一个变量都属于特定的数据类型，在使用前必须对其声明，声明格式
为：
type varName
；
例如：
int i;
int i1, i2, i3;
int a = 0;//变量赋值Java数据类型
●
程序中对于每一种数据都定义了明确的具体数据类型，在内存中
分配了不同大小的内存空间。
●
整数类型
● Java
各整数类型有固定的表数范围和字段长度，其不受具体操作系统的
影响，以保证
Java
程序的可移植性。
| 类型 | 占用存储空间 | 表数范围 |
| byte | 1字节 | -128 ~ 127 |
| short | 2字节 | -2^(15) ~ 2^(15)-1 |
| int | 4字节 |
-2^(31) ～ 2^(31)-1
|
| long | 8字节 |
-2^(63) ～ 2^(63)-1
|
●
Java
语言的整型常量默认为
int
型，声明
long
型常量可以后加‘
l
’或‘
L
’
●
计算机存储单位
●
字节（
Byte
）：是计算机用于计量存储容量的基本单位，一个字节等于
8 bit
。
●
位（
bit
）：是数据存储的最小单位。二进制数系统中，每个
0
或
1
就是一个位，
叫做
bit
（比特），其中
8 bit
就称为一个字节
(Byte)
。
●
转换关系：
8 bit = 1 Byte
1024 Byte = 1 KB
1024 KB = 1 MB
1024 MB = 1 GB
1024 GB = 1 TB
●
浮点类型
●
与整数类型类似，
Java
浮点类型有固定的表数范围和字段长度，不受平台 影
响。
Java
浮点类型有两种表示形式
●
十进制数形式，例如
: 3.14 314.0
●
科学记数法形式，如
3.14e2 3.14E2
定义
float
类型的变量，赋值时需要以
f
或
F
作为后缀。
Java
的浮点型常量默认为
double
型。
float
：单精度，可以精确到
8
位有效数字。很多情况下，精度很难满足需求。
double
：双精度，精度是
float
的两倍。
●
浮点数的问题
在计算机中十进制整数可以很准确的转为二进制(采用除2取余方式).
但是十进制浮点数有时不能精确的转为二进制,只能是一个近似值.
在
java
中如果需要使用精确的小数计算
,
后期会讲到
BigDecimal
类型
.
●
逻辑型
boolean(
布尔
)
● boolean
类型适于逻辑运算，一般用于程序流程控制 。
● java
语言中
boolean
类型数据只允许取值
true
或
false
。
●
注意
:
不可以
0
或非
0
的整数替代
false
和
true
，这点和
C
语言不同。
●
字符型
char char
型数据用来表示一个单个字符
.
char
占
2
字节
.
用单引号括起来
例如：
char c1 = 'a';
char c2 ='
中
';
由于
java
底层使用
unicode
编码
,
所以可以涵盖世界上所有书面语的字符。
● char
运算
char
类型是可以运算的因为
char
在字符编码表中有对应的数值。
在
JAVA
中，对
char
类型字符运行时，直接当做对应编码表的整数来对待。
char c=
‘
a
’
+1;
先将’
a
’提升为
int
，计算结果
98
。
ASCII 码
●
ASCII(ASCII American Standard Code for Information Interchange，
美国 信息互换标准代码) 上个世纪60年代，美国制定了一套字符编码，对英语
字符与二进制位之间的关系， 做了统一规定。这被称为ASCII码。
●
ASCII码： 在计算机内部，所有数据都使用二进制表示。每一个二进制位（bit）
有 0 和 1 两种状 态，因此 8 个二进制位就可以组合出 256 种状态，这被称为
一个字（byte）。
●
ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制
00100000），大写的字母A是65（二进制01000001）。这128个符号（包括
32个不 能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位
统一规定为0。
●
缺点：不能表示所有字符。
Unicode
编码
● Unicode
：一种编码，将世界上所有的符号都纳入其中。这个编号范围
从
0x000000
到
0x10FFFF (
十六进制
)
，有
110
多万，每个字符都有
一个唯一的
Unicode
编号，这个编号一般写成
16
进制，在前面加上
U+
。
●
例如：“马”的
Unicode
是
U+9A6C,
可以换算为整数。
● Java
底层采用
unicode
编码来存储字符
.
java
数据类型
-String
● String
不是基本数据类型，属于引用数据类型
●
使用一对
""
来表示一个字符串，内部可以包含
0
个、
1
个或多个字符。
●
声明方式
:
例如：
String str =
“
abcd
”
;
String name =
“张三”
;
String
是
java
类库中提供的一个类
,
用类来当做字符串变量类型
.
运算规则
1.
任意八种基本数据类型的数据与
String
类型只能进行连接
“+”
运算，且结果一定
也是
String
类型
2.String
类型不能转为其他的基本类型
基本数据类型转换
●
在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的
值经常需要进行相互转换。
●
转换分为默认转换和强制转换
●
规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）
的类型 。
●
容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但可能造
成精 度降低或溢出；使用时要格外注意。
●
有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的
那一 种数据类型，然后再进行计算。
●
浮点数不是简单的直接表示大小，而是按照一定的标准分配的。
其中第
1
位，符号位，即
S
。
接下来的
8
位，指数域，即
E
。
剩下的
23
位，小数域，即
M
。
也就是说，浮点数在内存中的二进制值不是直接转换为十进制数值的，而是按照
上述公式计算而来，通过这个公式，虽然只用到了
4
个字节，但是浮点数却比长整型的
最大值要大。
●
V=(-1)^s * M * 2^E
运算符
| 分类 | 运算符 |
| 算术运算符 | +，-，*，/，%，++，-- |
| 赋值运算符 | =，+=，/=，*=，-=，%= |
| 比较（或关系）运算符 | >，<，<=，>=，==，!= |
| 逻辑运算符 | &，|，&&，||，^，! |
| 位运算符 | &，|，^，~，<<，>>，<<< |
| 条件运算符 | (条件表达式)?结果1:f结果2 |
算数运算表：
| 运算符 | 运算 | 范例 | 结果 |
| + | 正号 | +3 | 3 |
| - | 负号 | -5 | -5 |
| + | 加 | 5+5 | 10 |
| - | 减 | 10-3 | 7 |
| * | 乘 | 3*9 | 27 |
| / | 除 | 9/3 | 3 |
| % | 取模 | 7%5 | 2 |
| ++ ++ | 1.自增（前）：先运算，后取值 2.自增（后）：先取值，后运算 | 1.a=2,b=++a 2.a=2,b=a++ | 1.a=3,b=3 2.a=3,b=2 |
| -- -- | 1.自减（前）：先运算，后取值 2.自减（后）：先取值，后运算 | 1.a=2,b=--a 2.a=2,b=a-- | 1.a=1,b=1 2.a=1,b=2 |
| + | 字符串相加 | "i"+" love"+" u" | i love u |
| 运算符 | 运算 | 范例 | 结果 |
| == | 等于 | 4 = 4 | true |
| != | 不等于 | 4 != 5 | true |
| < | 小于 | 4 < 5 | true |
| > | 大于 | 4 > 5 | true |
| <= | 小于等于 | 4 <= 5 | true |
| >= | 大于等于 | 4 >= 5 | true |
| instanceof | 检查是否是类的对象 | "Kobe" instanceof String | true |
比较运算符的计算结果是boolean值，要么是真true，要么是假false
注意比较运算符不能误写为：=
逻辑运算符
●
逻辑运算符
:
● &—
逻辑与
| —
逻辑或 ！
—
逻辑非
● && —
短路与
|| —
短路或
^ —
逻辑异或
| a | b | a & b | a | b | !a | a^b | a&&b | a||b |
| true | true | true | true | false | false | true | true |
| true | false | false | true | false | true | false | true |
| false | true | false | true | true | true | false | true |
| false | false | false | false | true | false | false | false |
●
“
&
”和“
&&
”的区别：
单
&
时，左边无论真假，右边表达式都进行运算；
双
&
时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
|
”和“
||
”的区别同理，
||
表示：当左边为真，右边不参与运算。
建议：开发中，推荐使用
&& ||
int x = 1;
int y = 1;
if(x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);
int x = 1;
int y = 1;
if(x++ == 2 && ++y == 2){
x = 7;
}
System.out.println("x=" + x + ",y=" + y);
赋值运算符
●
符号：
=
●
当“
=
”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原
则进行处 理。
●
扩展赋值运算符：
+=, -=, *=, /=, %=
| 运算符 | 用法举例 | 等效的表达式 |
| += |
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
|
条件运算符
●
语法
:
(
条件表达式
)?
表达式
1
：表达式
2
；//如果为真则执行表达式1，为假则执行表达式2
如果运算后的结果赋给新的变量，要求表达式
1
和表达式
2
为同种或兼容的类型
位运算
日常开发中位运算使用相对较少，但是巧妙的使用位运算可以大量减少运行开
销， 优化算法
|
位运算符
| |
|
<<
| 空位补0，被移除的高位丢弃，空缺位补0。 |
| >> |
被移位的二进制最高位是0，右移后，空缺位补0；
最高位是1，空缺位补1。
|
| >>> | 被移位二进制最高位无论是0或者是1，空缺位都用0补。 |
| & | 二进制位进行&运算，只有1&1时结果是1，否则是0; |
| | | 二进制位进行 | 运算，只有0 | 0时结果是0，否则是1; |
| ^ |
相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
|
| ~ |
正数取反，各二进制码按补码各位取反
负数取反，各二进制码按补码各位取反
|
控制台输入
●
java提供Scanner类来实现从控制台向程序输入信息功能.
具体步骤
1. 导入使用的类：import java.util.Scanner;
2. 创建Scanner类型的对象：Scanner scan = new Scanner(System.in);
3. 调用Scanner类的相关方法,来获取指定类型的变量
next()方法用以 取得用户输入的字符串；
nextInt()将取得的输入字符串转换为整数类型；
nextFloat()转换成浮点型；
nextBoolean()转 换成布尔型。
例:System.out.print("请输入姓名");
Scanner scan = new Scanner(System.in);
String name= scan.next ();
System.out.println("姓名："+name);
控制语句
●
条件语句
-
根据不同条件，执行不同语句。
● if
● if .. else
● if .. else if
● if .. else if .. else if .. else
● switch
●
循环语句
–
重复执行某些动作
● for
● while
● do .. while;
if条件结构
●
if条件结构是根据条件判断之后再做处理
条件表达式必须是一个返回布尔结果的表达式。
语句可以是用{}包含的语句块
还有if(){}else{}结构
if-else语句的另一种形式为:
if (条件1){
语句1；
} else if (条件2){
语句2；
}……
}else if (条件N){
语句N；
}
switch
语句
switch语句：多分支选择语句，根据表达式的值，来执行多个操作中的一个。
switch
(表达式){
case
value1: 语句序列1;
[
break
];
…………
case
valueN: 语句序列N;
[
break
];
[
default
: 缺省语句;]
}
表达式可以是byte、short、int、char、枚举类型、String类型；
case语句后面只能使用常量表达式；
case后的值不能重复；
某个case分支如果没有提供break语句，则继续执行下一个case后的语句；
当表达式的值与任一case子句中的值都不匹配时，将执行default后面的语句；
如果没有default子句，则程序直接跳出switch语句。
switch
语句
●
case的穿透性
在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会
在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，执行终止。
●
if-else语句与switch-case语句比较
结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。
开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效
率稍高。
●
if-else语句优势
if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可
以用于等值的判断，使用范围更广。
switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表
达式的结果是否等于某个常量值，使用场景较狭窄。
●
switch语句优势
当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上
使用switch更多。因为`效率稍高`。当条件是区间范围的判断时，只能使用if语句
循环
●
循环语句功能
在某些条件满足的情况下，反复执行特定代码的功能
●
循环语句的四个组成部分
循环变量的初始化
循环条件部分
循环体部分
迭代部分
●
循环语句分类
while 循环
do/while 循环
for 循环
while & do while
语句
●
while 语句为如下形式：
初始化部分
while(逻辑表达式){
循环体
迭代部分
}
●
执行过程
先判断逻辑表达式的值。
若=true.则执行其后面的语句,然
后再次判断条件并反复执行，直
到条件不成立为止
●
while 语句为如下形式：
do { 语句; … ; } while(逻辑表达式)；
●
执行过程
先执行语句,再判断逻辑表达式的值,若
为true,再执行语句,否则结束循环。
for
循环语句
•
for 语句为如下形式：
for(表达式1; 表达式2; 表达式3){ 语句; … ; }
•
执行过程
首先计算表达式1，接着执行表达式2，若表达式2的值 = true，则执行循环语句，
接着计算表达式3，再判断表达式2的值；依此重复下去，直到表达式2的值=false
三种循环结构对比
三种循环结构都具有四个要素：
循环变量的初始化条件
循环条件
循环体语句块
循环变量的修改的迭代表达式
从循环次数角度分析
do-while循环至少执行一次循环体语句。
for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。
如何选择
遍历有明显的循环次数（范围）的需求，选择for循环
遍历没有明显的循环次数（范围）的需求，选择while循环
如果循环体语句块至少执行一次，可以考虑使用do-while循环
本质上：三种循环之间完全可以互相转换，都能实现循环的功能
break & continue
break
语句用于终止某个语句块的执行。用在
循环语句体中，可以强行退出循环；例如：
int stop = 4;
for (int i = 1; i <= 10; i++) {
//
当
i
等于
stop
时，退出循环
if (i == stop){
break;
}
System.out.println(" i= " + i);
}
i = 1
i = 2
i = 3
continue
语句用在循环语句体中，用于终止某
次循环过程，跳过循环体中
continue
语句下
面未执行的循环，开始下一次循环过程；例
如：
int skip = 4;
for (int i = 1; i <= 5; i++) {
//
当
i
等于
skip
时，跳过当次循环
if (i == skip){
continue;
}
System.out.println("i = " + i);
}
i = 1
i = 2
i = 3
i = 5
循环嵌套
•
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，
for ,while ,do…while均可以作为外层循环和内层循环。
•
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层
循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当
次循环，开始下一次的循环。
•
结束外层循环
•
如果需要从多层循环跳出，则需要使用标签，定义一个标签,如label，
然后在需要跳出的地方，用break label就行了.
Java中的方法
方法的引入
《街霸》游戏中，每次人物出拳、出脚或跳跃等动作都需要编写
50-80
行的代码，在每次出
拳、出脚或跳跃的地方都需要重复地编写这
50-80
行代码，这样程序会变得
`
很臃肿
`
，可读
性也非常差。
为了解决代码重复编写的问题，可以将出拳、出脚或跳跃的代码提取出来放在一个
{}
中，
并为这段代码起个名字，这样在每次的出拳、出脚或跳跃的地方通过这个名字来调用这个
{}
的代码就可以了。
上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，程序在需要出拳、出
脚或跳跃时调用该方法即可。
Java中的方法类似于其它语言的函数，方法是解决一类问题步骤的组合,表示一种功能和行为.
将功能封装为方法的目的是，可以`实现代码重用，减少冗余，简化代码`
Java里的方法`不能独立存在`，所有的方法必须定义在类里。
方法声明格式：
[访问权限修饰符 修饰符…] [返回值类型] 方法名(形式参数类型 参数名){
Java语句；… … …
[return 返回值;]
}
•
修饰符：这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
•
形式参数: 在方法被调用时用于接收外界输入的数据。
•
返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型void。
•
方法体：方法体必须有{}括起来，在{}中编写完成方法功能的代码
•
返回值：方法在执行完毕后返还给调用它的环境的数据。
•
实参：调用方法时实际传给方法的数据。
•
Java语言中使用下述形式调用方法：
类名/对象名.方法名(实参列表)
实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配，
return 语句终止方法的运行并指定要返回的数据。
return语句
return语句用于从当前执行的方法中退出, 返回到调用该方法的语句处继续执行。
有两种格式:
return 值; //将值返回,方法必须声明有返回值
return; //不返回任何值，表示终止方法执行,可以在声明为void的方法中使用
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
