tips: 下一篇基础知识请点击链接
Java的概念
- Java是一个面向对象的高级编程语言。Java代码看起来很容易理解,像人类的自然语言。
- Java程序并非是直接运行的,Java编译器将Java源程序编译成与平台无关的字节码文件(class文件),然后由Java虚拟机(JVM)对字节码文件解释执行。所以在不同的操作系统下,只需安装不同的Java虚拟机即可实现Java程序的跨平台。
- Java适合做互联网web相关项目。(京东、淘宝等)
- JDK、JRE、JVM各自的作用和关系:
: JVM(Java Virtual Machine),Java虚拟机,真正运行Java程序的地方。
: JRE(Java Runtime Environment),Java运行环境,包含了JVM和Java的核心运行类库。
: JDK(Java Development Kit)称为Java开发工具集,包含了JRE和开发工具。
: 我们想要运行一个已有的Java程序,那么只需安装JRE即可,我们想要开发一个全新的Java程序,那么必须安装JDK。三者关系:JVM<JRE<JDK。
常用的DOS命令
在接触集成开发环境之前,我们需要使用命令行窗口对Java程序进行编译和运行,所以知道一些常用的DOS命令。
- 打开命令行窗口的方式:按下Windows+R键盘库,打开运行窗口,输入cmd回车,进入到DOS的操作窗口。
- 常用DOS命令:
操作 | 说明 |
---|---|
盘符名称: | 盘符切换。E:回车,表示切换到E盘 。 |
dir | 查看当前路径下的内容。 |
cd 目录 | 进入单级目录。 |
cd … | 回退到上一级目录。 |
cd目录1\目录2… | 进入多级目录。 |
cd \ | 回退到盘符目录。 |
cls | 清屏。 |
exit | 退出命令提示符窗口。 |
HelloWorld案例
- Java程序开发运行流程
开发Java程序,需要三个步骤:编写程序,编译程序,运行程序。 - HelloWorld案例的编写
: 新建文本文档文件,修改名称为HelloWorld.java。
: 用记事本打开HelloWorld.java文件,输写程序内容。
public class HelloWorld{
public static void main(String[] args){
System.out.println("HelloWorld");
}
}
- HelloWorld案例的编译和运行
存文件,打开命令行窗口,将目录切换至java文件所在目录,编译java文件生成class文件,运行class文件。
: 编译:javac 文件名.java
: 范例:javac HelloWorld.java
: 执行:java 类名
: 范例:java HelloWorld - 关于main方法
: 固定格式不能写错。
: 称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点,无论我们编写多少程序,JVM在运行的时候,都会从main方法这里开始执行。
Java基础语法
注释
注释是对代码的解释和说明文字,可以提高程序的可读性,因此在程序中添加必要的注释文字十分重要。Java中的注释分为三种:
- 单行注释。单行注释的格式是使用//,从//开始至本行结尾的文字将作为注释文字。每个单行注释只能注释一行注释信息。
// 这是单行注释文字
- 多行注释。多行注释的格式是使用/和/将一段较长的注释括起来。多行注释可以注释多行注释信息。
/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
- 文档注释。文档注释以/*开始。以/结束。文档注释也可以注释多行信息。
/** 描述
* @author xxx
* @version x.x
*/
关键字
- 关键字是指被java语言赋予了特殊含义的单词。
- 关键字的特点:
: 关键字的字母全部小写。
: 常用的代码编辑器对关键字都有高亮显示,比如现在我们能看到的public、class、static等。
常量
- 在程序运行过程中,其值不可以发生改变的量。
- 常量分为:整数常量、小数常量、字符常量、字符串常量、布尔常量、空常量。
类型 | 含义 | 数据举例 |
---|---|---|
整数常量 | 所有的整数 | 0,1,567,-9 |
小数常量 | 所有的小数 | 0.0,-0.1,2.55 |
字符常量 | 必须用单引号引起来,有且只有一个字符 | ‘a’,’ ',‘好’ |
字符串常量 | 必须用双引号引起来,多个或不写 | “A”,“你好”," " |
布尔常量 | 只有两个值 | true,false |
空常量 | 只有一个值 | null |
数据类型
计算机存储单元
我们知道计算机是可以用来存储数据的,但是无论是内存还是硬盘,计算机存储设备的最小信息单元叫“位(bit)”,我们又称为“比特位”,通常用小写的字母“b”表示。而计算机最基本的存储单元叫“字节(byte)”,通常用大写字母“B”表示,字节是由连续的8个位组成。除了字节外还有一些常用的存储单位,其换算单位如下:
1B(字节)= 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
Java中的数据类型
- Java是一个强类型语言,Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。
- Java中的基本数据类型:
数据类型 | 关键字 | 内存占用 | 取值范围 |
---|---|---|---|
整数 | byte | 1 | 负的2的7次方~2的7次方-1(-128~127) |
short | 2 | 负的2的15次方~2的15次方-1(-32758~32767) | |
int | 4 | 负的2的31次方~2的31次方-1 | |
long | 8 | 负的2的63次方~2的63次方-1 | |
浮点数 | float | 4 | 1.401298e-45~3.402823e+38 |
double | 8 | 4.9000000e-324~1.797693e+308 | |
字符 | char | 2 | 0-65535 |
布尔 | boolean | 1 | true,false |
说明:
e+38表示是乘以10的38次方,同样,e-45表示乘以10的负45次方。
在java中整数默认是int类型,浮点数默认是double类型。
变量
变量的定义
- 变量:在程序运行过程中,其值可以发生改变的量。从本质上讲,变量是内存中的一小块区域,其值可以在一定范围内变化。
- 变量的定义格式:
数据类型 变量名 = 初始化值; // 声明变量并赋值
int age = 18;
System.out.println(age);
或者
// 先声明,后赋值(使用前赋值即可)
数据类型 变量名;
变量名 = 初始化值;
double money;
money = 55.5;
System.out.println(money);
还可以在同一行定义多个同一种数据类型的变量,中间使用逗号隔开。但不建议使用这种方式,降低程序的可读性。
int a = 10, b = 20; // 定义int类型的变量a和b,中间使用逗号隔开
System.out.println(a);
System.out.println(b);
int c,d; // 声明int类型的变量c和d,中间使用逗号隔开
c = 30;
d = 40;
System.out.println(c);
System.out.println(d);
- 变量的使用:通过变量名访问即可。
使用变量时的注意事项
- 在同一对花括号中,变量名不能重复。
- 变量在使用之前,必须初始化(赋值)。
- 定义long类型的变量时,需要在整数的后面加L(大小写均可,建议大写)。因为整数默认是int类型,整数太大可能超出int范围。
- 定义float类型的变量时,需要在小数的后面加F(大小写均可,建议大写)。因为浮点数的默认类型时double,double的取值范围是大于float的,类型不兼容。
标识符
标识符的定义
标识符是用户编程时使用的名字,用于给类、方法、变量、常量等命名。
Java中表示符的组成规则
- 由字母、数字、下划线“_”、美元符号“$”组成,第一个字符不能是数字。
- 不能使用java中的关键字作为标识符。
- 标识符对大小写敏感(区分大小写)。
Java中标识符的命名约定
- 小驼峰式命名:变量名、方法名。首字母小写,从第二个单词开始每个单词的首字母大写。
- 大驼峰式命名:类名。每个单词的首字母都大写。
- 另外,标识符的命名最好可以做到见名知意,例如:username、studentNumber等。
类型转换
类型转换的定义
在Java中,一些数据类型之间是可以相互转换的。分为两种情况:自动类型转换和强制类型转换。
自动类型转换
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的,直接书写即可。例如:
double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0
强制类型转换
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。强制类型转换格式:目标数据类型 变量名 = (目标数据类型)值或者变量;。例如:
double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5(小数位直接舍弃)
// 表示数据范围从小到大
byte ===> short
===> int ===> long ===> float ===> double
char
说明
- char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中,‘a’对应97。
int a = 'a';
System.out.println(a); // 将输出97
- 整数默认是int类型,byte、short和char类型数据参与运算均会自动转换为int类型。
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错,b1和b2会自动转换为int类型,计算结果为int,int赋值给byte需要强制类型转换。
// 修改为:
int nun = b1 + b2;
// 或者:
byte b3 = (byte)(b1 + b2);
- boolean类型不能与其他基本数据类型相互转换。
运算符
算术运算符
运算符和表达式
- 运算符:对常量或者变量进行操作的符号。
- 表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。举例说明:
int a = 10;
int b = 20;
int c = a + b;
// +:是运算符,并且是算术运算符。
// a + b:是表达式,由于+是算术运算符,所以这个表达式叫算术表达式。
算术运算符
符号 | 作用 | 说明 |
---|---|---|
+ | 加 | + |
- | 减 | - |
* | 乘 | x |
/ | 除 | ÷ |
% | 取余 | 获取的是两个数据做除法的余数 |
注意:
- /和%的区别:两个数据做除法,/取结果的商,%取结果的余数。
- 整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。
int a = 10;
int b = 3;
System.out.println(a / b); //输出结果3
System.out.println(a % b); //输出结果1
字符的"+"操作
- char类型参与算术运算,使用的是计算机底层对应的十进制数值。需要记住三个字符对应的数值:
‘a’ - - 97,a-z是连续的,所以’b’对应的数值是98,'c’是99,依次递加
‘A’ - - 65,A-Z是连续的,所以’B’对应的数值是66,'C’是67,依次递加
‘0’ - - 48,0-9是连续的,所以’1’对应的数值是49,'2’是50,依次递加
// 可以通过使用字符与整数做算术运算,得出字符对应的数值是多少
char ch1 = 'a'
System.out.println(ch1 + 1); // 输出98,97 + 1 = 98
char ch2 = 'A';
System.out.println(ch2 + 1); // 输出66,65 + 1 = 66
char ch3 = '0';
System.out.println(ch3 + 1); // 输出49,48 + 1 = 49
算术表达式中包含不同的基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。
- 提升规则:
: byte类型,short类型和char类型将被提升到int类型,不管是否有其他类型参与运算。
: 整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型。
: 等级顺序:byte,short,char --> int --> long --> float --> double
例如:
byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2; //该行报错,因为byte类型参与算术运算会自动提示为int,int赋值给byte可能损失精度
int i3 = b1 + b2; // 应该使用int接收
byte b3 = (byte)(b1 + b2); // 或者将结果强制转换为byte类型
-----------------------------------
int num1 = 10;
double num2 = 20.0;
double num3 = num1 + num2; // 使用double接收,因为num1会自动提升为double类型
- tips:正是由于上述原因,所以在程序开发中我们很少使用byte或者short类型定义整数。也很少会使用char类型定义字符,而使用字符串类型,更不会使用char类型做算术运算。
字符串的"+"操作
- 当"+“操作中出现字符串时,这个”+"是字符串连接符,而不是算术运算。
System.out.println("hello" + 666); // 输出:hello666
- 在"+“操作中,如果出现了字符串,就是连接运算符,否则就是算术运算。当连续进行”+"操作时,从左到右逐个执行。
System.out.println(1 + 994 + "年"); // 输出:1994年
System.out.println(1 + 2 + "你" + 3 + 4); // 输出:3你34
// 可以使用小括号改变运算的优先级
System.out.println(1 + 2 + "你" + (3 + 4)); // 输出:3你7
赋值运算符
- 赋值运算符的作用是将一个表达式的值赋给左边,左边必须是可修改的,不能是常量。
符号 | 作用 | 说明 |
---|---|---|
= | 赋值 | a=10,将10赋值给变量a |
+= | 加后赋值 | a+=b,将a+b的值给a |
-= | 减后赋值 | a-=b,将a-b的值给a |
*= | 乘后赋值 | a*=b,将axb的值给a |
/= | 除后赋值 | a/=b,将a÷b的商给a |
%= | 取余后赋值 | a%=b,将a÷b的余数给a |
- 注意:扩展的赋值运算符隐含了强制类型转换。
short s = 10;
s = s + 10; // 此行代码报出,因为运算中s提升为int类型,运算结果int赋值给short可能损失精度
s += 10; // 此行代码没有问题,隐含了强制类型转换,相当于s = (short)(s + 10);
自增自减运算符
符号 | 作用 | 说明 |
---|---|---|
++ | 自增 | 变量的值加1 |
- - | 自减 | 变量的值减1 |
注意事项:
- ++和- -既可以放在变量的后边,也可以放在变量的前边。
- 单独使用的时候,++和- -无论是放在变量的前边还是后边,结果是一样的。
- 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者- -。
- 参与操作的时候,如果放在变量的前边,先拿变量做++或者- -,后拿变量参与操作。
- 最常见的用法:单独使用。
int i = 10;
i++; // 单独使用
System.out.println("i:" + i); // i:11
int j = 10;
++j; // 单独使用
System.out.println("j:" + j); // j:11
int x = 10;
int y = x++; // 赋值运算,++在后边,所以是使用x原来的值赋值给y,x本身自增1
System.out.println("x:" + x + ",y:" + y); // x:11,y:10
int m = 10;
int n = ++m; // 赋值运算,++在前边,所以是使用m自增后的值赋值给n,m本身自增1
System.out.println("m:" + m + ",m:" + m); // m:11,m:11
关系运算符
- 关系运算符有6种关系,分别为小于、小于等于、大于、等于、大于等于、不等于。
符号 | 说明 |
---|---|
== | a == b,判断a和b的值是否相等,成立为true,不成立为false |
!= | a != b,判断a和b的值是否不相等,成立为true,不成立为false |
> | a > b,判断a是否大于b,成立为true,不成立为false |
>= | a >= b,判断a是否大于等于b,成立为true,不成立为false |
< | a < b,判断a是否小于b,成立为true,不成立为false |
<= | a <= b,判断a是否小于等于b,成立为true,不成立为false |
- 注意事项:
: 关系运算符的结果都是boolean类型,要么是true,要么是false。
: 千万不要把“= =”误写成“=”,“= =”是判断是否相等的关系,"="是赋值。
int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a > b); // false
System.out.println(a >= b); // false
System.out.println(a < b); // true
System.out.println(a <= b); // true
// 关系运算的结果肯定是boolean类型,所以也可以将运算结果赋值给boolean类型的变量
boolean flag = a > b;
System.out.println(flag); // 输出false
逻辑运算符
逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式,以判断程序中的表达式是否成立,判断的结果是true或false。
符号 | 作用 | 说明 |
---|---|---|
& | 逻辑与 | a&b,a和b都是true,结果为true,否则为false |
| | 逻辑或 | a|b,a和b都是false,结果为false,否则为true |
^ | 逻辑异或 | a^b,a和b结果不同为true,相同为false |
! | 逻辑非 | !a,结果和a的结果正好相反 |
//定义变量
int i = 10;
int j = 20;
int k = 30
//& “与”,并且的关系,只要表达式中有一个值为false,结果即为false
System.out.println((i > j) & (i > k)); //false & false,输出false
System.out.println((i < j) & (i > k)); //true & false,输出false
System.out.println((i > j) & (i < k)); //false & true,输出false
System.out.println((i < j) & (i < k)); //true & true,输出true
//| “或”,或者的关系,只要表达式中有一个值为true,结果即为true
System.out.println((i > j) | (i > k)); //false | false,输出false
System.out.println((i < j) | (i > k)); //true | false,输出true
System.out.println((i > j) | (i < k)); //false | true,输出true
System.out.println((i < j) | (i < k)); //true | true,输出true
//^ “异或”,相同为false,不同为true
System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
//! “非”,取反
System.out.println((i > j)); //false
System.out.println(!(i > j)); //!false,,输出true
短路逻辑运算符
符号 | 作用 | 说明 |
---|---|---|
&& | 短路与 | 作用和&相同,但是有短路效果 |
|| | 短路或 | 作用和|相同,但是有短路效果 |
在逻辑与运算中,只要有一个表达式的值为false,那么结果就可以判定为false了,没有必要将所有表达式的值都计算出来,短路与操作就有这样的效果,可以提高效率。同理在逻辑或运算中,一旦发现值为true,右边的表达式将不再参与运算。
- 逻辑与&,无论左边真假,右边都要执行。
- 短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。
- 逻辑或|,无论左边真假,右边都要执行。
- 短路或 | |,如果左边为假,右边执行;如果左边为真,右边不执行。
int x = 3;
int y = 4;
System.out.println((x++ > 4) & (y++ > 5)); // 两个表达式都会运算
System.out.println(x); // 4
System.out.println(y); // 5
System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false,右边不参与运算
System.out.println(x); // 4
System.out.println(y); // 4
三元运算符
语法格式
关系表达式 ? 表达式1 : 表达式2;
- 解释:问号前面的位置是判断的条件,判断结果为boolean型,为true时调用表达式1,为false时调用表达式2。其逻辑为:如果条件表达式成立或者满足则执行表达式1,否则执行第二个。
- 举例:
int a = 10;
int b = 20;
int c = a > b ? a : b; // 判断 a > b 是否为真,如果为真取a的值,如果为假,取b的值
案例
需求:动物园里有两只老虎,已知两只老虎的体重分别为180kg、200kg,请用程序实现判断两只老虎的体重是否相同。
public class OperatorTest01 {
public static void main (String[] args) {
// 1:定义两个变量用于保存老虎的体重,单位为kg,这里仅仅体现数值即可。
int weight1 = 180;
int weight2 = 200;
// 2:用三元运算符实现老虎体重的判断,体重相同,返回true,否则返回false。
boolean b = weight1 == weight2 ? true : false;
// 3:输出结果
System.out.println("b:" + b);
}
}
运算符优先级
描述 | 运算符 |
---|---|
括号 | ()、[ ] |
正负号 | +、- |
自增自减 ,非 | ++、- -、! |
乘除,取余 | *、/、% |
加减 | +、- |
大小关系 | >、>=、<、<= |
相等关系 | ==、!= |
按位与 | & |
按位异或 | ^ |
按位或 | | |
逻辑与 | && |
逻辑或 | || |
条件运算 | ? |
赋值运算 | =、+=、-=、*=、/=、%= |
数据输入
我们可以通过Scanner类来获取用户的输入。使用步骤如下:
- 导包。Scanner类在java.util包下,所以需要将该类导入。导包的语句需要定义在类的上面。
import java.util.Scanner;
- 创建Scanner对象。
Scanner sc = new Scanner(System.in); // 创建Scanner对象,sc表示变量名,其他均不可变
- 接收数据
int i = sc.nextInt(); // 表示将键盘录入的值作为int数返回
示例:
import java.util.Scanner;
public class ScannerDemo {
public static void main (String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);
// 接收数据
int x = sc.nextInt();
// 输出数据
System.out.println("x:" + x);
}
}
tips:sc.next();只能获取输入的从开头到最近一个空之前的内容。获取的字符串是不包含空格的;sc.nextLine();获取包含空格在内的字符串,会获取从头到尾一行的数据。
选择结构
在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。所以,我们必须清楚每条语句的执行流程。而且,很多时候要通过控制语句的执行顺序来实现我们想要的功能。流程控制语句分类:顺序结构、分支结构(if,switch)、循环结构(for,while,do…while)。
顺序结构
顺序结构是程序中最简单最基本的流程控制,没有特定的语法结构,按照代码的先后顺序,依次执行,程序中大多数的代码都是这样执行的。
// 顺序结构执行流程图:
开始 -> 语句A -> 语句B -> 语句C -> 结束
分支结构
if语句
if语句格式1
格式:
if (关系表达式) {
语句体;
}
- 执行流程:
- 首先计算关系表达式的值
- 如果关系表达式的值为true就执行语句体
- 如果关系表达式的值为false就不执行语句体
- 继续执行后面的语句内容
- 示例:
public class IfDemo {
public static void main (String[] args) {
System.out.println("开始");
// 定义两个变量
int a = 10;
int b = 20;
// 需求:判断a和b的值是否相等,如果相等,就在控制台输出:a等于b
if(a == b) {
System.out.println("a等于b");
}
// 需求:判断a和c的值是否相等,如果相等,就在控制台输出:a等于c
int c = 10;
if(a == c) {
System.out.println("a等于c");
}
Sysytem.out.println("结束");
}
}
if语句格式2
格式:
if (关系表达式) {
语句体1;
} else {
语句体2;
}
- 执行流程:
- 首先计算关系表达式的值
- 如果关系表达式的值为true就执行语句体1
- 如果关系表达式的值为false就执行语句体2
- 继续执行后面的语句内容
- 示例:
public class IfDemo02 {
public static void main (String[] args) {
System.out.println("开始");
// 定义两个变量
int a = 10;
int b = 20;
b = 5;
// 需求:判断a是否大于b,如果是,在控制台输出:a的值大于b,否则,在控制台输出:a的值不大于b
if (a > b) {
System.out.println("a的值大于b");
} else {
System.out.println("a的值不大于b");
}
System.out.println("结束");
}
}
if语句格式3
格式:
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
...
else {
语句体n+1;
}
- 执行流程:
- 首先计算关系表达式1的值
- 如果值为true就执行语句体1;如果值为fasle就计算关系表达式2的值
- 如果值为true就执行语句体2;如果值为false就计算关系表达式3的值
- 。。。
- 如果没有任何关系表达式为true,就执行语句体n+1
- 示例:
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
System.out.println("开始");
// 需求:键盘录入一个星期数(1,2,...7),输出对应的星期一,星期二,...星期日
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数(1-7):");
int week = sc.nextInt();
if(week == 1) {
System.out.println("星期一");
} else if(week == 2) {
System.out.println("星期二");
} else if(week == 3) {
System.out.println("星期三");
} else if(week == 4) {
System.out.println("星期四");
} else if(week == 5) {
System.out.println("星期五");
} else if(week == 6) {
System.out.println("星期六");
} else {
System.out.println("星期日");
}
System.out.println("结束");
}
}
switch语句
- 格式
switch (表达式) {
case 1 :
语句体1;
break;
case 2 :
语句体2;
break;
...
default:
语句体n+1;
break;
}
- 执行流程:
- 首先计算出表达式的值
- 其次,和case依次比较,一旦有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束。
- 最后,如果所有的case都和表达式的值不匹配,就会执行default语句体部分,然后程序结束掉。
- switch匹配的类型:(因为switch在设计的时候就是匹配一些固定值)
- byte,short,char,int
- 枚举(jdk1.5)
- 字符串(jdk1.7)
- case的穿透性:
当匹配上一个case后,会穿过其他的case,直到遇到break才会停止。注意:开发中尽量不要使用穿透,流程的控制比较难。 - if和switch的区别:
- if:通常用于一定范围的判断
- switch:通常用于固定值的判断
循环结构
for循环
for循环结构
- 循环:
循环语句可以在满足循环条件的情况下,反复执行某一段代码,这段被重复执行的代码被称为循环体语句,当反复执行这个循环体时,需要在合适的时候把循环判断条件修改为false,从而结束循环,否则循环将一直执行下去,形成死循环。 - for循环格式:
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
- 格式解释:
- 初始化语句:用于表示循环开启时的起始状态,简单说就是循环开始的时候什么样
- 条件判断语句:用于表示循环反复执行的条件,简单说就是判断循环是否能一直执行下去
- 循环体语句:用于表示循环反复执行的内容,简单说就是循环反复执行的事情
- 条件控制语句:用于表示循环执行中每次变化的内容,简单说就是控制循环是否能执行下去
- 执行流程
- 执行初始化语句
- 执行条件判断语句,看其结果是true还是false。如果是false,循环结束;如果是true,继续执行。
- 执行循环体语句
- 执行条件控制语句
- 回到2继续
for循环练习
输出数据
需求:在控制台输出1-5和5-1的数据
public class ForTest01 {
public static void main(String[] args) {
//需求:输出数据1-5
for(int i=1; i<=5; i++) {
System.out.println(i);
}
System.out.println("--------");
//需求:输出数据5-1
for(int i=5; i>=1; i--) {
System.out.println(i);
}
}
}
求偶数和
需求:求1-100之间的偶数和,并把求和结果在控制台输出
public class ForTest03 {
public static void main(String[] args) {
//求和的最终结果必须保存起来,需要定义一个变量,用于保存求和的结果,初始值为0
int sum = 0;
//对1-100的数据求和与1-5的数据求和几乎完全一样,仅仅是结束条件不同
for(int i=1; i<=100; i++) {
//对1-100的偶数求和,需要对求和操作添加限制条件,判断是否是偶数
if(i%2 == 0) {
sum += i;
}
}
//当循环执行完毕时,将最终数据打印出来
System.out.println("1-100之间的偶数和是:" + sum);
}
}
本题要点:
- 今后遇到的需求中,如果带有求和二字,请立即联想到求和变量
- 求和变量的定义位置,必须在循环外部,如果在循环内部则计算出的数据将是错误的
统计水仙花数个数
需求:统计“水仙花数”一共有多少个,并在控制台输出个数
public class ForTest05 {
public static void main(String[] args) {
//定义变量count,用于保存“水仙花数”的数量,初始值为0
int count = 0;
//输出所有的水仙花数必然要使用到循环,遍历所有的三位数,三位数从100开始,到999结束
for(int i=100; i<1000; i++) {
//在计算之前获取三位数中每个位上的值
int ge = i%10;
int shi = i/10%10;
int bai = i/10/10%10;
//在判定水仙花数的过程中,满足条件不再输出,更改为修改count的值,使count+1
if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
count++;
}
}
//打印输出最终结果
System.out.println("水仙花共有:" + count + "个");
}
}
本题要点:
- 今后如果需求带有统计xxx,请先想到计数器变量
- 计数器变量定义的位置,必须在循环外部
while循环
while循环结构
- while循环完整格式:
初始化语句;
while (条件判断语句) {
循环体语句;
条件控制语句;
}
- while循环执行流程:
- 执行初始化语句
- 执行条件判断语句,看其结果是true还是false。如果是false,循环结束;如果是true,继续执行。
- 执行循环体语句
- 执行条件控制语句
- 回到2继续
- 示例代码:
public class WhileDemo {
public static void main(String[] args) {
//需求:在控制台输出5次"HelloWorld"
//for循环实现
for(int i=1; i<=5; i++) {
System.out.println("HelloWorld");
}
System.out.println("--------");
//while循环实现
int j = 1;
while(j<=5) {
System.out.println("HelloWorld");
j++;
}
}
}
while循环练习
需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米。请问,我折叠多少次,可以折成珠穆朗玛峰的高度?
public class WhileTest {
public static void main(String[] args) {
//定义一个计数器,初始值为0
int count = 0;
//定义纸张厚度
double paper = 0.1;
//定义珠穆朗玛峰的高度
int zf = 8844430;
//因为要反复折叠,所以要使用循环,但是不知道折叠多少次,这种情况下更适合使用while循环
//折叠的过程中当纸张厚度大于珠峰就停止了,因此继续执行的要求是纸张厚度小于珠峰高度
while(paper <= zf) {
//循环的执行过程中每次纸张折叠,纸张的厚度要加倍
paper *= 2;
//在循环中执行累加,对应折叠了多少次
count++;
}
//打印计数器的值
System.out.println("需要折叠:" + count + "次");
}
}
do…while循环
do…while循环结构
- 完整格式:
初始化语句;
do {
循环体语句;
条件控制语句;
} while (条件判断语句);
- 执行流程:
- 执行初始化语句
- 执行循环体语句
- 执行条件控制语句
- 执行条件判断语句,看其结果是true还是false。如果是false,循环结束;如果是true,继续执行
- 回到2继续
- 示例代码
public class DoWhileDemo {
public static void main(String[] args) {
//需求:在控制台输出5次"HelloWorld"
//for循环实现
for(int i=1; i<=5; i++) {
System.out.println("HelloWorld");
}
System.out.println("--------");
//do...while循环实现
int j = 1;
do {
System.out.println("HelloWorld");
j++;
}while(j<=5);
}
}
补充说明
三种循环的区别
- 三种循环的区别
- for循环和whlie循环先判断条件是否成立,然后决定是否执行循环体(先判断后执行)
- do…while循环先执行一次循环体,然后判断条件是否成立,是否继续执行循环体(先执行后判断)
- for循环和while的区别
- 条件控制语句所控制的自增变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了
- 条件控制语句所控制的自增变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用
- 死循环(无限循环)的三种格式
- for (;😉 { }
- while (true) { }
- do { } while (true)
跳转控制语句
- 跳转控制语句(break)
跳出循环,结束循环 - 跳转控制语句(continue)
跳过本次循环,继续下次循环 - 注意:
continue只能在循环中进行使用!
嵌套循环
所谓嵌套循环,循环中还有循环,一般都是for循环中嵌套一个for循环。
- 格式:
for (初始化语句;条件判断语句;条件控制语句) {
外循环;...
for (初始化语句;条件判断语句;条件控制语句) {
内循环;...
}
}
- 执行流程:
外循环执行一次,内循环执行完 - 总次数:
外循环次数 X 内循环次数 - 示例:
public static void main(String[] args) {
//外循环控制小时的范围,内循环控制分钟的范围
for (int hour = 0; hour < 24; hour++) {
for (int minute = 0; minute < 60; minute++) {
System.out.println(hour + "时" + minute + "分");
}
System.out.println("--------");
}
}
Random
Random产生随机数
- 概述:
Random类似Scanner,也是java提供好的API,内部提供了产生随机数的功能。 - 使用步骤:
- 导入包
import java.util.Random; - 创建对象
Random r = new Random(); - 产生随机数
int num = r.nextInt(10);
解释:10代表的是一个范围,如果括号写10,产生的随机数就是0-9,括号写20,参数的随机数则是0-19
- 示例代码:
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//创建对象
Random r = new Random();
//用循环获取10个随机数
for(int i=0; i<10; i++) {
//获取随机数
int number = r.nextInt(10);
System.out.println("number:" + number);
}
//需求:获取一个1-100之间的随机数
int x = r.nextInt(100) + 1;
System.out.println(x);
}
}
Random练习
需求:
程序自动生成一个1-100之间的数字,使用程序实现猜出这个数字是多少?当猜错的时候根据不同情况给出相应的提示:
A. 如果猜的数字比真实数字大,提示你猜的数据大了
B. 如果猜的数字比真实数字小,提示你猜的数据小了
C. 如果猜的数字与真实数字相等,提示恭喜你猜中了
import java.util.Random;
import java.util.Scanner;
public class RandomTest {
public static void main(String[] args) {
//要完成猜数字的游戏,首先需要有一个要猜的数字,使用随机数生成该数字,范围1到100
Random r = new Random();
int number = r.nextInt(100) + 1;
while(true) {
//使用程序实现猜数字,每次均要输入猜测的数字值,需要使用键盘录入实现
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字:");
int guessNumber = sc.nextInt();
//比较输入的数字和系统产生的数据,需要使用分支语句。
//这里使用if..else..if..格式,根据不同情况进行猜测结果显示
if(guessNumber > number) {
System.out.println("你猜的数字" + guessNumber + "大了");
} else if(guessNumber < number) {
System.out.println("你猜的数字" + guessNumber + "小了");
} else {
System.out.println("恭喜你猜中了");
break;
}
}
}
}