前期已学知识1、预科 --- HTML/CSS2、Java 面向对象
2-1、面向对象语法（理论）封装 继承多态抽象接口2-2、面向对象的应用（实践）后期课程安排第一阶段：Java常用API第二阶段：数据库第三阶段：Java进阶第四阶段：面向对象分析与设计
前期已学知识
1、预科 --- HTML/CSS
基于Java的程序语言基础
概念：
标识符、数据量（变量/常量）
数据类型（4类8种基本数据类型）
运算符（算术、赋值、比较、逻辑、位）
语句（输入语句、输出语句、调用语句、运算语句）
流程控制（分支/循环）
数组、函数（函数的定义---函数名、返回类型、形参、函数的实现、return关键字；函数的调用---参数的传递）
2、Java 面向对象
2-1、面向对象语法（理论）
面向对象的特征：
老的说法是三个：封装、继承、多态；
现在说法增加一个：抽象
封装
类的定义就是封装、方法的定义其实也是封装......
这里有两个概念：“封”和“装”
“装”是前提，比如类的定义，它通过{}
装入这个类拥有哪些数据、拥有哪些行为。
“封”是对装的内容对外使用的限制，也就是信息隐藏；在应用时，Java提供了3个关键字4种情况，以及get/set方法的设计。
继承
extends、单继承、Object、重写
让拥有is-a关系的类能够共享属性和行为，达到代码的共享。
对象与对象之间的关系：
use a: 这是一种很弱的关联关系，对象a只在某个方法当中要用到对象b，当方法结束的时候关系也就解除了。
所以在语法上，b是作为a的某个方法的局部变量存在。
has a: 这是一种中间态的关联关系，对象a当种包含了一个对象b，只要给对象a存在就可以用到b，a当中所有的方法都可以用到b。前提是要给b赋值。
所以在语法上，b是作为a的一个属性存在的。
is a: 这是继承关系；
强调：不是因为要共用属性和行为，所以我们做继承；而是因为它们有is-a关系，所以才有共有属性和行为。
至于like a关系不是标准的面向对象的关系。只是在Java语言当中有一个叫做接口数据类型，这种类型有点像继承关系又不是继承，所以给了一个like a---“像一个”。
继承的具体知识点：
1、extends关键字
2、单继承
在面向对象的概念中是没有单继承还是多继承这种说法的。只是说Java语言在设计它的实现的时候，采用了单继承；也有别的编程语言采用了多继承。
多继承的好处：丰富度。
坏处：复杂度。我们在复杂情况下设计出来的类结构图一定会呈现出网状结构。
单继承的好处：无论多复杂的情况，设计出来的类层次结构一定是简单的树状结构。
坏处：丢失了丰富度，所以也才有了后面的接口的多实现来进行补充。
3、Object类 --- 根类
所有的类和数组都继承于这个类，它是根也是祖宗。它的属性和行为是所有类都共有的。也就是说先人在设计的时候是把共用性最强的行为写在它当中了。所以这个类是唯一一个我们要把它所有方法都要进行掌握的一个类。
//强调一点，Object是所有类和数组的父类，但不是基本数据类型的父类; //Object的变量是不能指向基本数据类型的值的 objs[3] = 10;//这里虽然没有报错，但是其实这里是有一个语法糖的
在目前这个阶段至少要掌握两个方法的使用和知道一个方法：
a、equals() --- 经常重写
作用：判断两个对象业务规则是否能判定相等。
那么和"=="号有区别吗？
"=="是用来比较两个对象引用是否是同一个，或者说两个引用是否指向同一个对象。
“equals”是用来比较两个对象的内容是否相等。
只是由于原生的equals方法是定义在Object当中的，所以它不知道子类有哪些内容，所以在Object当中的实现只能是返回"=="号比较的结果。
而我们通过继承，子类会自动具备来自于Object的这个方法，然后通过重写我们自己定义比较的规则。
b、toString() --- 常常重写
作用：返回对象的字符串描述。
原生的toString方法是定义在Object当中的，同样不知道子类有哪些内容当然也就没有办法确认子类对象需要的字符串描述，所以只能采用统一的"类型@引用"的形式返回。
我们自己写的类需要通过重写，然后返回一个我们自己定义的字符串。
另外toString方法在对象做字符串操作的时候会被自动调用，无需我们显式调用。
c、finalize()
在JDK9之后过时了。
作用：在JDK9之前是用来销毁对象的方法。我们可以把它和构造方法看成一对儿。由于Java处于安全性的考虑，不让我们操作对象的销毁，所以它把销毁方法写好，放在Object当中，然后所有的类和数组通过继承都拥有了销毁方法。我们都知道Java的对象回收都是由GC（垃圾回收机制）来进行操作的，而GC正是通过调用这个方法来玩成对象的销毁。
记住：finalize方法是定义在Object当中的，由GC调用。
这个方法通常是不重写的，因为你不知道如何重写。如果有需要重写，那么在写完自己的实现后调用一下super.finalize()完成父类的实现。
4、重写 --- 子类把父类的方法给重写实现。
重写规范：
方法名必须一致；
参数列表必须一致（包括：参数的个数、参数的类型和参数的顺序，没有参数名）；
返回类型可以变，但是重写后只能返回重写前的返回类型或它的子类型；
访问修饰符也可以变，但是子类重写后的访问修饰符只能往大的方向变或不变。
多态
相同的行为，不同的实现
通过这句话，我们要掌握的内容：
a、多态是形容行为的，也就是“方法”；没有属性多态这一说；
b、相同的行为指的是同名的方法；也就是说所有的多态方法至少要有一个特征，那就是方法名相同。
c、当然，我们在Java中特指的多态是两种：静态多态 和 动态多态。
首先明确这里的“静态”与static没有关系。这里的动和静是指程序在运行（运行期）还是没有运行（编译期）。
所谓“静态多态”指的是在编译期我们就能够确定程序运行的最终效果，即我们就能确定程序到底要执行的是哪个方法。
在语法上，重载是静态的，但是单独使用重写也是静态的。
"动态多态"是由两个技术共同组成的：重写和动态绑定技术。所以重写本身并不是动态的，动态效果是由动态绑定技术带来的。
这里需要强调一下“动态绑定技术”，其核心归结于一个语法 --- 父类的引用可以指向子类对象。
其实说白了，就是“=”两边的数据类型可以不一致。
我们先归纳一下基本数据类型的情况
double d = 3.14;//同类型数据值赋给同类型的变量 double d = 3;//小类型的数据值赋值给大类型的变量 int i = 3.14;//报错，大类型的数据值赋给了小类型的变量 int i = (int)3.14;//强转，有风险，风险是精读的丢失
总结一下：
本类型的值赋给本类型的变量---成功；
小类型的值赋给大类型的变量---成功；
大类型的值赋给小类型的变量---失败--解决手段是强制转换，风险是精读丢失；
那么到了引用数据类型也是一样的：
类型A a = new 类型A();//成功 类型A a = new 子类型B();//成功 子类型B b = new 类型A();//报错 子类型B b = (子类型B)new 类型A();//强转,有风险，风险是编译通过了但是运行报异常
为什么父类引用可以指向子类对象？
1、从场景上来说，父类的范围是大于子类的，既然这个变量是父类类型，子类和父类又是is-a关系，所以当然子类对象也是父类类型的一种了。
钱 盒子 = 人民币对象；
钱 盒子 = 美元对象；
钱 盒子 = 欧元对象；
2、从内存上来说，子类对象的内部其实包含了一个完整的父类对象部分；这一点是Java继承的内部实现手段---“内存叠加”。
为什么子类引用不能指向父类对象？
1、场景上，父类范围大于子类，所以子类的变量是小类型的装不下大类型范围的数据；
人民币 盒子 = (人民币)钱对象;
2、从内存上，钱对象的内容中是没有子类人民币的特有属性和行为的，所以盒子变量会发现它找不到一个完整的人民币对象在内存中。
动态绑定技术的核心就是“父类引用可以指向子类对象”；那么当我们声明一个父类变量的时候，它可以是A子类对象，也可能是B子类对象。只有运行起来以后，才能够确定这个父类引用到底指向了哪种子类对象！！绑定是绑定这个！！
然后不同子类对象通过重写可能对同一个方法有不同的实现，所以当它指向不同子类对象的时候，调用同一个方法才有不同的效果。
不管你如何强转，如果要编译成功运行也成功，那么只有两种情况：本类指向本类 和 父类指向子类。
动态绑定的主要应用：
1、动态参数
public void method(父类 参数名){
}
2、动态集合
父类[] 集合 = new 父类[5];
集合[i] = 子类对象；
抽象
这里的抽象其实是一个狭义的抽象，专指的abstract。
我们把子类中共有行为和共有属性不断的往父类进行抽取，那么当我们抽取到某一个层度的时候，会发现在父类中只能确定这个类有这个方法，无法确定这个方法是如何实现的了。而一个拥有抽象方法的类也不应该产生对象了（因为对象是具体的实际的存在，它当中所有的内容都应该是确定的），这样的类也就成了抽象类。
与生俱来的行为要定义在抽象类中，表达了一种继承的传递结论：
有抽象方法的类一定是抽象类；
抽象类不能够产生对象；
如果一个类继承抽象类不去实现它的抽象方法，那么这个类也是抽象类。
抽象类除了不能产生对象，它的本质没有改变，一个普通类该有的它都有。它有属性、构造、方法、代码块，甚至内部类。它也是单继承的。它就是在我们设计层次的上层，用来规范子类内容的。唯一的缺点就是“单继承”。
接口
为了解决这个单继承的问题，提出“接口”的概念。
1、接口是Java中大家学到的第三种引用数据类型；（类、数组）；
Java里面核心的引用数据类型就它们三个，以后你们还会接触到的：枚举、注解、Lambda、记录.....
2、接口的定义
interface关键字；
接口的属性只能是公共的静态常量；
接口是没有构造方法的，所以接口不能直接产生对象；
长久以来，接口中我们最关注的是方法，而且是公共的抽象方法；大部分需求都是书写这种方法。直到JDK8开始才给接口添加了各种可以实现的方法，包括：default方法和static方法。但其实这两种方法是属于“锦上添花”的设计，在99.99%的情况下，我们设计接口的目的都是去书写抽象方法。这个跟接口的作用有关系。
接口的作用：让没有继承关系的类也能共享行为。
3、接口的使用
3-1、接口可以多继承接口；
3-2、类可以多实现接口。
4、面向对象编程逐步过渡到面向接口编程；甚至很多设计人员在设计的时候不去设计抽象类了，拿着就设计接口。
这个是实际使用者偷懒的地方，其实在面向对象概念中，这两个东西是有原则性区别的。
一个抽象方法到底设计到抽象类当中还是接口当中是有规则的。比如：门。有各种各样的门，门也有各种各样的行为，不同的行为也是各有不同的。比如：开门 关门 按门铃 猫眼观察 锁 解锁，那么所有的这些行为都应该写成抽象方法。
那么我们观察这6个方法，我们可以根据自然的生活经验讲这6个方法分级别。很明显，在这6个方法当中有两个方法是门不可或缺的，就是开和关，没有这个两个方法，就不是门。这两个行为就是门所谓的“与身俱来的行为”；
设计是没有对错的；只要能完成当前的功能任务，那么你就不能说这个设计是错的；
但是，设计是有优劣的，更符合场景的设计会带来更多的好处。
包括：代码量的减少，修改量的减少，可以更好的随着业务场景的变化而发生变化（不用推倒已有代码重来）。
/* 定义接口的时候，请定义小的接口，而不是大而全的接口。 除非某几个方法是同时出现或同时不出现的，那么才在一个接口里面定义这多个方法。 这是面向对象设计原则中的"最小接口原则"，也叫"接口隔离原则"。 如果一旦定义了大而全的接口，会导致实现类可能拥有它并不具备的方法。 所以设计上不要让上层接口的设计问题导致下层实现类的不干净，所以也叫"接口隔离"。 接口在命名的时候，包括后面你们学到先人在JDK中设计的接口，你们会发现它们通常 都叫做****able，代表的就是提供某种额外的能力（功能）。 */
2-2、面向对象的应用（实践）后期课程安排
第一阶段：Java常用API
这个阶段中我们要学习到JDK里面提供的很多常用API类和接口。这些类和接口无论以后你们做什么项目，只要是Java的就一定要用到。所以，这里对各位的熟练度要求很高。
异常处理（重点）
字符串类型（重点）
包装类类型
时间日期类型
集合类型（重点）
输入输出流
GUI（实践）
第二阶段：数据库
主要是数据的基础学习。包括：数据库中的基本概念，基本结构；对数据进行CRUD操作；以及使用JDBC技术，用我们的Java代码操作数据库。
第三阶段：Java进阶
主要学习Java当中的一些底层技术。这里所涉及的很多内容，以后大家不见的会直接写代码。不是因为它们用得少，很是初中级的程序员没资格写。我需要大家在这里对这些内容形成一个基本的概念认知和基本的语法实现。
反射（重点）
多线程技术（小重点）
网络编程
XML和注解
补充：枚举、泛型、lambda表达式等等
第四阶段：面向对象分析与设计
这个阶段主要是理论内容，掌握设计原则、设计模式和架构模式。
7个设计原则
常用设计模式
三层架构模式（Spring应用）