Java面向过程编程的学习

一.Java的基础结构:

1
2
3
4
5
6
public class Main {
public static void main(String[] args){
System.out.println("hello world!");
}

}

一个经典的输出hello world的例子,来介绍一下结构:

main : 在Java中称为主方法,main 是Java程序的入口点 所有的程序代码都写在main 方法下

1
2
3
public static void main(String[] args){
System.out.println("hello world!");
}

括号内包裹了两个参数 使用 System.out.println(“hello world!”); 来输出hello world!

在括号内的执行顺序是重上往下的,因此我们可以追加输出:你好,世界!

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
System.out.println("hello world!");
System.out.println("你好世界!");
}

}

public的main 要和文件名相互对应

二.Java的注释

每个程序语言都有自己的注释,比如Python C 以及其他语言,Java语言也有自己的注释 同样也分为多行注释和单行注释

  • 单行注释 : //
  • 多行注释 :/* */

例子:

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args){
System.out.println("hello world!");
System.out.println("你好世界!");
//我是一个单行注释
}

}

注释中的语句会被程序忽略 单行注释只能跟一行 无法跟多行

多行注释;

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args){
System.out.println("hello world!");
System.out.println("你好世界!");
/**你好
我是一个多行注释
**/
}

}

三.变量与常量的定义

在Java中,我们使用下面这种方式来定定义变量:

1
<数据类型> <变量名>

比如:

1
2
3
4
5
6
public class Main {
public static void main(String[] args){
int a=1;
}

}

或者同时声明两个变量:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
int a =1,b=2;
System.out.println(a);
System.out.println(b);
}
}

int a =1,b=2 中间用逗号隔开即可同时声明两个变量

或者变量之间互相赋值:

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args){
int a = 1;
int b = a;
System.out.println(a);
System.out.println(b);
}
}

3.1 常量的定义

常量不可修改 使用final 关键字进行声明:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
final int a = 1;
System.out.println(a);

}
}

使用final声明的变量不能被修改 否则会报错

四:基础的数据类型

在Java中,整数类型分为四种:byte,short,int,long 这几种整数类型的范围都不一样

整数型

1.Byte字节型

byte的取值范围在-128~127之间 如果超出范围就会报错

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
final byte a = 129;
System.out.println(a);

}
}

2.long 长整数类型

长整数类型的范围在-9223372036854775808L ~ 9223372036854775807L 是一个非常大的数字

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
long a = 222222222222222222;
System.out.println(a);

}
}

以上是一个错误示例 输入的数字类型默认为int ,想要让其转为长整数可以在数字类型后面加个222222222222222222L

上面的代码例子输出;

正确的案例:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
long a = 222222222222222222L;
System.out.println(a);

}
}

输出:

1
2
3
4
G:\java8\bin\java.exe "-javaagent:E:\IntelliJ IDEA 2026.2.0.1\lib\idea_rt.jar=7089" -Dfile.encoding=UTF-8 -classpath G:\java8\jre\lib\charsets.jar;G:\java8\jre\lib\deploy.jar;G:\java8\jre\lib\ext\access-bridge-32.jar;G:\java8\jre\lib\ext\cldrdata.jar;G:\java8\jre\lib\ext\dnsns.jar;G:\java8\jre\lib\ext\jaccess.jar;G:\java8\jre\lib\ext\jfxrt.jar;G:\java8\jre\lib\ext\localedata.jar;G:\java8\jre\lib\ext\nashorn.jar;G:\java8\jre\lib\ext\sunec.jar;G:\java8\jre\lib\ext\sunjce_provider.jar;G:\java8\jre\lib\ext\sunmscapi.jar;G:\java8\jre\lib\ext\sunpkcs11.jar;G:\java8\jre\lib\ext\zipfs.jar;G:\java8\jre\lib\javaws.jar;G:\java8\jre\lib\jce.jar;G:\java8\jre\lib\jfr.jar;G:\java8\jre\lib\jfxswt.jar;G:\java8\jre\lib\jsse.jar;G:\java8\jre\lib\management-agent.jar;G:\java8\jre\lib\plugin.jar;G:\java8\jre\lib\resources.jar;G:\java8\jre\lib\rt.jar;G:\JavaProject\Test1\out\production\Test1 Main
222222222222222222

进程已结束,退出代码为 0

补充:在最大值后面加1 则会让变量值返回到负数 整数型的所有类型都一样:

1
-9223372036854775808L
1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
long a = 9223372036854775807L;
System.out.println(a+1);

}
}

返回:

1
2
3
4
5
G:\java8\bin\java.exe "-javaagent:E:\IntelliJ IDEA 2026.2.0.1\lib\idea_rt.jar=2095" -Dfile.encoding=UTF-8 -classpath G:\java8\jre\lib\charsets.jar;G:\java8\jre\lib\deploy.jar;G:\java8\jre\lib\ext\access-bridge-32.jar;G:\java8\jre\lib\ext\cldrdata.jar;G:\java8\jre\lib\ext\dnsns.jar;G:\java8\jre\lib\ext\jaccess.jar;G:\java8\jre\lib\ext\jfxrt.jar;G:\java8\jre\lib\ext\localedata.jar;G:\java8\jre\lib\ext\nashorn.jar;G:\java8\jre\lib\ext\sunec.jar;G:\java8\jre\lib\ext\sunjce_provider.jar;G:\java8\jre\lib\ext\sunmscapi.jar;G:\java8\jre\lib\ext\sunpkcs11.jar;G:\java8\jre\lib\ext\zipfs.jar;G:\java8\jre\lib\javaws.jar;G:\java8\jre\lib\jce.jar;G:\java8\jre\lib\jfr.jar;G:\java8\jre\lib\jfxswt.jar;G:\java8\jre\lib\jsse.jar;G:\java8\jre\lib\management-agent.jar;G:\java8\jre\lib\plugin.jar;G:\java8\jre\lib\resources.jar;G:\java8\jre\lib\rt.jar;G:\JavaProject\Test1\out\production\Test1 Main
-9223372036854775808

进程已结束,退出代码为 0

3.int整数型

经典的整数型 范围在-2,147,483,648 ~ 2,147,483,647 区间:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
int a = 2147483647;
System.out.println(a);

}
}

4.short短整数型

short的取值类型在-32,768 ~ 32,767 这个区间

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
short a = 32767;
System.out.println(a);

}
}

在 Java 中,长整数赋值给短整数会报错,必须进行显式强制转换;而短整数赋值给长整数则可以隐式转换,不会报错。

浮点数型:

1.经典float型

float是单精度浮点数 范围:±3.40282347×1038±3.40282347×10

创建一个单精度浮点数:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args){
float a = 1.1F;


}
}

在Java中,浮点数末尾要加上F 否则默认是Double类型的

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args){
float a = 1.1F;
System.out.println(a);


}
}

输出1.1

2.double型浮点数

1
2
3
4
5
6
public class Main {
public static void main(String[] args){
double a = 1.1;
System.out.println(a);
}
}

输出1.1

将double赋值给float会发生错误 ,float的精度不如double:

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args){

double d = 3.14;
float f = d;
}
}


长整型long赋值为double不会报错:

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args){

long d = 100L;
double a = d;

}
}


因为float和double的范围比long要大很多

将int类型的值赋值给任意浮点类型会发生隐式转换:

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args){
int a=100;
float b = a; //这里发生隐式转换
System.out.println(b);


}
}

输出100.0

浮点数型介绍完毕

字符型

1.char 字符型

(16个bit,也就是2字节,它不带符号)范围是0 ~ 65535 可以表示一切字符的数据 使用char进行声明:

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {

char a = 'a';
System.out.println(a);
}
}

char只能放入单个字符 ,无法放入一组字符,否则会报错 因为char会映射ascii 同时 char也能将数字(ascii码)转换成对应的字母

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {

char a = 65;
System.out.println(a);
}
}

这里扩展一个知识 给int赋值为整数,通过print输出会返回相应的Unicode编码:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = '淦';
System.out.println(a);
}
}
//返回28134

Java 因为采用 Unicode 字符集,所以支持中文变量名;同时,编译时对源文件编码的多选项,保证了不同环境下中文源码都能被正确处理:

1
2
3
4
5
6
public class Main {
public static void main(String[] args) {
char 字母 = 'a';
System.out.println(字母);
}
}

正常输出a

由于char只能表示一个字符 因此我们利用下面的类型String:

2.String 字符串类型

1
2
3
4
5
6
public class Main {
public static void main(String[] args) {
String name = "Nxg7";
System.out.println(name);
}
}

String 在实际中是比较常见的类型,用于表示长串的字符

另外String并不是基础数据类型 是对象类型

布尔型

用于表示状态:

  • true 为真
  • false 为假

使用boolean进行声明:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
boolean a = true;
System.out.println(a);
}
}

布尔值中只有两个值:

true false 如果赋其他值会报错

布尔类型的变量通常用作流程控制判断语句(不同于C语言,C语言中一般使用0表示false,除0以外的所有数都表示true)布尔类型占据的空间大小并未明确定义,而是根据不同的JVM会有不同的实现。

五.程序的运算符

1.赋值运算符

用于给变量进行赋值操作

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
}
}

是我们一直在用的运算符 还可以进行连续赋值:

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args) {
int a;
int b = a = 222;
System.out.println(a);
System.out.println(b);
}
}

2.算数运算符

经典的+ - * / 这些

  • 加号运算符(+)
1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 1+1;
System.out.println(a);
}
}

输出2:

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
int a = 1;
int b = a+1 ;
System.out.println(b);
}
}

减法运算符(-):

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
int a = 10;
int b = a-1 ;
System.out.println(b);
}
}

输出9

不同类型的数据 相加减会发生隐式转换

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
int a = 1;
short b = 3;
int c = a+b;
System.out.println(c);
}
}

c被定义了int 然后a+b的结果会自动转换成int

小数和整数一起计算同样会发生隐式类型转换:

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args) {
float a = 1.1F;
int b = 19;
double c = a+b;
System.out.println(c);
}
}

+号 也可以对字符进行拼接:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
String a = "Nx";
System.out.println(a+"g7");
}
}

输出Nxg7

字符串也可以和各种数据类型拼接:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
String a = "Nx"+1.5+1+true;
System.out.println(a+"g7");
}
}

输出Nx1.5trueg7

除法运算符:/

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
int a = 8;
int b = 3;
System.out.println(a/b);
}
}

只取整数 输出2 后面的不输出

但是浮点数之间的运算就可以进行取小数

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
double a = 8.0, b = 5.0;
System.out.println(a / b);
}
}

返回1.6

整数和小数也会发生隐式转换

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
double a = 8.0;
int b = 5;
System.out.println(a / b);
}
}

运行结果为1.6 也就是浮点数(double)

乘法运算符: *

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 5;
int b =5;
System.out.println(a*b);
}
}

输出25

取模运算: %

只进行取余数:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 9;
int b =5;
System.out.println(a%b);
}
}

输出4 , 余数是4

3.自增运算符

当我们想进行自增操作的时候可以:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 9;
int b = a+1;
System.out.println(b);
}
}

输出10 但是我们可以使用自增运算符

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 9;
int b = ++a;
System.out.println(b);
}
}

一样也能输出10 在原来的基础上增加了一个1

自增运算符也可以放在后面:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 8;
int b = a++;
System.out.println(b);
}
}

与++a的区别是:a++先取原值,再自增 所以这里的 System.out.println(b); 是输出8 而不是9

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
int a = 8;
int b = a++; //先出结果,再自增
System.out.println(b); //b得到的是a自增前的值
System.out.println(a); //此时输出a,a变为9
}
}

自减运算符也是如此:–a,a–

4.位运算符

位运算符包括以下几个:

& ^ | ~

先介绍第一个:& 位与:两个同为1,结果才是1,举例:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 8;
int b = 5;
System.out.println(a&b);
}
}

8的二进制:1000

5的二进制:0101

每一位进行比较:

0:1 ->0

0:0->0

0:1->0

1:0->0

每一位的比较结果为0,因此返回0

例2:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 7;
int b = 5;
System.out.println(a&b);
}
}

7: 0111

5: 0101

0:0->0

1:1 -> 1

1:0->0

1:1->1

返回0101 也就是十进制数5,记住是从左往右的顺序依次进行比较

2.^

一句话总结:相同为0,不同为1

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 7;
int b = 5;
System.out.println(a^b);
}
}

7: 0111

5: 0101

1:1->0

1:0->1

1:1->0

0:0 ->0

0100

十进制就是4,因此代码返回4

六.作用域以及选择结构

6.1代码块和作用域

1.代码块就是被大括号包裹的语句

1
2
3
4
5
public class Main {
public static void main(String[] args) {
//xxxxx
}
} //被大括号包裹的部分称为代码块
2.作用域

变量中都有作用域,不可以在没有进行全局声明的情况下,直接引用局部变量,否则内部会无法解析报错,我们来看个例子:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 1;

}
System.out.println(a);
}

就像这样,a并没有在 public static 中定义,而是在Main中定义 所以读取不到,正确写法应该是:

1
2
3
4
5
6
public class Main {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
}
}
6.2选择结构

6.2.1 选择结构-1 if 语句

if语句的结构:

1
if (表达式) 执行的语句

很好理解,满足表达式的代码会被执行,如果只有一行代码,则可以省略花括号

1
2
3
4
5
6
public class Main {
public static void main(String[] args) {
boolean a = true;
if(a==true) System.out.println("a的值为"+a);
}
}

补充:当不加花括号时,if后存在多个代码,不满足条件时,紧挨if 后的第一个代码不会被执行:

1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
boolean a = false;
if(a==true) System.out.println("a的值为"+a);System.out.println("我会被输出");

}
}

像上面的例子: 语句 System.out.println(“a的值为”+a) 就不会被执行,因为if 中 a 的值必须为true,而实际上a的值为False,所以只会执行System.out.println(“我会被输出”);

else结构:不满足if (表达式) 条件的代码进入else分支

同if 一样,只有一行代码的情况下,不需要加上花括号{}

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args) {
boolean a = false;
if(a==true) {
System.out.println("a的值为" + a);
System.out.println("我会被输出");
}
else System.out.println("我会被输出");
}
}

但是前提是存在if代码块:

1
if (表达式) {语句}
1
2
3
if (表达式) {语句}
else
{语句}

上面是if else的代码块 区别就是可以写更多代码,泛用性也更强

6.3三元运算符
1
2
3
4
5
6
7
public class Main {
public static void main(String[] args) {
int a = 11;
char b = a == 11 ? 'A' : 'B';
System.out.println(b);
}
}

输出A , 这个和if else的效果是一样的 ,满足a==11 输出A 否则输出B

6.4 else if 结构

​ 相对于if else 可以写入多个表达式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Main {
public static void main(String[] args) {
int a = 61;
if (a > 100 || a < 0) {
System.out.print("重新填写你的分数");
} else if (a >= 80) {
System.out.print("优秀");
} else if (a >= 60) {
System.out.print("及格");
} else {
System.out.print("不及格");
}
}
}

选择结构分支是自上而下来执行,61不满足 >=80 进入条件B a >= 60 ,因此输出及格

6.5 switch选择结构
1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
int a = 60;
switch (a) {
case 60:
System.out.println("及格");
break;
case 90:
System.out.println("优秀");
}
}
}

使用switch case来进行分支判断

case相当于if中的 =

1
2
switch (a) {
case 60:

相当于选择变量a , case为= a的值为60,执行下面的语句

1
System.out.println("及格");

switch 中也可以嵌套if else语句

6.5.1 switch语句加强

在Java14中,可以给switch进行赋值

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
int a = 60;
String b = switch (a) {
case 20, 30, 60 -> "及格";
case 90, 100 -> "优秀";
default -> "其他";
};
System.out.println(b);
}
}

b的类型为字符串,值为及格,在新版中,可以给多个case值判断结果

case xxx -> 也可以嵌套代码块

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Main {
public static void main(String[] args) {
int a = 2;
String result = switch (a) {
case 1 -> "a";
case 2 -> {
System.out.printf("我是B");
yield "我是B";
}
default -> "a";
}
;}

}

但是代码块要强制加上 yield ,yield 相当于总结 ,就是代码块中代码运行的结果 **case 2 这个分支的最终结果就是 "我是B"**,这个值会被赋给左边的 result

也就是result 在这个分支的值为我是B , 代码块不加yield会导致编译错误,同样代码块中也可以嵌套if else语句

七.Java中的循环结构

7.1 while 循环

如果我们想打印5次以下这段话:

1
"JavaSec入门"

可以使用第一种方式:

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args) {
System.out.println("JavaSec入门");
System.out.println("JavaSec入门");
System.out.println("JavaSec入门");
System.out.println("JavaSec入门");
System.out.println("JavaSec入门");

}
}

可以输入五次 “JavaSec入门” , 但是,万一需要打印100条呢?这时候循环结构就派上用场了

结构:

1
2
3
while (表达式) {
执行的代码;
}

如果想利用while来执行输出5次”JavaSec入门” ,先要定义一个计数器:

1
int a = 0;

a的初始次数为0,接下来while的表达式写0<5

1
2
3
while(0<5) {
循环体执行语句;
}

代码块写入:

1
2
3
4
while(0<5) {
System.out.println("JavaSec入门");
a++;
}

这个代码的意思就是每当输出一次a的计数器值就累加一次

1
2
3
4
5
JavaSec入门
JavaSec入门
JavaSec入门
JavaSec入门
JavaSec入门

因此一共输出5次JavaSec入门,这里有个坑,如果a的值是1的话,就只能输出4次,第二次执行是从2开始的

2,3,4,5

7.2 for 循环

和while循环的结构很像,但是加强了很多东西,语法结构

1
2
3
for (表达式1;表达式2;表达式3....) {
循环体执行语句;
}

while只能写一个表达式,但是for循环能写多个表达式,比如我们想利用for循环来输出JavaSec入门

1
2
3
4
5
6
7
8
public class Main {
public static void main(String[] args) {
for (int i = 0; i<5 ;i++) {
System.out.println("JavaSec入门");
}

}
}

输出:

1
2
3
4
5
JavaSec入门
JavaSec入门
JavaSec入门
JavaSec入门
JavaSec入门

注意:这里的i是局部变量,及变量限制在了 for () 括号的表达式中 ,离开循环体语句无法使用

for的表达式也可以引用全局变量:

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args) {
int i = 0;
for (; i<5 ;i++) {

System.out.println("JavaSec入门");
}

}
}

这里的表达式中,必须要添加; 另外循环体可以写多个语句

1
2
3
4
5
6
7
8
9
10
11
public class Main {
public static void main(String[] args) {
int i = 0;
for ( ; i<5 ;i++) {

System.out.println("JavaSec入门");
System.out.println(i);
}

}
}

输出结果:

1
2
3
4
5
6
7
8
9
10
JavaSec入门
0
JavaSec入门
1
JavaSec入门
2
JavaSec入门
3
JavaSec入门
4

循环体中也可以嵌套if,或者双层嵌套for

先举第一个例子:如果i的值为4那么输出我是4

1
2
3
4
5
6
7
8
9
10
11
12
public class Main {
public static void main(String[] args) {
int i = 0;
for ( ; i<5 ;i++) {
if (i==4){
System.out.println("我是数字4");
}
System.out.println(i);
}

}
}

输出的结果会变成:

1
2
3
4
5
6
0
1
2
3
我是数字4
4

双层嵌套打印99乘法表:

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args) {
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + "*" + i + "=" + (i * j) + "\t");
}
System.out.println();
}
}
}

外层循环控制行,内层循环控制列:

外层 int i = 0; 控制1,2,3,4……

内层 int j = 0 ; 控制 列的1,2,3,4…..

最后拼接输出 括号中 (i*j)的结果使用 System.out.println(); 换行

1
2
3
4
5
6
7
8
9
1*1=1	
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
7.3 continue和break跳出循环

假如在写代码的过程中,我们想要代码在某个循环停止并进入下一个循环的时候,就可以使用continue关键字进入下一个循环

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args) {
for (int i = 0; i <= 9; i++) {
if (i==3) {
continue;
}
System.out.println(i);
}
}
}

如果i=3的时候,跳出循环体,进入下一个循环

1
2
3
4
5
6
7
8
9
0
1
2
4
5
6
7
8
9

可以看到3没有被输出,而是直接进入到了4,这就是continue 的作用,跳出本轮循环

break 关键字跳出整个循环:

1
2
3
4
5
6
7
8
9
10
public class Main {
public static void main(String[] args) {
for (int i = 0; i <= 9; i++) {
if (i==3) {
break;
}
System.out.println(i);
}
}
}

也用于跳出循环,但是是跳出整个循环体,输出0,1,2

1
2
3
0
1
2

当存在多层循环嵌套,break和continue 遵循就近原则,也就是哪个循环近就对哪个循环生效

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Main {
public static void main(String[] args) {
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= 9; j++) {
if (j == 3) {
continue;
}
System.out.print(j);
System.out.println();
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9
1
2
4
5
6
7
8
9

内层循环中的j==3被跳过了

7.4 do….while循环

do….while的语法是:

1
do {} while ();

和其他两个的区别是,不管while的表达式是否生效,都先执行do{}语句的内容

1
2
3
4
5
6
7
8
9
public class Main {
public static void main(String[] args) {
int a = 0;
do {
System.out.println("你好世界");
a++;
} while (a < 10);
}
}

先执行语句,再执行循环,尽管看上去和for 或者while没有任何区别但是执行顺序不一样

八.JShell交互式编程

在其他语言中例如python中,在终端输入python即可弹出交互式命令行编程,在Java中,Java9及以上版本中JShell实现了这种功能 在命令行输入jshell即可进入

1
2
3
4
5
6
7
C:\Users\alast\Downloads>jshell
| 欢迎使用 JShell -- 版本 21.0.5
| 要大致了解该版本, 请键入: /help intro



jshell>

输入代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
C:\Users\alast\Downloads>jshell
| 欢迎使用 JShell -- 版本 21.0.5
| 要大致了解该版本, 请键入: /help intro



jshell>
jshell> int a = 1;
a ==> 1

jshell> System.out.print(a);
1
jshell>

输入过程中可以使用tab进行补齐操作

至此,面向过程的编程告一段落,下面就是Java的面向对象的学习