本文已参与「新人创作礼」活动，一起开启掘金创作之路。
感谢你的路过，希望学生的笔记能给你一点微不足道的参考（2/100）
Java基础思维导图，完整Java体系的链接
@TOC
一，二进制与ASCI码
1.1进位计数制
1.1.1十进制计数法
推广：r进制计数法
1.1.2任意进制《-》十进制
1.1.3二进制-》八进制，十六进制
真值和机器数
1.2ASCI码
1.2.1BCD码
1.2.2ASCI码
汉字：区位码：９４＊９４
国标码：区位码＋２０２０H，机内码：机内码＋８０８０H
二，变量
2.1什么是变量？
变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。由于该存储单元中的数据可以发生改变，因此得名为"变量"。
2.2变量的分类？
按所属的数据类型划分：
基本数据类型变量
引用数据类型变量
按被声明的位置划分：
局部变量：方法或语句块内部定义的变量
成员变量：方法外部、类的内部定义的变量
// FIXME 类的外面不能有变量的声明
public class Demo01_shengmingweizhi {
// 成员变量位置
private void psvm() {
// TODO Auto-generated method stub
// 局部变量位置
}
}
注意：类的外面不能有变量的声明
变量名称：在同一个大括号范围内，变量的名字不可以相同。
变量赋值：定义的变量，不赋值不能使用。
对于float和long类型来说，字母后缀的F和L不要丢掉。
变量使用范围不能超过作用域的范围。
2.3变量与常量？
常量是固定不变的数据，那么在程序中可以变化的量称为变量。
说明：
数学中，可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。 程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可 以保存6，这样x保存的数据是可以改变的，也就是我们所讲解的变量。
2.4变量的定义格式？
变量定义的格式包括三个要素： 数据类型 、 变量名 、 数据值。
数据类型 变量名 = 数据值//创建变量，并赋值。
变量的创建与使用：
public class Demo02_ChuangJianYuShiYong {
/**
* 变量的创建与使用
* @param args
*/
public static void main(String[] args) {
// 创建变量的语法：数据类型 变量名 = 初始化值；
int a = 20;
// 创建变量暂时不赋值的语句： 数据类型 变量名；
// int b;
// 创建字符串变量；
String s = "abcde";
// 重新给变量赋值的语法： 变量名 = 值；
a = 30;
System.out.println(s);
}
}
补充：
1.变量的作用域
/**
* 在JAVA中，变量的作用域分为四个级别：类级、对象实例级、方法级、块级。
类级变量又称全局级变量或静态变量，需要使用static关键字修饰。
类级变量在类定义后就已经存在，占用内存空间，可以通过类名来访问，不需要实例化。
对象实例级变量就是成员变量，实例化后才会分配内存空间，才能访问。
成员变量是定义在方法之外，类之内的。成员变量随着对象的创建而存在，随着对象的消失而消失。
方法级变量就是在方法内部定义的变量，就是局部变量，局部变量在调用了对应的方法时执行到了创建该变量的语句时存在，
局部变量的作用域从它被声明的点开始，一旦出了自己的作用域马上从内存中消失。
块级变量就是定义在一个块内部的变量，变量的生存周期就是这个块，出了这个块就消失了，
比如 if、for 语句的块。块是指由大括号包围的代码
说明：
• 方法内部除了能访问方法级的变量，还可以访问类级和实例级的变量。
• 块内部能够访问类级、实例级变量，如果块被包含在方法内部，它还可以访问方法级的变量。
• 方法级和块级的变量必须被显示地初始化，否则不能访问。
*/
public class Demo14_BianLiangDeZuoYongYu {// TODO 这部分不是太清晰
public static String name = "开课吧";//类级变量
// 同一作用域范围的包裹下成员变量名和局部变量名是可以变量名相同的。
public int i;//对象实例级变量
//属性块，在类初始化属性时后运行
{
int j = 2;//块级变量
}
public void test1()
{
int j = 3;//方法级变量
if(j == 3)
{
int k = 5;//块级变量
}
//这里不能访问块级变量，块级变量只能在块内部访问
System.out.println("name=" + name + ", i=" + i + ", j=" + j);
}
public static void main(String[] args)
{
int i = 1;
//不创建对象，直接通过类名访问类级变量
System.out.println(Demo14_BianLiangDeZuoYongYu.name);
//创建对象并访问它的方法
Demo14_BianLiangDeZuoYongYu t = new Demo14_BianLiangDeZuoYongYu();
t.test1();
}
}
2.变量的定义细节
public class Demo06_BianLiangDingYiXiJie {
/**
* 变量定义细节
* 具体内容：float,long变量定义，及char变量使用的注意事项
* @param args
*/
public static void main(String[] args) {
// 1.float类型变量在定义时需注意： 我们直接写出的浮点数字，默认类型是double,会提示强转
// 解决：我们可以在浮点数字的后面加入f,来表示写出的数字类型是float
float f1 = 10.1f;
// 2.long类型变量定义需注意：我们直接写出的整形数字，默认类型是int，当值过大时会出错
// 解决： 我们可以在整形数字的后面加入L,来表示写出的整形数字是long类型的
long L1 = 22000000000L;
// 3.char类型
// char类型的字母可以参与数字运算
char c1 = 'A';
System.out.println(c1);
System.out.println((int)c1);
System.out.println(++c1);
}
}
3.变量的调换小练习
public class Demo03_BianLiangDiaoHuanLianXi {
/**
* 变量调换练习
* 任务：将下面变量a和变量b的值提高运算，进行调换。
* @param args
*/
public static void main(String[] args) {
// 变量a与b的初始值
int a = 10;
int b = 20;
// 定义一个变量c,帮助调换
int c = 0;
// c=a等于10，a=b等于20，b=c等于10；
c = a;
a = b;
b = c;
System.out.println(a);
System.out.println(b);
}
}
三，数据类型
3.1字节
介绍：字节是计算机信息技术用于计量存储容量的一种计量单位，作为一个单位来处理的一个二进制数字串，是构成 信息的一个小单位。Java 中的字节是八位的字节，即它包含八位的二进制数。
转换关系：
8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B。
8 bit = 1 B
1024 B =1 KB
1024 KB =1 MB
1024 MB =1 GB
1024 GB = 1 TB
3.2数据类型表
注意：
1，字符串不是基本数据类型，是引用数据类型
2，浮点型可能只是一个近似的值，不是精确的值
3，数据范围与字节数不一定相关，比如float与long
4，浮点数中的默认类型是double，如果一个使用float类型，需要加一个后缀F
5，如果是整数，默认类型是int，如果一定要使用long，需要加一个后缀L
举例：100-int,100L-long
四，标识符
介绍：Java 对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。
规则如下:
由字母、数字、下划线（_）和美元符号（$）组成。
不能以数字开头。
区分大小。
长度无限制。
不能是 Java 中的保留关键字。
标识符命名习惯：见名知意。
五，数据类型转换
5.1自动转换
定义：将取值范围小的类型 自动提升为 取值范围大的类型
转换规则：
范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int
byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double
转换原理图解：
代码：
/*
当数据类型不一样时，将会发生数据类型转换。
自动类型转换（隐式）
1. 特点：代码不需要进行特殊处理，自动完成。
2. 规则：数据范围从小到大。
强制类型转换（显式）
*/
public class Demo04_ZiDongZhuanHuan {
/**
* 自动类型转换
* @param args
*/
public static void main(String[] args) {
System.out.println(1024); // 这就是一个整数，默认就是int类型
System.out.println(3.14); // 这就是一个浮点数，默认就是double类型
// 左边是long类型，右边是默认的int类型，左右不一样
// 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
// int --> long，符合了数据范围从小到大的要求
// 这一行代码发生了自动类型转换。
long num1 = 100;
System.out.println(num1); // 100
// 左边是double类型，右边是float类型，左右不一样
// float --> double，符合从小到大的规则
// 也发生了自动类型转换
double num2 = 2.5F;
System.out.println(num2); // 2.5
// 左边是float类型，右边是long类型，左右不一样
// long --> float，范围是float更大一些，符合从小到大的规则
// 也发生了自动类型转换
float num3 = 30L;
System.out.println(num3); // 30.0
}
}
5.2强制转换
定义：将在这里插入代码片取值范围大的类型 强制转换成 取值范围小的类型自动转换是Java自动执行的，而强制转换需要我们自己手动执行。
转换格式：
数据类型 变量名 = （数据类型）被转数据值；
举例 // double类型数据强制转成int类型，直接去掉小数点。 int i = (int)1.5;
转换原理图解：
代码：
/*
强制类型转换
1. 特点：代码需要进行特殊的格式处理，不能自动完成。
2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
注意事项：
1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2. byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
3. byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
4. boolean类型不能发生数据类型转换
*/
public class Demo05_QiangZhiZhuanHuan {
/**
* 强制类型转换
* @param args
*/
public static void main(String[] args) {
// 左边是int类型，右边是long类型，不一样
// long --> int，不是从小到大
// 不能发生自动类型转换！
// 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
int num = (int) 100L;
System.out.println(num);
// long强制转换成为int类型
int num2 = (int) 6000000000L;
System.out.println(num2); // 1705032704
// double --> int，强制类型转换
int num3 = (int) 3.99;
System.out.println(num3); // 3，这并不是四舍五入，所有的小数位都会被舍弃掉
char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
System.out.println(zifu1 + 1); // 66，也就是大写字母A被当做65进行处理
// 计算机的底层会用一个数字（二进制）来代表字符A，就是65
// 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
byte num5 = 50;
// byte + byte --> int + int --> int
int result1 = num4 + num5;
System.out.println(result1); // 90
short num6 = 60;
// byte + short --> int + int --> int
// int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
short result2 = (short) (num4 + num6);
System.out.println(result2); // 100
}
}
注意：
浮点转成整数，直接取消小数点，可能造成数据损失精度。
int 强制转成 short 砍掉2个字节，可能造成数据丢失。
六，方法
概述：封装的一段特定的逻辑功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
格式：
权限修饰符 返回值声明 方法名 （参数列表）｛
方法中封装的逻辑功能
return ; ｝
权限修饰符： 标志着方法在什么情况下可以使用。目前固定写法 public static
返回值类型：
方法调用结束后可以返回一个数据，称之为返回值。 方法在声明时必须指定返回值的类型。 通过 return 语句返回，return 语句的作用在于结束方法且将数据返回。 如果方法没有返回值（即方法不需要返回数据），需将返回值类型声明为 void。
方法名：
为我们定义的方法起名，满足标识符的规范，用来调用方法。
参数列表：
方法的参数列表：在调用时传递给方法，需要被方法处理的数据。
在方法定义时，需要声明该方法所需要的参数变量。
在方法调用时，会将实际参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。方法结束。返回参数
例子：
public class Demo07_FangFaShiYongJianShu {
/**
* 方法的使用简述
* @param args
*/
public static void main(String[] args) {
// 调用我自己的方法
me();
// 求和
int num = sum(10, 30);
System.out.println(num);
}
// 我
public static void me() {
System.out.println("吃");
}
// 求和
public static int sum(int x,int y) {
int s = x+y;
return s;
}
}
补充：
1权限修饰符：
四种访问权限介绍：
public：公共的
protected：受保护的
default：默认的
private：私有的
权限表格：
2.转义字符
将原本就有特殊含义的字符进行转义。让其代表新的含义。
/**
* 所有的ASCII码都可以用“\”加数字（一般是8进制数字）来表示。
* 而C中定义了一些字母前加"\"来表示常见的那些不能 显示的ASCII字符，
* 如\0,\t,\n等，就称为转义字符，因为后面的字符，都不是它本来的ASCII字符意思了
*
* 转义字符 意义 ASCII码值（十进制）
* \n 换行，将当前位置移到下一行开头 010
* \r 回车 ，将当前位置移到本行开头 013
* \t 水平制表(HT) （跳到下一个TAB位置） 009
* \\ 代表一个反斜线字符''\' 092
* \' 代表一个单引号（撇号）字符 039
* \" 代表一个双引号字符 034
*
*/
public class Demo15_ZhuanYiZiFu {
/**
* 转义字符
* @param args
*/
public static void main(String[] args) {
// char c = '\'; //警告 \把'转义了
char c = '\'';
System.out.println(c);
// System.out.println("\"); // 同上
System.out.println("\\");
}
}
七，运算符
笔记写代码里了，看代码吧
7.1算数运算符
package FangFaYuYunSuanFu.YunSuanFu;
public class Demo08_SuanShu {
/**
* 算数运算符
* 具体内容：1，常见的加减乘除运算。2，++，——运算符
* @param args
*/
public static void main(String[] args) {
jiaJianChengChu();
System.out.println("-----------------------------");
ziZengZiJian();
}
/* 1常见的加减乘除运算
运算符：进行特定操作的符号。例如：+
表达式：用运算符连起来的式子叫做表达式。例如：20 + 5。又例如：a + b
四则运算：加：+ 减：- 乘：* 除：/
取模（取余数）：%
首先计算得到表达式的结果，然后再打印输出这个结果。
复习一下小学一年级的除法公式：
被除数 / 除数 = 商 ... 余数
对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数。
只有对于整数的除法来说，取模运算符才有余数的意义。
注意事项：
一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
*/
public static void jiaJianChengChu() {
// 两个常量之间可以进行数学运算
System.out.println(20 + 30);
// 两个变量之间也可以进行数学运算
int a = 20;
int b = 30;
System.out.println(a - b); // -10
// 变量和常量之间可以混合使用
System.out.println(a * 10); // 200
int x = 10;
int y = 3;
int result1 = x / y;
System.out.println(result1); // 3
int result2 = x % y;
System.out.println(result2); // 余数，模，1
// int + double --> double + double --> double
double result3 = x + 2.5;
System.out.println(result3); // 12.5
}
/* 2自增自减运算符
运算符：进行特定操作的符号。例如：+
自增运算符：++
自减运算符：--
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num，也可以num++
使用方式：
1. 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
2. 混合使用：和其他操作混合，例如与赋值混合，或者与打印操作混合，等。
使用区别：
1. 在单独使用的时候，前++和后++没有任何区别。也就是：++num;和num++;是完全一样的。
2. 在混合的时候，有【重大区别】
A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。 【先加后用】
B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。 【先用后加】
注意事项：
只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。
*/
public static void ziZengZiJian() {
int num1 = 10;
System.out.println(num1); // 10
++num1; // 单独使用，前++
System.out.println(num1); // 11
num1++; // 单独使用，后++
System.out.println(num1); // 12
System.out.println("=================");
// 与打印操作混合的时候
int num2 = 20;
// 混合使用，先++，变量立刻马上变成21，然后打印结果21
System.out.println(++num2); // 21
System.out.println(num2); // 21
System.out.println("=================");
int num3 = 30;
// 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
System.out.println(num3++); // 30
System.out.println(num3); // 31
System.out.println("=================");
int num4 = 40;
// 和赋值操作混合
int result11 = --num4; // 混合使用，前--，变量立刻马上-1变成39，然后将结果39交给result1变量
System.out.println(result11); // 39
System.out.println(num4); // 39
System.out.println("=================");
int num5 = 50;
// 混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
int result22 = num5--;
System.out.println(result22); // 50
System.out.println(num5); // 49
System.out.println("=================");
int x1 = 10;
int y2 = 20;
// 11 + 20 = 31
int result33 = ++x1 + y2--;
System.out.println(result33); // 31
System.out.println(x1); // 11
System.out.println(y2); // 19
// 30++; // 错误写法！常量不可以使用++或者--
}
}
7.2赋值运算符
package FangFaYuYunSuanFu.YunSuanFu;
/*
赋值运算符分为：
基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。
int a = 30;
复合赋值运算符：
+= a += 3 相当于 a = a + 3
-= b -= 4 相当于 b = b - 4
*= c *= 5 相当于 c = c * 5
/= d /= 6 相当于 d = d / 6
%= e %= 7 相当于 e = e % 7
注意事项：
1. 只有变量才能使用赋值运算符，常量不能进行赋值。
2. 复合赋值运算符其中隐含了一个强制类型转换。
*/
public class Demo09_FuZhi {
/**
* 赋值运算符
* @param args
*/
public static void main(String[] args) {
int a = 10;
// 按照公式进行翻译：a = a + 5
// a = 10 + 5;
// a = 15;
// a本来是10，现在重新赋值得到15
a += 5;
System.out.println(a); // 15
int x = 10;
// x = x % 3;
// x = 10 % 3;
// x = 1;
// x本来是10，现在重新赋值得到1
x %= 3;
System.out.println(x); // 1
// 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！
byte num = 30;
// num = num + 5;
// num = byte + int
// num = int + int
// num = int
// num = (byte) int
num += 5;
System.out.println(num); // 35
}
}
7.3比较运算符
package FangFaYuYunSuanFu.YunSuanFu;
/*
比较运算符：
大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等： !=
注意事项：
1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2. 如果进行多次判断，不能连着写。
数学当中的写法，例如：1 < x < 3
程序当中【不允许】这种写法。
*/
public class Demo10_GuanXi {
/**
* 关系运算符
* @param args
*/
public static void main(String[] args) {
System.out.println(10 > 5); // true
int num1 = 10;
int num2 = 12;
System.out.println(num1 < num2); // true
System.out.println(num2 >= 100); // false
System.out.println(num2 <= 100); // true
System.out.println(num2 <= 12); // true
System.out.println("===============");
System.out.println(10 == 10); // true
System.out.println(20 != 25); // true
System.out.println(20 != 20); // false
int x = 2;
// System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。
}
}
7.4逻辑运算符
```php
package FangFaYuYunSuanFu.YunSuanFu;
/*
与（并且） && 全都是true，才是true；否则就是false
或（或者） || 至少一个是true，就是true；全都是false，才是false
非（取反） ! 本来是true，变成false；本来是false，变成true
异或（同假异真） ^ 全都是true/false，是false；一true，一false是true
& 与
| 或
^ 异或
! 非
&& 短路与
|| 短路或
与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，
从而节省一定的性能。“&”，“|”不管是否在左边得到最终结果，都会执行完右边的代码。
注意事项：
1. 逻辑运算符只能用于boolean值。
2. 与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3. 与、或两种运算符，如果有多个条件，可以连续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C
TIPS：
对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来：
int x = 2;
1 < x && x < 3
*/
public class Demo11_Logic {
/**
* 逻辑运算符
* @param args
*/
public static void main(String[] args) {
System.out.println(true & false); // false
System.out.println(true && false); // false
// true && true --> true
System.out.println(3 < 4 && 10 > 5); // true
System.out.println("============");
System.out.println(true | false); // true
System.out.println(true || false); // true
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println("============");
System.out.println(true); // true
System.out.println(!true); // false
System.out.println("============");
System.out.println(true ^ false); // true
System.out.println(true ^ true); // false
System.out.println(false ^ true); // true
System.out.println(false ^ false); // false
System.out.println("============");
int a = 10;
// false && ...
System.out.println(3 > 4 && ++a < 100); // false
System.out.println(a); // 10
System.out.println("============");
int b = 20;
// true || ...
System.out.println(3 < 4 || ++b < 100); // true
System.out.println(b); // 20
}
}
7.5+号运算
package FangFaYuYunSuanFu.YunSuanFu;
/*
四则运算当中的加号“+”有常见的三种用法：
1. 对于数值来说，那就是加法。
2. 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo12_ZifuChuanLianJie {
/**
* 字符串连接运算符
* @param args
*/
public static void main(String[] args) {
// 字符串类型的变量基本使用
// 数据类型 变量名称 = 数据值;
String str1 = "Hello";
System.out.println(str1); // Hello
System.out.println("Hello" + "World"); // HelloWorld
String str2 = "Java";
// String + int --> String
System.out.println(str2 + 20); // Java20
// 优先级问题
// String + int + int
// String + int
// String
System.out.println(str2 + 20 + 30); // Java2030
System.out.println(str2 + (20 + 30)); // Java50
}
}
7.6三元运算符
package FangFaYuYunSuanFu.YunSuanFu;
/*
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。
格式：
数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
流程：
首先判断条件是否成立：
如果成立为true，那么将表达式A的值赋值给左侧的变量；
如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。
注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2. 三元运算符的结果必须被使用。
*/
public class Demo13_SanMu {
/**
* 三元运算符
* @param args
*/
public static void main(String[] args) {
int a = 10;
int b = 20;
// 数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B;
// 判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
int max = a > b ? a : b; // 最大值的变量
System.out.println("最大值：" + max); // 20
//int result = 3 > 4 ? 2.5 : 10; // 错误写法！
System.out.println(a > b ? a : b); // 正确写法！
// a > b ? a : b; // 错误写法！
}
}
八，综合练习
需求：
* 1. 定义一个整型变量并赋任意五位正整数作为初始值，判断它是不是五位回文数
* （五位回文数：个位与万位相同，十位与千位相同，例如：12321）：
* 2. 定义一个整型变量并赋任意五位正整数作为初始值，输出各位数字之和
* （例如：12345 各位之和是：1+2+3+4+5 。也就是 15）
* 3. 定义整型变量 a、b，写出将 a、b 两个变量值进行互换的程序
* （要求不能使用第三个变量）
* 4. 请写出一段遵守编码规范的 Hello World 代码（注意，注释必须有，也要遵守规范）
package LianXi;
/**
* @Description: TODO(小王的面试任务)
* @author: 王宇辉
* @Date: 2021年8月5日 下午10:13:36
*/
public class Demo16_XiaoWangMianShi {
/**
* 需求：
* 1. 定义一个整型变量并赋任意五位正整数作为初始值，判断它是不是五位回文数
* （五位回文数：个位与万位相同，十位与千位相同，例如：12321）：
* 2. 定义一个整型变量并赋任意五位正整数作为初始值，输出各位数字之和
* （例如：12345 各位之和是：1+2+3+4+5 。也就是 15）
* 3. 定义整型变量 a、b，写出将 a、b 两个变量值进行互换的程序
* （要求不能使用第三个变量）
* 4. 请写出一段遵守编码规范的 Hello World 代码（注意，注释必须有，也要遵守规范）
* @param args
*/
public static void main(String[] args) {
// 想看哪个需求改一下方法然后执行就OK了
xuQiu4();
}
// 需求一
public static void xuQiu1() {
// 随机获取五位正整数
// （Math.random() * 9 + 1） 代表生成随机数，后面乘几代表生成几位随机数
int num = (int) ((Math.random() * 9 + 1) * 10000);
//随机生成的五位数是
System.out.println(num);
// 因为要进行逻辑判断，所以定义一个布尔类型变量（返回结果）
boolean result;
// 进行五位回文数的判断：个位与万位相同，十位与千位相同，为回文数
// 判断逻辑 个位与万位相同：num%10 == num/10000，十位与千位相同：num/1000%10 ==num/10%10
// 使用三元运算符进行判断
result = (num%10 == num/10000 && num%100/10 == num%10000/1000 ) ? true:false; // 最大值的变量
//懒得写返回值了，直接输出结果
System.out.println(result);
}
// 需求二
public static void xuQiu2() {
// 随机获取五位正整数
// （Math.random() * 9 + 1） 代表生成随机数，后面乘几代表生成几位随机数
int num = (int) ((Math.random() * 9 + 1) * 10000);
//随机生成的五位数是
System.out.println(num);
// 求和逻辑就是各个位数相加
// 使用三元运算符进行判断
int geWeiShu = num%10;
int shiWeiShu = num%100/10;
int baiWeiShu = num%1000/100;
int qianWeiShu = num%10000/1000;
int wanWeiShu = num/10000;
int sum = geWeiShu + shiWeiShu + baiWeiShu + qianWeiShu + wanWeiShu;
//懒得写返回值了，直接输出结果
System.out.println(sum);
}
// 需求三
public static void xuQiu3() {
// 定义值
int a = 10;
int b = 20;
// 功能逻辑
a = a+b;
b = a-b;
a = a-b;
// 输出结果
System.out.println(a);
System.out.println(b);
}
/**
* 一段遵守编码规范的 Hello World
*/
public static void xuQiu4() {
// 输出Hello World
System.out.println("Hello World");
}
}
参考：距离记笔记的时候过了一段时间，如果我的笔记有明显借鉴了您的内容，请见谅。（我记忆力很差的，当初写笔记的时候，参考文档记录的可能不全）
二进制与ASCI参考：王道计算机组成原理-2.2.1进位计数制
资料下载链接（笔记+代码+其他）：百度网盘
提取码：1111 感谢阅读，祝你从此一帆风顺。
