基础不牢，地动山摇，Java基础干货满满（建议收藏）

小伙伴，你们好啊，现在已经是凌晨两点钟了🕑，今晚没有看到月亮，窗外的蟋蟀声衬得夜十分安静，学了十天 Java SE了，最近事有点多，学习进度有点拖，不过，今天算是完成了SE的第一个阶段，在这里和大家分享一下我学习中的问题和感想，学习过程中别眼高手低，会害死人，多动手，勤思考，打好基础，万丈高楼平地起，然后就是对于代码，能理解就理解，理解并能独立就是收获，而不是记忆，特殊除外，学习不要半途而费，对于基础，更应趁热打铁，同时在写代码时，多思考，理解感悟编程思想，比如：先死后活，化繁为简，不对即错，这些不是说说那么简单，而是从写代码中得到领悟提升，每个人都有惰性，都想玩，可在18岁的年纪，你真的就愿意这样度过吗？还不点个关注一起拿下 SE，向下一阶段出发 🔎

过去

1995年，sun公司发布Java的第一个版本
2009年，甲骨文公司收购sun

三大版本

• Java SE 标准版
• Java EE 企业版
• Java ME 小型版

Java 语言特点

• Java 语言是面向对象的(oop)
• Java 语言是健壮的。Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证
• Java 语言是解释型
• Java 语言是跨平台性的。[即: 一个编译好的.class 文件可以在多个系统下运行，这种特性称为跨平台]
• ……

---

Java开发工具

• sublime
• Eclipse
• IDEA（有基础推荐，用的很多，确实强大，IDEA使用Java开发的哦）
  

---

跨平台 Java虚拟机（JVM）

• JVM 是一个虚拟的计算机，具有指令集并使用不同的存储区域。负责执行指令，管理数据、内存、寄存器，包含在JDK 中
• 对于不同的平台，有不同的虚拟机
• Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”

你 get 到了吗？

---

什么是 JDK，JRE？

JDK

JDK 的全称(Java Development Kit Java 开发工具包)
JDK = JRE + java 的开发工具 [java, javac,javadoc,javap 等]
JDK 是提供给 Java 开发人员使用的，其中包含了 java 的开发工具，也包括了 JRE。所以安装了 JDK，就不用在单独安装 JRE

JRE

JRE(Java Runtime Environment Java 运行环境)
JRE = JVM + Java 的核心类库[类]
包括 Java 虚拟机(JVM Java Virtual Machine)和 Java 程序所需的核心类库等，如果想要运行一个开发好的 Java 程序，计算机中只需要安装 JRE 即可。

JDK = JRE + 开发工具集
JRE = JVM + Java SE 标准类库（java 核心类)

---

注释

用于注解说明解释程序的文字就是注释，注释提高了代码的阅读性（可读性）；注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

1. 单行注释 //
2. 多行注释 /* */
3. 文档注释 /** *

---

变量

变量是程序的基本组成单位

变量相当于内存中一个数据存储空间的表示

变量声明

int a;

变量赋值

a = 2;

声明及赋值

int a = 2;

---

+号的使用

• 当两边是数字，就做数学运算
• 当两边有一边是字符串，做拼接运算

数据类型

Java是强类型语言，必须要知道你的类型

在内存中根据不同类型分配不同大小的空间

---

8大基本类型

数值型：

• 整数 byte（1）short（2） int（4）long（8）
• 小数 float（4）double（8）

字符型：

• char（2）

布尔型

• boolean（true）（false）

---

引用数据类型

• 类（class）
• 接口（interface）
• 数组（[]）

---

Java API文档

Java API在线文档 点击查看

运算细节

浮点数在机器中存放的方式： 浮点数=符号位+指数位+尾数位

尾数部分可能丢失，造成精度的损失，小数都是近似值

对于浮点数的陷阱，可以通过绝对值处理,绝对值的差小于我们能接受的范围，就认为是相等的

double a = 2.7;
double b = 8.1/3;
if(Math.abs(a-b <= 0.000001)){}

在Java中，char的本质是一个整数，默认输出时，是Unicode码对应的字符

char 类型是可以进行运算的，相当于一个整数

---

Java 中不可以用 0 或非 0 的整数代替false 和 true，这和C语言不同

取模的本质：

一个公式：a % b = a - a/b * b

---

基本数据类型转换

自动类型转换
Java程序在运行赋值或进行运算时，精度小的会自动向精度大的转换(兼容)

• 表达式结果自动提升为操作数中最大的类型
• byte，short，char 三者进行运算时，首先转为 int 型
• (byte，short)和char 之间不会相互自动转换
• 把精度大的给精度小的，不做处理，就会报错

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

• 会使用括号来提升优先级
• char 可以保存 int 的常量值，但不可以保存 int 的变量值，需要强转
• byte和short，char类型在运算时，当作 int 类型处理

---

运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

1. 算术运算符
2. 赋值运算符
3. 关系运算符 [比较运算符]
4. 逻辑运算符
5. 位运算符 [需要二进制基础]
6. 三元运算符
   a>b?a:b(a大于b吗，如果为真，就返回a，否则返回b)，二分支缩写

算术运算符：+，-，*，/，%
逻辑运算符：&&，&，！，||，|
比较运算符：>,<,=,==,>=,<=,!=
移位运算符：>>右移除以2，<<左移乘以2
会用括号就🆗了，用好括号

%模运算，就是取余数
&&，逻辑与，相当于and，两者都为真才为真
&，二进制的and
||，逻辑或，相当于or，只要有一个满足就执行
|，二进制下的or
！非，取反操作，假变真，真变假

---

优先级

---

进制转换

• 2进制，8进制，16进制-------------------10进制

2—10

0b1101—0b是标记，用来标记它是一个2进制数

1*2^0+0*2^1+1*2^2+1*2^3=13

---

8—10

0110

8进制第一个数是0来做标记

0*8^0+1*8^1+1*8^2=72

---

16—10

0x或0X标记

0x123A

10*16^0+3*16^1+2*16^2+1*16^3=4666

---

• 10进制------------------------2进制

把该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来

• 8进制--------------------------2进制

把该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来

• 16进制------------------------2进制

把该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来

---

• 二进制的最高位表示的是符号位，0表示正数，1表示负数
• 正数的原码，反码，补码都一样（三码合一）
• 负数的反码 = 它的原码符号位不变，其他位取反，0变1，1变0
• 负数的补码 = 它的反码+1，负数的反码 = 负数的补码-1
• 0的反码，补码都是0
• Java没有无符号数，Java中的数都是有符号的
• 计算机运算时，都是以补码的方式进行的
• 看运算结果的时候，要看他的原码

---

位运算符(原码，反码，补码)

Java中有7个位运算（&，|,^,~,>>,<<,>>>）

按位与& //两位全为1，结果是1，否则是0

按位或| //两位有一个为1，结果为1，否则为0

按位异或^ //两位一个为0，一个为1，结果为1，否则为0

按位取反~ //0bian1,1bian0

2&3

首先得到2的补码，要想得到补码，首先得到2的原码，2是int型，4个字节，1字节是8bit，因此2的原码是： 00000000 00000000 00000000 00000010 ，因为正数三码合一，所以它的补码就是原码，同理 3的补码就是：00000000 00000000 00000000 000000101，然后按位与

2 00000000 00000000 00000000 00000010
3 00000000 00000000 00000000 00000011
& 00000000 00000000 00000000 00000010
//这是运算过后得到的补码，看结果要看原码，正数的三码合一，OK
结果就是 00000000 00000000 00000000 00000010 所以2&3就是2

~-2

-2的原码是 10000000 00000000 00000000 00000010 符号位1代表是一个负数，运算时是以补码方式运算的，想要补码，先得到反码，反码+1=补码，-2的反码，符号位不变，其他取反，11111111 11111111 11111111 11111101，反码+1=补码：11111111 11111111 11111111 11111110取反，~-2 00000000 00000000 00000000 00000001，运算后时一个正数，三码合一，即原码就是，转换为10进制为1

~2

2的补码： 00000000 00000000 00000000 00000010
~2操作：  11111111 11111111 11111111 11111101
运算后的反码： 11111111 11111111 11111111 11111100
运算后的原码： 10000000 00000000 00000000 00000011
   结果就是  -3

---

>> 算术右移
<< 算术左移
>>> 无符号右移  低位溢出，高位补0
没有<<<符号

int a = 1>>2; //00000000 00000000 00000000 00000001=>00000000 00000000 00000000 00000000
低位溢出，符号位不变，使用符号位补溢出的高位，本质就是1/2/2 = 0

int b = 1<<2; //00000000 00000000 00000000 00000001=>00000000 00000000 00000000 00000100
符号位不变，低位补0，本质就是1*2*2 = 4

4<<3=4*2*2*2=32
1>>2=1/2/2=0
15>>2=15/2/2=3

-10.5%3
-10.5-（-10）/3*3 = -10.5+9 = -1.5

int a = 66;
System.out.println(++i+i);//67+67=134

---

命名规范

1. 包名：多单词组成时所有字母都小写：aaa.bbb.ccc //比如 com.hsp.crm
2. 类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰]，例如： TankShotGame
3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小驼峰， 简称 驼峰法]，例如： tankShotGame
4. 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ

---

关键字和保留字

关键字定义：被 Java 语言赋予了特殊含义，用做专门用途的字符串（单词）
关键字特点：关键字中所有字母都为小写

Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留
字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、cons

---

获取用户输入 Scanner

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取，需要一个 扫描器(对象), 就是
Scanner

Scanner scanner = new Scanner(System.in);

---

程序控制结构

三大流程控制语句

1. 顺序控制
2. 分支控制
3. 循环控制

顺序控制

程序从上至下逐行执行，中间没有任何的跳转和判断

分支控制

1. 单分支 if
2. 双分支 if-else
3. 多分支 if-else if -…else

if

if(i%5==0){
    System.out.print(i+"\t");
}

if-else

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/1:05
 */
public class demo18 {
    public static void main(String[] args) {
        int a = 3;
        if(a>5){
            System.out.println("大于5");
        }else{
            System.out.println("小于5");
        }
    }
}

if-else if -…else

public class Demo05 {
    public static void main(String[] args) {
        int score = 0 ;
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入成绩，童鞋");
        int s = scanner.nextInt();
        if(s>=60 && s<=100){
            System.out.println("恭喜，没挂科");
        }else if(s>=0 && s<60){
            System.out.println("额，你懂");
        }else{
            System.out.println("不是整数");
        }
        scanner.close();
    }
}

switch

• case中的值不能是变量，只能是常量
• default 语句是可选的，当没有匹配的 case 时，执行 default
• break 使程序在执行完分支退出 switch

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/1:08
 */
public class demo19 {
    //break用于跳出，防止穿透
    public static void main(String[] args) {
        char c = 'a';
        switch (c){
            case 'a':
                System.out.println("a");
                break;
            case 'b':
                System.out.println("b");
                break;
            default:
                System.out.println("其他");
        }
    }
}

switch 和 if 的比较

1. 如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句。
2. 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围

for 循环控制

1. for 关键字，表示循环控制
2. for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
3. 循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
4. 如果 循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略

• 循环条件是返回一个布尔值的表达式
• for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
• 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开

---

while 循环控制

1. 循环条件是返回一个布尔值的表达式
2. while 循环是先判断再执行语句

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/1:33
 */
public class demo20 {
    public static void main(String[] args) {
        int i = 5;
        while (--i > 0){
            System.out.println("i="+i);
        }
    }
}

输出：

do while 循环控制

1. do while 是关键字
2. 也有循环四要素, 只是位置不一样
3. 先执行，再判断，也就是说，一定会至少执行一次
4. 最后 有一个 分号 ;

• 循环条件是返回一个布尔值的表达式
• do…while 循环是先执行，再判断， 因此它至少执行一次

/**
 * @Author: liu sen
 * @Version: 1.0
 * @Date: 2021/08/31/1:33
 */
public class demo20 {
    public static void main(String[] args) {
        //统计 1---200 之间能被 5 整除但不能被 3 整除的 个数
        // 化繁为简
        //(1) 使用 do-while 输出 1-200
        //(2) 过滤 能被 5 整除但不能被 3 整除的数 %
        //(3) 统计满足条件的个数 int count = 0;
        //先死后活
        //(1) 范围的值 1-200 你可以做出变量
        //(2) 能被 5 整除但不能被 3 整除的 , 5 和 3 可以改成变量
        int i = 1;
        int count = 0; //统计满足条件的个数
        do {
            if( i % 5 == 0 && i % 3 != 0 ) {
                System.out.println("i=" + i);
                count++;
            }
            i++;
        }while(i <= 200);
        System.out.println("count=" + count);
    }
}

多重循环

1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环
3. 设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n

跳转控制语句-break

break 语句用于终止某个语句块的执行，一般使用在 switch 或者循环 for , while , do-while 中

{ ……
break; ……
}

跳转控制语句-continue

1. continue 语句用于结束本次循环，继续执行下一次循环。
2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

{ ……
continue; ……
}

跳转控制语句-return

return 使用在方法，表示跳出所在的方法

---

编程思想

• 化繁为简 (把一个大问题拆分为小问题解决)

• 先死后活 (先设置成常量，实现后可以把常量用变量来替代，程序的扩展性大大提升)

• 一段代码实现一个功能 (高内聚低耦合)