Java-基础知识

1变量与数据类型

1.1 标识符

java对包、类、方法、参数和变量等要素命名时使用的字符序列为标识符

命名规则如下：

• 由字母、数字、下划线（_）和美元符号（ $ ）组成
• 不能以数字开头
• 区分大小写
• 长度无限制
• 不能是java中的保留关键字
  命名规范：
  标识符命名习惯：见名知意
  类名规范：首字母大写，后面每个单词首字母大写（大驼峰）
  方法名规范：首字母小写，后面每个单词首字母大写（小驼峰）
  变量名规范：首字母小写，后面每个单词首字母大写
  包名规范：全部小写

1.2 关键字

java中一些赋予特定的含义，有专门用途的字符串称为字符串（keyword），全是小写

保留字：没有定义用途，但保留备用
例如：goto,const

1.3 进制

1.3.1 二进制

• 计算机中的数据都以二进制保存
• 二进制：逢二进一。即只有0、1两个值。
  如：十进制的10在计算机内保存为二进制的1010
• 计算机中信息的存储单位
  位（Bit）：表示一个二进制数码0或1，是计算机存储处理信息的最基本的单位。
  字节（Byte）：一个字节由8个位组成。它表示作为一个完整处理单位的8个二进制数码。
  字：32位计算机：1字=32位=4字节，64位计算机：1字=64位=8字节

1.3.2 十六进制 0x

二进制表示法太冗长，所以在程序中一般喜欢用十六进制。
十六进制：基数为十六，逢十六进一。它用abcdef表示从0-9之上的值。
Java中十六进制数据要以0x或0X开头。如：0x23D
十六进制转换成二进制只需将每个十六进制数字替换为相对应的四个二进制位即可

二进制	十六进制
0000	0
0001	1
0010	2
0011	3
0100	4
0101	5
0110	6
0111	7
1000	8
1001	9
1010	A
1011	B
1100	C
1101	D
1110	E
1111	F

1.3.3 八进制

八进制：基数为八。
Java中八进制数据要以0开头。如：0123
八进制转换成二进制：只需将每个八进制数字替换为相对应的三个二进制位即可。
现在的计算机系统很少用八进制的了。

二进制	八进制
000	0
001	1
010	2
011	3
100	4
101	5
110	6
111	7

1.3.4 原码、反码、补码

1. 原码

十进制数据的二进制表现形式就是原码，原码最左边的一个数字就是符号位，0为正，1为负。
例如：56 -> 0 0 1 1 1 0 0 0
左边第一位为符号位，其他位为数据位。
一个 byte 有 8bit，最大值是 0 1 1 1 1 1 1 1 (+127)，最小值是 1 1 1 1 1 1 1 1 (-127)
在计算机中之所以使用二进制来表示原码是因为逻辑简单，对于电路来说只有开或者关两种状态，用二进制是在方便不过的了。如果使用的进制是十进制、八进制或者十六进制的话，电路没有办法表示那么
多的状态
（1）正数计算
使用原码对正数进行计算不会有任何问题的
例如：5 + 2
把这个结果转成十进制刚好就等于 7，完全正确无误
（2）负数计算
但是如果是负数的话，那计算的结果就会大相径庭了
我们拿 -56 这个数字来举例，它的原码是 1 0 1 1 1 0 0 0 ，减一之后，就会变成 1 0 1 1 0 1 1 1 ，这个数转成十进制就是 -55。计算前是 -56，减一之后正确的结果应该是 -57（1 0 1 1 1 0 0 1）才对，居然还越减越大了

为了解决原码不能用于计算负数的这种问题，这时候，反码它出现了，作为负数的“计算的救星”。
计算规则是正数的反码不变和原码一致，负数的反码会在原码的基础上，高位的符号位不变，其他位取反（ 1 变成 0 ， 0 变为 1 ）

2. 反码
   正数的反码是其本身（等于原码），负数的反码是符号位保持不变，其余位取反。 反码的存在是为了正确计算负数，因为原码不能用于计算负数
   
   （1）负数计算
   这时候，我们再来使用反码计算一下 -56 - 1 的结果-56 的原码是 1 0 1 1 1 0 0 0 ，如果转成反码（符号位不变，其他位取反），那么它的反码就是 1 1 0 0 0 1 1 1
   
   -56 -1 = -57，-57 的原码是 1 0 1 1 1 0 0 1，转成反码刚好是 1 1 0 0 0 1 1 0，刚好等于刚才我们算出的值
   （2）跨零计算
   不过反码也有它的 “ 软肋 ”，如果是负数跨零进行计算的话，计算得出的结果不对
   我们拿 -3 + 5 来举例
   -3 的原码是 1 0 0 0 0 0 1 1，转成反码的话就是 1 1 1 1 1 1 0 0
   
   把计算结果转成十进制就是 1，这结果显然不对。那么我们该怎么计算呢，这时候，作为反码的补充编码 —— 补码就出现了。
3. 补码
   正数的补码是其本身，负数的补码等于其反码 +1。
   因为反码不能解决负数跨零（类似于 -6 + 7）的问题，所以补码出现了。
   
   （1）跨零计算
   这时候，我们再来使用反码计算一下 -3 + 5 的结果
   -3 的原码是 1 0 0 0 0 0 1 1，转成反码的话就是 1 1 1 1 1 1 0 0，再转成补码就是 1 1 1 1 1 1 0 1
   
   把这个数转成十进制刚好等于2，结果正确

总结

• 原码：最高位符号位，0表示正数，1:表示负数
• 反码：正数的补码不变，负数反码：符号位不变，其他按位取反，解决负数的计算问题
• 补码：正数的补码不变，负数补码是反码+1，解决跨零计算问题

1.2 数据类型

1.2.1 基本数据类型

程序处理的都是数据，由于不同数据的内容大小不同, 导致所需的存储单元大小不同，在Java语言中使用
数据类型的概念加以描述 。
字节是计算机技术用于计量存储容量的一种计量单位，作为一个单位来处理的一个二进制数字串，是构
成信息的一个小单位。Java中的字节是八位的字节，即它包含八位的二进制数。

1.2.2 基本数据类型转换

• 自动类型转换 小变大：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：
  
• 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再
  进行计算。
• byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型。
• boolean类型不能与其它数据类型运算。
• 当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

1.2.3 字符串类型：String

• String不是基本数据类型，属于引用数据类型
• 使用方式与基本数据类型一致。例如：String str = “abcd”;
• 一个字符串可以串接另一个字符串，也可以直接串接其他类型的数据。例如：

（从左到右执行）

1.2.4 强制类型转换 大变小 会降精度

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出,格外要注意。

• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

• boolean类型不可以转换为其它的数据类型。

string强制转换成int

String a="43";
int i=Integer.parseInt(a);

注意，如果字符串无法被解析为合法的整数，比如包含非数字字符或超出整数的取值范围，将会抛出 NumberFormatException 异常。因此，在使用 Integer.parseInt() 进行字符串到整数的转换时，请确保字符串中只包含合法的数字字符。

string强制转换成double

String str = "3.14";
double d = Double.parseDouble(str);

1.3 变量

1.3.1 定义

变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。简单理解就是内存中一块空间的
表示。
由于该存储单元中的数据可以发生改变，因此得名为"变量"。

1.3.2 声明变量

1. 方式1：先声明变量后赋值
   语法：
   数据类型 变量名；
   变量名=值；
2. 方式2：声明变量的同时赋初值
   语法：
   数据类型 变量名=值；

1.3.3 变量使用

package lina;
/*
* 变量的声明与使用
*/
public class Demo02_var {
public static void main(String[] args) {
//1、声明变量
//1.1 先声明后赋值：数据类型 变量名称；
int age;//声明
age=18;//赋值
//1.2 声明变量的同时赋初值：数据类型 变量名称=初值；
double money=1000.0;
//2、变量的使用：先声明并赋值之后才能使用
System.out.println("年龄是："+age);
System.out.println("私房钱有："+money);
//System.out.println(name);//错误 没有声明
//其他类型的变量
float num=12.5F;//小数点的数字默认是double类型，如果赋值给float,需要在值后面
加上后缀f 大小写都OK
long num2=100L;//整数数字默认是int类型，long类型的 变量的值后面可以添加L后
缀，也可以省略（省略的时候暗含类型转换,但是不能超过int的范围，否则不能省略）
char gender='男';//字符类型的值必须使用单引号引起来
String str="我爱你中国";//字符串类型的值必须使用双引号引起来
System.out.println(num);
System.out.println(num2);
System.out.println(gender);
System.out.println(str);
}
}

1.3.4 控制台输入

package lina;
import java.util.Scanner;
/**
* 控制台输入
*
*/
public class Demo03_input {
public static void main(String[] args) {
//理解为扫描仪
Scanner input=new Scanner(System.in);//需要导入java.util.Scanner;
System.out.print("请输入您的年龄：");
int age=18;//声明变量并附了初值
//调用扫描仪的功能干活
age=input.nextInt();//扫描整数
System.out.print("请输入您的私房钱：");
double money=input.nextDouble();//扫描小数
System.out.print("请输入您的姓名：");
String name=input.next();//扫描字符串，空格不能扫描
System.out.print("请输入性别：M/F");
char gender=input.next().charAt(0);//扫描字符
System.out.println("你是单身嘛？");
boolean isSingle=input.nextBoolean();//扫描boolean类型
System.out.println("输入的年龄是："+age);
System.out.println(money);
System.out.println(name);
System.out.println(gender);
System.out.println(isSingle);
input.close();//可以省略，避免有黄色的警告
}
}

在Java中，nextLine()和next()是Scanner类的两个方法，用于从标准输入中读取用户输入的内容。它们之间有一些重要的区别。

1. nextLine()方法：

   • 读取一行完整的输入，包括空格和特殊字符，直到遇到换行符（回车键）为止。
   • 返回类型为String，表示整行输入的内容。
   • 例如，String line = scanner.nextLine();

2. next()方法：

   • 读取输入中的下一个单词（以空格为分隔符）或下一个完整的标记。
   • 返回类型为String，表示下一个单词或标记。
   • 例如，String word = scanner.next();

下面是一个示例，演示了nextLine()和next()的差异：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一行文本：");
        String line = scanner.nextLine();
        System.out.println("输入的整行文本是：" + line);

        System.out.print("请输入多个单词：");
        String word1 = scanner.next();
        String word2 = scanner.next();
        System.out.println("输入的第一个单词是：" + word1);
        System.out.println("输入的第二个单词是：" + word2);

        scanner.close();
    }
}

请输入一行文本：i am genius
你输入的文本是： i am genius
请输入多个词：i am genius
你输入的第一个词是： i

在这个示例中，首先使用nextLine()方法读取整行文本，然后使用next()方法分别读取多个单词。注意，next()遇到空格或换行符时会停止读取。用户输入的内容将被打印到控制台。

需要注意的是，由于next()和nextLine()方法的使用方式不同，它们会对输入流产生影响。如果在调用nextLine()之前先调用了nextInt()、nextDouble()等方法，可能需要在输入之前调用scanner.nextLine()来消耗掉换行符。这是因为nextLine()方法会读取上一次输入后剩余的换行符。

2 运算符

2.1 算数运算符

++a:先加一再执行
a++:先执行后执行

        int a=6,b=6;
        //++a先自增再运算
        System.out.println(++a+7);
        //a++先运算再自增
        System.out.println(b+++7);

		14
		13

2.2 赋值运算符

赋值运算符作用是将一个值赋给一个变量，运算顺序从右到左

2.3 关系运算符

关系运算符作用是比较两边的操作数，结果总是boolean型的

2.4 逻辑运算符

逻辑运算符用于对boolean型结果的表达式进行运算，运算结果总是boolean型

短路与，短路或：前一个表达式能得出结果就不执行第二个表达式

 public static boolean f1(){
        System.out.println("f1");
        return false;
    }
    public static boolean f2(){
        System.out.println("f2");
        return true;
    }
    public static void main(String[] args) {

        System.out.println(f1()&f2());
        System.out.println("------------------");
        System.out.println(f1()&&f2());
        System.out.println("------------------");
        System.out.println(f1()|f2());
        System.out.println("------------------");
        System.out.println(f1()||f2());
    }

f1
f2
false
------------------
f1
false
------------------
f1
f2
true
------------------
f1
f2
true

2.5 字符串连接运算符

String s="He" + "llo";//结果"Hello"
//"+"除了可用于字符串相连接，也能将字符串与其它的数据类型相连成一个新的字符串。
//如：
String s="x" + 123;// 结果"x123"

2.6 三目运算符

X?Y:Z
X为boolean类型表达式（判断条件是否成立）
先计算x的值（判断），若为true,整个三目运算的结果为表达式y的值，否则为z。
例如：

int score = 75;
String type = score >=60 ? "及格" : "不及格";

及格

2.7 位运算符

位运算符对两个操作数中的每一个二进制位都进行运算
位运算符功能：
按位取反 ~
按位与 &
按位或 |
按位异或 ^

移位运算符
左移："a<<b; "将二进制形式的a逐位左移b位，最低位空出的b位补0
带符号右移："a>>b; "将二进制形式的a逐位右移b位，最高位空出的b位补原来的符号位
无符号右移："a>>>b;"将二进制形式的a逐位右移b位，最高位空出的b位补0

2.8 操作符优先级

优先 小括号

3 程序的流程控制

1996年，计算机科学家Bohm和Jacopini证明了：任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本结构组合而成。
它们的共同点是都包含一个入口和一个出口，它们的每个代码都有机会被执行，不会出现死循环

3.1 顺序结构

3.2 分支结构

又称为选择结构，根据条件成立与否来执行操作

3.2.1 基本选择结构 if-else

if(条件）{
	条件成立执行的内容；
}else{
	条件不成立执行的内容；
}

else if{
 .......
}

3.2.2 switch

替换等值判定的多重选择结构
语法

switch(表达式){
case 值1://相当于if(){}
//满足表达式的结果==值1的时候执行的代码
break;//退出当前的switch选择结构
case 值2://相当于else if(){}
//满足表达式的结果==值2的时候执行的代码
break;
......
case 值n:
//满足表达式的结果==值n的时候执行的代码
break;
default://相当于else
//以上的匹配都失败的时候执行的内容
break;
}
/*
表达式的返回值必须是下述几种类型之一：int, byte, char, short,String；
case子句中的取值必须是常量，且所有case子句中的取值应是不同的；
default子句是可选的；
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果case后面没有写break则直
接往下面执行！
Case后面的执行体可写{ }也可以不写{ }
*/

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 基金经理的业绩排名：1、欧洲游 2、东南亚游 3、国内游 其他：再接再厉！
System.out.println("请输入你的排名：");
int num = input.nextInt();
// 方式2：
switch (num) {// 小括号中的表达式或者变量结果类型可以是：int char String
byte short
case 1:// 相当于if(num==1){}//case 后面的值必须是常量 'A' "星期一"
System.out.println("奖励是：欧洲游");
break;// 执行完毕一个case分支后跳出switch语句块
case 2:// 相当于if(num==2)
System.out.println("奖励是：东南亚游");
break;
case 3:// 相当于if(num==3)
System.out.println("奖励是：国内游");
break;
default:// 相当于else ,是可选的
System.out.println("再接再厉");
break;
}
// 方式1：
/*
if (num == 1) {
System.out.println("奖励是：欧洲游");
} else if (num == 2) {
System.out.println("奖励是：东南亚游");
} else if (num == 3) {
System.out.println("奖励是：国内游");
} else {
System.out.println("再接再厉");
}
*/
}

用break

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
// 根据用户输入的月份，输出当月的天数，不考虑平年闰年
System.out.println("请输入月份：");
int month = input.nextInt();
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月共有31天！");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月共有30天！");
break;
case 2:
System.out.println(month + "月共有28天！");
break;
default:
System.out.println("您输入的月份有误！");
break;
}
}

3.2.3 字符串比较

• ==比较内存地址
• equlas比较内容
  在编程中，“==”（双等号）和equals()方法都用于比较两个值是否相等，但它们有一些不同之处。

"=="操作符主要用于比较基本类型（例如整数、字符等）和引用类型的变量。对于基本类型，它比较它们的值是否相等。对于引用类型，它比较的是对象的引用是否相等，即它们是否指向同一个内存地址。

举个例子：

int a = 5;
int b = 5;
System.out.println(a == b); // 输出true

String str1 = "Hello";
String str2 = new String("Hello");
System.out.println(str1 == str2); // 输出false，因为str1和str2指向的是不同的内存地址

equals()方法则用于比较两个对象的内容是否相等。在Java中，equals()方法是在Object类中定义的，可以被所有的对象继承和使用。默认情况下，它与"=="相同，也是比较两个对象的引用是否相等。但是，许多类（例如String、Integer等）覆盖了Object类中的equals()方法，以便比较对象的内容而不是引用。

举个例子：

String str1 = "Hello";
String str2 = new String("Hello");
System.out.println(str1.equals(str2)); // 输出true，因为String类覆盖了equals()方法，比较的是内容是否相等

总之，对于基本类型，可以使用"=="来比较它们的值是否相等。对于引用类型，通常使用equals()方法来比较它们的内容是否相等，但要注意不同类的equals()方法可能有不同的实现。

3.3 循环结构

循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。
循环两个点：1、循环操作 2、循环条件

3.3.1 while循环

语法
while(循环条件){
循环操作；
}
流程图

案例
1
int num=1;
while(num<=25){
sout(num);
num++;
}
2打印1-100内数字
int i=1;
while(i<=100){
sout(i);
i++;
}

3.3.2 do-while循环

语法
do{
循环操作；
}while(循环条件)；
//注意最后的分号！！！！！
流程图

特征：先执行后判断，循环至少执行一次
案例
用户登录，用户必须是admin,密码必须是12,否则登录失败

 public static void main(String[] args) {
        Scanner src = new Scanner(System.in);
        String name;
        int ps;
        do {
            System.out.println("输入你的名字");
            name = src.next();
            System.out.println("输入你的密码");
            ps = src.nextInt();
            if (!"admin".equals(name) | (ps != 12)) {
                System.out.println("登录失败，再次输入");
            } else {
                System.out.println("登录成功");

            }
        } while ((!"admin".equals(name) | (ps != 12)));
        // 注意：加小括号会引起 短路与 优先级问题
        //给ps!=12加括号会提高判断的优先级，导致如果true就不执行前面的 用户名 判断；
        /*
         do {
            System.out.println("输入你的名字");
            name = src.next();
            System.out.println("输入你的密码");
            ps = src.nextInt();
            if (!"admin".equals(name) || ps != 12) {
                System.out.println("登录失败，再次输入");
            } else {
                System.out.println("登录成功");
            }
        } while ((!"admin".equals(name) || ps != 12));
        */
        //白智炫：牛批
    }

3.3.3 for循环

idea快捷输入：
数组名.fori
score.fori

for (int i = 0; i < score.length; i++) {
            
}

语法
for(表达式1：定义循环变量；表达式2：循环条件；表达式3：循环变量的变化){
循环操作；
}
执行顺序

1. 先执行表达式1：定义循环变量，只执行一次
2. 判断表达式2 循环条件是否成立
3. 循环条件成立，执行循环操作，执行表达式3 循环变量变化；循环条件不成立，退出循环
   
   使用场合
   适合解决循环次数固定的题目

package lina;
public class Demo12_for {
public static void main(String[] args) {
//案例1：打印1-100
for (int i = 1; i <= 100; i++) {
System.out.println(i);
}
//案例2：打印1-100的所有的数字之和
//循环条件：没有加到100次
//循环操作：累加
int sum=0;
for(int k=1;k<=100;k++) {
sum=sum+k;
}
System.out.println("1-100之和："+sum);
//案例3：打印1-100之间所有的偶数
for(int i=1;i<=100;i++) {
if(i%2==0) {
System.out.println(i);
}
}
//可以仿写while的格式，语法正确，但是不推荐
// int j=1;
// for(;j<=100;) {
// System.out.println(j);
// j++;
// }
}
}

！！！增强for循环

public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int element : arr) {
            System.out.println(element);
        }
    }

1
2
3
4
5

增强for循环，也称为for-each循环，是一种用于遍历数组、集合或其他可迭代对象的简化循环结构。

它的语法形式如下：

for (元素类型 元素变量 : 可迭代对象) {
    // 迭代执行的代码
}

其中，元素类型 是要遍历的元素的数据类型，元素变量 是一个新声明的变量，用于存储每次迭代的元素值。可迭代对象 是一个数组、集合或其他实现了Iterable接口的对象。

举个例子，假设有一个整数数组 arr，我们可以使用增强for循环来遍历数组中的所有元素：

int[] arr = {1, 2, 3, 4, 5};

for (int element : arr) {
    System.out.println(element);
}

上述代码会依次输出数组中的每个元素。

增强for循环会自动迭代对象中的每个元素，并将其赋值给元素变量，然后执行相应的代码块。我们无需手动管理索引或迭代器，使代码更加简洁和易读。

需要注意的是，增强for循环只能用于遍历集合或数组等可迭代对象，不能直接用于遍历范围或其他非可迭代的数据结构。

总结起来，增强for循环提供了一种简化的遍历方式，能够方便地遍历数组、集合或其他可迭代对象中的元素，使代码更加简洁和易读。

3.3.4 死循环

3.3.5 break与continue

1.break

在编程中，"break"是用于中断循环或switch语句的关键字。

在循环语句（例如for循环、while循环、do-while循环）中，"break"可以用于提前终止循环，并跳出循环体之外的代码块。当满足某种条件时，可以使用"break"语句来立即结束循环。

举个例子，下面的代码使用for循环来遍历一个数组，当找到目标元素时，使用"break"语句中断循环：

int[] numbers = {1, 2, 3, 4, 5};
int target = 3;

for (int i = 0; i < numbers.length; i++) {
    if (numbers[i] == target) {
        System.out.println("目标元素找到了！");
        break; // 中断循环
    }
}

System.out.println("循环结束");

在上面的例子中，当找到目标元素3时，"break"语句被执行，循环立即中断，然后程序继续执行循环外的代码。

同样地，在switch语句中，"break"用于在满足条件的情况下退出整个switch语句。每个case分支通常以"break"语句结束，以防止执行其他case分支。

举个例子：

int day = 3;
switch (day) {
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    default:
        System.out.println("其他");
}

在上面的例子中，当day等于3时，打印出"星期三"，然后由于存在"break"语句，整个switch语句立即结束。

总结起来，"break"关键字用于中断循环或switch语句，并跳出相应的代码块。
2.continue
当次循环结束，进入下一次循环

在编程中，"continue"是一个关键字，用于跳过当前循环中剩余的代码，并开始下一次循环。

在循环语句（例如for循环、while循环、do-while循环）中，当满足某种条件时，可以使用"continue"语句来立即结束当前迭代，并开始下一次迭代。也就是说，它会跳过剩余的循环体代码，直接进入下一次迭代。

举个例子，下面的代码使用for循环来遍历一个数组，当遇到奇数时，使用"continue"语句跳过当前迭代：

int[] numbers = {1, 2, 3, 4, 5};

for (int i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 != 0) {
        continue; // 跳过奇数，开始下一次迭代
    }

    System.out.println(numbers[i]); // 只打印偶数
}

System.out.println("循环结束");

在上面的例子中，当遇到奇数时，“continue"语句会跳过当前迭代，然后直接进行下一次迭代。因此，只有偶数会被打印出来。最后，当循环结束时，会输出"循环结束”。

需要注意的是，"continue"语句只会跳过当前循环体中的代码，而不会跳过整个循环。它提供了一种方式来跳过某些特定的迭代，并继续进行下一次迭代。

总结起来，"continue"关键字用于跳过当前循环中剩余的代码，并开始下一次循环。它常用于特定条件下忽略某些迭代的情况。

3.3.6 嵌套循环

矩形

for(int i=1;i<6;i++){
            for(int j=1;j<5;j++){
                System.out.print(" *");
            }
            System.out.print("\n");
        }

 * * * *
 * * * *
 * * * *
 * * * *
 * * * *

等腰三角形

public static void main(String[] args) {
//打印等腰三角形
for(int i=1;i<=5;i++) {
//打印空格
for(int k=1;k<=5-i;k++) {
System.out.print(" ");
}
//打印*号
for(int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println();
}
}

直角三角形

public static void main(String[] args) {
//打印直角三角形
for(int i=1;i<=5;i++) {
for(int j=1;j<=2*i-1;j++) {
System.out.print("*");
}
System.out.println();
}
}