面向对象

类：抽象的，概念上的内容

对象：实实在在的个体，在堆空间中分配了空间；对象是由类派生出来的

在java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

涉及到java语言与前端html，后端数据库交互是都体现为类、对象

field：属性 = 成员变量

method：成员函数

堆（heap）：唯一目的是存放对象实例（所有的对象实例和数组都要在堆上分配

栈（stack）：主要指虚拟机栈，存储局部变量

方法区（Method Area）：存储被虚拟机加载的类信息，常量，静态变量，即时编译器编译后的代码等

定义变量的格式：数据类型 变量名 = 变量值

先声明，后使用

变量都有其对应的作用域

1. 声明的位置不同

2. 权限修饰符的不同

3. 默认初始化值的情况

4. 在内存中加载的位置（非static）（静态的加载到静态域）

1. 权限修饰符 -->封装性

2. 返回值

3. 方法名

4. 形参列表：可以声明0-n个形参

特别的：方法A中又调用自己（A），即递归方法

方法内调用本类的方法时，可以直接写方法名或者this.的形式

方法内调用其他类的static方法，类名.方法名的形式

方法内调用父类的方法，super.的形式

1. 求圆的面积

2. 对象数组Student类

3. 匿名对象的使用 #tips

4. 自定义工具类

两同一不同

跟方法的权限修饰符，返回值类型，形参变量名，方法体都没有关系

看方法名

看参数列表

可变个数形参的格式：数据类型... 变量名

可变形参的方法和同一个类中的同名函数构成重载

可变形参必须声明在末尾

可变个数形参在方法的形参中，最多只能声明一个可变形参

和数组的方式一样，编译器认为是同一个函数；可以和数组一样获取下标值

基本数据类型：变量保存的数据值

引用数据类型：地址值

参数类型：

（java中的形参传递）值传递机制

举例说明（交换）

调用自身

隐式的循环，不需要循环控制

终止条件：没有再调用自身的时候就结束了

求和

数列问题

斐波那契数列 #题目

汉诺塔

快排

两同一不同：同一个类，相同方法名；参数列表不同（参数名不一样步算）

和权限修饰符，参数返回值没有关系

如何调用确定的方法：方法名+确定的参数列表

基本数据类型：数据值

引用数据类型：地址值（含有变量的数据类型）

结束方法（后面不能有东西），不论return在方法的什么位置，只要return就结束方法

有返回值的情况

内存的结构：栈（局部变量）；堆：new的结构（对象，数组）

变量：成员变量 & 局部变量（栈）

1. 如上

2. 对类内使用的方法（不对外暴露的私有的方法）

3. 单例模式（构造器私有化）：只有一个对象实例

4. 如果不希望类在包外被调用，可以将类定义为缺省的

private

缺省

protected

public

最好不理解为方法Method（构造器没有返回值）

1. 默认初始化值（成员变量和局部变量的区别之一：成员变量有默认初始化值）（比如int型默认1，Boolean型默认false）

2. 显式初始化：int age = 1；（声明属性的时候顺便赋值，修改了默认初始化值）

3. 构造器中赋值

4. 通过"对象.方法"或'对象.属性‘赋值

类是公共的

有一个无参的公共的构造器

有属性，且有对应的get、set方法

this.属性表明此变量是属性，不是形参

空指针异常

model：Customer为实体对象，用来封装客户信息（一个JavaBean）

view：CustomerView为主模块，负责菜单的显示和处理用户操作

controller：CustomerList为Customer对象的管理模块，内部用数组管理一组Customer对象，并提供相应的添加、修改、删除和遍历方法，供CustomerView调用

A子类 subclass 派生类

一旦继承之后，子类就获取了所有父类的属性和方法，特别的，父类中的private的属性和方法，子类继承后仍然全部获取了父类的这些私有的结构，只是由于封装性的影响，使得子类不能直接调用父类的这些私有结构（可以用setter和getter方法）

B父类Superclass超类 基类

子类直接继承的父类：直接父类

子类间接继承的父类：间接父类

子类继承了直接父类和间接父类的所有结构

方法的声明：权限修饰符 返回值 方法名（形参列表）{//方法体}

约定俗成：子类中的方法：重写的方法；父类中的：被重写的方法

子类的权限要更广，但返回值更紧

子类和父类中的同名同参数的方法

子类不能重写父类中声明为private的方法

如果父类的是void，则子类的只能是void（相同）

父类的：基本数据类型A，子类的也必须是A类型（相同）

父类的：引用数据类型A，子类的可以是A或者A向下（A的子类）

重载：方法名相同，参数列表不同；在同一个类中

重写：参数列表和方法名都一样；有子父类关系，在不同的类中

...

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不 同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了 不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。 所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法， 这称为“早绑定”或“静态绑定”；

而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体 方法，这称为“晚绑定”或“动态绑定”。

用了super先去直接父类找，如果没找到，接着往上找

不用super默认调用自己的

为了尽量避免报错，一般都要提供空参构造器 #tips

用了父类的有参构造器，再加上this.自己新加的属性构造一下

一般账户余额不会有set方法，只有get方法，此时可以用父类的withdraw方法（有基本的关于balance的冲减情况）；注意使用到透支金额的分支条件下的方法体，先冲减overdraft再把balance置为0；和日常思维顺序不一致

当调用子类父类的同名同参数的方法时，调的是子类重写的方法

不能调用子类独有的方法，因为编译时要查看引用变量所声明的类（父类）中是否有所调用的方法或属性

总结：编译看左边，执行看右边

有类的继承关系

要有方法的重写

方法声明的形参类型为父类类型，可以使用子类的对象作为实参调用该方法

引入（为什么使用向下转型）

解决（如何使用向下转型）

面试题目：如何实现向下转型

若子类重写了父类的方法，就意味着子类定义的方法彻底覆盖了父类的同名方法，系统不可能把父类的方法转移到子类里

对于实例变量不存在这种现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类里的实例变量

多态性体现

一些要注意的问题

多态是编译时行为还是运行时行为

如何理解多态性

另外

3.1 equals：两个对象是不是相等的

3.2 toString（）:转换为字符串（经常需要重写自定义类的toString()方法）

2.1 包装类和基本数据类型（自动装箱，自动装箱）

2.2 包装类和基本数据类型 --> String （调用String类的valueOf（））

2.3 String --> 基本数据类型和包装类（调用包装类.parseXxx）

三元运算符两个分支的类型必须一致，不一致的话会自动类型转换

IntegerCache问题

题目：利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级；若与最高分相差10分内：A等；20分内：B等；* 30分内：C等；其它：D等

静态属性（静态变量 / 类变量）

非静态属性（实例变量）

2.1 加载：静态变量随着类的加载而加载

2.2 调用：静态变量的加载早于对象的创建，new对象之前就能用静态变量，”类名.静态变量名“（实例变量不能通过类调用）

2.3 独立性：由于类只会加载一次，所以静态变量在内存中只存在一份，存在方法区的静态域中

2.4 静态属性一般不在构造器里初始化

System.out，Math.PI

可以被多个对象共享的，不会随着对象的不同而不同

类中的常量也常常声明为static（final更严格，不妨加个static）

1. 操作静态属性的方法

2. 工具类中的方法（没有必要造对象去调方法了）：直接类名.静态工具方法名就可以

圆

银行账户

是在大量的实践中总结和理论化之后优选的代码结构、编程风格、 以及解决问题的思考方式

设计模免去我们自己再思考和摸索。就像是经典的棋谱，不同的棋局，我们用不同的棋谱

”套路” 

2.1 定义：

2.2 优点：

2.3 举例：

2.4 单例模式的应用场景

步骤

饿汉式

懒汉式

饿汉式：（面试中直接写这个吧）

懒汉式：

权限修饰符：封装性

修饰符：static / final / abstract / native 可以修饰方法

返回值类型： void / 有返回值（return）

方法名：命名规则

形参列表：重载 / 重写；参数的值传递机制（数据值 / 地址值）；体现对象的多态性（代码的复用性）

方法体：体现方法的功能

内部可以有输出语句

随着类的加载而 执行（静态方法随着类的加载而加载，但是需要用类来调用），且只能执行一次

作用：初始化类的属性：初始化类的static

可以定义多个，按照声明的顺序

代码块内只能调用静态的xxx（因为随着类的加载而执行）

内部可以有输出语句

随着对象的创建而执行

每创建一个对象都会执行一次

作用：可以在创建对象时，对对象的属性进行初始化

可以调用静态 & 非静态

实例化子类对象时，涉及父类、子类中的静态、非静态代码块、构造器的加载顺序：

不能被继承：提高安全性，提高程序的可读性

比如String类，System类，StringBuffer类

不能被子类重写

比如Object类中的getClass（）

3.1 特点:

3.2 修饰的成员变量

修饰的局部变量

1.1 此类不能实例化

1.2 抽象类一定有构造器（所有的类都有构造器），便于子类实例化时调用（涉及：子类对象的实例化过程）

1.3 开发中都会提供抽象类的子类，让子类对象实例化完成相关操作

2.1 抽象方法只有方法的声明，没有方法体

2.2 包含抽象方法的类，一定是一个抽象类；反之一个抽象类可以没有抽象方法

2.3 若子类重写了所有父类（包含间接父类）中的所有抽象方法之后，此子类才能实例化

2.4 若子类没有全部重写父类的抽象方法，则此子类仍然是一个抽象类，要用abstract修饰

3.1 abstract不能修饰属性、构造器等结构

3.2 abstract不能用来修饰私有方法、静态方法、final方法、final的类

抽象类体现的就是一种模板模式的设计

抽象类作为多个子类的通用模板

子类在抽象类的基础上进行扩展、改造

但子类总体上会保留抽象类的行为方式

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以 把不确定的部分暴露出去，让子类去实现

在软件开发中实现一个算法时，整体步骤很固定、通用， 这些步骤已经在父类中写好了；但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式

抽象模板类

实现抽象模板类（质数）

测试

初始化的时候如果类型是引用数据类型，要new一下

声明属性的时候，如果属性是引用数据类型的数组，则声明只是声明了一个数组，该数组里的元素（引用数据类型）并没有被创建 ----> 比如如下为Employee是一个抽象类也没关系

抽象类的一切（属性、抽象方法、非抽象方法）生来就是服务于子类的，否则没有存在的意义，因为抽象类压根不能创建对象。这里的抽象类Employee的toString（）的重写就完全是为了子类方便而改的格式

日期类

构造器的声明和使用

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方 法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果

另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又 没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打 印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都 支持USB连接

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则 必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能" 的关系

接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守，不能改

1.1 用interface定义

1.2 Java中，接口和类是两个并列的结构

1.3 接口、类之间的关系

2.1 JDK7及以前：只能定义全局常量和抽象方法

2.2 JDK8：除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法default关键字（可以省略public）

2.3 接口不能定义构造器！意味着接口不能实例化

3. 1 如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化

3. 2 如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类

3.3 一个类可以实现多个接口 ---- >弥补了Java类单继承的缺陷

3.4 先写extends，后写implements

3.5 也可以创建接口的匿名实现类 的 匿名对象（匿名的四种组合）

4.1. 接口的具体使用，体现多态性

4.2. 接口，实际上可以看做是一种规范

4.3. 面试题：抽象类与接口有哪些异同？

5.1 代理模式

5.2 工厂模式

6.1 全局常量的问题

作为类

作为成员

递归调用无终点

IOException

ClassNotFoundException

NullPointerException

ArrayIndexOutOfBoundsException

ClassCastException：类型转换异常

NumberFormatException

InputMismatchException：Scanner时输入不匹配（int 和 String）

ArithmeticException：算数异常（比如除以0）

FileNotFoundException没找到文件

除以0了

输入不匹配（要求int输入String）

程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出

一旦抛出对象以后，其后的代码就不再执行

关于异常的产生：

可以理解为异常的处理方式

2.1 花边儿

2.2 过程

2.3 catch中异常类型的顺序

2.4 finally

"throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。

一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。

异常代码后续的代码，就不再执行

try-catch-finally:真正的将异常给处理掉了

throws的方式只是将异常抛给了方法的调用者。 并没有真正将异常处理掉

3.1 子父类关系角度

3.2 多个方法和总方法的角度

继承Exception：编译时异常

继承RunTimeException：运行时异常

自定义异常类

测试

可以省略Data

自定义异常类（继承；全局常量；构造器两个）

小函数的小功能就直接throws向上抛出，先不处理，以后统一try-catch处理

函数有扔异常，那么调用该函数的时候就要给出相应的处理异常的方法

类型匹配问题（字符串和类的转换匹配）

输出问题：转换成字符串（重写toString（）方法

写一部分就测试一下，因为main函数还没办法运行

static final类型的成员变量（是自己这个类的对象）

只要是引用的类型的比较值是否相等，就用equals（）

为了避免空指针异常的风险，建议把字符串放在前面：

正确写法：一步一步判断，有先后

错误：

删除操作时没找到，则i是走到结束才退出循环的，不是break出的