java后端开发day34--脑子空空如何无痛想起所有知识点--概念拟人化

在这里插入图片描述

1.上半部学习思考

1.1反思–浮躁–二倍速

刚开始算半个小白吧，从最基础的知识点开始学习，到后面学习整个项目的布局和功能。可能是后面慢慢懂得多了，每次打代码搞项目啊什么的，就能明显感觉到自己很浮躁：脑子里已经明显有一个项目主体的搭建，所以就不愿意慢慢跟着课听了，最后的解决办法是干脆二倍速听，有一种自己脑子中的东西随着自己的思考慢慢实现的感觉。当然，不建议像我这样，纯脑子跟上节奏甚至往前跨越了一步，但是自己的行为还滞留在节奏之后。明知道这样不好，所以就只能耐着性子慢慢继续打代码，但是又觉得过于浪费时间。所以我最后琢磨出一个步骤：大体–部分–细节。

1.2大体–部分–细节

课堂项目嘛，无非就那几部分，脑海中先有一个项目的大致布局，再仔细看题目中的要求能够根据所学的内容分为几个部分，类啊，方法啊，接口啊，先浅浅分个类，确定每个部分的具体写法（涉及到具体部分的格式要求）。

在脑海中先把前两个部分简单定下来，最后一个就需要自己对知识点啊什么的熟练掌握，下意识知道这个部分的格式啊要求啊什么的，自己脑子里能具体呈现出格式代码，再根据题目具体要求修改（相当于修改模板）。

现在这里简单提一嘴吧，下面儿讲完知识点，会再具体提一嘴。

1.3反思–焦虑–沉淀

总而言之，越往后学，因为只是对自己刚学完的知识的重复，浮躁算是我最大的一个敌人。其次就是焦虑自己能不能学完这么多东西（因为本人的麻麻一直催我暑假就找实习，亚历山大，，，），焦虑了一阵，结果发现根本就是庸人自扰。因为自己焦虑不但改善不了自己计划好的进度，反而一直会把自己拉近一个恶性循环，会持续消耗自己的积极情感，拖慢自己的进度啊啥的，所以我干脆就什么都没干，沉淀了一周，让自己的脑子好好想想。

一周，不长不短，适当的休息也有助于自己接下来的进步。焦虑无用，所以把它隔离掉就好。专注于自己手上的事情，一忙起来自然而然就会忘掉了。

1.4思考–熏陶–比喻

就是随着学习语言越来越深入（其实学什么都是），自己的思维会不由自主的向上生长，土了说就是腌入味儿了，别人提出什么什么，你下意识地会说出术语啊专业名词啊，就算熏陶成功。进一步，当你能够自然而然觉得一个算法，它本就该这样，而不需要什么理由的时候，就算是大能了（大概吧）。

这就是为什么有些好的研究学术的专业人员，没办法成为一个好的老师的原因。

也是我为什么会随时写感想的原因，我发现自己慢慢不受控制地去用一些术语，很贴切但很难理解。当然，对自己来说是一个好事，但是为了有助于其他人理解，我还是更倾向于多具像，多用比喻来表达含义，便于理解嘛，为了以后面试背八股文也有好处。

2.从0想起知识点

设想如果你从来没学过java，你只需要有意识地觉得java是一个绝对对称的世界就好。

2.1 “我”&“我们”

对称：个体&群体

2.1.1 基本数据类型

先想：我是“一名学生（或者其他的职业）”。
一个学生：包括了一个单位“个”，一个职业“学生”。
就可以想到：职业—基本数据类型
（转至看2.2.2）

2.1.2 引用数据类型

先想：我们是一个被边界包裹住的整体（群体，也可以理解为不同行业、部门），里面可以有无数个“我”（打工人），
引用：别的部门需要“我”，借用“我”。
一个整体：相当于一个盒子，里面可以有很多物品，需要用物品就得从盒子里拿（引用）。
就可以想到：引用数据类型。
（转至看2.2.2）

2.2 对称–变&不变

而我这个人，有的特点会改变，而有的就不会。
就可以想到：会变得—变量，不会变的—常量。

2.2.1 常量

不会变的量，既然是个量–个体–>会有很多类。
就像是一个动物–>会有很多类动物一样，只不过生物的种类不会互相改变。

具体分类也是对称的：
整数&小数：整&分
字符&字符串：短&长
布尔：本身就是对称的，对&不对
空：相当于0，虚无。

而原本就存在世界上的东西：太阳，月亮…
像是已经定义好的东西----->关键字。

2.2.2 变量

会改变的量，既然已经会改变了，所以也会有分类。
像人类的职业一样，可以来回改变---->个体----->基本数据类型。

具体分类与常量分类相似：
整型&浮点型：整&分
字符型：因为是基本。
布尔型：本身对称

与基本数据类型相对应的是：引用数据类型
创建以下的几个引用数据类型，都会用到new，相当于一个动词，创造。
相当于把所有职业的人圈在一起形成一个公司。
类：部门，分工及作用都很分明的整体。（转至看2.8.1）
接口：纯工具箱。
数组：工厂员工的名单。每个工人都有自己的编号。（转至看2.6）

2.3 运算符

对称：舍&得
就像人类生活：你给我、我给你的交易行为。
就可以想到：加减乘除等运算----->运算符。

算术运算符：单纯加减乘除以及取余。
赋值运算符：算术运算符后加一个等号。
关系运算符：大于小于等于…
逻辑运算符：与或非
三元运算符： a > b ? a : b a>b么，大于输出a，不大于输出b。

2.4 转换

就像人类花钱交易，金钱的单位不同：元，角，分。一元=十角。
就可以想到：隐式转换和强制转换。

隐式转换：小票整合换大票。（范围）
强制转换：大票换分散的小票。（范围）

2.5 判断与循环

一件事情：重复&不重复无前提条件&有前提条件：一个条件&多个条件
重复：循环 for（知道重复次数） & while（不知道重复次数）
单条件：if
条件：if else
多条件：if else if else & switch case default

2.6 数组–名单

2.2.2讲的公司旁支的工厂。
相同物种的生物组成一个工厂。
（人和人一个工厂，兔子和兔子一个工厂）
所以：一个数组（工厂）里存储同种基本数据类型（物种）的多个值（生物）。

2.6.1 命名

对称：变&不变（静态&动态）
不同物种不同工厂，所以先确定种类，再加特征符号[ ]，最后是这个工厂的姓名。
例子：物种：int + [ ] + 工厂名字：array = new（动词，新建一个）+ 物种：int + [ ]+ 同物种的个体：{ …};
静态：已知确定个体（就知道这个场子由谁谁谁工作）
动态：已知个体数目，不知道具体个体（知道招几个人，但没招到）

//静态：
int [ ] array = new int[ ] {11,22,33};
int [ ] array = {11,22,33};
//动态：
int [ ] arr = new int [3];

2.6.2 元素访问

有厂子，有人工作，必要的时候需要某个人就要找这个人：元素访问。
进厂子的每个个体都有自己的编号：从零开始，依次往后加1。
你要找哪个厂的哪个人，就要先确定厂名：array + 员工编号：[0] （或者其他）

int [] arr = {1,2,3,4,5};
System.out.println(arr[1]); //2

2.7 方法–行为

不论是“我”或者是“我们”，我们生活就必然会有重合的动作啊行为什么的----->方法
就像吃饭：拿碗–盛饭–盛菜–开吃
方法也是将几个重复的有顺序的动作的步骤打包在一起，实现这个名称的作用。

2.7.1 命名

吃饭这个行为：
public（大家都能吃） static（稳定的）吃八分饱（结果）吃饭（饭，菜）{
拿碗；
盛饭；
盛菜；
开吃；
最后八分饱；
}
提取固定格式：
public（面向公众的） static（稳定的）返回值类型（结果）方法名（需要的东西1，需要的东西2）{
主要实现这个方法的步骤
最后实现的结果；
}

public static int method(int num1, int num2){
	int result = num1 + num2;
	return result;
}

2.7.2 方法重载

我们保持吃饭的这个行为，但是每个人吃饭中菜肯定不都是一样的。
所以我们就可以重新修改吃饭中吃菜的步骤------>方法重载。

2.8 面向对象–创造工具，使用工具

我们有“我”这个概念之后，避免不了和别人接触，所以要学会见人说人话，见鬼说鬼话---->面向对象。
比如我们碰到一个同学有一道数学题需要解决，授人以鱼不如授人以渔，我们就需要告诉他：
问题的知识点（成员变量）、问题的解决方法（成员方法）。

//大差不差展示一下格式
public class Phone{
	//属性（成员变量）
	String brand;
	double price;
	//行为（方法）
	public void call(){

}
	public void playGame(){

}
}

当我们教完这个同学这个问题的解决方法之后，有其他的同学不会，我们就可以让这位同学去帮忙讲。
上述算是学习如何自己设计对象并使用。
但如果这位同学本身就会其他问题的解法，我们也可以让他去帮别的同学。
上述算是学习获取已有对象并使用.
总而言之，面向对象就是一个好为人师然后一劳永逸（不是）的过程。
而会这个题的同学们就是----->类。
这位同学就是这个类里的一个----->对象。

2.8.1 类

我们总讲一类人啊什么的，就是指拥有共同特征和行为的一个群体。
提取关键字：特征（属性）------ 成员变量行为（方法）------成员方法

2.8.2 对象

上述的“这位同学”是“会这道题的学生”这个类里的一个个体，也就称为对象。
当我们需要这位同学来解决一个他会的问题的时候，称为调用这个类的对象的成员方法。

首先得到这个类的对象：
那就是先知道他是属于这群会这道题的学生里---->类名 + 指定的某个人---->对象名 = new 类名（）

//类名 对象名 = new 类名（）;
Phone p = new Phone（）;

调用这个对象：
直接用. .相当于一个动词，作用就是使用某个东西。

 p.brand = "xiaomi";  //赋值
 p.price = 1999;
 p.call();
 p.playGame();

2.8.3 封装

延续上述的例子：
会这道题的这类学生------这类学生中单独的一位学生------这个题所需的知识点------这个题的解法

上述有类、类中有对象、有方法，就称为封装。
封装：就是把一个个体所需的各种东西都封存在一个个单元中。

2.8.4 构造方法&JavaBean

一个人的基本出生状况---------->初始化---------->构造方法
一个人出生的详尽信息---------->多个构造方法-------->JavaBean

（可以快捷键，详情去看day12）

2.9 API

就一个纯工具箱。
相当于这个世界上前人已经创造出来的车啊各种工具什么的。
只要你需要，就可以随便儿调用。

2.10 集合

与2.6的数组类似，都是一个名单的作用。
存储对象。
与数组最主要的区别就是数组的名单人数（长度）的确定的，集合（长度）的名单人数是可变的。

2.10.1 包装类

我们在2.1.1中了解到的“职业”------>基本数据类型
可以把它（职业）理解成一个口语化的表达。
而包装类（岗位）就是它的书面化表达。

2.10.2 泛型

数组本身是一个按职业划分归属的厂子，所以先确定确定职业（基本数据类型）才能建立工厂（数组），再确认名单。
集合就完全相反，集合本身就是一个大工厂（类），本身就有工厂姓名（类名），只需要在内部划分岗位（包装类），就可以生成一份名单。
而划分岗位就用到了泛型。

2.10.3 命名

厂名 + <岗位名> + 自称 = new + 厂名<>();
这里只有岗位名和自称（基本确定但可改）需要手动确定，其余都不变。

ArrayList<String> list = new ArrayList<>();

2.11 static静态

上述2.8.1，我们讲类就是一个群体。
static就是修饰这个群体的一个形容词，先有固定形容词才会依照这个固有属性进行对象的划分。
可以把它看成一个公有的物品，属于群体（类）而非个人（对象）。

2.12 继承

个体------->群体
很好懂了：爷爷–爹–儿子

2.12.1 方法重写

长江后浪推前浪，一代更比一代强。
爷爷会的手艺经历时代的改革，到达儿子那代传下来的手艺经过改良就叫做方法重写。

2.13 多态

又当爹又当儿子------>多态

2.13.1 命名

父类类型对象名称 = 子类对象；
ok我们现在是儿子，长大之后就会变成一个父亲。
先new一个子类对象，再赋值给父类。
Fu f = new Zi( )；

Animal a = new Dog();

2.14 权限修饰符

private（私房钱）<空着不写（自己家）<protected（私生子）<public（公益）

2.15 抽象类

我是“人”，我想吃饭（行为----方法）。
我想干什么事情，这是一个抽象的动作，所以有抽象方法的才是抽象类。
当然我想吃饭，我也有吃饭这个能力，所以抽象类也可以有普通方法。
相当于同性质幻想的结合，所以不能具象化（不能创建对象）。
与“我”这个主体有关，所以可以有构造方法。

2.15.1 命名

抽象方法
public abstract 返回值类型方法名（参数列表）; （无{}方法体）

抽象类
public abstract class 类名{}

2.16 接口

就是2.15中我想干什么事情，干什么事情的这个行为----方法。
我想干什么，别人也可能和我一个想法，所以接口默认是公开抽象的。
普遍可以理解为不止我一个能拥有的想法（想做自己有能力做的事情）和能力。
与“我”这个个体无关，所以没有构造方法。

public interface 接口名{}

2.17 内部类

上述2.8.1可知，类就是一个群体，内部类就是大群体中的小群体。
内部类可以直接访问外部类的成员，包括私有
：小群体中的人本就是大群体中的一员。类比一个班的学生和班中一个小群体里的学生。
外部类要访问内部类的成员，必须创建对象 （new一个）
：而一个班非小群体的人想要融进小群体，就要学会伪装自己（new一个对象）。