目录
前言
爪哇哇哇哇笔记！！
由于学习任务要求，于是本人制作出了目前为止课程学到的爪哇笔记，都是一些爪哇基础，一起来看看吧！有基础的同学可以跳到"爪哇流程控制小结"来写一些题目，看看只能的能力如何
（本文把所有的java都写成了爪哇，看不下去不要打我）
爪哇简介
爪哇是一种相对简单的编程语言，有着纯粹的面向对象、安全性较高、跨平台能力强、支持多线程的特点。
Java Downloads | Oracle
下载完JDK以后，是不能直接写代码的，还需要配置环境变量与下载软件，这里就以我的window11为例来让大家看看怎么配置java环境变量。
环境变量配置
首先安装JDK，全部都点下一步，安装位置直接默认在C盘某个文件夹不要管它，这样比较方便查找。
C:\Program Files\Java
按键盘上的win键(键盘最下面一行，一般在从左往右数第二个按键，有四个方块的)，在搜索框中搜索环境变量
点击"高级"——“环境变量”
找到"系统"中的"path"
双击打开后，点新建，并复制黏贴你的JDK安装路径下的bin文件目录，这里我的目录为C:\Program Files\Java\jdk1.8.0_161\bin，大家可以修改成自己的目录版本，JDK文件默认是下载在C:\Program Files\Java下的。可以对着这一段修改C:\Program Files\Java\对应版本JDK文件夹\bin。
复制黏贴后点确定，环境变量应该就配置好了！
爪哇编写软件推荐
写爪哇代码的软件有很多，常见的有IntelliJ IDEA、eclipse，这里我们推荐使用IntelliJ IDEA，它在业界被公认为最好的爪哇开发工具，大部分写爪哇的程序员都使用IntelliJ IDEA来编写代码。这里就不放IntelliJ IDEA的下载链接，大家可以自行搜索“IntelliJ IDEA官网”进行下载，学生是可以用学习网的验证码注册并领取为期1年的正版IntelliJ IDEA使用权限的，但申请通常需要一周左右的时间才可以成功（太长了！），有需要“学习版”软件的同学也可以通过文档结尾的联系方式联系我，让我发给你一些免费的资源。
爪哇的命名规范
爪哇的命名规范很简单，通常由数字、英文字母组成，但是开头必须得是是英文或者是下划线，并且不能使用爪哇中自带的关键字命名（具体的关键字大家可以自行在网络上搜索)。爪哇是支持使用中文做为变量名！但是通常不这样，大家都认为这样的命名是不规范的。并且为了命名的规范，需要尽量用有意义的英文单词命名，开发人员还规定了特殊的命名要求，就是我们写爪哇代码中常见驼峰命名法。
那，什么是驼峰命名法？
驼峰命名法又分为大驼峰和小驼峰，
// nekoLovely oneClick （小驼峰）
// NekoLovely JavaStudy （大驼峰）小驼峰一般用于定义方法和变量，大驼峰一般用于定义类名。俩者的区别就是，小驼峰命名规范是从第二个单词开始全都大写，而大驼峰命名规范是从第一个单词就开始大写，虽然我也不知道为什么要这样大写，但是其他程序员都这样用，你不用就显得你鹤立鸡群，会被其他的程序员嫌弃。命名不规范，亲人俩行泪。
爪哇的基本数据类型
爪哇有八大基本的数据类型，比如说String(String不是基本数据类型! String不是基本数据类型! String不是基本数据类型! 重要的事情说3遍。String字符串是一种特殊的对象，实际上是一种特殊的引用类型。但是因为较为常见，经常会有同学认为这是八大基本数据类型的其中一种。) 这些基本数据类型被创建以后，将会被存放在爪哇的栈里。
整型 int
作用：储存整数
占用内存长度：4字节（32位）
取值范围：-2^31~2^31-1
int number1 = 11;
int number2 = 23;短整型 short
作用：储存整数
占用内存长度：2字节（16位）
取值范围：-2^15~^215-1
short number1 = 11;
short number2 = -5;
长整型 long
作用：储存整数
占用内存长度：8字节（64位）
取值范围：-2^62~2^62-1
long number1 = 11;
long number2 = -5;单精度浮点型 float
作用：储存小数
占用内存长度：4字节（32位）
取值范围：3.4e-45~1.4e38
注：float类型的小数结尾要加上f，否则将会被识别为double，当然大部分情况都是用double。
float number1 = 11.1f;
float number2 = -5.0f;双精度浮点型 double
作用：储存小数
占用内存长度：8字节（64位）
取值范围：4.9e-324~1.8e308
double number1 = 11.1;
double number2 = -5.0d;布尔逻辑型 boolean
作用：存储逻辑true 或者 false，用于逻辑运算
占用内存长度：1字节
取值范围：’true’ or ‘false’
boolean bol1 = true;
boolean bol2 = false;字节型byte
作用：存储单个字节
占用内存长度：1字节（8位）
取值范围：-128-127
byte bol1 = 1;
byte bol2 = -127;字符型 char
作用： 2个字节
占用内存长度：2个（表示单个Unicode字符）
取值范围：单个Unicode字符
char char1 = '5';
char char2 = '行';
char char3 = '彳亍'; //如果是“彳亍”就是2个字符，就会报错了！爪哇基本数据类型小结
好，现在既然了解了java的基本数据类型，那就让我们开始来写项目吧！（不是）
对于上述描述，我们可以看到，float和int都是4字节，但是为什么float存储的数据范围更大？
首先，float和int的第一位都是符号位，1表负，0表正。所以剩下的31位int是直接用来存储。而float不一样，它会把数据分成指数部分和小数部分，取自己的2-9位来进行存储指数部分，其余的位置来存储小数部分，对于多出的部分会进行舍弃处理，因此使用float时经常会出现奇怪的事情。
float ff = 1.1f + 2.2f;
System.out.println(ff);//结果为3.3000002以上便是这一段爪哇基本类型的全部内容。(从word里写了部分文案以后复制到网站，结果带次方的数字范围居然不能在文章中正常显示了，进来以后变成“-231~231-1”，这太糟了)
这里我们有题目让大家来做做
1、
下列选项中，可以正确实现 String 初始化的是（ ）
A. String str = "abc";
B. String str = 'abc';
C. String str = abc;
D. String str = 0;2、
下面语句哪个是正确的（ ）
A. char = 'abc';
B. long o1 = oxfff;
C. float f = 0.23;
D. double d = 0.7E-3;3、
下列哪个选项是 short 型数据的取值范围（ ）
A. -128 ～ +127
B. -32768 ～ +32767
C. -2147483648 ～ +2417483647
D. -3.40282347E38 ～ +3.40282347E384、
在 Java 中，int 数据类型占多少位（ ）
A. 8
B. 16
C. 32
D. 64答案 ：1A 2D 3B 4C
爪哇数组
数组的定义与定义(中华文字博大精深)
定义：一组类型相同或者相兼容类型在内存中连续存储的数据。
数组的基本数据类型：int, boolean, char, long, float, double, short, byte（也就是java的八大基本数据类型).
简单来说，把2个及以上数据类型相同的的数，存放到一个数据集合当中，这样的一个数据集合就被我们称作数组。以下是我们数组的定义语句。
数据类型[] 数组名称 = new 数据类型[数组长度];
数据类型[] 变量名称 = new 数据类型[]{值1，值2，......};
数据类型[] 变量名称 = {值1，值2，......};通常来说，数组定义中，前后两个数据类型是一样的，这点不能写错。这里我们距离几个定义数组的例子。
//定义一个长度为10、存放整型的数组
int[] intNumbers1 = new int[10];
//定义一个内容为1-10的整形数组
int[] intNumbers2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//定义一个长度为10、存放double类型数据的数组
double[] doubleNumbers1 = new double[10];
//定义一个内容为1-10的double数组
double[] doubleNumbers2 = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0};
以上便是几个简单的一维数组定义，int[] intNumbers1 = new int[10]; 这条定义语句创建了一个长度为10的数组，于是爪哇就在栈中为intNumbers1开辟了一个长度为10的空间，由于数组的特殊性，这个数组内的每个数字都被赋予一个初始值，int类型数组每一个数的初始值都为0，而在单独定义一个变量时(int i;)，爪哇是不会给这个变量赋予初始值的。
数组下标长度、遍历方式与使用
爪哇数组和其他语言一样，有一个很重要的东西，叫做下标。我们可以把int[] intNumbers1 = new int[10];这条语句当成为我们开了一个固定长度为10的抽屉，而下标的出现，就是帮助我们区分这些抽屉排序的前后位置的。
int[] intNumbers2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; //1-10的整型数组
//下标为:0 1 2 3 4 5 6 7 8 9
//取出数组对应数的办法
//数组名字[对应下标]
//比方我要拿出这个数组的最后一个数10
System.out.print(intNumbers2[9]); 要想将数组数组对应的值取出，就要通过下标来完成。并且要注意的点是，数组的下标都是从0开始的，数组中最后一个内存的下标为数组的长度-1。有了数组长度，我们就可以做很多的事情。那么问题来了，我们要如何获取数组的长度呢？这里我们就使用到了数组自带的方法length，通过数组命.length就可以获得数组长度，就可以很方便的通过一些循环语句对数组的值进行有规律的初始化。这里我们使用了for循环给数组intNumbers初始化，然后用foreach循环将数组初始化后的值遍历打印出来。
int[] intNumbers1 = new int[10]; //定义一个长度为10、存放整型的数组
System.out.println(intNumbers1.length); //将数组的长度打印出来，结果为10
//初始化数组，通过for循环，让数组存放整数1-10
for (int i = 0; i < intNumbers1.length; i++) {
intNumbers1[i] = i+1;
}
//通过foreach遍历数组，将数组各个元素打印出来
for (int i: intNumbers1) {
System.out.println(i);
}数组其他方法
当然，数组还有很多非常方便的方法，这里我们就举了一部分的例子，可以通过这些方法实现开发项目的更多不同的操作。
数组.clone() //创建并返回一个相同内容的数组.(地址不同)
数组1.equals(数组2) //判断这两个数组的地址是否相同.相同则返回true
数组.clone() //创建并返回此对象的副本.
数组.toString() //返回对象的字符串表示形式.
数组.hashCode() //根据指定数组的内容返回哈希码.
数组.hashCode() //根据指定数组的内容返回哈希码.
数组.copy(原数组, 长度) //复制原来的数组
数组.sort() //排序二维数组
这里还有一个知识点二维数组，由于时间关系这里我们就不细写，有感兴趣的同学可以联系我，我的联系方式放在文章末尾.（问就是不会awa）
数组小结
以上就是本章数组学习内容，这里我们有几个题目可以来做一下。
1、
以下能对二维数组 a 进行正确初始化的语句是( )
A. int a[2][] = { {1 , 0 , 1} , {5 , 2 , 3} };
B. int[][] a = { { 1, 2, 3 }, { 4, 5, 6 } };
C. int a[2][4] = { { 1 , 2 , 3 }, { 4 , 5 } , { 6 } };
D. int[] a = { { 1 , 0 , 1 } { } , { 1 , 1 } };2、
若有说明：int a[][]=new int[2][3];则数组 a 中各元素( )
A. 可在程序的运行阶段得到初值 0
B. 可在程序的编译阶段得到初值 0
C. 不能得到确定的初值
D. 可在程序的编译或运行阶段得到初值 03、
下面创建二维数组正确的是（ ）
A. int[][] a = new int[][3];
B. int[][] a = new int[2][3];
C. int[] a = new int[2][3];
D. int a[][] = new int[][2];4、
若有说明：int a[] = { 1, 2, 3, 4, 5, 6, 7 }; 则获取 a 数组的大小是（ ）
A. length
B. length()
C. getLen()
D. size()答案：1 B，2 A，3 B，4 A
爪哇运算符
爪哇有很多常见的运算符，这点和其他的语言好像都是一样的。 这边通过chatgpt快速找出了所有运算符，并且增加了一些自己的内容!下面将对一些常见的运算符举一些例子！
算术运算符
加法（+）：用于将两个值相加。
System.out.println(3 + 3); //结果为6
System.out.println(4 + 3); //结果为7减法（-）：用于将一个值减去另一个值。
System.out.println(3 - 3); //结果为0
System.out.println(4 - 3); //结果为1自增（++）：用于将一个变量增加1。
int x = 1;
x++; //自增
System.out.println(x); //打印结果为2自减（--）：用于将一个变量减少1。
int x = 1;
x--; //自减
System.out.println(x); //打印结果为0自增和自减在计算表达式中，"++"和"--"在变量的前面和后面的效果是不一样的。为"++变量"变量时是先自增，然后再使用。为 "变量++"时，是先使用再自增。这里举一段代码为例。
int x = 5;
System.out.println(++x);
//打印结果为6
int y = 5;
System.out.println(y++);
//打印结果为5这俩种不同的情况是可以写出很多的爪哇题目的，在本章节结尾小结我们会出一些题目，来检验同学们的对本章节的理解。
乘法（*）：用于将两个值相乘。
System.out.println(3 * 3); //结果为9
System.out.println(4 * 3); //结果为12除法（/）：用于将一个值除以另一个值。
System.out.println(3 / 3); //结果为1
System.out.println(4 / 3); //结果为1 （4和3默认类型为int，所以会自动向下取整）
System.out.println(4.0 / 3.0); //结果为1.3333333333333333
取余（%）：返回两个值相除的余数。
System.out.println(3 % 3); //结果为0
System.out.println(4 % 3); //结果为1关系运算符
相等（==）：用于检查两个值是否相等。
System.out.println(1 == 3);//结果为false
System.out.println("你好" == "你好");//结果为true
//这里我们还要特别注意一下“==”操作符用于基本数据类型时是对值的比较，
//用于对象则是对引用（也就是地址）的比较。
//后期学习中等我们学习到了对象，“==”操作符用于基本数据类型时是对值的比较，
//而用于对象则是对引用的比较。这边我们举例一段例子
int a = 1;
int b = 1;
Hello hello1 = new Hello();
Hello hello2 = new Hello();
Hello hello3 = hello1;
System.out.println(a == b);//结果为true
System.out.println(hello1 == hello2);//结果为false
System.out.println(hello1 == hello3);//结果为true
//对象赋值是引用赋值，可以看到hello1 hello2 hello3都是new了一个新的对象
//但是我们把hello1的地址都复制给了hello2
//可以看到，只有地址相等的hello1和hello2是==的，返回true
//因为是hello类的对象，地址不相等的hello1 == hello3，返回了false
//而java类库中的String对象，而在String类中重写了equals()方法
不相等（!=）：用于检查两个值是否不相等。
System.out.println(1 != 3);//结果为true
System.out.println("你好" != "你好");//结果为false大于（>）：用于检查一个值是否大于另一个值。
System.out.println(4 > 3);//结果为true
System.out.println(5 > 5);//结果为false小于（<）：用于检查一个值是否小于另一个值。
System.out.println(1 < 3);//结果为false
System.out.println(5 < 5);//结果为true大于等于（>=）：用于检查一个值是否大于或等于另一个值。
System.out.println(4 >= 3);//结果为true
System.out.println(5 >= 5);//结果为true
System.out.println(5 >= 6);//结果为false小于等于（<=）：用于检查一个值是否小于或等于另一个值。
（这里和大于等于同理，不做代码示例）
逻辑运算符
与（&&）：用于组合多个条件，所有条件必须为真才返回真。
System.out.println(true && false);//结果为false
System.out.println(true && true);//结果为true或（||）：用于组合多个条件，只要任一条件为真即返回真。
System.out.println(true || false);//结果为true
System.out.println(false || false);//结果为false非（!）：用于对条件进行取反操作，如果条件为真则返回假，如果条件为假则返回真。
System.out.println(!false);//结果为true
System.out.println(!true);//结果为false赋值运算符
简单赋值（=）：用于将一个值赋给一个变量。
int num1 = 1;
System.out.println(num1);//结果为1
//这就是我们最简单赋值语句加等于（+=）：用于将一个值加到变量上，并将结果赋给该变量。
int num2 = 3;
System.out.println(num2 += 3);//结果为6
// “num2 += 3;” 效果实际上是和 “num2 = num2 + 3;” 是一样的减等于（-=）：用于将一个值减去变量，并将结果赋给该变量。
int num3 = 3;
System.out.println(num3 -= 3);//结果为0
// “num3 -= 3;” 效果实际上是和 “num3 = num3 - 3;” 是一样的乘等于（*=）：用于将一个值乘以变量，并将结果赋给该变量。
int num4 = 3;
System.out.println(num4 *= 3);//结果为9
// 原理同上除等于（/=）：用于将一个值除以变量，并将结果赋给该变量。
int num5 = 3;
System.out.println(num5 /= 3);//结果为1
// 原理同上awa取余等于（%=）：用于将一个值取余变量，并将结果赋给该变量。
int num6 = 3;
System.out.println(num6 %= 3);//结果为0
// 原理同上位运算符
按位与（&）：对两个操作数进行按位与运算。
按位或（|）：对两个操作数进行按位或运算。
按位异或（^）：对两个操作数进行按位异或运算。
按位取反（~）：对操作数进行按位取反运算。
左移（<<）：将第一个操作数的二进制表示左移指定的位数。
右移（>>）：将第一个操作数的二进制表示右移指定的位数，保留符号位。
无符号右移（>>>）：将第一个操作数的二进制表示右移指定的位数，不保留符号位。
这些位运算符由于在实际编写代码的时候并不常见，博主就很不负责任的不附加代码以及解释了！有需要学习这部分内容的同学，可以自行搜索位运算符来进行学习。
爪哇运算符小结
在对这章节学习以后，我们就可以使用运算符来对我们的变量进行一些的改变。在爪哇中有很多运算符相关的计算题，这里就让我们一起来做一做！
1.请阅读下面的代码
int x = 10;
int y = 5;
System.out.println(x++ + --y);
//问：打印结果是多少？2.请阅读下面的代码
int c1 = 1, c2 = 2;
double c3;
c3 = 1.0 / c2 * c1;
则执行后，c3 中的值是（ ）
A. 0
B. 0.5
C. 1
D. 2 String s1=new String(“abc”);
String s2=”abc”;
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
//问下列选项中，程序的输出结果为：4、
设 int x = 1, y = 1; 表达式( x > 0 || y-- >1 )运算后 y 的值是( )
A. 0
B. 1
C. 2
D. -15、
设有 int x = 11; 则表达式( x++ * 1 / 3 )的值是( )
A. 3
B. 4
C. 11
D. 12答案：1 14，2 B，3 ，4 B，5 A，6 答：运算符“&”和“&&”都表示与操作，当且仅当运算符两边的操作数都为 true 时，其结果才为 true，否则结果为 false。当运算符“&”和“&&”的右边为表达式时，两者在使用上还有一定的区别。在使用“&”进行运算时，不论左边为 true 或者 false，右边的表达式都会进行运算。如果使用“&&”进行运算，当左边为 false 时，右边的表达式则不会进行运算，因此“&&”被称作短路与。
爪哇流程控制
首先我们要知道，爪哇虚拟机会将字节码转换为机器码，并从main方法开始逐行执行。这种方式使得Java具有与编译型语言相似的性能，并且能够在不同平台上运行。
条件语句
有if、if-else if-else、switch3种，其中if最常见。
if语句：根据括号内的条件来判断是否执行大括号内的代码段。
if (条件) {
代码块
}下面我们写了一段有关if语句的代码。结合了我们先前所学习的逻辑运算符和关系运算符，我们对变量Money的行为进行判断。通过代码的结果我们可以看到，最后打印了"你的钱刚刚好"和"你有很多钱"，这是因为money=100同时满足了后面俩个if的条件。
int money = 100; //定义一个变量 money
if (money < 50) { //判断money是否小于50
System.out.println("你的钱是不够的");//打印
}
if (money > 50) { //判断money是否大于50
System.out.println("你的钱刚刚好");//打印
}
if (money > 80) { //判断money是否大于50
System.out.println("你有很多钱");//打印
}
//结果打印了 "你的钱刚刚好" “你有很多钱”
if-else if-else语句：根据多个括号内的条件判断执行不同的代码块。
if (条件1) {
代码块1
} else if (条件2) {
代码块2
} else { //其他情况
代码块3
}下面我们写了一段有关if-else if-else语句的代码。同样的，这里我们继续让变量money等于整型50，这个值是同时符合＜80和＜200的，但结果只执行了＜80的代码块"你的钱刚刚好"，这是因为在if-else if语句，按照从上到下的顺序，当我符合了其中一个if或else if的条件，就不会继续判断后面的if-else if-else，执行完对应的代码块后就直接跳出这一段if-else if-else代码块，因此在这里if-else if-else语句和单独的if语句是不一样的。
单独一个else则是在if-else if-else代码块的末尾，来执行条件之外的情况。就比如我们下面的这段代码，当money为1000、10000、100000的情况，就会执行else下的代码块。
int money = 50; //定义一个变量 money
if (money < 50) { //判断money是否小于50
System.out.println("你的钱是不够的");//打印
} else if (money < 80) { //判断money是否小于80
System.out.println("你的钱刚刚好");//打印
} else if (money < 200) { //判断money是否小于200
System.out.println("你的还蛮有钱的");//打印
} else { //判断money除此之外其他的情况(这里是>=200的情况)
System.out.println("你发大财了！");//打印
}
//结果只打印了 “你的钱刚刚好””switch语句：用于根据表达式的值或者变量的值，从不同的代码块中选择执行。
switch (表达式或变量) {
case 条件值1:
//代码块1
break;
case 条件值2:
//代码块2
break;
default:
//其他情况的 代码块
break;
}下面我们写了一段switch语句的代码，通过switch来帮助我们判断，到底我们有多少钱（虽然这个例子好像不太直观）,switch-case语句的条件也是一条一条向下判断的，每段代码块后面请一定一定一定要记住写break中断语句，不然会发生不好的事情。可以看到最后的结果为"我猜你有100元"，这是因为我们money=100，刚刚好等于我们的第二个case语句的条件值，因此执行了第二个代码块的值，当然中间是可以有非常很多case的，这样才可以满足更多的需求，这里我们只写俩个case是为了方便举例子。
int money = 100; //定义一个变量 money
switch (money) {
case 80://查看是否是80的钱
System.out.println("我猜你有80元");//打印
break;
case 100://查看是否是100的钱
System.out.println("我猜你有100元");//打印
break;
default://其他的情况
System.out.println("我猜不到你有多少钱");//打印
break;
}
//结果为："我猜你有100元"循环语句
一共有for、while、do-while、foreach4种循环。for循环像是遵守规章程序办事的对象，会根据你规定好的规章制度，来扇你几巴掌（执行代码块次数）。while循环像是你知情达理的对象，会先问问你做没做错事，然后根据情况决定要打你几巴掌。而do-while循环就像是你的野蛮对象，不管三七二十一先打你一巴掌再说，然后再问问你想要被打几巴掌。最后的foreach则是帮你从数组中，找出你的所有罪行，数组有多长，代码就跑几次。
for循环：用于执行已知次数的循环。for循环可以说是我们在写代码过程中，最常用的一个循环语句，因为它比while和do-while泛用性强太多了。
for (定义变量; 循环条件; 变量自增) {
// 循环代码块
}for循环会根据我们定义的条件和变量自增，来不断执行我们的代码块。这里我们写了一个简单的for循环，来打印数字1到10。开始时i为1，程序判断符合<=10的条件，于是进入代码块，将当前的i（也就是1）打印了出来，完成代码块内的操作后，i会根据我们的设定（i++）进行自增，i变为2，然后程序继续判断，发现i=2也符合<=10的条件，然后继续执行代码块内的操作后进行自增........一直执行到当i自增到11时，程序发现i=11不符合<=10的条件了，这个时候就会跳出代码块。
//通过for循环打印1 - 10
for (int i = 1; i <= 10; i++) {
System.out.println(i);
}while循环：用于执行未知次数的循环，循环前判断条件。
while (条件) {
// 循环体，会重复执行的代码
if(条件)
break;
}
while (变量在一定范围内的条件) {
// 循环体，会重复执行的代码
变量发生改变;
}需要我们在while的代码块中，根据while继续循环的条件(变量)，来写出跳出while变量的自增、自减，在这点上是远远不如for循环方便的。但是，while循环是我最喜欢、最好写的死循环(死循环是坏事，但是能跳出的死循环是好事awa)，只要写上while(true){}，就可以一直执行大括号内的语句，当然要记得写上能跳出循环的break语句，这点我们在本块知识的后面部分会提到！
//用while循环打印出10以内能被3整除的数
int i = 0; //定义变量
while (i < 10) { //变量范围限制
if(i % 3 == 0) //条件语句
System.out.println(i); //打印语句
i++; //变量自增
}do-while循环：用于执行未知次数的循环，循环后判断条件。
do {
// 循环体，会重复执行的代码
} while (条件);do-while循环唯一不同于while循环的地方，在于进行循环判断的条件是在这一段代码的末尾，因此do-while代码块内的语句会被先执行一次，然后再进行判断是否继续循环。这里我们写了一段do-while循环，可以看到我们的do-while条件是false，如果是在正常的while语句中，这个循环里的代码块是一次都不会执行的。但这里我们是do-while语句，它不管三七二十一的先执行了一次代码块里的内容，然后由于条件是false，才结束了这个循环罪恶的一生。
//用do-while打印你好
do {
System.out.println("你好");
} while (false);
//结果打印了一次"你好"foreach循环：用于遍历数组，循环次数为数组的长度，每次循环按顺序将数组的一个值取出使用。
在实际使用情况中，foreach循环适用于不知道循环次数，或者是循环次数很难计算。for循环适用于知道循环次数，在复杂的循环中效率更高。如果说只要把数组中的所有数据打印出来，那大可使用foreach循环，这将非常快捷的帮我们取出数组的每个变量，以此来实现各种操作。
//定义一个内容为1-10的整形数组
int[] intNumbers1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i: intNumbers1) { //用foreach遍历数组
System.out.print(i); //打印数组内的元素
}
//打印结果为 12345678910 System.out.print(i);是没有换行的控制台输出语句跳转语句
有break、continue、return三种。
break语句：用于终止循环或switch语句，并跳出当前代码块。
我们首先使用了前面的"通过for循环打印1 - 10"的案例，来使用我们的break语句，可以发现，我们这段代码块当打印到4的时候，就会结束，那是因为代码块中多了一跳if判断语句，。当i等于5的时候，条件为真，我们的程序就会执行break操作，不管三七二十一直接让一整个循环结束。当有多个循环的嵌套的时，break语句将会优先结束最内层的一个循环，一个break只能结束一个循环语句。（同理，break也用于跳出switch语句，如果switch语句没有break，将会把每一个switch下的case代码块都执行过去。）
//通过for循环打印1 - 4
for (int i = 1; i <= 10; i++) {
if(i == 5) {
break;
}
System.out.println(i);
}为了让大家更理解不了，于是我修改了前面的“用while循环打印出10以内能被3整除的数”的案例，来使用了我们的break语句，进行举例。可以看到，while循环的条件为true，如果没有通过条件判断来跳出break的话，这将会是一个无法跳出死循环，如果电脑性能不足的话，后期写程序出现这种情况是非常的危险的。因此这里我们继续使用if条件语句来跳出循环，当循环执行到第十一次时，i为10，将会执行break语句跳出当前循环。在后期代码的书写中，我们可以灵活的运用条件判断语句和break，根据项目需求来执行对应的操作。
//用while循环打印出10以内能被3整除的数
int i = 0; //定义变量
while (true) { //变量范围限制
if (i == 10) {
break;
}
if(i % 3 == 0) //条件语句
System.out.println(i); //打印语句
i++; //变量自增
}continue语句：用于跳过当前循环的剩余代码，并继续执行下一次循环。
continue不同于break，不会将一整个循环都终止掉，只会跳过当前循环，然后继续进行下一次循环。通过i % 2 == 0的判断进行continue操作，就可以有效的跳过i为偶数的情况，让后面的打印语句只能打印奇数。
//通过for循环打印1 - 10中不能被2整除的数
for (int i = 0; i <= 10; i++) {
if (i % 2 == 0)
continue;
System.out.println(i);
}
//打印结果为 1 3 5 7 9 (每个数字之间实际上都是换行的，为了方便展示作空格处理)return语句：用于从方法中返回结果，并终止方法的执行。这里执行的效果和break相似，但是break语句跳出的是循环，而return语句跳出的是方法，并且还可以根据方法设置的返回值类型，将我们的处理好的结果送出去。
//public：方法公开 int：返回值类型为整型 mathAdd：自定义的方法名
//(int a, int b) ：方法的参数
public int mathAdd(int a, int b) {
return a + b; //返回两数和，结束本代码块
}爪哇流程控制小结
本章节，我们学习了条件语句、循环语句、跳转语句，结合我们先前学习的数据，是可以完成很多简单的例题的。这边我们就找出几道题目让大家来做一做，大家自行查看代码打印结果，这里就不附带例题答案，有问题的同学可以通过文档末尾的联系方式联系我(发邮箱或+Q)，有看到会尽快回复！
简单题：
1、编写一个java程序，找出1-100中的所有的奇数并且打印出来。(使用循环语句完成，需要用到条件语句以及，推荐使用for循环完成，实现后建议再使用while循环和do-while循环再完成)
2、编写一个java程序，用循环初始化一个数组，使数组的内容为[5,6,7,8,9,10]，并将数组的各个元素打印出来。（进阶：将该数组各个元素逆序打印）
3、编写一个Java程序，接受键盘输入一个年份，判断该年份是平年还是闰年。
4、编写一个Java程序，求5!。（n!是一个数的阶层，比方3! = 1*2*3 = 6, 4! = 1*2*3*4，以此类推.....）
5. 输入三个整数 x,y,z，请把这三个数由小到大输出。（提示：使用条件判断语句和关系运算符来完成）
升级进阶题：(有能力的同学可以尝试着做一下)
1、编写一个Java程序，求n!，n从键盘输入。（n!是一个数的阶层，比方3! = 1*2*3 = 6, 4! = 1*2*3*4，以此类推.....）
2. 编写一个 Java 程序在屏幕上输出 1！+2！+3！+……+10！的和。
3. 实现会员注册，要求用户名长度不小于 3，密码长度不小于 6，注册时两次输入密
码必须相同。
4. 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前 20 项之和。
5. 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加
密规则如下：每位数字都加上 5,然后用和除以 10 的余数代替该数字，再将第一位
和第四位交换，第二位和第三位交换。
6. 编写一个函数，输入 n 为偶数时，调用函数求 1/2+1/4+...+1/n,当输入 n 为奇数时，
调用函数 1/1+1/3+...+1/n。
7. 有 n 个人围成一圈，顺序排号。从第一个人开始报数（从 1 到 3 报数），凡报到 3 的
人退出圈子，问最后留下的是原来第几号的那位。
爪哇类与对象
待完成........
结尾
由于时间关系，本文目前就只能先更新到这里了。本文创作的初衷是为了应付老师布置的作业："标识符、运算符、流程控制、循环结构、分支结构、数组、方法、类与对象等相关知识点的 梳理与总结。"，但由于时间问题，并没有全部完成，讲的也不够细致，大部分代码、讲解手敲，还没花时间回过头自己读一遍，如果出现难以理解的地方实属抱歉，还请多多海涵。浏览本文章发现问题时请尽管指出，有看到留言将会尽快修改！本人学生党一名，时间且算宽裕，但太过贪玩，大部分时间都用于游戏(什么类型的游戏都玩，不要来找我玩游戏，已经忙不过来了！)，有想继续在本文学习爪哇的同学请狠狠的私信我，您的每一份催更消息都将化为我的一份有气无力(积小力为大力!)。联系方式：1749112929@qq.com.
562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
