本章节涵盖内容如上述目录所属，博文的起拟时间为： 2022.4.13 日。 完成时间即发布时间。与其相对应时期发布的还有 python 的第二章。请到个人主页中进行查看。
文章内容来自 第一行代码 的读后分享，此博客会涵盖书中摘录内容和个人理解的分享，请广大朋友们给予点评和支持，兔C会给大家分享出更多优质的知识内容。感谢。
导言
任何程序都是对数据的操作，所以在程序开发过程中首先需要掌握的就是数据类型的选择。为了让程序数据控制的更加灵活，可以使用各种流程控制语句，如判断语句，循环语句。在实际开发工作中为了达到结构化以及可重用的目的，往往需要利用方法来将部分程序代码进行封装。本章将讲解数据类型划分，数据运算，程序结构，方法定义与使用等与程序相关的核心概念。
1. Java 的注释
注释的概念：
在程序开发中，由于其基本组成都是代码，所以考虑到程序可维护性的特点，在编写代码时都要在每段代码上增加若干个说明文字，这些文字不需要被编译器解释，它们被称为 java 的注释。
简单理解就是你自己写的代码，加上说明， 这个说明不会同代码一起被执行到程序当中，但是你自己在看代码的时候 看到上面的说明 又可以告知你自己相关的提示。这个东东就叫注释。
之前看过一本书，忘了叫什么了，但是挺有意思的。
书中的观点大概如下：
- 注释要点名命题，不要什么都注释，关键性代码打上注释。简洁有力，直接点出要害，即 一针见血。
- 通过第一点，可得知第二点建议，注释不要打的太过麻瓜，简单的代码 一看就知其意，还打注释干嘛。
如果是新手村的朋友看到此篇文章，还不明其意，也不用太过纠结，很多事都是后知后觉。晓得了注释的基本概念，我们来看如果实现。
首先，我们要知道 java 的注释 有三种类型，下面我们一一介绍：
1.1 单行注释
单行注释，就是在注释内容的前面加 双斜杠(//), java 编译器在进行程序编译时会忽略掉这部分内容。
我们来写一下：
public void main(String args[]){
//这句代码在调用：System系统类下的out对象的println方法
System.out.printn("你好，我是来自新手村的兔C");
}
Look！ 你看上面的代码示例，双斜杠后面的说明内容，就是我写给自己的注释。
这样我日后在看到这句代码之后，我就会得到提示信息，
哦！原来这句代码的意思是：调用 系统类下的out对象的println的方法啊。
注意：
但是你要注意啊！ 我的注释内容和代码是分开的，你不要把 双斜杠打到代码前面，如果你注释到代码前面了 如： // Systme.out.prinltn(“…”); 你的这句代码一样是会被 编译器忽略掉的。
被编译器忽略掉的后果就是不会被执行。
1.2 多行注释
多行注释，就是在内容前面加上一个星型标记 ( /* ) 开头，并在注释内容末尾也加上一个 ( */ ) 用来结尾。当注释内容超过一行的时候推荐使用。
代码示例：
/*
这是兔C定义的main方法
这个方法只定义了一个sout输出语句，
语句中输出了一句，兔C的自我介绍。
sout语句，是调用自 System 系统类下的 out 对象的 println 方法
*/
public static void main(String[] args){
System.out.println("你好，我是来自新手村的兔C");
}
看上述代码注释内容，，以 /*开头， 又以 */ 进行结尾，这就是一个多行注释的使用方法。其中的文字描述内容，在代码编译执行时，同样会被编译器忽略掉。
1.3 文档注释
文档注释，是以单斜线加两个星形标记( /** )开头，并以一个星形标记加单斜线( */ ) 结束。用这种方法进行注释的内容会被解释成程序的文档，并能包含进入 javadoc 工具生成的文档里，用以说明该程序的层次结构及其方法。
public class Test_HelloWorld{
/**
* 文档注释犹如其概念一样，
* 可以加一些参数设置，后生成程序说明文档
*
* 参数注解：
* @Description HelloWorld
* @Author 兔C
* @version 版本说明
* @param args
*/
public static void main(String[] args){
System.out.println("Hello World！");
}
}
文档注释，说明程序信息后，可以使用命令 生成对应的程序文档说明，
其命令为： javadoc
其后的参数 我们下面继续讨论。这里先来看一下效果图：
命令执行之后，java文件的存储位置会生成上述图片中的内容，我们点击打开红色框框标记的 html。 然后会看到如下：
如果你使用 javadoc命令，不知道怎么设置参数，你可以先打上 javadoc -help 命令查看可以设置的参数。
如图：
我这里使用的参数为：
javadoc -d 路径 … 后述内容省略，自己去试试体验一下吧。
2. 标识符与关键字
讨论完了 java 的三种注释，我们接下来继续讨标识符与关键字。
我们在进行一个类的创建时，需要给其起一个名称，这个名字就是一个标识符。但是除了类名称，还有属性名称，方法名称等也都属于标识符的定义范畴，但是在我们的java中，标识符也有自己严格的定义范畴和规则。
它的要求是 由字母，数字，下划线_，美元$ 组成，不能以数字开头，也不能是java当中的关键字 。
所谓的关键字就是java语言的研发者们定义好的，具有特殊意义的保留字单词。
如 public class 等等 等等… 而且还有三个是你需要知道的特殊含义的，严格来讲不算是关键字标记的 三个关键字， true flase null
废话：
现在是4.18号，此刻坐在电脑前写博客的我觉得这种写，只是一种纯知识的搬运。
在用文字表达知识点的时候，总在追求形容的够不够完整，不完整就把书上的内容摘录出来… 我感觉很是无趣，下述内容 风格会有些许变化…
3. 数据类型划分
任何的程序 严格上讲都属于一个数据的处理游戏。所以对于数据的保存就必须有严格的限制，这些个限制就体现在了数据类型的划分上，不同的数据类型可以保存不同的数据内容。
Java的数据内容可以分为：基础数据类型和引用数据类型两大类。
基本数据类型包括，byte short int long float double char boolean
引用数据类型包括，(类似于 C / C++)在操作的时候必须要进行内存的开辟。
两者的就别在于：基本数据类型不牵扯到内存的开辟问题，而引用数据类型会牵扯到内存的开辟,而后进行关系的匹配。
3.0 基础数据类型简介
| No. | 数据类型 | 大小/位 | 可表示的取值范围 | 默认值 |
|---|---|---|---|---|
| 1 | byte 字节 | 8 | -128 ~ 127 | 0 |
| 2 | short 短型 | 16 | -32678 ~ 32767 | 0 |
| 3 | int 整型 | 32 | -2147483648 ~ 2147483647 | 0 |
| 4 | long 长整型 | 64 | -9223372036854775808 ~ 9223372036854775807 | 0 |
| 5 | float 单精度 | 32 | -3.4E38(-3.4 * 10^38) ~ 3.4E38(3.4 * 10 ^36) | 0.0 |
| 6 | double 双精度 | 64 | -1.7E308(-1.7 * 10^308) ~ 1.7E308(1.7 * 10^308) | 0.0 |
| 7 | char 字符 | 16 | 0~255 | ‘\u0000’ |
| 8 | boolean 布尔 | 1位 | true 或 false | false |
那在使用过程中如何选择数据类型？
针对这个问题，作者已经在书中给出了答案，下面我给大家摘录出书中的介绍。
整数类型，我们就用 int
日期 时间 表示文件或者是内存大小，我们就用long
内存传递，编码转换，IO操作，网络编程，我们就用 byte
逻辑控制，我们就用 boolean
处理中文，我们就用 byte
其实针对这个问题，在后期继续学习和理解深入下，我们自然而然就能掌握。
3.1 整型
我们来写个 练习的小demo，其目的 观察int的使用方式，以及带入变量和常量的概念。
//这里为了减少代码的冗余性，我把主函数去掉了。
int num = 10;
int result = num *2;
System.out.println(result);
在这段代码中，我们先将常量10，赋值给 num变量，然后在用 num *2，并且将其值 重新定义了一个 int 类型的 result 变量进行接收。最后打印，结果为：20
这是整段代码的步骤，
3.1.1 什么是常量？什么是变量？
在我们的这段代码中，常量是10，变量有 num 和 result，
两者的根本区别和概念就在于，常量的值是固定的，而变量的值是可变的。
还有一点就是变量的使用，必须先进行数据类型和变量名的声明，然后才可以把内存中的值，存储于声明的变量中，供程序使用。
3.1.2 编码习惯。
在上述的代码中，我们看到 数据类型之后打了一个空格，在变量名之后，也打了一个空格，然后是赋值运算符，又有一个空格。
使用空格隔开我们编写的每个代码的间距，可避免 编译器的bug 导致的非正常性语法错误问题。这就是一个编码习惯。
3.1.3 int 类型的取值范围
我们来针对这个标题 进行一个练习。
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
System.out.println(max);
System.out.println(min);
在这里我们获取了 int类型范围的最大值和最小值，然后进行输出，其结果为：
现在不管是int类型的最大范围值还是最小范围值，都已经到了边界，
接下来我们用最大值继续+，用最小值继续-。看后面会发生什么样的情况。
此时 code 状态：
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;
System.out.println(max);
System.out.println(min);
System.out.println("最大值继续+，结果为："+(max+1));
System.out.println("最小值继续-，结果为："+(min-1));
其结果为：
出现这个结果的原因：
存储的数值超过了取值范围的边界，所以造成了数据溢出。当我们进行最大范围值+1的时候，计算机的二进制是基本的单元，而int所占长度是32位，第一位所代表的是符号位，其余位是数值位，当数据类型已经为最大值时，符号位继续+1就发生变化时，可想而知，你的正数 就变成了负数。
在这个过程当中，程序会出现计算循环操作，最大值继续增加，就会加为最小值，随后一直向其次的最小位进行循环。反之最小值同理，计算循环出最大值。
我们在选用数据类型后，使用时，一定要注意取值范围，避免数据溢出。
其实解决这个问题的办法就是将其进行类型转换。
例如 我们现在的最大值，是int类型，已然到达了int的一头边界。
而加 1 后，使用 比他大的数据类型重新进行接收，在输出时，就会输出正确的数值了。
3.1.4 数据类型转换
自动转换
从小范围的数据类型转为大类型的数据类型，我们称为：自动类型转换，自转.
第一种：
int max = Integer.MAX_VALUE;
System.out.println(max + 1l); // 这个l 也可以是 大写L
这是自动类型转换的第一种方式，我称这个招数为，在值的后面加单位。。
第二种：
int max = Integer.MAX_VALUE;
System.out.println((long)max+1);
第二种方式就是将其要转换的目标数据类型 显示定义。
这里不进行结果展示了，自己输出看一下吧。
强制转换
强制类型转换与自动类型转换有些许相同，相同之处在于 其定义方式 需要显示的定义出要转换的数据类型目标。
但是强制类型转换是针对 大的数据类型转换为小的数据类型。具备这个特征才被称为强制转换。
long num = 100;
System.out.println((int)num +1);
这个会正常的输出为101。当然如果你存储的是 long类型的边界最大值，然后在转换为 int类型时，其值明细超出了int类型的取值范围，一定会被省略掉的。
因为long类型的取值范围 远远超出了 int 类型的取值范围了。
其实这么说我也不太确定，但是我不这么说，你也会这么想。
与其这样，不然我们大家都测试一下。
看代码：
public static void main(String[] args) {
long max = Long.MAX_VALUE;
System.out.println(max);
System.out.println((int) max);
}
结果是溢出了。。
说明什么，我们在使用强制类型转换的时候，一定要注意 数据溢出问题！！
小结
咨上所述内容：
- 整数类型的使用
- 变量和常量的概念及区别
- 数据溢出问题
- 数据类型转换：自动转换，强制转换。
3.2 浮点型
浮点数就是小数，Java只要是小数，对应的默认数据类型就是 double 型数据(double 是保存范围最广的数据类型)。
这里写一个小demo，看一下double的简单使用，和之前聊到过的数据类型转换问题
double num = 10.2;
System.out.println(num*2);
在这段代码中，变量num 存储了值为10.2的常量，然后在输出语句中和常量2进行乘法的运算。常量2的值属于int数据类型，和变量num进行计算时，num是double数据类型，当这两种数据类型的值进行计算得出的结果，会转换为数据类型大的一方，为结果值的数据类型。最终结果为double类型，这里就存在自动转换。
3.2.1 有一个问题
刚才我们讨论了自动类型转换的案例，但是有一个问题，你有没有想到？
double 和 int 进行计算时，到底是先进行计算，然后把结果转换为计算类型较大的数据类型，还是先进行转型，统一数据类型之后在进行计算的呢？
这个问题我告诉大家：
由于int数据类型的数据范围要小于double数据类型，所以 int 类型会自动转型为double类型，转型完成之后参与的计算。
而且java的默认小数类型为double，如果使用float类型表示需要将double型变为float型，这时需要采用强制类型转换。(如果阅读之后感觉概念不清晰可以看code)
float num1 = 10.2F; //大写F或小写f 都是表示转型为 float数据类型
float num2 =(float) 10.2;
System.out.println(num1 * num2); //此结果为 float 数据类型
/*
在这段code中，我们用常量10.2给变量num赋值时，就需要指定的去转换为什么类型。
因为java中小数的默认值为double类型，但是我们使用float数据类型进行接收时，
就需要做强制类型转换
*/
下面我们来讲解关于浮点数的其他知识点内容
3.2.2 关于 java中的Bug
这个bug指小数计算时的结果值不准确问题。
我们上述中的codedemo 结果值应该为： 10.2*10.2 = 104.4。但是程序运行的结果值是多少？
Look：：
并不是我们期待的 104.4，为什么呢？
这个是因为 问题本身是属于java的Bug(从 JDK 1.0 开始的)，只依靠计算本身无法解决，我们可以通过后期的学习，利用 math 类 或者 bigdecimal 两个工具类来解决这个问题。
3.2.3 推荐以后选择小数操作时都用double型
实际上最早开发的时候，考虑到内存问题，往往能使用 float 就不用 double，例如 J2ME 开发时，由于内存苛刻，所以往往会压缩数据范围，以解约空间。现在随着硬件成本的降低，是否使用double和float 区别意义就不大了，可以直接使用double类型。
但是我们需要注意的是：所有的数据类型只有double或float才可以保存小数。
3.2.4 关于除法的问题
int x = 9;
int y = 5;
System.out.println(x/y);
此结果的计算值为1是因为，当我们使用int类型计算时，即便计算结果存在小数也会自动省略掉小数部分，如果想改变这种现象，可以进行类型转换，使用小数类型来接收计算后的结果，亦或者将参与计算的两个变量类型，将其中一个变为小数类型，然后计算时让其发生自动转换，这样就可以让我们的小数位计算之后也能成功保存下来了。
3.3 字符型
byte 属于字节，按照传统的概念来讲，一个字符 = 2个字节，对于字符除了与字节有一些关系外，最主要的关系在于 int 型 变量的转换。
在计算机的世界中一切都是编码的形式出现的， java 使用的是 十六进制的 UNICODE 编码，此类编码可以进行文字的保存，但是这个编码在设计的过程中，考虑到与其他语言的结合问题（C/C++），此编码还包含了部分 ASCII 编码，所以之前学习的是其他编程语言，也很容易和 java 无缝衔接。
关于 int 和 char 转换
C和C++的ASCII编码范围：
大写字母：65 ~ 90
小写字母：97 ~ 122
大写字母和小写字母之间差了32，而Java的编码很好的继承了这一特性，即也可以按照此范围的编码表示常见的英文字母。
在程序中使用单引号引起来的就称为字符，每一对单引号里面只能够保存一个字符。
一个字符 = 两个字节。
codeDemo
char t = 't';
int num = t;
System.out.println(t);
System.out.println(num);
通过此案例，我们可以正常的输出一个字符，还可以通过int类型，来看此字符在编码表中占的数字是多少。
通过此案例我们可知 t字符，在码表中所对应的数字为： 116
3.3.1 常用的编码范围介绍
如果根据上面的案例继续进行测试，就会发现：字母’a’，字母’Z’，字母’z’，数字’0’，数字’9’ 等字符的编码，会存在以下常用范围的规律：
‘A’(65) - ‘Z’(90);
‘a’(97) - ‘z’(122);
‘0’(48) - ‘9’(57);
即：大写字母与对应的小写字母之间相差32，所以可以利用他们之间的规律来实现对应的大小写的转换
//定义大写字母A利用上述规律将其转换为对应的小写字母
//定义大写字母A，并获取其字符对应的 码表中数字
char A = 'A';
int num = A;
//给其加上32，在转为char类型输出
num = num + 32;
char a = (char)num;
System.out.println(a);
这里我们清楚了java采用的 UNICODE 编码，这种十六进制的编码格式包含了 ASCII编码的部分内容，不仅如此，它还可以保存中文字符
char a = '兔';
int num = a;
System.out.println(num);
//输出此程序，可得知 兔在 码表中的占位是：20820
3.3.2 关于编码类型的背景故事
在最早的编程语言中，由于中文与英文字母所占的字节位数不同，在进行断句信息处理时候，为了避免产生乱码问题(例如，在进行切割时将一个汉字拆成了两半，编码就会造成错误)，往往需要进行编码范围的判断，操作过程会比较麻烦，但是在 java 中由于英文与中文都统一使用了 UNICODE 编码，所以此类问题也不再需要开发者做过多考虑。
3.4 布尔型
布尔型是一种逻辑结果，主要保存 true，false两类数据，这类数据只要用于一些程序的逻辑使用。
布尔是一位数学家的名字，
乔治·布尔，1815年11月2日，生于英格兰的林肯，是19世纪最重要的数学家之一。
//定义一个标记，默认为false
boolean flag = false;
//布尔类型的值只有两种：true 和 false，默认为false。即 真或假，0为false，1为true
//这里进行逻辑判断，取反值，不为false时输出
if(!flag){
System.out.println("Hello World!");
}
布尔数据类型在大多数情况下都是用于程序逻辑控制的，所以在本程序中使用 if 分支结构来操作，在 if分支结构中，如果判断的结果为true，则表示执行相应语句，如果为false，则表示不执行。
3.4.1 关于 boolean 的 背景故事
在许多的编程语言中，由于设计的初期没有考虑到布尔型的问题，那么就使用了数字0表示false，而非数字0表示true，例如 1 ， 2 ， 3 都为 true。但是这样的设计对于代码开发比较混乱， java 里面不允许使用 0 或 1 来填充布尔型的变量内容。
3.5 String 类型
只要是项目开发，百分之百会用到 String 数据类型，但是与其他的几种基本数据类型相比，String 属于引用类型（它属于一个类，在 java 里面只要是大写字母开头的单词名称，一定是一个类，大驼峰命名规则）。但是这个类的使用比较特殊
String表示的是一个字符串，即多个字符的集合。String 要求使用 “” 双引号进行包裹声明其内容。
String str ="HelloWorld!"; //字符串变量
System.out.println(str); //输出字符串变量中的内容
System.out.println("HelloWorld！"); //输出字符串常量
通过在这段代码中，我们可以得知 在使用String类型时，有两种实现方式，
- 通过自己定义，实现一个字符串变量，然后通过输出，输出变量中的内容
- 可以通过双引号，来表示一个字符串类型的常量
3.5.1 加号拼接的使用
String str = "Hello";
str = str+ "World";
str+="！";
System.out.println(str)
在这段代码中，先通过自己定义的方式，定义一个接收常量值"Hello" 的变量 str，然后又给str变量拼接了一个"World"的常量，最后又用简化的方式，拼接了一个感叹号。以上就是+号拼接的使用。
下面我们来说在加号拼接使用在数学计算中的方式
int numA = 100;
double numB = 99.0;
String str = "" + numA + numB;
System.out.println(str);
//最后的输出结果会为10099.0
因为在str变量中，先写入了一个""双引号，然后使用+号和后面的变量内容进行拼接，它会将后面变量中的内容都拼接成字符串。
它的过程是，一个空的字符串和变量值100进行拼接，虽然输出的内容还为100，但是此时的100是String类型，然后又和下一个变量值进行计算，会将其也拼接成字符串类型。所以最后拼接出来的结果就为：10099.0。
那上述代码我们如何得到正确的结果呢？
如果想获得正确的计算内容，并且拼接成字符串的形式可以通过()来改变计算的优先级，如：
int numA = 100;
double numB =99.0;
String str ="加法计算："+(numA + numB);
System.out.println(str);
//最后的计算结果为：加法计算：199.0
这次我们使用()来改变程序运算的优先级，先进行了变量值的加法计算，在计算完成之后，在与其字符串类型拼接，就可以完成正确的数学结果计算后的拼接了。
3.5.2 转义字符的使用
Java 中也支持转义字符的使用，常用的转义字符有：
换行\n，制表符\t，单斜杠 \，双引号 "，单引号 ’
String str = "Hello\"World\"\n\tHello Tu C";
System.out.println(str);
最后输出的结果为：
4. 运算符
Java 中的语句有很多种形式，表达式就是其中一种形式。表达式由 操作数与运算符组成，操作数可以是常量，变量，方法。而运算符就是数学中的运算符，如：+ - * / %等。
int z = 100;
System.out.println(z+100);
在这段代码中，该表达式由操作数变量z 和 操作数常量100 构成
Java 给我们提供了很多运算符：
数学运算符
逻辑运算符
地址运算符
赋值运算符
算术运算符
关系运算符
条件运算符
括号运算符…等等
下面我们来进行常用运算符的详细介绍
4.1 关系运算符
关系运算符的主要功能是进行数据的大小关系比较，返回的结果是 boolean型数据(只有true和false 两种取值)，常用的关系运算符有大于，大于等于，小于，小于等于，等于，不等于
System.out.println("3 > 1 =" + (3>1)); //使用大于号
System.out.println("3 < 1 =" + (3<1)); //使用小于号
System.out.println("3 >= 1 =" + (3>=1)); //使用大于等于号
System.out.println("3 <= 1 ="+ (3<=1)); //使用小于等于号
System.out.println("3 == 1 ="+ (3==1)); //使用等于号
System.out.println("3 != 1 ="+ (3!=1)); //使用不等于号
上述代码，当结果成立时返回true，结果不成立时，返回false。
我们看一下上述代码的返回结果：
4.2 数学运算符
数学运算符在开发中经常使用到,例如四则运算，取模，自增等。
四则运算：
int numA = 10;
int numB = 20;
System.out.println("加法运算：" + (numA+numB));
System.out.println("减法运算：" + (numA-numB));
System.out.println("乘法运算：" + (numA*numB));
//除法比较特殊，需要给其转型，不然用int类型接收小数部分会自动省略
System.out.println("除法运算：" + ((double)numA/numB));
四则运算就是对应的数学计算中的 + - * /
下面我们来看看取模的相关使用：
int numA = 10;
int numB = 3;
System.out.println(numA % numB);
我们可以利用取模来进行判断是否为奇数或者偶数
int numA =10;
int numB =3;
System.out.println(numA%2);
System.out.println(numB%2);
当结果为0时，证明没有余数，可以被整除，该结果为偶数。
反之，结果不为0时，证明有余数，不可被整除，该结果为奇数。
当然这是直接输出的形式，我们可以加入条件分支语句进行判断
int numA = 10;
if(numA % 2 ==0){
System.out.println(numA+"该数为偶数");
}else{
System.out.println(numA+"该数为奇数");
}
4.3 简化运算符
Java为我们提供了四则运算符，但是为了我们编写方便，还给我们提供了简化运算符：+=，-=，*=，/=，%=
我们用 *= 进行举例测试
//定义变量
int num = 10;
//利用简化运算符，让变量值和2进行乘法运算
System.out.println(num*=2);
4.4 自增运算符，自减运算符
这类运算符写作 ++ --，它根据编写的位置不同，执行的顺序也不同。
当写在变量前面时，先进行变量值内容的自增或自减。然后再使用变量进行数学计算
当写在变量后面时，先使用变量内容进行计算，然后再实现自增或自减的操作。
int numA =10;
int numB =20;
int result = ++numA + numB;
System.out.println(numA);
System.out.println(result);
在这段代码中，变量a和变量b的值分别为10和20，让两者进行加法计算，然后将其结果赋值到result变量当中。但是变量a的前面有一个自增运算符，自增写在了变量a的前面。其作用就会在变量 a 和 b 进行加法计算之前，先进行一个自动的操作。10 +1 变为11。
也就是变量a的值就自增为11了，然后变量a和b进行加法计算时，实际上是 11 和 20 的加法计算，所以最后 numA 的值为：11，result的值为：31。
我们在来看将这个运算符放在变量后面发生的变化。
int numA =10;
int numB =20;
int result = numA++ +numB;
System.out.println(numA);
System.out.println(result);
在这段代码中，定义的加法计算变量里，++自增运算符写在了变量a的后面，也就是a 和 b 先进行+法计算，计算完成之后，变量a在自己去完成自增运算。这个概念就体现了 ++ 自增符写在变量后面的作用了。
变量该参与计算参与计算，计算完了，在自己单独进行自增的运算。
简单理解就是：你该干嘛去干嘛，咱俩的账，等你回来再算，我不影响你。
++运算符写在变量前面，就是一件比较着急的事，你现在就必须给我做这个事，我着急，你做完了你在干别的，要不哪也别去，所以嘛，结果值一定会发生变化了，站在变量a的角度就看：真扫兴，又让我加功能，加完了，心里一肚子气，还得憋着火接着给老板干活。
++运算符写在变量后面，就比较宽容的多的多了，兔C 你这事没干好是吧？ 是？那行，行行，你该干活干活，等你撸完这个功能，咱俩在算你上个功能的事。我先不跟你计较。站在兔C 的角度看就是：老板又虚张声势，TMD 不管他，该干嘛干嘛，本分工作做好了就行了。
4.5 三目运算符
三目运算是一种赋值运算的形式，执行三目时可以以一个布尔表达式的结果进行赋值。
基本语法：
数据类型 变量名 = 布尔表达式 ? 满足此表达式时设置的内容 : 不满足此表达式时设置的内容
int numA = 10;
int numB = 20;
int max = numA > numB ? numA : numB;
System.out.println(max);
在这段代码中，我们定义了两个变量，numA 和 numB，然后利用三目运算进行结果的赋值，满足条件时结果为 第一个设置的内容值，不满足条件时，结果值为第二个设置的内容值。程序执行完成之后 max 变量的值为 = numB 的值。
我们也可以利用条件判断语句，实现和 三目运算同样的效果
int numA = 10;
int numB = 20;
int max =0;
if(numA > numB){
max = numA;
}else{
max = numB;
}
System.out.println(max);
此段代码的逻辑定义和使用三目运算的效果相同。
4.6 背景故事
对于三目运算符，在单独讲解基础的过程中，使用到的频率不会很高，但是在进行Java EE开发时，JSP 页面一定会通过 EL (语言表达式) 使用三目运算符进行操作。
4.7 逻辑运算符
逻辑运算符一共包含三种：
与(多个条件一起满足)
或(多个条件有一个满足)
非(使用 “!” 操作，可以实现true变false，fasle变true的结果转换 )
与和或操作的真表值
| No. | 条件1 | 条件2 | (与)：结果 | (或)：结果 |
|---|---|---|---|---|
| 1 | true | true | true | true |
| 2 | true | false | false | true |
| 3 | false | true | false | true |
| 4 | false | true | false | true |
| 5 | fasle | false | false | false |
下面我们来详细的看一下对于逻辑运算符在code中的使用
! 非运算符的使用，非就是针对布尔结果进行求反
boolean flag = true;
System.out.println(!flag);
利用非运算符，我们定义的变量值flag 为 true，但是输出时用了一下非运算符，就会取得相反的结果，所以输出的结果为 false。
由此我们可以得知：非操作的主要功能就是进行布尔值结果的转换。
与操作符的使用，与操作表示将若干个条件一起进行连接判断，同时满足返回true，有一个不满足时 就会返回false。
.
与操作符有两种，一种是普通与 & ，一种是短路与 &&
//普通与在code中的使用
if((1 == 2) & (10 /0 ==0)){
System.out.println("Hello World！");
}
其实直接运行会出现错误的，它会编译报错，告诉你 0 不能作为除数。
但是我们由此可知，在条件判断语句中，它先进行了第一个条件值的判断，当第一个条件不满足之后，它会继续执行第二个条件值，而在第二个程序进行判断时 发现0 作为了除数。
所以报错： ArthmeticException 需要异常处理。
其实抛开这个问题来说，真正的问题并不在这里，因为我们可以抛处异常，或者不在将0作为除数，先解决这个报错问题。
但是有一个问题是根深蒂固的，我既然使用普通与，那前面的结果值已经为 false，结果肯定是 false，那为什么还要继续往后进行判断呢？ 结果已经必然是false了啊。
所以针对这个问题，我们可以将使用的普通与改用短路与。
if((1 == 2 ) && (10 /0 == 0)){
System.out.println("Hello World！");
}
我们来执行看一下，同样用0作为除数的条件判断，同样没有抛处异常的情况下，短路与产生的作用：
我们看到程序没有报错，正常执行走完了。
这就是短路与的作用：当第一个条件为false时，后面的条件将不在执行，结果直接会返回为false。对比普通与来说，普通与虽然第一个条件值判断已经为false，但是还是会执行下去，把程序走完。
但是为什么 什么也没输出呢？没有输出出 HelloWolrd语句？
结果都不成立了，还输出 if分支语句中的程序干毛…
别慌 我们马上就开始介绍程序逻辑控制语句的使用
别急，看完了与操作，在来看一下或操作。
或操作是若干个条件一起判断，其中只要一个结果返回为true，其结果就一定为true，只有在逗为false的情况下，结果才会为false
if((1 == 1) | (10 / 0 ==0)){
System.out.println("Hello World！");
}
同样报错：java.lang.ArithmeticException: / by zero at …
告诉你0不能作为除数。
普通或也会将设置的条件都进行一次判断，当结果都为false时才会返回false，虽然在这里前面的条件满足了 已经为 true了，但是它也不会直接返回结果，和普通与一样，都要等整个判断走完，才返回结果。
所以也同样的报错了。
那 短路或呢？
if((1 == 1) || (10 / 0 ==0)){
System.out.pritnln("Hello World！");
}
短路或，与短路与一样，当它得到可返回的结果时，
例如 短路与 操作需要得到一个false，它就会自己变聪明，知道我需要都为true才会返回true，但是我有一个false了，我一会拿到的结果一定是false的。那不等执行了 我自己直接返回了。
那短路或就是，哦，我有一个为true了，那我肯定能返回true了，我直接返回接行了，如果在拿到的结果是false时，我在继续往下执行呗，看看都是false么？还有没有true，要都是false我就返回false了。
回到现在，我作为短路或，我现在得到一个true了，我肯定能返回true的结果值了，那我就返回true了。
又因为返回了true，随之我也能输出出 Hello World！了。
4.8 位运算
位运算在Java中有：& | ^ ~ >> << >>>而所有的位运算都是采用二进制数据进行操作的。
4.8.1 十进制转二进制
十进制转换为二进制的原则为：数据除2取余，随后倒着排列。
位与操作：
与操作是将十进制转换为二进制之后，在两个值或多个值上 对应的位上的数进行比较，如果两者都为 0 那与操作的结果就为0，如果有一个为 0 那结果也为 0，但是如果结果都为1的情况下，结果才会为1。以此类推将重新得到的一串二进制数，重新转换为十进制，就是你通过与操作计算得到的结果了。
位或操作：
位操作同理，将其转换为二进制数，对比其位上的数，如果都为0结果为0，如果有一个为1，那结果就为1，都为1也肯定没的说了。
简化一下就是：
& ：有一个为0结果就是0，都为1的情况下才为1.
| ：有一个为1结果就为1，都为0才给你返回0.
如果你将来遇到这样一个面试题：
请问如何更快计算出一个数的平方？
如果直接使用* 法 并不是最快的获取方法，因为你需要将十进制转换为二进制，计算出结果后，再将二进制转换为十进制。
你可以回答使用位运算符，<< 左移。使用这种方式实现，是直接在位上做手脚，也就是结果的本身，避免了转换进制的过程。好比如，你向计算机中存储一个数字，然后你想更改，取出来，更改，存储回去。使用位运算的情况，就好比你可以进入计算机中，不用取出，不用更改后存储，你直接进去改了。
如果感觉有点乱的话就这样记：
普通与，一直会执行下去，不会短路，结果：没有false的情况下就返回true。
短路与，如果执行语句碰到false，结果就为false，因为都为true才为true。
普通或，一直执行下去，不会短路，结果：有true的情况下就返回true。
短路或，如果执行语句碰到true，结果就为true，因为都为false才为false。
非，取反值
位与，有0就返回0，没有0才返回1
位或，有1就返回1，没有1才返回0
异或，都为1时接返回0，其余情况只要有1就返回1，都为0就返回0
5. 程序逻辑控制
一般来说程序结构包括顺序结构，选择结构，循环结构3种。
这三种不同的结构有一个共同特点，就是他们都只有一个入口，也只有一个出口，在程序中使用这些结构具备如下好处：程序易读，好维护，也可以减少调试时的时间。
5.1 基本概念陈述
顺序结构的特点让程序按照我们设定好的过程，由上而下的执行。他在程序中扮演着最基本的角色，在程序开发中较为常用
选择结构的特点是根据条件的成立与否，再决定执行哪些语句的一种结构
如图：
这种结构可以依据判断条件的结构，来决定要执行的语句。当条件判断为true时，运行语句1，当条件判断为fasle时候执行语句2。不论结果为false或是true，在执行完成之后都会回到语句3继续执行。
循环结构的特点是根据条件判断的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。
如图：
经上述内容，我们了解了程序逻辑控制的三种结构。
-
顺序结构，其特点就是按照顺序依次执行
-
选择结构，其特点是按照判断之后的结果，执行所对应的处理语句
-
循环结构，其特点是按照条件的成立与否，循环进行程序段落的执行
-
分支结构，除此之外这里补充分支结构的说明
分支结构为程序增加了选择的逻辑结构，针对不同的选择会产生不同的结果，其实就是我们熟知的 if…else 和 switch (if…else包括嵌套if…else的使用)
总结概念知识之后，我们现在即可着手code实操练习
5.2 选择结构的应用
if 语句的使用
double score = 99.0;
if(score <= 60){
System.out.println("该同学成绩不合格！");
}
在这段代码中，我们定义了一个常量值为 99.0的常量值，并将其存储在变量 score当中，然后使用选择结构，如果条件成立 就会输出该同学的成绩不合格。
补充说明：
在实际的开发中，经常会看到 if 的使用 没有加 { }。其实对于这一点来说，如果 if 语句当中 没有太多逻辑，就像我们案例当中体现的这样，只有一行代码，其实不写 { } 也不会有区别。对于这一点，我们只是说可以不加，但是不推荐。
if … else 的使用
int score = 99.0;
if(score > 60){
System.out.println("该同学成绩已经合格");
}else{
System.out.println("该同学成绩不合格！");
}
针对这段代码，我们定义的变量会进入到if语句中执行，首先进入到判断当中，如果判断结果为 true，就会执行对应的输出语句，如果此时并不满足结果 大于 60 的条件，就会执行 else 当中的语句。
if…else if … else 嵌套使用
int score = 99.0;
if(score < 60){
System.out.println("该同学成绩不合格！");
}else if(score >= 60 && score <= 90){
System.out.println("该同学成绩良好");
}else if(score >= 90 && score <=100){
System.out.println("该同学的成绩非常优秀");
}else{
System.out.println("该同学的成绩存在问题");
}
在这段代码当中，程序向下执行，碰到if语句，然后会进入到判断语句当中，当满足条件，为 true时，就会执行对应的输出语句。如果依次执行均为false，那么最后的结果只能为 else 中的语句了。
这种嵌套的使用，可以判断多个boolean值，其实对于这种情况，我们可以使用 switch来完成。
switch 语句只能进行四种数据类型的判断：int double 枚举 String
switch和if语句的区别在于：if语句可以进行boolean值的判断，而使用switch只能判断内容值
int ch =10;
switch(ch){
case 1:{
System.out.println("传入的内容值为:1");
break;
}
case 2:{
System.out.println("传入的内容值是：2");
break;
}
case 3:{
System.out.pritnln("传入的内容值是：3");
break;
}
default:{
System.out.println("没有匹配到内容值");
break;
}
}
此处我们使用的switch语句中 传入的内容值为变量 ch，然后ch会进入到整个switch语句当中进行匹配，当匹配到对应的内容值时，程序就会进入到该段落当中，然后执行当中的程序内容，如果未匹配成功，会进入到 default 语句当中，输出defalut当中的内容，defalut 是一个兜底的动作。
break 的作用：
brea的作用起到跳出的作用，如果不加break语句，则会每个case条件都依次执行，也就是会进入到每一个case当中，并且将其case当中的内容都执行出来，你可以理解成程序会一直进行穿透。加入break可以防止switch语句的穿透。
switch 重点强调：
switch中可以进行判断的值只有四个：int double 枚举 String。
而其中String的使用要切忌 Java 严格区分大小写，而对于在switch中使用String类型，是从 JDK 1.7 加入的。
5.2 循环结构的应用
当代码需要循环执行的时候，可以考虑使用循环结构。
循环结构的使用有两种：for循环，while循环(其中 while循环又分为两种：while和do…while)
循环结构的特点：
- 循环的结束判断
- 每次循环体执行的时候，循环条件要求修改
所有的循环语句里面都必须有循环的初始化条件，每次循环的时候都要去修改这个条件，以判断循环是否结束。
// 1 - 100 的训话累加
int num =0;
int count =1;
while(count <= 100){
num += count;
count++;
}
System.out.println(num);
在此段代码当中，我们可以将 变量 count 看做是一个起始值，该值在不小于等于100的时候，不断循环执行循环体中的操作。而循环体当中，让变量 num不断和 我们定义的 count 循环条件 累加，在每次累加过程之后，都让该循环条件进行+1。最后在不满足判断条件之后，也就不在进行循环操作了。
do…while 的使用
int num =0;
int count =1;
do{
num += count;
count++;
}while(count <=100 );
System.out.println(num);
该段代码也是进行1到100的累加计算，与while不同的是，while是先进入判断，然后进行循环的操作。而do…while的特点是先进循环操作，然后在进入到判断当中。其实对于这个特点不难混淆，看其语法就清楚了。
for 循环的使用
for循环的使用特点是在明确循环次数的情况下进行使用。
//使用for循环实现 1-100的累加
int num =0;
for(int i =0; i <=100; i++){
num +=i;
}
System.out.println(num);
关于for循环的分开定义
int num =0;
int i =1;
for(; i <=100;){
num += i;
i++;
}
System.out.println(num);
//不推荐此方法
关于for循环的嵌套使用
//打印乘法口诀表
for(int i =1; i <= 9; i++){
for(int j =1; j <= i; j++){
System.out.print(j+"*"+i+"="+(i*j)+\t)
}
System.out.println(); //换行
}
对于此段代码，外层循环是针对控制轮数的，而内层循环控制的则是在每轮循环下需要变动的元素。
例如：
我们知道乘法口诀表长这样：
而外层循环控制的就是第一列乘法算式中，每个算式的第一个值，也就是1。内层循环是基于当前循环的这个轮次中，算式中第二个值的控制。
也就是在第一轮循环下，你只能看到第一列的算式被打印出来，而第一列算式当中，每个算式的第一个元素都是依靠外层循环打印出来的，然后第二个值是基于在当前外层循环下打印出来的1-9。
第一轮结束之后，
开始第二轮循环，在第二轮循环中，外层循环先打印出来了 第二列 2这一列，然后在由内层循环将与其2对应的元素打印出来。
图片中，红色的一列是外层循环打印出来的，黄色线条的一列，就是基于当前外层循环下，内层循环打印出来的。
至于内层循环的条件 小于 外层循环的 条件值，是为了防止计算重复，然后是乘法计算，这个就好说了，将当前循环控制的元素进行乘法运算。
最后在这里补充关于循环中用到的两个关键字：continue 和 brea
continue 是结束当前次循环的执行，直接进入下一次
break 则是结束当前的整个循环。
6. 方法的定义及使用
在这一部分，我只打算将概念性的东西叙述出来。在后续的学习当中少不了这个知识点的使用，我不太打算详细介绍了，因为这个章节到25号才进行到这里。
方法的概念：
方法在很多地方又被称为函数，在java中的单词为 Method，在其他的编程语言当中的单词为：Function，方法是一段可以被重复调用的代码块
语法
public 返回值类型 方法名称(参数类型 参数名称){
方法体(方法当中可执行的逻辑程序);
return 返回值;
}
其中return 返回值的意思是说：该方法定义了一个返回值类型，所以你调用这个方法的使用，需要给其返回一个参数，而在java当中，方法的返回值类型可以有两种：基本数据类型，引用数据类型。如果你调用的方法设置了返回值，那调用时，就必须使用 return 关键字 返回一个与其对应数据类型的返回值。
但是如果该方法的返回值定义为了 void ，那他是不需要返回值的，所以你就不用再考虑使用 return 返回与其对应数据类型的结果值了。
下面我们来讨论一下关于方法相关的内容。
方法的命名规范
方法的命名和变量一样，均使用小驼峰
方法重载：
方法的重载是指，方法名称相同，参数类型和个数不同。
虽然方法重载可以返回不同的数据类型，但是建议使用定义方法的重载时，尽量返回相同的数据类型，因为方法重载的特点是依据参数个数和参数类型来区分的。
方法的递归
方法的递归是指自己调用自己的操作，在使用方法的递归时，需要满足两个条件：必须有结束条件。每次调用时都需要改变传递的参数。
//通过递归实现 1 - 100 的累加操作
public class Test_dg{
public static void main(String[] args){
System.out.println(sum(100));
}
public static int sum(int num){
if(num == 1){
return 1;
}
return num + sum(num - 1);
}
}
关于第六知识点，可以查阅往期内容下述是地址链接：
关于循环的往期内容
关于方法和递归的往期内容
1528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
