本文详细介绍了Java编程中的关键字，包括数据类型、流程控制和访问修饰符等，以及常量、变量的定义和使用。同时，讲解了标识符的命名规则，并探讨了数据类型的转换。此外，还涵盖了运算符的种类和用法，以及流程控制结构如if语句、switch语句和循环结构。最后，提到了如何利用Scanner进行键盘输入，并给出了循环控制语句break和continue的使用示例。
Java 常量、变量与标识符
注释
- 单行注释
// 单行注释
- 多行注释
/*
多行注释
*/
- 文档注释
/**
文档注释
*/
关键字
关键字是被 Java 语言赋予特定含义的单词，组成关键字的字母全部小写
常见关键字：
- 用于定义数据类型的关键字
class、interface、enum、@interface
byte、short、int、long、char、float、double、boolean、void
- 用于定义数据类型值的关键字
true、false、null
- 用于定义流程控制的关键字
if、else、switch、case、default、for、while、do、break、conintue、return
- 用于定义访问权限修饰符的关键字
public、protected、private
- 用于定义类、函数、变量修饰符的关键字
abstract、final、static、synchronized
- 用于定义类与类之间关系的关键字
extends、implements
- 用于定义创建实例、引用实例、判断实例的关键字
new、this、super、instanceof
- 用于处理异常的关键字
try、catch、finally、throw、throws
- 用于包的关键字
package、import
- 用于其他的关键字
native、strictfp、transient、volatile、assert
常量
常量，程序执行过程中，其值不发生改变的量
包括字面值常量和自定义常量
字面值常量包括：字符串常量、整数常量、小数常量、字符常量、布尔常量（true 、 false）、空常量（null）
自定义常量：用 final 关键字修饰的量
变量
在程序执行的过程中，其值可以在某个范围内发生改变的量
变量的本质，是内存中的一小块区域
定义格式：
数据类型 变量名 = 初始化值;
数据类型的分类：
数据类型就是变量的变化范围，包括 基本数据类型（四类八种）、引用数据类型（对象类型）
- 基本数据类型
四类：整数类、小数类、字符类、布尔类
八种：byte（1个字节）、short（2个字节）、int（4个字节）、long（8个字节）、float（4个字节）、double（8个字节）、char（2个字节）、boolean（1个字节）
- 引用数据类型
数据类型的转换：
自动（隐式）类型转换：
小类型转大类型，自动提升为大类型，运算结果是大类型
强制（显示）类型转换：
手动将大类型转换为小类型，运算结果是小类型
转换格式：小类型 变量名 = （小类型）大类型数据;
当且仅当大类型数据可以转换为小类型数据时，才进行转换，否则会造成精度损失
自动类型转换顺序如下：
标识符
标识符，给类、方法、变量、常量等起名字的字符序列
组成部分：
英文大小写字母、数字、下划线（_）、美元符号（$）
定义规则：
- 不能以数字开头
- 不能是关键字
- 严格区分大小写
命名规范：
驼峰命名，见名知意
-
类和接口：首字母大写，如果有多个单词，每个单词首字母大写：
XxxYyyZzz -
变量和方法：首字母小写，如果有多个单词，从第二个单词开始首字母大写：
xxxYyyZzz -
常量名（自定义常量）：所有字母大写，多个单词用下划线（
_）分割 ：XXX_YYY_ZZZ -
包名：全部小写，如果多级，用点号（
.）隔开，遵循域名反写的格式：xxx.yyy.zzz
运算符
运算符，对变量和常量进行运算操作的符号
表达式，用运算符把常量或者变量连接起来的式子
表达式的类型为表达式运算结果的数据类型
常见运算符包括：
算术运算符、赋值运算符、关系运算符、逻辑运算符、三元运算符
算术运算符
用来进行算术运算的符号
/ ： 除法运算符，得到两个数据相除的商，Java 中整数除以整数结果还是整数
% ：取模（取余）运算，得到两个数据相除的余数
- 加法运算：
-
加号两边是数值型数据时，进行加法运算；当有字符型数据参与运算时，用该字符在计算机中所表示的数值进行运算
字符
'0'——'9'： 48 —— 57
字符'a'——'z'： 97 —— 122
字符'A'——'Z'： 65 —— 90 -
加号两边有任意一边是字符串时，进行字符串的拼接
-
自增（
++）和自减（--）：单独使用时，放在变量前后都一样；参与运算时，在变量前，先自增（减），再进行其他运算，在变量后，先以原值进行其他运算，再自增（减）
-
赋值运算符
包括基本运算符和扩展运算符
扩展运算符可以省略强制类型转换的操作
short s = 1; // s = s + 1; // 报错，默认 1 是 int 类型 s += 1; // 相当于 s = (short)(s + 1); System.out.println("s: " + s); // s: 2 -
关系运算符
关系运算符是用来描述两个变量之间的关系的，如，
>、<、==、!=、>=、<=其运算结果都是布尔类型，要么是
true， 要么是false -
逻辑运算符
&&：逻辑与
||： 逻辑或
!： 逻辑非 -
三目运算符
三目运算符，又叫 “三元运算符”，格式如下
（关系表达式）？表达式1：表达式2如果关系表达式结果为
true，运算后的结果是表达式1
如果关系表达式结果为false，运算后的结果是表达式2
流程控制
程序的结果与代码的执行顺序紧密相关，通过使用一些特定的语句控制代码的执行顺序从而完成特定的功能，这就是流程控制结构
流程控制结构包括：顺序结构、选择（判断）结构、循环结构
选择结构
根据不同的条件选择不同的代码来执行的代码结构
选择结构要先判断条件是否成立，条件成立则执行一部分代码，不成立则执行另一部分代码或者结束代码，因此，选择结构也叫做 判断结构
Scanner
Java 通过 Scanner 实现键盘录入
// 第一步：导包
import java.util.Scanner;
public class ScannerDemo {
public static void main (String[] args) {
// 第二步：创建录入对象
Scanner sc = new Scanner(System.in);
System.out.println("输入一个整数：");
// 第三步：接收数据
int i = sc.nextInt();
System.out.println("i = " + i);
}
}
if 语句
格式：
// 格式 1：
if (关系表达式) {
// 语句体
}
// 格式 2：
if (关系表达式) {
// 语句体 1
} else {
// 语句体 2
}
// 格式 3：
if (关系表达式 1) } {
// 语句体 1
} else if (关系表达式 2) {
// 语句体 2
} //...
else {
// 语句体 n+1
}
案例：
package cn.itcast.demo;
import java.util.Scanner;
public class FlowControlDemo {
public static void main(String[] args) {
// Scanner
// 1、导包
// 2、创建录入对象
// 3、接收数据
Scanner sc = new Scanner(System.in);
System.out.println("Please input the first: ");
int i = sc.nextInt();
System.out.println("Please input the second: ");
int j = sc.nextInt();
int res = i + j;
System.out.println("res = " + res);
/*
* 流程控制结构：顺序结构、选择（判断）结构、循环结构
*
* */
if (res > 20) {
System.out.println("res > " + 20);
}
if (res > 50) {
System.out.println("res > " + 50);
} else {
System.out.println("res < " + 50);
}
if (res > 200) {
System.out.println("res > 200");
} else if (res > 100) {
System.out.println("200 >= res > 100");
} else {
System.out.println("res <= " + 100);
}
System.out.println("end");
}
}
switch 语句
格式：
// 表达式的取值类型：byte、short、int、char、枚举、String
switch (表达式) {
case 值1：
语句体1；
break;
case 值2：
语句体2；
break;
// ...
default:
语句体n+1;
break;
}
案例：
Scanner sc = new Scanner(System.in);
System.out.println("Input a number : ");
int day = sc.nextInt();
switch (day) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("ThursDay");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
default:
System.out.println("Error");
break;
}
循环结构
循环结构，使一部分代码按照次数或者一定的条件反复执行的一种代码结构
for 循环
格式：
for (初始化语句; 判断条件语句; 控制条件语句) {
// 循环体
}
案例：
package cn.itcast.demo;
// break 在 switch 语句中，表示结束 switch 代码块
// 在 循环语句中，表示结束循环
// continue 用于循环语句，表示结束本次循环，继续下次循环
public class FlowControlDemo3 {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("Hello World ! " + i);
}
int sum = 0;
for (int i = 5; i > 0; i--) {
sum += i;
System.out.println("i = " + i);
}
// 水仙花数
int bit = 0;
int ten = 0;
int hundred = 0;
int iForCount = 0;
System.out.println("水仙花数 ： ");
for (int i = 100; i < 1000; i++) {
bit = i % 10;
ten = (i % 100) / 10;
hundred = i / 100;
int bit3 = bit * bit * bit;
int ten3 = ten * ten * ten;
int hundred3 = hundred * hundred * hundred;
if ( i == (bit3 + ten3 + hundred3)) {
iForCount++;
System.out.println(i);
}
}
System.out.println("水仙花数的数量 = " + iForCount);
}
}
while 循环
格式：
初始化语句; // 可省略
while (判断条件语句) {
循环体语句;
控制条件语句; // 可省略
}
案例：
System.out.println("----------while----------");
int j = 100;
int iWhileCount = 0;
while ( j < 1000) {
bit = j % 10;
ten = (j % 100) / 10;
hundred = j / 100;
int bit3 = bit * bit * bit;
int ten3 = ten * ten * ten;
int hundred3 = hundred * hundred * hundred;
if ( j == (bit3 + ten3 + hundred3)) {
iWhileCount++;
System.out.println(j);
}
j++;
}
System.out.println("水仙花数的数量 = " + iWhileCount);
do...while 循环
格式：
初始化语句;
do {
循环体语句;
控制条件语句;
} while (判断条件语句);
while小括号后的分号不可省略
do...while循环的循环体语句至少执行 1 遍
案例：
System.out.println("-------do-while--------");
int exerciseCount = 1;
boolean isOk = false;
do {
System.out.println(" exercising " + exerciseCount);
if (exerciseCount >= 3) {
isOk = true;
}
exerciseCount++;
} while (!isOk);
区别
A. 格式不同：
for循环各部分形成一个整体while和do...while的初始化语句与循环定义分离while和do...while的初始化语句、控制语句一般都会省略，而for循环一般不省略
B. 初始化语句不同：
- 定义位置不同
- 作用域不同：
for循环的初始化语句仅限于循环内使用；
while和do...while的初始化语句可以在循环外使用
C. 循环体执行次数不同：
for和while执行 0 − n 0 - n 0−n 次do...while执行 1 − n 1 - n 1−n 次，即，至少执行一次
D. 使用场景不同：
for和while可以互换，但是while的格式更加简洁- 仅当循环体至少需要执行一次时使用
do...while
两种简单的死循环
// for 循环
for (;;) {
// 循环体，根据实际需求结束循环
}
// while 循环
while (true) {
// 循环体，根据实际需要结束循环
}
break 和 continue
break 在 switch 语句中，表示结束 switch 代码块；
break 在循环语句中，表示结束循环
continue 用于循环语句，表示结束本次循环，继续下次循环
循环嵌套
在一个循环体语句中包含另一个循环语句时，称为循环嵌套
标号
标号，即是循环的名称
给循环定义一个标号，就可以根据需要结束或者跳转到指定循环，常用于多层嵌套循环中
格式：
标号:for() {} // while 和 do...while 类似
break 标号; // 结束指定标号的循环
continue 标号; // 跳转到指定标号的循环继续执行
案例：
public class FlowControlDemo4 {
public static void main(String[] args) {
/*
* 标号：for() {} or while {} or do {} while()
* break 标号; // 结束指定标号的循环
* continue 标号; // 跳转到指定标号的循环继续执行
* */
label_class: for (int i = 0; i < 3; i++) {
System.out.println("the class " + i + " - :");
for (int j = 0; j < 15; j++) {
System.out.println(i + " class's " + j + " stu");
if (i == 1 && j == 9) {
System.out.println("find");
break label_class;
// continue label_class;
}
}
System.out.println();
}
int OrangeNum = 0;
orange: for (int i = 0; i < 3; i++) {
for (int j = 0; j < 35; j++) {
if ( j % 5 == 0) {
System.out.println("had");
continue;
}
System.out.println("send " + i + " class's " + j);
OrangeNum++;
if (OrangeNum >= 100) {
break orange;
}
}
}
System.out.println(OrangeNum);
Random 类的简单使用
Random 即随机数，用于产生随机数的类
使用步骤：
- 导包
- 创建键盘录入对象
- 获取随机数
案例：
// 导包
import java.util.Random;
import java.util.Scanner;
public class FlowControlDemo4 {
public static void main(String[] args) {
// Random 类
// 使用一个类前，必须先创建对象
Random r = new Random();
for (int i = 1; i <= 10; i++) {
int number = r.nextInt(10); // 获取 0-9 之间 int 类型随机数
System.out.println(" number = " + number);
}
Random rd = new Random();
int goal = rd.nextInt(100) + 1;
Scanner sc = new Scanner(System.in);
int guass;
while (true) {
System.out.println("Please input your number: ");
guass = sc.nextInt();
if (guass > goal) {
System.out.println("it's bigger");
} else if(guass < goal) {
System.out.println("it's smaller");
} else {
System.out.println("Right");
break;
}
}
}
}
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
