投稿
  1. 首页
  2. python

code • 2022-4-28 • python • 阅读 39

第1张

文章目录
          • 1. Java 的注释
            • 1.1 单行注释
            • 1.2 多行注释
            • 1.3 文档注释
          • 2. 标识符与关键字
          • 3. 数据类型划分
            • 3.0 基础数据类型简介
            • 3.1 整型
            • 3.1.1 什么是常量？什么是变量？
            • 3.1.2 编码习惯。
            • 3.1.3 int 类型的取值范围
            • 3.1.4 数据类型转换
            • 3.2 浮点型
            • 3.2.1 有一个问题
            • 3.2.2 关于 java中的Bug
            • 3.2.3 推荐以后选择小数 *** 作时都用double型
            • 3.2.4 关于除法的问题
            • 3.3 字符型
            • 3.3.1 常用的编码范围介绍
            • 3.3.2 关于编码类型的背景故事
            • 3.4 布尔型
            • 3.4.1 关于 boolean 的 背景故事
            • 3.5 String 类型
            • 3.5.1 加号拼接的使用
            • 3.5.2 转义字符的使用
          • 4. 运算符
            • 4.1 关系运算符
            • 4.2 数学运算符
            • 4.3 简化运算符
            • 4.4 自增运算符，自减运算符
            • 4.5 三目运算符
            • 4.6 背景故事
            • 4.7 逻辑运算符
            • 4.8 位运算
            • 4.8.1 十进制转二进制
          • 5. 程序逻辑控制
            • 5.1 基本概念陈述
            • 5.2 选择结构的应用
            • 5.2 循环结构的应用
          • 6. 方法的定义及使用

本章节涵盖内容如上述目录所属，博文的起拟时间为： 2022.4.13 日。 完成时间即发布时间。与其相对应时期发布的还有 python 的第二章。请到个人主页中进行查看。

文章内容来自 第一行代码 的读后分享，此博客会涵盖书中摘录内容和个人理解的分享，请广大朋友们给予点评和支持，兔C会给大家分享出更多优质的知识内容。感谢。

导言

任何程序都是对数据的 *** 作，所以在程序开发过程中首先需要掌握的就是数据类型的选择。为了让程序数据控制的更加灵活，可以使用各种流程控制语句，如判断语句，循环语句。在实际开发工作中为了达到结构化以及可重用的目的，往往需要利用方法来将部分程序代码进行封装。本章将讲解数据类型划分，数据运算，程序结构，方法定义与使用等与程序相关的核心概念。

1. Java 的注释

注释的概念：

在程序开发中，由于其基本组成都是代码，所以考虑到程序可维护性的特点，在编写代码时都要在每段代码上增加若干个说明文字，这些文字不需要被编译器解释，它们被称为 java 的注释。

简单理解就是你自己写的代码，加上说明， 这个说明不会同代码一起被执行到程序当中，但是你自己在看代码的时候 看到上面的说明 又可以告知你自己相关的提示。这个东东就叫注释。

之前看过一本书，忘了叫什么了，但是挺有意思的。
书中的观点大概如下：

  1. 注释要点名命题，不要什么都注释，关键性代码打上注释。简洁有力，直接点出要害，即 一针见血。
  2. 通过第一点，可得知第二点建议，注释不要打的太过麻瓜，简单的代码 一看就知其意，还打注释干嘛。

如果是新手村的朋友看到此篇文章，还不明其意，也不用太过纠结，很多事都是后知后觉。晓得了注释的基本概念，我们来看如果实现。

首先，我们要知道 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.数据类型大小/位可表示的取值范围默认值
1byte 字节8-128 ~ 1270
2short 短型16-32678 ~ 327670
3int 整型32-2147483648 ~ 21474836470
4long 长整型64-9223372036854775808 ~ 92233720368547758070
5float 单精度32-3.4E38(-3.4 * 10^38) ~ 3.4E38(3.4 * 10 ^36)0.0
6double 双精度64-1.7E308(-1.7 * 10^308) ~ 1.7E308(1.7 * 10^308)0.0
7char 字符160~255‘\u0000’
8boolean 布尔1位true 或 falsefalse

那在使用过程中如何选择数据类型？
针对这个问题，作者已经在书中给出了答案，下面我给大家摘录出书中的介绍。
整数类型，我们就用 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);
    }

结果是溢出了。。
说明什么，我们在使用强制类型转换的时候，一定要注意 数据溢出问题！！

小结
咨上所述内容：

  1. 整数类型的使用
  2. 变量和常量的概念及区别
  3. 数据溢出问题
  4. 数据类型转换：自动转换，强制转换。
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类型时，有两种实现方式，

  1. 通过自己定义，实现一个字符串变量，然后通过输出，输出变量中的内容
  2. 可以通过双引号，来表示一个字符串类型的常量
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(与)：结果(或)：结果
1truetruetruetrue
2truefalsefalsetrue
3falsetruefalsetrue
4falsetruefalsetrue
5faslefalsefalsefalse

下面我们来详细的看一下对于逻辑运算符在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继续执行。

循环结构的特点是根据条件判断的成立与否，决定程序段落的执行次数，而这个程序段落就称为循环主体。
如图：

经上述内容，我们了解了程序逻辑控制的三种结构。

  1. 顺序结构，其特点就是按照顺序依次执行

  2. 选择结构，其特点是按照判断之后的结果，执行所对应的处理语句

  3. 循环结构，其特点是按照条件的成立与否，循环进行程序段落的执行

  4. 分支结构，除此之外这里补充分支结构的说明

分支结构为程序增加了选择的逻辑结构，针对不同的选择会产生不同的结果，其实就是我们熟知的 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. 循环的结束判断
  2. 每次循环体执行的时候，循环条件要求修改
    所有的循环语句里面都必须有循环的初始化条件，每次循环的时候都要去修改这个条件，以判断循环是否结束。
// 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);
 }
}

关于第六知识点，可以查阅往期内容下述是地址链接：
关于循环的往期内容
关于方法和递归的往期内容

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/741976.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-04-28
下一篇 2022-04-28

发表评论

登录后才能评论

评论列表（0条）

保存