JavaSE-QuickStart

老话常说：基础不牢地动山摇，于是我在b站上看杨中科老师的课程脑补一下，便记录这岁月的点滴

1、什么是编程 ？

• 编程：编写能够控制计算机来执行特定任务的代码。

2、什么是编程语言 ？

• 编程语言：是指程序员和计算机沟通的语言，用编程语言编写的就是代码。

• 自然语言：通常是指一种自然地随文化演化的语言。例如，汉语、英语、日语都是自然语言的例子。

3、学编程究竟学的是什么？

• 语法？
• 开发工具？
• 框架？
• 编程思想（程序化的思维方式） √

4、学习的心态：

• 不要小看

• 不要吓Niao

5、编程的学习方法是什么？

• 不要题海战术。
• 不要背代码，because代码背不完。
• 要：理解、记笔记、通过笔记去写程序、脱稿流利写程序。

6、环境搭建

• JDK：编译、运行Java程序，基本类库。

• IDEA:集成开发环境(IDE)。

• Maven：解决 jar 过多导致配置出错的问题。

• 安装教程:

  • JDK：https://blog.csdn.net/qq_46921028/article/details/108742360
  • IDEA：https://blog.csdn.net/qq_46921028/article/details/116375654
  • Maven：https://blog.csdn.net/a805814077/article/details/100545928

7、helloworld

首先我们要创建一个普通的Maven项目，取名为: JavaSE-01-HelloWorld。

然后呢在./src/main/java目录下创建一个包，取名为com.baidou，目的是为了方便管理我们所写的类；

之后选中包名并鼠标右击，创建一个Java类，取名为Hello01。

Hello01.java

package com.baidou;

// 主类名要与文件名保持同步
public class Hello01 {
    // main方法是程序的执行入口    快捷键: psvm + tab键  或者  main + 回车
    public static void main(String[] args) {
        //控制台打印输出  快捷键: sout + 回车
        System.out.println("lxm18");
    }
}

关于缩进和大括号的猫腻：

• 和Python不一样，Java中的缩进不是强制的，不过缩进可以让代码更清晰。
• Java中{}同一行、换行两种习惯，没有什么区别。

if(xxx)
{
  ...
}

if(xxx){
  ...
}

8、常用数据类型

程序 = 命令 + 数据 + 逻辑

例如：

整数：1、0、-1、365

小数：0.03、3.14、1.68

字符：'a'、'B'、'男'。一个汉字是一个字符。

字符串："lxm18"、"我爱你中国"、"java"、""

布尔值：true、false

常用数据类型：

整数: 主要是int。还用long、short、byte等。

浮点数: 主要是float。还有double。

字符: char。

布尔: boolean。 

字符串: String。字符串中\和换行的转义("难点"):"hello\\world\n你好"

Test.java

package com.baidou;

public class Test1 {
    public static void main(String[] args) {
        int i1 = 5;
        long i2 = 6;
        float f1 = 3.14f;
        double f2 = 3.14;
        char c1 = '帅';
        String s1 = "躺平";
        String s2 = "巴适得板";
        String s3 = "";
        System.out.println(s1);

        String s4 ="hello\nworld"; // '/n' 算1个字符
        System.out.println(s4.length()); //11
        System.out.println(s4);

        String s5 = "hello\nworld\\123";  // '//'算一个字符 ---> '/'
        System.out.println(s5);

    }
}

9、标识符（变量名等）命名规则

• 只能由数字、字母、下划线_、美元符号$、中文字符组成。
• 首字母不能是数字。
• 大小写敏感的。max与Max是不同的。
• 不能全部是关键字。break、case、char、for、if、void、int、long等。

10、注释

被注释的内容会被编译器忽略。

主要的作用：对代码进行解释说明。

原则：适当的注释。自解释的代码。

副作用：暂时停用部分代码。

// 单行注释

/*
   多行注释
 */

/**
 * 文档注释
 */

11、变量

变量来源于数学，是计算机语言中能储存计算结果或能表示值的抽象概念。

变量3部分：变量类型、变量名、变量值。

11.1、定义变量：

• 变量要先定义后使用。

例如：

// 1、直接声明变量并赋值
int age = 18;
double pi = 3.14;
String name = "白豆五";

// 2、先声明变量后赋值
int age;
age=18;

11.2、引用已有变量：

主要的作用有两种：

• 重新赋值。
• 读取变量的数据。

例如：

int age = 0;
System.out.println(age); //读取变量的值
age = 18; //为已有的变量重新赋值
System.out.println(age); //读取变量的值

11.3、变量命名的规范

• 要取有意义的变量名，不要a1、a2、c3、p。
• 变量一般小写开头，尽量遵循驼峰。
• 如果英语很不好或者专业术语不知道怎么翻译或者非专业程序员，可以根据情况决定用户中文变量名。

12、运算符

算数运算符：

+、- 、*（乘）、/（除）、%（取余）、++（自增）、--（自减）。

先乘除后加减，可以使用（）改变运算优先级。

对于字符串也可以用+进行字符串连接操作。

例如：

/*
     int i = 1+2+3+4+5+6-3*2/2;
     System.out.println(i);
 */

// 用()小括号来改变运算的优先级  可以嵌套使用  从内到外执行
int i = 1 + 2 + 3 + 4 + 5 + (6 - 3) * 2 / 2;
System.out.println(i);

int i2 = 1 / 3 * 3;
System.out.println(i2); //0

double d =  1.0 / 3 ;
System.out.println(d); //0.3333333333333333

String name = "巴";
String name2 = "适";
String name3 = "得";
String name4 = "板";
String s = name + name2 + name3 + name4; //拼接字符串
System.out.println(s); //巴适得板

/**
* 表达式从左向右执行 除非()改变优先级
* 其他数据类型遇到字符串之后就都按照字符串来进行运算
*/
System.out.println(1 + "1" + 1); //111
System.out.println(1 + 1 + "1"); //21
System.out.println("1" + 1 + 1 ); //111
System.out.println("1" +( 1 + 1) ); //12
System.out.println(3+(6+"a")+("b"+(1+2)*3)); //36ab9

赋值运算符：

赋值：=
加等于：+=             a+=b等价于a=a+b
减等于：-=
除等于：/=
模等于：%=

顺序执行：程序从上往下逐一执行，一条执行结束再执行下一条。

关系运算符：

小于：<
小于等于：<=
大于：>
大于等于：>=
等于：==
不等于：!=
关系运算符的结果为boolean类型。

注：java 中 equals 和 == 的区别：

• 值类型是存储在内存中的堆栈（简称栈），而引用类型的变量在栈中仅仅是存储引用类型变量的地址，而其本身则存储在堆中。
• == 操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
• equals 操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
• == 比较的是2个对象的地址，而 equals 比较的是2个对象的内容，显然，当 equals 为 true 时，== 不一定为true。

逻辑运算符：

三元运算符：

布尔表达式 ? 表达式1 : 表达式2

int a = 9;
int b = 1;
int c = a > b ? 666 : 888;
System.out.println(c); // 666

13、选择结构

目的：满足某些条件的时候才执行一段代码。

两种语句：if 、switch 。if 用的最多，可以代替 switch 。

13.1、第一种IF：

if(表达式)
{
   语句块
}

1、语句可以是单行语句，也可以是复合语句；

2、如果是单行语句，{}可以省略，但最好不要省略；

3、整个 if 是一个逻辑语句，因此不能直接在 if 后面加分号。

例如：

int age = 19;
if (age>18)
{
    System.out.println("到达主战场");
}

13.2、第二种IF：

if(表达式)
{
    语句1
}
else
{
    语句2
}

例如:

int score = 80;
if (score >= 60) {
   	 	System.out.println("合格");
    } else {
  	 	 System.out.println("尚未合格");
	}
}

13.3、第三种IF:

if(表达式1)
{
    语句1;
}
else if(表达式2)
{
    语句2;
}
...
else
{
    语句n;
}

有点像一给我里giao giao，那鬼东西。

例如：

int score = 1011;
if (score <60)
{
    System.out.println("不及格");
}
else if(score>= 60&& score <70 )
{
    System.out.println("及格");
}
else  if (score>=70&&score<80)
{
    System.out.println("一般");
}
else  if (score>=80&&score<90)
{
    System.out.println("中等");
}
else
{
    System.out.println("优秀");
}

还有的就是IF嵌套。

if(表达式1){
    if(表达式2){
        语句1;
    }else{
        语句2;
    }
}else{
     语句3;
}

13.4、SWITCH:

可以被if替代，用的少。

switch(条件表达式)
{
    case 条件1:
        语句1;
        break;
    case 条件2:
        语句2;
        break;
        ...
    default:
        语句;
}

14、循环结构

目的：反复执行N次（或一直执行）某段代码。

三种语句：for、while、do......while。

循环就好比操场跑圈，当达到圈数时，证明你的体育测试是有成绩的哈哈

14.1、WHILE

while(条件表达式)
{
    循环体
}

先判断条件表达式，如果为ture就执行循环体，执行完循环体再判断条件表达式......

例如：

// 从10倒数到0
int i = 10;
while (i>=0)
{
    System.out.println("白豆五"+i);
    i--;
}
System.out.println("while结束");

控制台输出:
白豆五10
白豆五9
白豆五8
白豆五7
白豆五6
白豆五5
白豆五4
白豆五3
白豆五2
白豆五1
白豆五0
while结束

// 统计0到10的和
int j = 0;
int sum = 0; //创建一个临时变量用于加和操作
while (j <= 10)
{
    sum += j;
    j++;
}
System.out.println(sum); //55

// 用while循环实现：从5打印到11
int y = 5;
while(y <= 11)
{
    System.out.println(y);
    y++;
}

14.2、FOR

既 WHILE 何生 FOR

• while 、do...while 、for 都可以实现循环，可以互换。
• 不同的需求，用不同语法难易程度不同。
• 使用频率：for > while > do...while 。

for(表达式1;表达式2;表达式3)
{
    循环体;
}

(1)先执行表达式1,只会执行一次。
(2)执行表达式2,如果该表达式2结果为真,执行for循环体,然后执行下面第(3)部。如果为假,直接结束for循环。
(3)执行表达式3,然后跳到第(2)步重新执行。

用while表示for：

表达式1;
while(表达式2)
{
    循环体;
    表达式3;
}

例如:

for (int i=1;i<=10;i++)
{
    System.out.print(i+"\t"); // 1 2 3 4 5 6 7 8 9 10
}

// 第二种声明
int j = 0;  //将之前for循环内部的局部变量,丢到循环体外面相当于提权,然后都可以调用这个变量。
for(;j<=3;j++)
{
    System.out.println(j);
}

// 用while等价for
int i = 0;
while (i <= 10)
{
    System.out.println(i);
    i++;
}

// 从10倒数到0
for (int i = 10; i >= 0; i--) {
    System.out.print(i + "\t");
}

// 统计0到10的和
int sum = 0;
for (int i = 0; i <= 10; i++) {
    sum += i;
}
System.out.println(sum);

// 打印2 4 6 8 10
for (int y = 2; y <= 10; y = y + 3) {
    System.out.println(y);
}

int z;
for (z = 0; z <= 3; z++) ;
{
    System.out.println(z);
}

14.3、循环嵌套

• 循环嵌套：循环里套着循环。此套娃非彼套娃。嵌套循环可以是嵌套n层，一般也就用两层。

• 三种循环(while、do...while、for)可以相互嵌套，不过使用最多的是for循环嵌套。

例如：

// 外层循环一次内层循环三次
for (int i= 0;i<3;i++)
{
    for (int j = 1;j<=3;j++)
    {
        System.out.println(i+","+j);
    }
}

14.4、BREAK和CONTINUE

• break 和 continue都可以和while、do...while、for 一起用。
• break：强制结束循环。
• continue：不再执行本次循环后面的代码，进行下一次循环。

例如:

//break
for (int i=0;i<=5;i++){
    if (i==3){
        break;
    }
    System.out.println(i);
}
打印结果：
0
1
2

// continue
for (int i=0;i<=5;i++){
    if (i==3){
        continue;
    }
    System.out.println(i);
}
打印结果：
0
1
2
4
5

例如：

// 循环打印99乘法表
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=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
1*4=4	2*4=8	3*4=12	4*4=16
1*5=5	2*5=10	3*5=15	4*5=20	5*5=25
1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36
1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49
1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64
1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81

15、数组

• 如果记录全班同学的姓名，难道声明60个String变量?

• 有序数据的集合就是数组(Array)。

• 数组中每项都有一个编号，被称为数组下标，通过下标就可以找到数组中指定的数据，也可以给指定位置赋值。

15.1、数组的定义和初始化

第一种方式：
    int[] a = {1,2,3,4,5};

第二种方式：
    int[] a = new int[5];
	每个元素的初始值为默认值。int、double等默认值是0,boolean默认值是false,String等默认值是null。

15.2、引用元素

• 数组元素的下标从0开始，最后一个元素的下标为"长度-1"。

• 引用数组的形式：数组名[下标] 。

数组+下标使用：

• a[2]单独使用或者放到=右边，就是取值，放到=左边就是赋值。
• 数组元素完全可以当作变量使用，可以进行数学运算、赋值操作、自加、自减操作...等。

举例：如何给元素赋值、取值？

int[] nums1 = {99, 77, 66, 22};
int[] nums2 = new int[8];
System.out.println(nums1[2]); //66
System.out.println(nums2[1]); //0
nums2[1] = 3; //赋值操作
System.out.println(nums2[1]); //3
nums1[0] = nums1[1] + nums2[1];
System.out.println(nums1[0]); //80

数组越界：

一切类型皆可数组：

String[] str1 = new String[10];
String[] str2 = {"hello","白豆五"};
byte[] bytes1 = new byte[];
byte[] bytes2 = {3,5,7,9};

15.3、数组长度

• 通过 数组名.length 来获取数组长度。
• 避免魔法数。

String[] str1 = new String[5];
int len = str1.length;
System.out.println(len);

15.4、遍历数组

如果直接打印数组他会输出一串内存地址，而并非是我们想要的数据。

 int[] ints = {77,2,3,45,6,8,3,1};
System.out.println(ints); //[I@1540e19d

所以接下来学习遍历数组。

第一种方式：使用FOR循环遍历数组

int[] ints = {77,2,3,45,6,8,3,1};
for (int i = 0; i < ints.length; i++) {
    System.out.println(ints[i]);
}

第二种方式：使用增强FOR循环遍历数组（jdk1.5的新特性）

如果只是对数组进行从头到尾的遍历获取值，可以用如下写法：

for(元素类型 item:arr)
{

}

例如：

int[] ints = {77,2,3,45,6,8,3,1};
for (int i : ints) {
    System.out.println(i);
}

第三种方式：通过Arrays.toString(arr);遍历数组。

//导包
import java.util.Arrays;

int[] ints = {77, 2, 3, 45, 6, 8, 3, 1};
String str = Arrays.toString(ints);
System.out.println(str);

小测试

test1：打印除小红以外所有同学姓名。

System.out.println("-------begin--------");
String[] str = {"小明", "小红", "小黄", "小绿", "小黑"};
for (String name : str) {
    if ("小红".equals(name)){
        continue;
    }
    System.out.println(name);
}
System.out.println("-------end--------");

test2：逆向输出数组的值。

System.out.println("-------begin--------");
String[] str = {"小明", "小红", "小黄", "小绿", "小黑"};
for (int i = str.length - 1; i >= 0; i--) {
    System.out.println(str[i]);
}
System.out.println("-------end--------");

test3：逐位计算两个数组，并将值赋给第三数组。

System.out.println("-------begin--------");
int[] nums1 = {9, 8, 7};
int[] nums2 = {3, 1, 2};
int[] nums3 = new int[nums1.length];
for (int i = 0; i < nums1.length; i++) {
    nums3[i] = nums1[i] + nums2[i];
}
System.out.println(Arrays.toString(nums3));
System.out.println("-------end--------\n");

test4：查找数组中最大值。

System.out.println("-------begin--------");
int[] nums = {3, 1, 2, 9, 8, 7};
int max = 0;
for (int i = 0; i < nums.length; i++) {
    int n = nums[i];
    if (n > max) {
        System.out.println(n+"比目前的最大值大"+max+",因此更新最大值为"+n);
        max = n;
    }else {
        System.out.println(n+"不比目前的最大值"+max+"大");
    }
}
System.out.println(max);
System.out.println("-------end--------\n");

16、方法

16.1、什么是方法？

• 方法（method）也可以叫函数（function）。

• 方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，也就是说一个方法只完成一个功能，这样利于我们后期的扩展。

16.2、方法的组成

方法：由方法名、参数、返回值组成。

• 方法名：是别人调用本"命令"的标识符。
• 参数：是调用方法的时候传递的数据。方法可能没有参数，可能有1个或多个参数。
• 返回值：是方法调用完成的结果。方法可能没有返回值，对于有返回值的方法，我们也可以忽略返回值。

修饰符 返回值类型  方法名(参数列表){
    方法体
   return 返回值;
}

如果方法没有返回值,则把"返回值类型"改写为"void",然后把"return xxx;"去掉。

例如：

public int printA(int a){ //这里的a指的是形参
   a=10;
    return a;
}

16.3、方法重载

方法重载：就是在一个类中，有相同的函数名称，但形参不同的函数。

方法重载规则：

• 方法名称必须相同；

• 参数列表 必须不同 (个数不同，类型不同，参数排列顺序不同)；

• 方法的返回类型可以相同也可以不同；

• 仅仅返回类型不同不足以成为方法重载；

16.4、方法的调用

• 方法名(参数列表)；
• 或者有返回值且需要有返回值，则：变量=方法名(参数列表)；

举例：调用System.out的方法、Arrays.toString()。

调用方法的时候需要提前把对应方法中的类import进来（俗称导包）。