Day 13开篇：
"今天java基础主要学习了接口的问题，四种访问权限的修饰符，关于返回值深入的问题,代理设计模式，Object，Object的常用方法， Scanner等同时总结了面向对象的知识点。 "
知识点反馈：
今天的知识点总结的思维导图
一．接口的问题:
1. 注意：
(1)JDK8版本之前，接口中的所有方法都是也只能是抽象方法
(2)JDK8版本之后，接口当中允许出现默认方法，因为某些接口本身来说就可以具备一些默认的行为
public default int show3(){
}
(3)JDK8版本之后，接口当中也允许出现静态方法。
public static int show3(){
}
(4) 如果接口允许存在非抽象，那么也就意味着N个接口都可以存在一个重名且具体的默认方法,当实现类进行多接口实现的时候,就会造成一个接口冲突的问题
(5)如何去解决?
类优先原则(在类中重写一个跟接口声明一模一样的方法)然后根据重写方法，来进行选择性调用 A2.super.help();
2. 四种访问权限的修饰符:
二. 关于返回值深入的问题:
1. 返回值类型的问题:
(1)接口:要的是这个接口任意实现类的对象
(2)抽象类:要的的该抽象类具体子类对象
(3)具体类:要的是该类的具体对象
2.形式参数的问题:
(1)接口:要的是这个接口任意实现类的对象
(2)抽象类:要的是这个抽象的具体子类对象
(3)具体类:要的是该类的具体对象
三．代理设计模式:
1.例子：
在程序的开发当中，我们也经常需要隐藏一些信息，比如说，我的服务端连接其他的服务端，我不想让别人获取到我们服务端的信息，咋办？
这种情况，我们既要保证代码能够正常运行，又不能让对方获取信息，所有使用一个中间代理进行完成
2. 分类：
（1）静态代理模式:就是一个类的对象的任务，自己不想处理，交给另外的一个类的对象去处理
（2）动态代理模式:代理类不重写接口的方法，在程序运行中动态绑定要代理的方法
四．Net
1. Object:类Object是类层次结构的根类。每个类都使用Object作为超类;所有对象（包括数组）都实现这个类的方法,(只有是一个类，都是Object的子类)
2. Object的常用方法:
（1）int hashCode():返回该对象的哈希码值
（2）哈希码值其实是根据哈希算法算出来的一个值，这个值和我们的内存地址值相关，但是不是实际地址
（3）只不过是实际地址转换的一个虚拟地址
Class getClass():
返回此 Object 的运行时类
3. Scanner：
（1）public boolean hasNextXXX():判断你输入是否为某一种数据类型
（2）出现了问题:
<1>当我们使用Scanner的时候。在使用nextLine的时候，发现只输入了一位就已经结束了
<2> next:如果字符串当中包含了首尾空格,next不会进行识别
<3>nextLine:如果字符串包含了空格，nextLine依旧保留
<4>由于nextLine会的空格或者换行等转义字符都会进行识别，当我们上一次输入完毕之后，其实会产生一个/n的转义字符
<5>在转义字符产生之后nextLine以为自己获取到了数据，所以直接结束掉了
<6> 怎么解决掉这个问题？
无法解决，除非你新建一个Scanner对象。
面向对象总结:
知识点一：
1.概念：
一种基于面向过程的编程思想，顾名思义，就是站在对象的角度上面去考虑问题，不需要在乎每一个功能是如何实现的，强调的某些具备完成功能的对象。
2.面向对象的三大特征:
（1）封装(Encapsulation)：封装是把客观事物抽象成类，并且把自己的属性和方法让可信的类或对象操作，对不可信的隐藏。
（2）继承(Inheritance)：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
（3）多态性（polymorphisn）：多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。
3.面向对象思想:
（1）是一种更加符合我们思想习惯的思想
（2）将复杂的事情简单化
（3）我们从原来的执行者变换为了指挥者
（4）万事物皆对象
4.事物，类和对象：
（1）事物：事物是对现实生活当中的描述
（2）类：其实就是分门别类意思,他是一组相关属性的行为和集合，是一个抽象的概念
（3）对象:是某一个事物的具体表现形式，是一个真正且具体存在的东西
（4）一个对象内存的走向图
5.属性和行为:
（1）属性：属性其实是对一个事物的描述，比如人有高、眼睛是什么颜色
（2）行为:行为其实是这个事物能完成的功能，，比如人可以学习，人可以打篮球
6.成员变量和成员方法:
（1）成员变量：和我们之前定义的变量是一样的，只不过位置不同，在类中方法方法外。
（2）成员方法：和我们之前定义的方法是一样的，只不过先不写static
知识点二：
一．匿名对象:
1. 概念：就是没有名字的实体，也就是说这个这个实体只存在了堆内存地址，并没有栈空间(就是没有名字的对象）
2. 匿名对象的用途:
（1）当对象对方法只进行一次调用的时候，可以使用匿名对象进行简化
（为什么？因为匿名对象没有栈空间，所以只能使用一次，第二次使用一定会产生新的空间出来，如果你的方法被多次调用，且要求使用 的是同一个对象的时候，匿名就不合适了，他只适合这个对象一次性使用的时候。）
（2）可以作为实际参数进行传递或者返回（前提是你对于这个对象的使用度只有一次的时候）
3. 匿名对象的好处:
（1) 使用完毕就是垃圾，等着GC来回收
（2) 语法简洁，不需要创建对象
4. 匿名对象的缺点:就是一次性使用的
二．封装：
1. 概念：隐藏内部实现细节，提供对外的公共访问方式；一般来说，一个即将被作为对象的类，它里面所有的属性都应该是被私有化的。
2. 封装好处:
（1）隐藏了内部实现细节
（2）提高了代码的安全性
（3）相对来说，简化了代码检验程度
3.private关键字：可以对成员变量和成员方法进行修饰，被修饰后，其他类无法进行访问 只能本类进行访问。
4.public：表明该数据成员、成员函数是对所有用户开放的，提供一个公共的访问方式。
三.this关键字：
1.概念：可以将一个查找变量的方式指向了所在对象的堆空间，哪个对象使用我，我就代表哪个对象的堆空间(简单的记，this代表的就是成员变量)
2.作用：
（1）使用this来区分当前对象
（2）在构造器中使用this来调用对象本身的其他构造器
（3）this关键字还有一个重大的作用就是返回类的引用
四.static关键字：
1.概念:修饰符，被static修饰的成员变量或者成员方法，可以被所有对象共享
2.static的特点:
(1)随着的类的加载而加载
(2)优于对象存在
(3)被所有对象共享（什么样的数据需要被static修饰呢?如果你的数据需要被n个方法或者对象共享，则用static修饰）
(4)直接通过类名调用（因为static修饰的变量，在类加载的时候就已经出生了，所以可以直接通过类名进行调用，同理，也可以使用对象名 进行调用，因为对象产生的时候，static修饰的数据早就已经进入了内存）
(5)出生的顺序:加载类 -> 加载static(num2出生) -> 加载main -> 加载对象进堆(num出生) ->调用num2
4.static的注意事项:
（1）静态方法无法调用非静态数据（因为静态出来的时候，非静态数据还没出生呢，去哪儿找？）
（2）静态方法当中，不能存在任何的this关键字（如何理解？静态是随着类的加载而加载，this随着对象的创建而存在静态的优先级比this要高 太多
（3）非静态方法，可以调用静态数据也可以调用非静态数据
（简单记住:静态只能访问静态，非静态啥都可以访问）
五．public static void main(String []args){}每个关键字的作用：1）public:公共的访问修饰符
（2）static:静态方法,（如果没有static,是不是意味着JVM调用mian方法之前还得给你创建对象??）
（3） void:说明这个方法不需要返回值
（4）main:方法名(这个方法名比较特殊，由Jvm直接调用)
（5）tring []args:这个方法的形参是一个String的数组
知识点三：
一. 构造方法
1. 构造方法的特征：
(1)他的名字和类名必须完全一致
(2)构造方法没有返回值，连void也不存在
(3)不能被任何的修饰符进行修饰(权限修饰符除外)
(4)不能有return语句返回值
2. 构造方法的作用：
创建对象；给对象进行初始化
例：String name = null;
这个等于null,也有赋值的过程，这个过程是谁完成呢?
构造器完成的，这个过程被称之为隐式赋值
3. 构造器的分类:
（1）隐式无参构造器（系统默认提供）
（2）显式定义一个或多个构造器（无参、有参,自己提供）
4. 构造器的注意事项：
（1) Java语言中，每个类都至少有一个构造器
（2) 默认构造器的修饰符与所属类的修饰符一致
（3) 一旦显式定义了构造器，则系统不再提供默认构造器（一般我们即使提供了带参，一般也会自己手动的写上一个无参）
（4) 一个类可以创建多个重载的构造器(构造器的名字既然和类名一致，那么是不是意味着，同一个类当中只能出现一个名字的构造;这种情况其实就会造成构造重载:当一个构造方法无法满足我们的需求的时候，定义多个同名的构造方法。就是所谓的构造重载)。
（5) 父类的构造器不可被子类继承
（6) 所有的对象被实例，一定会去调用该类的构造方法
5. JavaBean:
(1) 定义：JavaBean其实就是一个Java的可重用组件
(2) JavaBean必须具备特征：
<1>具备封装思想
<2>类必须是公共
<3>必须提供一个无参构造(必须是公共),如果你对一个构造器进行了私有化，那么也就意味其他人无法通过这个构造器创建对象
二. 代码块
1. 定义：在Java语言当中，用{}包裹起来的被称之为代码块。
2. 代码块的分类：
（1）局部代码块:位置是在方法的范围，作用是为了限制某一段代码只能在限制的区域生效，其实就是限制作用范围。
举例:
mian(){
{
//code
}
}
（2）构造代码块:位置是在方法的范围，作用是为了限制某一段代码只能在限制的区域生效，其实就是限制作用范围
当你的这个类，存在多个构造方法被重载，且每一个重载有一个一模一样的代码的时候，可以将这些代码单独的提取出来，
放到构造代码块当中，减少了代码的编码量。
举例:
class Demo{
{
//code
}
}
（3）静态代码块:位置是类的成员位置，这个代码块使用static进行修饰。
他主要的作用是,一般是类的数据进行初始化、一些代码片段只需要被执行一次的时候、当某一些代码片段是需要被共享的时候
举例:
class Demo{
static{
//code
}
}
3. 执行顺序:静态的代码块 > 构造代码块 > 构造方法
4. 执行特点:静态代码块只会被执行一次；构造代码块、构造方法每一次实例化对象都会执行。
三. 继承
1. 定义：把多个类当中，相同的属性和行为进行单独提取到一个独立类
2. 如何实现继承？
java提供了一个关键字:extends
3. 格式: class 子类名 extends 父类名{}
4. 继承的好处:
（1）避免了代码的冗余
（2）提高了代码复用
（3）提高了代码的维护性
（4）让每个类之间产生了联系，是多态必学的
5. 继承的弊端:
其实就是他的"让每个类之间产生了联系，是多态必学的"，高内聚（就是自己独立完成工作能力），低耦合（类和类之间的联系）
"牵一发而动全身"
6. 继承的特点:
（1）java当中的继承只支持单根继承，不支持多根继承
例如：class Son extends Father,GrandFather{} //错误
（2）不过java支持多层继承
例如：class Father extends GrandFather{}
class Son extends Father{}
7. 继承的注意的问题:
（1）子类无法访问父类的私有属性和私有方法
（2）子类无法继承父类的构造,但是可以通过一些手段进行访问(super)
（3）不要仅为了获取其他类中某个功能而去继承
例如; class A{
public void show1(){}
public void show2(){}
public void show3(){}
}
class B extends A{
//在编写B类的时候，你发现A类有一个show2方法是可以自己用到的，所以你应该考虑使用继承了
//如果你使用了继承，你要考虑show1和show3要不要用?
//如果不要用，那么这个两个方法同样会被继承下来(拷贝到你类B的内存当中)
}
8. 继承，在什么时候使用？
继承的前提一定是要实现一个is-a的原则（B是A的某一种）
假设法:如果有一个A/B类，只有B类是A类的某一种，或者A类下面能够兼容B类就可以使用继承。
9. 成员变量查找的顺序问题：
（1）a.子类的成员变量和父类的成员变量名字冲突的时候
1.先去局部访问去选择，如果就有执行
2.再去本类的成员位置去寻找，有就执行
3.本类仍然不存在，则去父类的成员变量去选择
4.父类依旧不存在，就去父类的父类的去选择，到了顶层父类仍然不存在，则报错。
（2）不行，我偏偏要访问父类的数据
1.访问局部变量，直接写变量名
2.访问成员变量，写上this
3.访问父类变量，如果命名冲突，可以参考this一样的道理
访问的是父类的空间:super
10. this和super的区别：
this:本类对象的应用，哪个对象进行调用即代表哪个对象的堆空间
super:代表的是父类存储空间的标识(就是父类的地址值),子类就可以通过这个地址值去访问父类空间
11. this和super操作:
(1)调用成员方法:
this.成员方法 调用的本类的方法
super.成员方法 调用的是父类的成员方法
(2)调用成员变量:
this.成员变量 调用的本类的成员变量
super.成员变量 用的是父类的成员变量
(3)调用构造方法:
this.(...) 调用本类构造，但是this必须是第一句，而且只能是构造方法里面
super(...) 调研是父类构造，但是super必须第一句，而且只能是在构造方法里面
注意:this和super不能同时存在。因为避免同一个被子类和父类反复初始化
12. 构造方法的关系:
(1)子类当中所有的构造方法，默认第一句都是super(你不写,默认访问父类无参)
(2)为什么?因为子类是不是要继承父类的数据？ 这个父类的数据谁来初始化?是不是父类的自己的构造方法。
所以子类在自己初始化之前，是不是想要解决好父类初始化的问题，不然你怎么使用父类的数据呢？
一般父类一定要提供一个无参构造，因为子类默认访问父类无法，否则子类无法实例。
13. extends关键字：
（1）Java中使用extends关键字实现类的集成机制
（2)通过继承子类自动拥有了基类（superclass）的所有成员（成员变量和成员方法）
(3)Java只支持单继承
(4)一个子类只能有一个基类，一个基类可以派生出多个子类
知识点四：
一. 继承
1. 注意事项:
（1）子类在初始化数据之前一定会先访问父类的无参构造(默认的)，父类如果没有提供无参，就会报错。
（如何解决?）
a.手动给父类提供一个无参构造
b.通过super关键字手动去调用父类的其他构造
（2）this()和super()必须是在构造方法第一句，如果不是放在第一句，就有可能对自己或者父类的数据进行多次初始化。
2.问题：
我定义了一个手机的类，这个类包含了手机打电话、发短信、打游戏、陌陌聊天等常见的手机功能再定义了一个iphonexsMax手机，同样具备了如上功能，所以我们考虑使用继承。现在有一种情况是这样的，手机一般都具备function()这个方法里面的所有功能，这个可以理解但是，IphoneXSMax是不是还有面容解锁的功能?这是所有手机都具备的吗？不是，所以这个问题怎么解决?
(1) 在子类定义一个子类特有的方法(没问题,不是特别好，因为面容解锁也属于功能，那么命名是不应该叫function)
(2) 继承父类的某一个方法，却又发现父类的方法无法满足的时候，可以考虑使用方法重写(覆盖)
3. 方法重写:
(1)定义：当父类数据无法满足子类需求的时候，声明了和父类方法一模一样的时候，被称之为方法重写(覆盖)
(2)方法重写的注意事项:
<1>父类的私有方法不能被重写
<2>子类的重写方法必须保持和父类方法一模一样的返回值、命名、参数列表
<3>子类的重写方法的访问权限不能小于父类(一般保持一致即可，不用刻意写成不一样)
<4>如果存在static的修饰，则不存在重写的概念，重写的前提是子类继承了父类的方法，而两个方法的加载时候都应该属于对象调用;而static属于类加载，两个static完全是两个不同的空间，所以根本不存在重写的概念。只是两个static的方法名字一致，而地址值不一致。
4. 例子：
class Fu{
int num = 10;
Fu(){
System.out.println("Fu");
}
}
class Zi extends Fu{
int num = 20;
Zi(){
System.out.println("Zi");
}
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
public class ExtendsTest01 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
}
}
5. 方法重载与方法重写的区别：
(1)概念上：
方法重载：同一个类当中，方法名相同，参数列表不同，与返回值无关。
方法重写：当父类数据无法满足子类需求的时候，声明了和父类方法一模一样的时候，被称之为方法重写(覆盖)
(2)范围上：
方法重载：一个类中
方法重写：有继承关系的类中
(3)权限要求：
方法重载：无
方法重写：被覆盖的方法不能拥有比父类更严格的权限
二. 多态
1. 定义：就是某一个对象在不同时刻体现出来的状态。
2. 如何写好多态?
a.具备继承的前提
b.存在方法的重写
class 动物{
void show(){
sout("动物吃东西");
}
}
class 猫 extends 动物{
void show(){
sout("猫吃猫粮");
}
}
动物 d = new 猫();
d.show();
c.要有父类的引用指向子类的对象
Fu f = new Zi();
3. 多态当成成员访问特点:
a.成员变量： 当父类和子类具有相同的成员变量的时候，那么在多态的情况访问的是父类的成员变量
b.成员方法：当父类和子类存在相同的成员方法的时候，在多态的情况下默认方法的是父类的成员(但是因为方法重写的问题，所有最后输出的是子类的方法)
c.静态方法：当父类和子类存在相同的成员方法的时候，在多态的情况下，因为静态不存在重写的问题，所以访问的是父类的
（不管什么样的方式进行方法，除了考虑子类重写成员方法的问题，全部都是以父类为主。）
4. 多态的优点:
（1）提高了代码的可维护性(继承提供)
（2）提高了代码的扩展性(多态提供)
（3）多态可以作为形参提供，接收更广的赋值范围，避免方法的形参过度重载
（4）多态还可以作为返回值提供，返回更广的数据类型，避免因为不确定的返回数据而不能明确返回值的问题
5.多态的弊端:
无法使用子类的特有属性和功能(这不算弊端，因为本身就有解决方案)
如何解决?
a.直接创建子类对象使用(可以实现使用子类的方法的问题，但是不合理 因为丧失了多态的所有功能，而且浪费空间)
Zi zi = new Zi();
向上转型://子 - > 父 使用的是父类空间
Fu f = new Zi();
向下转型://父 -> 子 使用的是子类空间
Zi z = (Zi)f;
5. ClassCastException:类型转换失败异常（多态的向下转型当中出现的比较多的）
6. 多态的内存走向图：
三. 单例设计模式
1. 定义：
某一个类比较特殊，他并不需要被反复创建，所有人都共享这个堆区的数据即可，如果这个类被反复的实例化，将会对空间内存造成极大的浪费；个类只能被实例化一次，且所有人共享即可，这种方式就被称之为单例设计模式。
2. 单例设计模式的特点：
(1)我不能让别人创建对象(构造私有化)
(2)既然别人不能创建对象了，那这么保证一次实例
(3)写一个方法，返回当前类对象即可，这个方法必须是静态的 否则人家无法调用
(4)为了保证人家访问的是同一个对象，所以在成员位置创建了一个类对象，且是私有和静态的
(5)在写好的方法里面，将成员位置的类对象进行返回即可
四. Final关键字
1. 定义：final是一个用于修饰变量、方法、类的修饰符
2. 问题解决方法：
（1）父类的某一个数据不想让子类进行继承的话,怎么办?
父类进行私有化
（2）父类某一个数据，可以让子类继承，但是不能修改?
使用final关键字
3. final关键字的特点：
（1）final如果修饰的是变量，则该变量转变成为常量,程序不能进行重新(二次)赋值
（2）final如果修饰的是方法，则该方法无法被子类进行重写,但是可以被子类继承
（3）final如果修饰的是类,则该类无法被继承
（4）final如果修饰的是对象，则该对象无法改变其堆空间的地址值
知识点五：
一. 多态
1. 多态情况下虚拟方法调用:
子类当中定义了和父类同名同参数的方法，在多态的情况下，将此时父类的那个方法称之为"虚拟方法"；父类根据赋给他的不同子类对象，动态的调用该子类的方法，这样的方法调用在编译器是无法确定的，所以也被称之为动态绑定。
例子：
Person s = new Student();
s.getInfo();
我们在编译s的Person类的时候，而方法的调用是在运行时确定的，所以调用的是Student的getInfo方法
2. 关于多态当中方法重写的或者重载的问题:
(1) 重载:在同一个类当中，出现了方法名相同参数列表不同，与返回值无关。编译器会根据方法的不同参数列表，对方法名进行标识修饰，对于编译器而言，这些同名的方法其实已经被划分不同的标识地址，他们在编译的时候其实就已经分好类了，这个其实也被称之为"静态绑定"/"早绑定"。
(2) 重写：对于多态的这种情况，如果存在了方法重写，因为编译器在编译的时候涉及到了N个类，他无法确定你究竟是调用哪个类，或者说是不是有进行重写。 因为类不是被同时加载，所以在类加载的时候根本无法确定你到底调用的是哪个类的哪个方法，只有你在运行的时候，才内确定你的内存空间是什么,这种也被称之为"动态绑定"/"晚绑定"。
(3) 多态采用的是动态绑定，所有是运行时确定。
(4) 成员方法:因为方法存在重写的问题，如果是重写则一定执行子类
(5) 成员变量:变量不存在重写，所以一定以左边栈内存为主
(6) 静态资源:因为不存在，所以一定左边的栈内存位置
3. instanceof操作符:
(1) 格式： x instanceof A:检查x是否为A类的对象，返回值为boolean类型
(2) 注意:
<1>x必须是A的直属类，或者是父子关系类，否则编译错误
<2>如果x是A的子类，或者A的孙子类，其结果也是true
<3>这个操作符一般使用多态的向下转型当中，避免类型不同而操作类型转换失败
4. 对象的类型转换问题:
(1) 基本数据类转换:
<1>自动转换:小的数据可以自动的转化为大的数据:
例如：int a = 10; long l = a;
<2>强制转换:将大的数据类型强制赋值小的数据类型
例如：long l = 200; int a = (int)l;
(2) Java的对象的强制类型转换也被称之为造型转换:
<1>从子类转换父类直接进行自动转换
<2>从父类到子类必须进行强制转换
<3>无继承关系的情况下，所有引用数据的相互转换都是非法
<4>在转换之前，如果代码复杂，建议您使用instanceof进行类型校验
二. 接口
1. 接口的特点:
(1) 接口使用interface进行定义:interface 接口名{}
(2) 如果一个类需要实现一个接口，则使用implements:class 类名 implements 接口名{}
(3) 接口无法进行实例化,使用具体的实现类来进行实例:Eraser e = new ClearPencil();
(4) 接口会不会有子类?
<1>接口可以继承接口，但是意义不大 因为继承的还是一个接口
<2>具体类可以实现接口，但是不能继承接口(具体类实现接口是推荐方案，一般只会这么做)
<3>抽象类可以实现接口，但是不能继承接口
2. 接口的成员特点:
(1) 成员变量:只能定义常量，必须是静态常量
例如： 默认语法为:
public final static int num = 20;
却什么关键字，系统默认给你补什么关键字，你无法控制。
(2)成员方法:只能是抽象方法
例如：默认修饰符：public abstract void show();
(3)构造方法:没有构造方法，因为对于接口来说，构造方法没有任何用途，因为没有任何数据需要进行初始化
3.继承和实现区别(类和接口的区别):
(1)类和类:继承关系(extends)，而且只能是单继承
(2)类和接口:实现关系(implements),可以是多实现,而且可以继承一个类的时候，仍然可以实现多个接口
(3)接口和接口：继承关系，可以是单根继承，也可是多根继承
4.接口的作用：约束、规范、标准、扩展
5.什么时候使用抽象或使用接口？
（1）抽象：适合的场景是在继承的前提下，当父类出现了无法具体的行为的时候，要求子类必须具体化的过程。
（2）接口：适合使用的场景是在某一些类无法满足功能的时候，进行扩展的行为，且某一些行为需要被约束的时候。
6.抽象和接口的区别：
（1）接口是一个比抽象更加抽象的行为，以为抽象类允许存在非抽象方法，而接口只能抽象方法。
（2）抽象类允许存在常量、变量以及静态，而接口只能是常量静态。
三. 模板设计模式
1. 概念：
例如以后再开发当中，可能会遇到不同的算法，而这个算法需要被经常使用，这个算法只有某一个部分是其他程序进行编写，而大部分是进行固定的。此时这种情况，我们就应该将固定的代码包裹成一个方法，不固定的代码要求其他程序员进行填充。这种模式其实就是模板设计模式。
2. 步骤：
（1）定义一个骨架方法(固定的代码片段)
（2）定义一个强制要求填充的代码片段(抽象方法)
（3）调用骨架方法，此时也会要求其他人必须填充不固定的代码(继承和多态的前提)
四. 抽象类：
1. 概念：
当一个类的大部分行为是不具体的，那么这个时候，就应该将这些方法进行抽象，那么谁来继承这个类，子类就要求必须将该方法进行具体，父类不能具体方法，强制要求子类去实现。
2. 抽象类的特点:
（1）用abstract关键字来修饰一个类，这个类叫做抽象类
（2）用abstract来修饰一个方法，该方法叫做抽象方法；抽象方法：只有方法的声明，没有方法的实现。以分号结束(因为一个抽象方法，本身就不是一个具体，何必去写代码)
（3）含有抽象方法的类必须被声明为抽象类。
（4）抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写，那么怎么去使用抽象，就是多态，利用其具体的子类来进行实例。
（5）不能用abstract修饰变量、代码块、构造器
（6）不能用abstract修饰私有方法、静态方法、final的方法、final的类。
（6）不能用abstract修饰私有方法、静态方法、final的方法、final的类。
（7）抽象类的子类：
a.子类必须重新父类的所有抽象方法
我能不能不重写?
能，因抽象类子类依旧还可以是抽象类，那么就继续用abstract修饰子类就可以了
b.如果子类不想继续抽象，就必须重新父类的所有抽象方法。
总结一句话:
强制要求子类必须实现父类没有完成方法，父类进行抽象，子类进行具体，谁继承谁负责
