Java零基础笔记自用版（一）

momo_via

已于 2024-01-08 15:49:44 修改

阅读量371

点赞数 1

分类专栏：学习总结文章标签： java 数据结构后端

于 2022-10-26 16:51:41 首次发布

本文链接：https://blog.csdn.net/momohhhhh/article/details/127515930

版权

学习总结专栏收录该内容

2 篇文章 0 订阅

订阅专栏

系列文章目录

前言

最近在学习Java，找了许多视频，最后看到韩老师的Java视频课，一种真零基础保姆级教学，从软件的下载安装解压缩都会讲解，自己就打算边学习并且根据自身情况整理笔记，文末有完整版笔记资料链接（后续会分享代码、软件等）

一、⭐️Java概述

程序——有序指令的集合
Java语言区分大小写，并且必须带分号；
一个文件可以有多个类，但只能有一个public修饰的类，并且文件名与public修饰的类一致；不过每一个非public的类都可以有main方法，运行时调用自己的main就可以。
Tab实现命令补齐
注释：单行注释 // xxx；多行注释/* xxx */；文档注释 /** */ 可以自动生成
ab可以整体右移，shift+tab整体左移

二、⭐️变量

变量三要素：类型名称值
变量在同一作用域不能重名，不同类型范围内可以不断变化
加号，左右两边为数值，做加法运算；若有一边为字符串，则为拼接
整数类型用来存放整数值
一个字节有8bit，eg：long有八字节*8bit=64bit
浮点型默认double，float需要加f或F
Char的本质是一个整数，默认输出时，为Unicode对应的字符，输出对应的数字可以为（int（字符））
常用编码：①ASCLL码表，128字符，不能表示所有字符。②unicode编码表，英文和汉字都占两个字节，资源浪费，Unicode兼容ASCLL。③utf-8,unicode一种实现方式，字母占一字节，汉字三字节。
布尔类型一般用在逻辑运算，如条件、循环等语句，不可以用0或非0代替true or false
基本数据类型转换规则：低精度向高精度
①char->int->long->float->double
②Byte->short->int->long->float->double
12. 强制类型转换大转小，要加()——强转符号
```
int b= 10;
byte c = (byte)b; //数据溢出
```
13. 强转符号只对最近的操作数有效，可以加小括号提升优先级
14. Char可以保存int常量值，不可以保存int变量值
```
 char a =100; //ok
        int c = 100; //ok
//      char a2 = m; //错误
        char a2 = (char)m; // ok
```
15. 基本数据类型转字符串string，将基本数据类型值加“”即可，字符串string转基本数据类型，通过基本类型包装类调用parseXX方法即可
16.

String s1 = "123";
int num = Integer.parseInt(s1);

String s1 = "123";
int num1 = Integer.parseInt(s1);
double num2 = Double.parseDouble(s1);
float num3 = Float.parseFloat(s1);
long num4 = Long.parseLong(s1);
byte num5 = Byte.parseByte(s1);
boolean a = java.lang.Boolean.parseBoolean("true");
short num6 = Short.parseShort(s1);
System.out.println(num1); //123
System.out.println(num2); //123.0
System.out.println(num3); //123.0
System.out.println(num4); //123
System.out.println(num5); //123
System.out.println(a); //true
System.out.println(num6); //123

三、⭐️运算符

%模运算取余，公式：a % b = a - a / b * b b--，先返回b的值再--
Println换行，不加ln不换行
==关系运算符，=赋值，关系运算符只有true、false
逻辑运算符

逻辑与&和短路与&&都是一假则假，但是&&若第一个条件为false则不会判断第二个条件，结果为false，&两个结果都要判断，效率低。
短路或||和逻辑或|都是一真全真，||第一个为true就不会判断第二个，结果为true，|不管第一个是否为true都要判断第二个。
异或，两个不同则为true，否则为false
赋值运算符，a+=b<==>a=a+b

5. 实际开发中不可以使用简单的a=xx，b=xx.....；开发中使用短路与&&，短路或||

6. 三元运算符，条件表达式？表达式1：表达式2，若条件真则为表达式1，否则为2。三元运算符一般可以改为if--else。

7. 运算符优先级

上一行优先于下一行
单目运算和赋值运算从右向左运算

8. 标识符：自己取名的地方都叫标识符

规则；

英文字母、$、_组成
不可以数字开头
区分大小写，长度无限制
不能有空格
不能使用关键字和保留字，但是可以包含关键字和保留字

规范；

包名，小写字母，如aaa.bbb.ccc
类名、接口名：所有首字母大写，大驼峰
变量名、方法名：第一个首字母小写，小驼峰
常量名：所有字母大写，多个单词用下划线_连接

9. 关键字、保留字

10. 进制介绍

11. （1）二进制转十进制：从右向左一次提取乘2的（位数-1）次方，再求和

（2）八进制转十进制：从右向左一次提取乘8的（位数-1）次方，再求和

（3）十六进制转十进制：从右向左一次提取乘16的（位数-1）次方，再求和A-10，B-11...

12. （1）十进制转二进制：将改数不断除以2，直到商0为止，将余数倒过来就是对应二进制，如果位数不够八位前面补0。

（2）十进制转八进制：将改数不断除以8，直到商0为止，将余数倒过来就是对应八进制，如果位数不够四位前面补0

（3）十进制转十六进制：将改数不断除以16，直到商0为止，将余数倒过来就是对应十六进制

13. （1）二进制转八进制：将二进制数3位一组，转为对应八进制即可

（2）二进制转十六进制：将二进制数4位一组，转为对应十六进制即可，要加0x

14. （1）八进制转二进制：每一位转成一个三位二进制数即可，不够一个字节(4)的倍数要补0，或者删除前面多余0

（2）十六进制转二进制：每一位转成一个4位二进制数即可

15. 位运算：1>>2:1的二级制向右位移2位，与、或、异或运算（都为补码运算，结果载转为原码）

16. 原码、反码、补码

四、⭐️控制结构

程序从上到下依次执行
Scanner输入语句，使用时要先导入scanner类
分支控制if-else： if （aa）{xx} else if （bb）{xx}..... else {xx}
嵌套分支不要超过三层：if（aa）{if（bb）{xxx} else{xxx}} else {xxx}
Switch分支：switch（表达式）{ case常量1：语句块1； breake；case常量2......}

表达式数据类型，应该和case后的常量一致，或者是可以自动转换成可以相互比较的类型，比如输入的是字符，而常量是int
表达式中的返回值必须是（byte、short、int、char、enum[]、string）
Case子句中的值必须是常量，而不是变量
Default子句是可选的，当没有匹配的case时，执行default

6. for循环：for（循环变量初始化；循环条件；循环变量的迭代）{ 循环操作（可以多条语句）} 循环条件为假时省略

7. While循环：先判断在执行

8. do...while循环：先执行一次，再判断，至少执行一次

9. 多重循环

10. break语句用于终止某个语句块的执行，一般使用在switch或者循环[for , while , do-while]中，brake可以指定退出到哪个标签，lable1为标签，名字可以指定，breake后面跟哪个lable就退出到哪个lable

11. 字符串的内容比较使用的方法equals

12. continue语句用于结束本次循环，继续执行下一次循环；在多层嵌套循环中也可以指定跳过哪一层循环

13. return表示跳出所在方法，如果return写在main方法，表示退出程序。

五、⭐️数组、排序、查找

数组可以存放多个同一类型的数据，数组也是一种数据类型——引用类型，数组型数据是对象（object）
数组下标从0开始编号，对应第一个数据；数组下标必须在指定范围内使用，否则会报下标越界异常。
可以通过数组名.length得到数组长度
定义： ①数据类型[ ] 数组名=new 数据类型[大小] 或数据类型数组名[ ] = new 数据类型[大小] ②先声明：数据类型数组名[ ] 或数据类型[ ] 数组名、在创建：数组名= new数据类型[大小]------>eg: int a[ ] ; a = new int [5]; ③ 数据类型数组名[ ] = {数据}
使用：数组名[下标i]-->表示访问第i+1个数据
数组为引用传递，赋的是地址，arr2会影响到arr1

数组拷贝，数据空间是独立的

int[] arr1 = {10, 20, 30};
// 创建新数组arr2,大小为arr1.length
int[] arr2 = new int[arr1.length];
// 遍历arr1，把每个元素拷贝到对应位置
for (int i = 0; i < arr1.length; i++) {
    arr2[i] = arr1[i];
}
// 修改arr2
arr2[0] = 16;
System.out.println("arr1元素");
for (int i = 0; i < arr1.length; i++) {
    System.out.println(arr1[i] + " ");
}
System.out.println("arr2元素");
for (int i = 0; i < arr2.length; i++) {
    System.out.print(arr2[i] + " ");
}

数组翻转：①通过找规律翻转 ②使用逆序赋值的方式
排序：可参考数据结构 ①外部排序：数据量过大，无法全部加载到内存中，需要借助外部存储进行排序（包括合并排序法和直接合并排序法） ②内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序（包括交换式排序法、选择排序法和插入排序法）

冒泡排序：两两比较，根据要求交换，可以从小到大也可以从大到小。

int[] arr = {25, 16, -20, -2, 116, 15};
int temp = 0; //用于辅助交换的变量
//将多轮排序使用外层循环包括起来即可
//比较次数 arr.length - 1
for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - 1 - i; j++) {
        //如果前面的数>后面的数，就交换
        if (arr[j] > arr[j + 1]) {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    System.out.println("\n==第" + (i + 1) + "轮==");
    for (int j = 0; j < arr.length; j++) {
        System.out.print(arr[j] + "\t");
    }
}

查找：可参考数据结构
二维数组：原来的一维数组的每个元素又是一维数组，构成二维数组
数据类型[ ] [ ] 数组名={ {第一个元素}，{第二个元素}，{第三个元素}，{第四个元素}} 或数据类型数组名[ ] [ ]; 数组名 =new 数据类型[大小][大小]

杨辉三角：

int[][] yangHui = new int[12][];
for (int i = 0; i < yangHui.length; i++) {//遍历 yangHui 的每个元素
    //给每个一维数组(行) 开空间
    yangHui[i] = new int[i + 1];
    //给每个一维数组(行) 赋值
    for (int j = 0; j < yangHui[i].length; j++) {
        //每一行的第一个元素和最后一个元素都是 1
        if (j == 0 || j == yangHui[i].length - 1) {
            yangHui[i][j] = 1;
        } else {//中间的元素
            yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
        }
    }
}
//输出杨辉三角
for (int i = 0; i < yangHui.length; i++) {
    for (int j = 0; j < yangHui[i].length; j++) {//遍历输出该行
        System.out.print(yangHui[i][j] + "\t");
    }
    System.out.println();//换行.
}