为满足移动端和PC端的双重阅读体验,以及文章质量的保证,开始重构的以及新写的文章都会基于 “语雀” 平台编写,公众号会同步刚发布的文章,但随后的修改或者更新只会在语雀中维护。👉 点击底部左下角 “阅读原文” 即可跳转到文章最新页面!理想二旬不止@BWH_Steven
文章过长,很可能有一些排版问题,后面会把每一篇的篇幅缩短哈,这样更加适合阅读,微信这边推送后无法修改,所以会在语雀同步更新~ 表格等有一些多,PC端、 Pad 端阅读更佳。
基础非常重要哈!!!
package cn.ideal.javase;
/**
* @Description: HelloWorld
* @Author:BWH_Steven
* @Date: 2021/8/30 3:03 下午
*/
public class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld !");
}
}
上面的代码,就是一个最简单的 Java 程序 —— HelloWorld,它也是梦开始的地方。 别看程序虽小,但是五脏俱全,package、public、class、static 关键字, /** */ 类注释,HelloWorld 类名,main 主函数,println() 输出打印方法,"HelloWorld !" 关键字。各个不同的语法结合,就构成了这个入门的程序。
如果看不明白,没关系,这就是这一篇文章想要讲解的。
关键字是被Java语言赋予特定含义的单词,他们有着特定的使用位置和方式。 注意:
列举:
虽然下面表格中,你或许大部分关键字都没有见过,这里不必细究其含义,也不必去刻意记忆,因为后面都会涉及到,但是你只需要记住一点:下面表格中 接近 100% 的关键字将会陪伴你的 Java 生涯!
类别 | 关键字 |
---|---|
private | 私有的 |
protected | 受保护的 |
public | 公共的 |
abstract | 声明抽象 |
class | 类 |
extends | 扩充,继承 |
final | 最终值,不可改变的 |
implements | 实现(接口) |
interface | 接口 |
native | 本地,原生方法(非Java实现) |
new | 新,创建 |
static | 静态 |
strictfp | 严格,精准 |
synchronized | 线程,同步 |
transient | 短暂 |
volatile | 易失 |
break | 跳出循环 |
case | 定义一个值以供switch选择 |
continue | 继续 |
default | 默认 |
do | 运行 |
else | 否则 |
for | 循环 |
if | 如果 |
instanceof | 实例 |
return | 返回 |
switch | 根据值选择执行 |
while | 循环 |
assert | 错误处理,断言表达式是否为真 |
catch | 捕捉异常 |
finally | 有没有异常都执行 |
throw | 抛出一个异常对象 |
throws | 声明一个异常可能被抛出 |
try | 捕获异常 |
import | 引入包 |
package | 包 |
boolean | 布尔型 |
byte | 字节型 |
char | 字符型 |
double | 双精度浮点 |
float | 单精度浮点 |
int | 整型 |
long | 长整型 |
short | 短整型 |
super | 父类,超类 |
this | 本类 |
void | 无返回值 |
goto | 保留关键字,是关键字,但不能使用 |
const | 保留关键字,是关键字,但不能使用 |
null | 空 |
标识符就是给类,接口,方法,变量等起名字的字符序列。
组成规则:
A-Z、a-z
)、美元符($
)、下划线(_
)A-Z、a-z
)、美元符($
)、下划线(_
)或者数的任何字符组合注意事项:
组成规范: 命名规范是我们不得不提的一个话题,虽说命名本应该是自由的,但是仍然有一定的“潜规则”,通过你对命名的书写,别人一眼就能看出你是不是一个“行家”。而且往往这些规范,能巧妙的帮助我们规避很多潜在的风险。
下面的引用来自 《阿里巴巴 Java 开发手册》:
注释就是对程序进行解释说明的文字(不会被编译运行) 其目的是为了方便自己或别人后期阅读这部分代码的提示,能够快速的让阅读者了解这部分代码的作用。 当你需要维护一个老项目的代码时,几万甚至几十万行的代码量非常常见,除了相对规范的包结构和文档能把你带到入口处(前后端接口),如何去梳理业务的逻辑就大大的依赖你的技术经验和前人的注释了。 虽然有个梗:“只要我的代码谁也看不懂,我在公司就是不可或缺的”,不过这句话图个乐就得了,如果不养成良好的习惯,以后团队协作和提交前/日后 review 代码就会变得异常折磨。
// 这行注释
/*
uid 用户id
name 姓名
age 年龄
*/
类注释
/**
* @Description: HelloWorld
* @Author: BWH_Steven
* @Date: 2021/8/30 3:03 下午
*/
方法注释
/**
* 用户消息查看
*
* @param req SearchUserMsgReq 请求参数
* @return List<SearchUserMsgDO> 封装DO的List
*/
编写代码时,类注释和方法注释都必须使用 JavaDoc 注释,而不是 // 这种单行注释,类能看到作者以及描述创建时间,方法能不进入代码块的情况下方便的看到方法描述和参数以及返回值。
常量就是在程序执行的过程中,其值不发生改变的量(例如π、重力加速度,光速等) 在 Java 中我们使用 final 关键字来修饰常量
注意:虽然常量名也可以用小写,但为了便于识别,通常使用大写字母 表示常量,这也算是大家默认的要求。
一般来说,我们写代码时,是不允许出现魔法值的(即未预先经过定义的值) 例如根据 id 查询用户的昵称和头像时,如果查询不到,则给一个默认值,避免直接返回 null。
// 例如 userInfo 就是查询到的用户信息
if (userInfo == null || StingUtils.isBlank(userInfo.getUserName)){
userInfo.setUserName("用户");
}
像 userInfo.setUserName("用户"); 中的 "用户" 就是魔法值,因为我们并没有事前定义它,所以可以定义一个常量类,其中使用 final 修饰我们想定义的常量。
public class DefaultInfoConstant {
public static final String DEFAULT_PERSON_HEAD_IMAGE_URL = "xxx.png";
public static final String DEFAULT_USER_NAME = "用户";
}
这样就可以这样调用了,以后所有调用了这个常量的部分我们都不需要去操心了,修改这个常量类即可,所有引用它的地方都会跟着变化了。
// 例如 userInfo 就是查询到的用户信息
if (userInfo == null || StingUtils.isBlank(userInfo.getUserName)){
userInfo.setUserName(DefaultInfoConstant.DEFAULT_USER_NAME);
}
我们刚介绍了什么是常量,那么什么是变量呢,顾名思义,变量就是在某个范围内可以变化的量,其实它就是一个被你所定义的变量,在一个数据类型的约束下,可以在数据类型所允许的范围内进行,被赋值,运算,等操作。
image.png 格式:数据类型 变量名 = 初始化值 注意:可以在一行中声明多个变量,但是我们不推荐这种方式。 尤其真实项目中往往变量名会比较长,逐一声明变量能提高程序的可读性。
// 不推荐
String name, address;
// 推荐
String name;
String address;
局部变量就是定义在方法、构造方法、或者语句块中的变量
public class HelloWorld {
public static void main(String[] args) {
// 下一行的 name 会报错
System.out.println(name);
}
public static void testMethod() {
String name = "张三";
}
}
局部变量即只能在一定范围内使用的变量,随着这个方法/语句块的结束,这个变量也就无效了。(生而带来,死而带去 只能活在自己的世界),所以上述代码中,我们在 testMethod 方法中定义了 name 字符串,其值为 "张三",但是这也就意味着这个变量的作用域只在 testMethod 方法中,自然不能在别的地方,例如 main 函数中去调用了。
PS:对于局部变量的理解,刚入门可能也不会太深,等后面几篇我们学习到方法后,再回过头来看这部分内容,就会有一种明了的感觉。
实例变量:声明在类中,但在方法、构造方法和语句块之外
public class Student {
private String name;
private int age;
public void print(){
System.out.println("print: " + name + ", " + age);
}
}
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见。例如文中的 name 和 age 就都是实例变量,在同一个类中的 print 方法中是可以直接访问的,同时利用 private 控制了变量的可访问范围。
暂时在学习基础语法知识的时候可以暂时忽略实例变量这部分内容,这部分内容主要被使用在面向对象的部分,但是极其重要。
static 修饰的变量也称作静态变量,静态变量属于类,所以也称为类变量,存储于方法区中的静态区,随着类的加载而加载,消失而消失,可以通过类名调用,也可以通过对象调用。 例如在 Student 类中定义两个 public 修饰的变量 name 和 address,而且其中 name 是用 static 修饰的,即是一个类变量。
public class Student {
public static String name;
public String address;
}
当我们在另一个类中去调用这个变量的时候,只有 name 可以用类名调用。而 address 就必须创建对象后才能调用。(这部分后面的文章会讲到)
public class Demo {
public void testMethod() {
// 可以用类名调用
String name = Student.name;
// 不可以
String address = Student.address;
}
}
Java是一种强类型的语言,针对每一种数据都定义了明确的数据类型(就是将一些值的范围做了约束,从而为不同类型的值在内存中分配不同的内存空间) 注意:在此部分暂时不用深究引用类型,着重认熟悉一下基本数据类型,引用类型在面向对象的部分会详细解释。 我们来看一下八种基本数据类型的详细说明:
Name | Size* | Rang |
---|---|---|
byte | 1byte | 8bit |
short | 2bytes | 16bit |
int | 4bytes | 32bit |
long | 4bytes | 64bit |
float | 4bytes | 32bit |
double | 8bytes | 64bit |
boolean | 只有true和false两个取值。 | |
char | 2bytes | 存储Unicode码,用单引号赋值。 |
注意:
如:long l = 66666666666666L; // 否则报错
double d = 521.1;// double 不需要加字符
float f = 52.1f; // float 必须加f
一般来说,我们在运算的时候,要求参与运算的数值类型必须一致,很多时候就需要进行数据类型的转换。类型的转换大致分为两种:
默认转换就是从小类型转换为大类型的自动类型转换。
举个例子:int 类型的 520 可以被 long 类型的变量接收,然后输出。
public static void main(String[] args) {
int numInt = 520;
long numLong = numInt;
System.out.println(numLong);
}
疑惑:为什么 float(4个字节)在 long(8个字节)后面?
long:2^63-1
float:3.410^38 > 210^38 > 28^38 > 22^3^38
= 2*2^144 > 2^63 -1
正例:低精度byte到高精度int 会根据默认转换,自动转换类型 反例:高精度int到低精度byte 可能会损失精度
public class Demo {
public static void main(String[] args) {
byte a = 3;
int b = 4;
byte c = a + b;
System.out.println(c);
}
}
image.png byte 数据类型是 1个字节、8位 int 数据类型是 4个字节、32位 但是有没有办法能够让我们输出这种运算的结果呢?这就需要我们用到强制类型转换的知识。
格式:目标数据类型 变量 = (目标数据类型)被转换的数据
int i = 128;
// 格式如下
byte b = (byte)i;
注意:
来看两个例子:
public static void main(String[] args) {
byte b1 = 3;
byte b2 = 4;
byte b;
// 下面两个赋值有什么区别吗
b = (byte) (b1 + b2);
b = 3 + 4;
System.out.println(b);
}
第一个赋值语句:
第二个赋值语句:
总结:
再配合下一个例子,大家就能深刻的理解丢失精度的意义了。
public static void main(String[] args) {
byte b = 130;
byte b = (byte) 130;
System.out.println(b);
}
byte b = 130;
时,编译器应该已经在代码处报红了,因为 byte 的范围是:-128 到 127,所以报错了。byte b = (byte) 130;
使用了强制类型转换却不会报错,并且能输出结果 -126。分析(原反补码将在下面具体介绍) 我们想要知道结果是什么,就应该知道是如何计算的,而我们又知道计算机中数据的运算都是补码进行的。 得到补码,首先要计算出数据的二进制,如下,求出130的二进制 10000010
130 是一个整数 所以补齐4个字节 (一个字节8位)
0000000 00000000 00000000 10000010
接着做截取操作,截成 byte 类型的 10000010,而这个结果是补码,如下表已知补码求原码,最后的结果是 11111110 转换为十进制为 -126
值位 | 符号位 | 数值位 |
---|---|---|
补码: | 1 | 0000010 |
反码: | 1 | 0000001 |
原码 | 1 | 1111110 |
字符是指在计算机中所使用的 字母、数字、汉字、和符号,表示时用单引号包含在内。例如:'5' 和 'R' 和 '和' 均是字符 在内存中,字符数据以ASCII码存储 ,即以整数表示 需要记忆的常见字符 'a' → 97 'A' → 65 '0'→ 48,其余字符依次递推即可
值 | 符号 | 值 | 符号 | 值 | 符号 | 值 | 符号 |
---|---|---|---|---|---|---|---|
0 | 空格符\0 | 42 | * | 62 | > | 123 | { |
32 | 空格 | 43 | + | 63 | ? | 124 | | |
33 | ! | 44 | , | 64 | @ | 125 | } |
34 | " | 45 | - | 65~90 | A~Z | 126 | ~ |
35 | # | 46 | . | 91 | [ | 127 | Delete 键 |
36 | $ | 47 | / | 92 | </td> | ||
37 | % | 48~57 | 0~9 | 93 | ] | ||
38 | & | 58 | : | 94 | ^ | ||
39 | ' | 59 | ; | 95 | - | ||
40 | ( | 60 | < | 96 | ` | ||
41 | ) | 61 | = | 97~122 | a~z |
有一些特殊的字符叫做转义字符,其格式为通过 \ + 一些特定的字母
转义 + 字符 = 转移字符 = 转变含义的字符(不再是本来字符的意思)
转义字符 | 意义 | ASCII码值(十进制) |
---|---|---|
\a | 响铃(BEL) | 007 |
\b | 退格(BS) ,将当前位置移到前一列 | 008 |
\f | 换页(FF),将当前位置移到下页开头 | 012 |
\n | 换行(LF) ,将当前位置移到下一行开头 | 010 |
\r | 回车(CR) ,将当前位置移到本行开头 | 013 |
\t | 水平制表(HT) (跳到下一个TAB位置) | 009 |
\v | 垂直制表(VT) | 011 |
\ | 代表一个反斜线字符''\' | 092 |
\' | 代表一个单引号(撇号)字符 | 039 |
\" | 代表一个双引号字符 | 034 |
\? | 代表一个问号 | 063 |
\0 | 空字符(NUL) | 000 |
\ddd | 1到3位八进制数所代表的任意字符 | 三位八进制 |
\xhh | 十六进制所代表的任意字符 | 十六进制 |
举个例子,例如 \n 就是换行的意思:
public static void main(String[] args) {
System.out.println(520 + "\n" + 1314);
}
输出的结果是这样的(要注意,我当前是基于 macbook 演示的):
520
1314
回车 \r 意思是光标重新回到本行的开头,换行 \n 表示光标移动到下一行,不一定是行首,取决于其后是否还有内容。(因为我们常用在一行的句末,所以会误以为会在下一行的行首)
针对不同系统换行符也不同:苹果系统Mac \n
,Unix、Linux系统 \n
,Windows系统 \r\n
在Wwindows 中,如果在两端字符串的中间使用转义字符,只有使用 \r\n才能真正的达到了我们日常操作中,回车换行的那种效果。
注:虽然字符串并不是一个基本数据类型,但是因为这里讲解的比较简单,所以直接跟在字符类型下面做个比对好了。 字符串(String)是由零个或者多个字符组成的有限序列,它是编程中表示文本的数据类型,字符串使用的时候用双引号括起来即可,而且 String 并不是 Java 中的基本方法,而是一个类。 我们在此部分不做过多的介绍,但要知道,String类是一个非常非常重要的类!!! 我们会在后面有专门一大篇介绍 下面举几个例子简单看一下:
public static void main(String[] args) {
// 输出 Hello1
System.out.println("Hello" + 'a' + 1);
// 输出 98Hello
System.out.println('a' + 1 + "Hello");
// 输出 5 + 5 = 55
System.out.println("5 + 5 = " + 5 + 5);
// 输出 10 = 5 + 5
System.out.println(5 + 5 + " = 5 + 5 ");
}
大家可以看看是不是和自己想象中的输出值是一致的
说道运算符,大家能想到最简单的就是加减乘除了,是的它们就是运算符中的算数运算符,而运算符其实就是用于执行程序代码运算的,通过运算符,能够实现计算、比较、赋值等多种运算效果。 常见的运算符类型:算数运算符、赋值运算符、比较运算符、逻辑运算符、位运算符、三目运算符。
算数运算符有:+ - * / % ++ --
int x = 3;
int y = 4;
System.out.println(x/y); →System.out.println(x * 1.0 / y );
int x = 4;
int y = ( x++ ) + ( ++x ) + ( x * 10);
System.out.println( y );
首先 x 后置++ 所以括号1中 x运算时取4 然后自增为5
其次 x前置++ 所以括号2中 x = 6
最后 x * 10 = 6 * 10 = 60
Output y → 4 + 6 + 60 = 70
基本的赋值运算符:= 扩展的赋值运算符:+=,-=,*=,/=,%=
public static void main(String[] args) {
// 定义一个变量
int x = 520;
// 和 x = x + 520 是等价的
x += 520;
// 输出
System.out.println(x);
}
首先,基本的赋值运算符就是将等号右侧的值赋予给左边定义的变量,这样当你去调用 x 就知道整型类型的变量 x 的值现在等于 520 而 += 这些操作其实都是一些简化的扩展,例如代码中 x += 520 就相当于 x = x + 520,就是在自己本身的基础上进行加减乘除某个值,就可以写成这种形式。
既然这两种形式相同,那么代码中 ① 和 ② 的执行结果相同吗?
public static void main(String[] args) {
short s = 1;
s = s + 1; // ①
s += 1; // ②
System.out.println(s);
}
结果是否定的,代码编译到 s = s + 1 这句的时候就会报错了
image.png 但是直接去编译第二个语句,其实不会报错的: 扩展的赋值运算符其实隐含了一个强制类型转换 s += 1;不是等价于 s = s + 1 而是等价于 s = (s的数据类型) (s + 1);
经常我们需要比对两个值的关系,例如比较是否相等,谁大谁小。而这种关系正好契合 布尔类型 boolean,即只有 true 和 false 两种情况,用来比较符号就是关系运算符,它有这几个:==, !=, >=, <, <=
public static void main(String[] args) {
int a = 10;
int b = 20;
boolean flag = (a == b);
System.out.println(flag);
}
输出:false
逻辑运算符用于连接布尔型表达式,常见的逻辑运算符有:& | && || !
问题:&& 和 & 的区别?同理 || 和 | 的区别
位运算在前期看来,似乎用处并不是很大,但是当你后面去看一些源码,自己造一些轮子的时候,就知道位运算的重要了。而学习位运算,就必须补充原码、反码、补码的知识。
为什么我们要学习这些呢?首先我们要知道,在计算机内,有符号数有三种表示方法,原码、反码、和补码。而所有的数据运算都是采用补码进行的。它的重要性可想而知。
举个例子:7的二进制 :111
原码 | 正数的原码最高位是0的原码最高位是1其他的是数值位 | |
---|---|---|
符号位 | 数值位数 | |
+7 | 0 | 0000111(补够8个字节,在左面补4个0) |
-7 | 1 | 0000111 |
反码 | 正数的反码与原码相同负数的反码与源码符号位相同,数值位取反1 → 0 、 0 → 1 | |
---|---|---|
符号位 | 数值位数 | |
+7 | 0 | 0000111(补够8个字节,在左面补4个0) |
-7 | 1 | 1111000 |
补码 | 正数的补码与原码相同负数的补码是在反码的基础上+1 | |
---|---|---|
符号位 | 数值位数 | |
+7 | 0 | 0000111(补够8个字节,在左面补4个0) |
-7 | 1 | 1111001 |
7.5.2 位运算符
(3 & 4) (3 | 4) (3 ^ 4) (~3) (3 << 2) (>>) (>>>) 因为是位运算,所以我们需要把数据换算成二进制
// 3 的二进制是 11
00000000 00000000 00000000 00000011
// 4 的二进制是 100
00000000 00000000 00000000 00000100
&位与运算:有 0 则 0
00000000 00000000 00000000 00000011
& 00000000 00000000 00000000 00000100
------------------------------------------
00000000 00000000 00000000 00000000
结果是 0
&位与运算:有 1 则 1
00000000 00000000 00000000 00000011
& 00000000 00000000 00000000 00000100
------------------------------------------
00000000 00000000 00000000 00000111
结果是 7
^位异或运算:相同则 0,不同则 1
00000000 00000000 00000000 00000011
& 00000000 00000000 00000000 00000100
------------------------------------------
00000000 00000000 00000000 00000111
结果是 7
~按位取反运算符:0 变 1,1 变 0
00000000 00000000 00000000 00000011
& 11111111 11111111 11111111 11111100(补码)
补码:11111111 11111111 11111111 11111100
反码:11111111 11111111 11111111 11111011
原码:10000000 00000000 00000000 00000100
结果是 -4
<< 按位左移运算符,左操作数按位左移右操作数指定的位数(左边最高位丢弃,右边补齐 0)
>>
按位右移运算符,左操作数按位又移右操作数指定的位数(最高位是 0,左面补齐0;最高位是 1,左边补齐 1)
>>>
按位右移补 0 运算符,无论最高位是 0 还是 1,左边补齐 0
-24 的二进制为 -11000
原码:10000000 00000000 00000000 00011000
反码:11111111 11111111 11111111 11100111
补码:11111111 11111111 11111111 11101000
右移:0011111111 11111111 11111111 111010(00)
结果是 1073741818
// 方式1:使用一个中间传递变量(开发中常用)
c = a;
a = b;
b = a;
// 方式2:用位异或实现
a = a ^ b;
b = a ^ b; // b = a ^ b ^ b = a
a = a ^ b; // a ^ b ^ a = b
// 方式3:用变量相加的做法
a = a + b;
b = a - b;
a = a -b;
// 方式4:一句话的事
b = (a + b) - (a = b)
这一部分要与下面马上要学习的if语句进行对照学习 满足表达式则执行冒号前的表达式,反之则时候后面的 格式 :(条件表达式)?(条件真的表达式):(条件假的表达式)
将a,b 中的较小数赋值给x
x = a < b ? a : b
// 两者等价
if (a < b) {
x = a;
} else {
x = b
}
就 Java 基础而言,大部分操作都是在控制台中的,所以当你想进行一些交互的时候,大部分都是依赖于键盘的输入,所以这里也需简单的提及一下:
现在我们对于导包以及对象的概念仍然比较模糊,但是我们在介绍别的知识的时候也会频繁的用到,所以大家暂时按照以下的格式记忆下来。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("first");
int a = sc.nextInt();
System.out.println("second");
int b = sc.nextInt();
int max = ((a > b) ? a : b);
System.out.println(max);
}
分支结构就是能让我们的程序根据判断条件,在不同的情况下,执行不同的逻辑,主要的选择结构有 if 和 switch 两个。
使用 if 后,圆括号内的部分就是你想设定的条件,其中会计算出一个布尔值,例如 if (a > b) ,如果结果为 true 就执行语句体,不执行就出去。 而如果想为 true 就执行语句体1,为 false 就执行语句体2,就可以使用 if else 这个结构,它适用于两种情况都分别处理的情况。 第三种情况更加多样,它允许你指定多个 if 条件,从第二个开始用 else if 表示,只有当 if 中的条件全部不满足时候,才会执行 else
if (比较表达式) {
语句体;
}
if (比较表达式) {
语句体1;
} else {
语句体2;
}
if (比较表达式) {
语句体1;
} else if (比较表达式2) {
语句体2;
} else if (比较表达式3) {
语句体3;
} else {
语句体4;
}
这里有几个点要说明一下:
switch 语句也是一种选择结构,并且在一些情况下看起来更加简洁明了。
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体 n + 1;
break;
}
格式解释:
注意:
以下条件选用switch:
原因:
举例:
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("input your score");
int score = sc.nextInt();
score = score / 10;
switch (score) {
case 9:
System.out.println("very good");
break;
case 8:
System.out.println("good");
break;
case 7:
System.out.println("ok");
break;
case 6:
System.out.println("just so so");
break;
default:
System.out.println("once again");
}
}
循环语句,顾名思义就是把一些代码,按我们要求的次数,多次循环执行,例如需要重复执行的语句等等。主要有三种:for 循环、while 循环、do…while 循环。
for 循环堪称最常见的循环了,它不仅适用于循环次数明确的情况,也适用于循环次数不明确的情况(满足条件继续循环,不满足就跳出) 格式:
for(初始化语句, 判断条件语句, 控制条件语句){
循环语句
}
public static void main(String[] args) {
int sum1 = 0;
for (int x = 1; x <= 10; x++){
sum1 += x;
}
System.out.println("sum(1-100): " + sum1);
System.out.println("--------------------");
int sum2 = 0;
for (int x = 1; x <= 100; x++){
if(x % 2 == 0){
sum2 += x;
}
}
System.out.println("sum(1-100): 偶数和" + sum2);
}
结果:
sum(1-100): 5050
--------------------
sum(1-100): 偶数和2550
求偶数和还有一个办法:
for ( int x = 0; x <= 100; x += 2){
Sum += x
}
int jc = 1; //定义最终结果变量
for ( int x = 1; x <= 5; x++ ){
Jc *= x
}
Ge: 153 % 10 =3
Shi :153 / 10 % 10 = 5
Bai: 153 / 10 / 10 % 10 = 1
Qian:x/10/10/10%10
Wan :x/10/10/10/10%10
判断条件表达式的值为逻辑真时,重复执行循环体(不满足出去) 格式
while(判断条件语句){
循环语句;
控制条件语句;
}
while(true){
循环体
}
for(;;){
循环体
}
注意:一定设置结束条件,否则就会一直死循环。
使用区别:
另一种理解:
先执行循环体,再判断继续条件不为逻辑真时,再执行循环体并判断条 件, 直到条件为假转去执行while下面的语句(不满足出去),所以至少要执行一次。 格式
do{
循环语句
} while(判断条件语句)
break 的意思是中断 适用:switch、循环语句中(循环语句中加入了if判断的情况) 跳出单层循环(从最近的封闭循环体中跳出) 若想跳出多层循环 需要使用带标签的语句
wc:for(int x = 0; x < 3; x++){ // wc:外层
nc:for(int y = 0; y < 4; y++){ nc:内层
if(y == 2){
break nc;
}
}
}
continue 的意思是跳出一次循环进入下一次的执行。
return关键字不是为了跳出循环体,更常用的功能是(结束一个方法),也就是退出一个方法。跳转到上层调用的方法。
🔥️ 语雀地址:
🔥️ 本篇语雀地址:
🔥️ 或者点击左下角 “阅读原文”