前期准备01-2.1
一、程序的流程控制语句
①判断结构(if)
格式：
❶if(条件表达式)
→{条件表达式为true，执行此语句；}
❷if(条件表达式)
→{条件表达式为true，执行此语句；}
→else
→{条件表达式为false，执行此语句；}
❸if中嵌套if或者else中嵌套if
❹if-else结构，有时可以简写为三元运算符，如：变量 = 三元运算符；好处是，可以简化代码；局限性是，运算必须要有结果。
②选择结构(switch)
格式：
switch(表达式)
{
→case 取值1：
→→→→执行语句；
→→→→break；
→case 取值2：
→→→→执行语句；
→→→→break；
→default：
→→→→执行语句；
→→→→break；
}
❶switch语句中的表达式的值只能是四种类型：byte，short，int，char。
当表达式的值满足了某个case的取值时，将在此处一直向下执行，直至遇到break或者switch语句结束。
❷多个case可以共同执行一条语句，如判断季节；case之间也可以没有顺序，可以任意排列，只是先执行第一个。
❸default语句后加了break，就可以放在switch语句的任意位置；如果default语句后没有加break，当它后面还有属于switch语句的代码时，执行到它之后，还会继续向下执行，一直到switch语句结束或者遇到break为止。
❹if的使用范围更广，switch适合判断具体数值不多，且数值属于byte，short，int，char四种类型的情况，效率更高一些，代码更直观。
③循环结构(while，do-while，for)
❶while语句
格式：
while(循环条件表达式)
{循环体(参与循环的语句)；}
注意：while()后没有分号，否则while一旦被执行就会进入无限循环。
❷do-while语句
格式：
do
{循环体(参与循环的语句)；}
while(循环条件表达式)；
注意：while()后有分号。
其特点是：无论条件是否满足，循环体至少被执行一次。也可以在循环体中，再加上条件判断(可以使用if语句)，来控制循环体的执行。
❸for语句
格式：
for(初始化表达式；循环条件表达式；循环后要操作的表达式)
{循环体(参与循环的语句)；}
当初始化表达式中有多个表达式时，用逗号隔开；循环后要操作的表达式中有多个表达式时，用逗号隔开。
for语句中各表达式的执行顺序：初始表达式只执行一次，然后判断循环条件，为true就执行循环体，然后再执行循环后要操作的表达式，接着继续判断循环条件，一直重复这个过程，直到条件不满足为止，结束循环。
while与for可以互换，区别在于for为了循环而定义的变量在for循环结束后，就在内存中释放了，而while循环使用的变量在循环结束后还可以继续使用。如果参与循环的变量不被外部使用，用for更合适。
最简单无限循环格式：while(ture){}，for(;;){}
for的嵌套循环可以控制有规律的二维空间。
④关键字break(跳出)
break可以跳出选择语句(switch)，循环语句(while、do-while、for)。
⑤关键字continue(继续)
continue应用于循环语句中(while、do-while、for)。表示只结束本次循环，继续执行下一次循环。
注意：break和continue离开了应用范围，其存在是没有意义的。当这两个语句单独存在时，其下面的语句将执行不到。标号(标记名：)可以让这两个语句能够作用于标号所指定的范围。
二、函数(即方法)
①函数的定义
❶函数就是定义在类中的具有特定功能的一段小程序。
❷函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，...)
{
→执行语句；
→return 返回值；
}
修饰符：限定函数的访问权限；标明函数的状态。
返回值类型：函数运行后所得结果的数据类型，函数可以没有返回值，用void修饰。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储函数调用者传递给函数的实际参数。函数可以是空参数函数。参数是有顺序的，应用于函数的重载。
实际参数：传递给形式参数的具体数值或引用，参与函数功能的实现。
return：用于结束函数，若需要则传递返回值给该函数的调用者。
返回值：该值会返回给函数的调用者。用void修饰的函数没有返回值。
②函数的特点
❶可以将功能代码进行封装
❷方便功能的复用
❸只有在被调用时才被执行
❹函数的出现提高了代码的复用性
❺对于函数没有具体返回值的情况，返回值类型用void表示，这时该函数的return语句如果是在最后一行，就可以省略不写。
注意：函数只能调用函数，不可以在函数内部再定义函数。
③函数的应用
程序中实现应用功能的最小单元即为函数，函数的功能就是对实际应用的一种抽象和提取，它可以使得对实际应用的操作更加高效。
④函数的重载
在同一个类或子父类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型或者参数的排列顺序不同即可(函数同名，参数不同)。
❶重载的特点：
与返回值类型无关，只看参数列表。参数是有顺序的。
❷重载的好处：
方便于阅读，优化了程序设计。
三、数组
①数组的定义
数组就是一个集合或者容器，用于存放同一种类型的数据。
❶数组的好处：可以自动给数组中的元素从0开始编号，方便对数组中各个元素的操作。数组中的第i个元素为：数组名[i-1]。
❷数组中的元素可以是基本数据类型，也可以是引用数据类型。
②数组的格式：
数据类型[] 数组名 = new 数据类型[元素个数(即数组长度)]；
数据类型[] 数组名 = new 数据类型[]{元素1，元素2，...}；
对于数组的两种显式初始化方式，定义了数组的长度就不能再罗列数组中的元素，反之亦然。
❶数组名作为一个变量存在于栈内存中，离开其使用范围即被自动释放。
❷数组中的元素，存在于堆内存中，当其不被引用时，只能依靠垃圾回收机制才能被释放掉。
❸数组名的取值，是数组元素在堆内存中存放的首地址，数组名只是一个引用变量，当其离开作用范围或者通过对其赋值null，可以让它结束引用，使得其之前的引用数据变为垃圾(只是在堆中数据被单引用时生效)。
③数组的操作
获取数组中的各个元素的值，要使用遍历，通过循环语句实现。
❶选择排序
从数组的第一个元素开始，将当前位置上的值，同其之后的每一个值进行比较，将符合条件的值换位到当前位置，然后从第二个元素开始再次循环操作，直至数组的最后一个值，完成对数组中各个元素的排序。
对于选择排序，数组中的第一个位置上的值，最先完成排序动作。
❷冒泡排序
从数组的第一个元素开始，将当前位置上的值，同后面的第二个元素的值相比较，符合条件即换位，然后将第二个元素的值同其后面的值相比较，符合条件再次换位，以此类推，一直比到数组的最后一个元素；然后从数组的第一个元素开始，再次循环操作。每次循环都比前一次少比较一个元素的值，即经过前一次比较之后的最后一个元素，直至操作到只剩第一个元素为止。
对于冒泡排序，数组中的最后一个位置上的值，最先完成排序动作。
❸排序相关知识点
排序中都会涉及到换位操作，可以将此操作封装成一个函数。
数组排序：
java.util.Arrays.sort(object[] a)
(['dʒa:və][ju'til][ə'reiz][sɔ:t]['ɔbdʒikt])
根据元素的自然顺序，对指定的对象数组中的元素，按升序进行排序。要保证数组中的所有元素都是可相互比较的。
❹折半查找
通过移动数组中最小角标和最大角标的位置，来判断数组中不断变化的中间角标位的值，是否与所查找的元素相等，从而实现查找的功能。
折半查找返回角标值为-1时，表示数组中没有此元素，因为数组的角标最小是0。
折半查找可以提高效率，但是要求数组必须是有序的。
④二维数组
数组中的元素依然是数组。
格式：
❶元素类型[][] 数组名 = new 元素类型[m][n]；
此数组中有m个一维数组元素，每个一维数组中有n个值。
❷元素类型[][] 数组名 = new 元素类型[m][]；
此数组中有m个一维数组元素，每个一维数组默认初始化为null。可以分别给每个一维数组进行显式初始化，如：a[i]=new int[j]。
⑤定义数组时需要注意的地方：
一维数组：int[] x；int x[]
二维数组：int[][] x；int x[][]；int[]x[]
四、面向对象
面向对象是相对于面向过程而言的。面向过程强调的是功能、行为；面向对象将功能封装进对象内部，强调具备了功能的对象。面向对象是基于面向过程的。
①类与对象的关系：
类是一种描述，是一个概念，是抽象的。
对象是一个实际存在的个体，是类的实现，是物质的。
类决定了对象的属性和功能，对象丰富了类的表现形式。
类中的成员变量决定对象的属性，随着对象的创建而实现(静态成员变量在数据区中，非静态成员变量在堆内存中)；类中的成员函数决定对象的功能，需要对象的调用才能实现，存在于方法区(共享区、数据区)中。
②创建对象：
一个类，只有创建了对象，才能实现具体功能，才有其存在的意义。
格式：
类名 对象名(标示符) = new 类名()；
❶一个类可以创建无限多个对象，每一个对象的生命轨迹，可以自由书写。
❷对象名是一个引用型变量，属于类类型，它指向该类的一个对象，这个对象的属性(非final型)的取值是可以变化的，功能的实现是可以选择的。
❸匿名对象：当对一个对象只是被使用一次时，可以使用匿名对象；匿名对象可以作为实际参数，进行值的传递。
五、面向对象的三大特征之一：封装
①封装的定义：
封装是指隐藏对象的属性和实现细节，仅对外提供公共访问的方式。
②封装的好处：
将变化隔离，便于使用，提高复用性，提高安全性。
③封装的原则：
❶将不需要对外提供的内容都隐藏起来。
❷把所有的属性都隐藏起来，只对外提供公有方法对其进行访问。
④封装的实现：
对象是对类的实现，是对类中的成员变量和成员函数的实现。把对象的属性和实现细节隐藏，就是把类中的成员变量和成员函数隐藏。对类中的成员甚至类本身进行隐藏，使用的是可以限制访问权限的修饰符。
❶权限修饰符private：
私有的，用于修饰类的成员(包括成员变量、成员函数和内部类)，私有之后的成员，只能被本类中的成员所访问。
私有只是一种表现形式，若是私有成员有必要被外部访问，可以向外部提供能够访问内部私有成员的公有的方法。通过该方法，来判断外部的访问是否合理，合理即允许访问，不合理即不允许访问。公有方法的功能，是可以进行逻辑判断，提高了代码的健壮性。
❷其它权限修饰符：public(公有)、protected(保护)
六、构造函数
①构造函数的特点：
函数名与类名相同，不用定义返回值类型，不可以写return语句。
相对于每个不同的对象而言，其自身的构造函数只被执行一次。
②构造函数的作用：
给对象进行初始化，包括对象的属性和对象的功能。对象一被创建，就会调用与之对应的构造函数。
③默认构造函数：
❶若是类中没有定义构造函数，系统会自动添加一个无参数的构造函数，即：类名(){}。
❷若是类中定义了构造函数，则系统就不再自动添加。
❸当类中定义了非空参数的构造函数，一般还要再定义一个空参数的构造函数。因为，当此类被其子类继承时，其子类的所有构造函数中，都会默认包含一个父类的空参数构造函数。
❹默认构造函数的权限和所属类的权限保持一致，其权限随着类权限的变化而变化。当然，可以做显式的修改。
④构造函数的重载：
多个构造函数的存在，是以函数重载的形式完成的。它们决定了不同对象的创建，可以拥有不同的初始化属性。
⑤构造代码块：
❶格式：
{需要执行的代码；}
❷作用：
给对象进行初始化。对象一被创建就会运行，而且优先于构造函数执行。构造代码块中定义的，是不同对象所共性的初始化内容。
❸构造代码块和构造函数的区别：
构造代码块是给所有对象进行统一的初始化，而构造函数是给其所相对应的对象进行初始化；构造代码块的执行顺序在构造函数之前。
⑥构造函数的私有化
❶构造函数是可以被私有化的，当一个类中的所有的构造函数都被私有化后，该类就不能够被外部的程序创建它的对象了。
❷单例设计模式，应用了构造函数的私有化，并在类中自己创建了一个唯一的对象，供外部使用(饿汉式、懒汉式)。
❸工具类中的构造函数都是私有的。工具类中的函数都是静态的，可以由类名直接调用，没有创建对象的必要性。
⑦关键字this：
含义有两个：一是调用当前实例对象；二是调用本类的另一个构造函数。
this的应用：
❶当定义成员函数时，函数内部要用到调用该函数的对象，就用this来代表这个对象。也用于区分同名的成员变量和局部变量。
❷一个类中的成员被使用，都必须要有对象调用才可以。有好多的地方，由于是在本类中的调用，从而省略了this，但它必然存在。尤其是，在多态的应用中，极其重要。
❸在构造函数中调用本类的另一个构造函数时，this一定要放在该构造函数的第一行，被优先执行。
七、静态
①关键字static：
用于修饰类的成员(包括成员变量、成员函数和内部类)。
②静态的特点：
❶被static修饰的成员随着类的加载而加载，优先于对象而存在，被该类的所有对象所共享。
❷当类中的成员被静态修饰后，除了可以被本类的对象调用之外，还可以被类名直接调用。
❸静态成员只能访问静态成员。
❹静态方法只能覆盖静态方法。
③类变量和实例变量的区别：
❶存放位置不同
类变量(即静态的成员变量)，存储在方法区(共享区、数据区)中，实例变量(即非静态成员变量)，随着对象的创建而存在，存储在堆内存中。
❷生命周期不同
类变量的生命周期最长，随着类的消失而消失；实例变量的生命周期，随着对象的消失而消失。
④静态修饰符使用的注意事项：
❶静态方法只能访问静态成员；非静态方法既可以访问静态成员，也可以访问非静态成员。
❷静态方法中不可以使用this、super关键字，因为静态优先于对象而存在。
⑤静态的利弊：
❶好处
将对象的共享数据进行单独存储，节省内存空间；可以被类名直接调用。
❷弊端
对于成员变量，生命周期过长；对于成员函数，其内部只能访问静态成员，访问有局限性。
⑥静态的定义规则：
❶对于类变量，当所有的对象中出现共有数据时，该数据应该被静态修饰，存储于方法区(共享区、数据区)中。而实例变量，是每个对象特有的数据，要定义成非静态，存在于堆内存中。
❷对于成员函数，当功能内部没有访问到非静态数据(对象的特有数据)时，该方法可以定义为静态的。若是访问到了非静态数据，就不可以定义为静态的。
⑦静态代码块：
格式：static{需要执行的语句；}
特点：随着类的加载而执行，只执行一次，并且优先于主函数。
作用：用于给类进行初始化。
⑧静态的应用-工具类：
工具类，即为了完成某些特定的功能，而将这些作用相同的功能进行封装的类。
❶工具类中的方法都是静态的，可以通过类名直接调用。工具类中的构造方法都是私有的，因为用类名就可以实现对象所具有的功能，没有创建对象的意义。
❷将工具类中的构造函数私有化，可以统一工具类的调用方式，更加严谨。
八、主函数：
主函数是一个特殊的函数，是静态的。作为程序的入口，被JVM识别并调用。
①主函数的定义：
public：代表着主函数的访问权限是最大的。
static：代表主函数随着类的加载已经存在了。
void：代表主函数没有具体的返回值。
main：不是关键字，但作为一个特殊的单词，可以被JVM识别。
(String[] args)：主函数的参数列表，参数的类型是一个字符串类型的数组，该数组中的元素是字符串。
②主函数的识别：
❶主函数的格式，是固定的。
❷JVM只识别固定参数列表的主函数，将其作为程序的入口。
❸拥有不同参数列表的其它同名函数，能够以函数重载的方式与主函数同时存在，但不能被JVM识别。
③主函数的调用：
❶JVM在调用主函时，传入的是一个字符串类型的数组(new String[0])。
❷因为主函数是静态的，可以在程序运行的同时，向主函数中传值。
❸主函数会将收到的数据，封装和存储进其自身的数组中，并以数组角标的形式，为每一个传入的元素进行标号。主函数的数组长度，由所传入的数据决定，其格式为：java 函数名 字符串 字符串 ...
④对象的初始化过程：
当用new关键字创建了一个对象之后，系统会对其进行相应的初始化。
类名 对象名 = new 类名()；
❶先在内存中加载其对应的类的字节码文件(类名.class)
❷执行该类的static代码块，给类进行初始化
❸在栈内存中给对象名变量分配空间
❹给栈内存中的对象名进行默认初始化，赋值null
❺在堆内存中开辟空间，分配内存地址
❻在堆内存中建立对象的特有属性，并进行默认初始化
❼给对象的特有属性进行显示初始化
❽执行该类的构造代码块，给对象进行共有属性的初始化
❾给对象进行其所对应的构造函数初始化
❿将对象在堆内存中的首地址，赋值给栈内存中的对象名，实现引用
⑤对象的调用过程：
❶对象调用的过程，是在栈内存中完成的
❷对象调用的实现，是在堆内存中完成的
❸对于静态成员变量，对象在栈内存中的引用，指向对象在堆内存中的实体，堆内存中的实体有相应的引用，指向方法区中的目标数据，从而实现调用。
❹对于非静态成员变量，对象在栈内存中的引用，指向对象在堆内存中的实体，堆内存中的实体直接调用，存在于堆内存中的自身的相应的变量，从而实现调用。
❺对于成员函数，与静态成员变量的调用方式相同。
❻每一个线程都会有一个方法调用栈，用来跟踪该线程运行中的一系列的方法调用过程。栈中的每一个元素就被称为栈帧，每当线程调用一个方法的时候，就会向方法栈压入一个新帧。这里的帧用来存储方法的参数、局部变量和运算过程中的临时数据。
九、Java文档注释的编写：
Java中的注释有三种：
//：单行注释
/*(被注释的信息)*/：多行注释
/**(被注释的信息)*/：Java文档注释专用
注释的特性：多行注释只可以嵌套单行注释，不可以嵌套多行注释。
①Java注释文档的制作前提：
若要制作一个类的注释文档，则该类必须是共有的，才能够向外暴露其内部的功能。
②Java文档注释的作用：
对程序的功能进行说明，方便程序开发者使用该程序的功能。
③Java文档注释的格式：
❶将该程序的所有功能，作者信息，版本信息等放在类的前面。
@author：作者信息
@version：版本信息
❷将该类中各个方法的具体功能，所需要传递的参数列表的形式，返回值类型等放在方法的前面。
@param：各个参数的说明
@return：返回值说明
④注释文档的生成方法：
运行：javadoc -d 指定文件的存放目录 类的源文件全名
❶如果需要生成作者和版本信息，需要在-d后面单独添加-author、-version，各个字段间用空格隔开。
❷如果磁盘中没有指定的目录，则系统会自动新建一个。
⑤注释文档的生成规则：
❶在程序中编写的注释文档，系统只会抽出被public和protected修饰的部分，其它部分不会被抽取。
❷默认构造函数的权限和所属类的权限保持一致，其权限随着类权限的变化而变化。
十、单例设计模式
设计模式的意义：解决某一类问题最行之有效的方法。
Java中有23种设计模式。
①单例设计模式：
解决一个类在内存中，只存在一个对象的问题。
②单例设计的规则：
❶将构造函数私有化。
❷在类中创建一个静态的本类对象。
❸提供一个公有并且静态的方法，可以让外部获取到这个对象。
③单例设计的实现方法：
❶饿汉式
该类一被加载，就创建一个对象。
特点：安全，方便。
❷懒汉式
当该类的方法被外部调用时，才创建对象，也叫做对象的延时加载。
特点：在多线程时，为了解决安全问题，要使用双重判断，并且在第二次判断之前，加上同步。效率比较低，因为判断即会消耗资源。
④单例的好处：
❶内存中只有一个对象，节省系统开销。
❷实现了本类对实例化的有效控制。
十一、面向对象的三大特征之一：继承
①继承的由来：
对类的描述的不断抽取，可以形成更加抽象的类；反之，对类的描述的不断扩展，可以形成更加具象的类。
②继承的特点：
❶提高了代码的复用性。
❷让类与类之间产生了关系，实现了程序的多态性。
❸不能为了获取其它类的功能，为了简化代码而继承。必须是类与类之间有所属关系，才可以继承。所属关系即is a。
③关键字extends：
继承，表示一个类是另一个类的子类。
❶Java只支持单继承，也支持多实现。
❷Java支持多层继承，也就是一个继承体系。
❸若要使用某个体系，应先查阅父类的描述，因为父类中定义的是该体系中的共性功能。在使用这些功能时，要创建最子类的对象，原因有两个：一是有可能父类不能创建对象；二是创建子类对象可以使用更多的功能，包括共性的功能，也包括特有功能。(即查阅父类功能，创建子类对象使用功能)
④关键字super：
含义有两个：一是表 示父类对象的引用；二是调用父类的构造函数。
❶子类中的所有的构造函数都默认包含一个父类的空参数构造函数，即super()。
❷使用super调用父类的构造函数时，一定要放在子类构造函数的第一行，被优先执行。
❸在子类构造函数中，super与this不能同时存在。
❹若要子类构造函数调用父类的非空参数构造函数，需要显式指定。
⑤函数的覆盖(重写)：
子父类中出现了同名函数，子类直接调用自身的方法，父类的方法就被隐藏了起来，如同父类的方法被覆盖(重写)。
❶覆盖的意义：
子类拥有父类的功能，却有与父类不同的实现方式，这时就保留父类功能的定义，重写父类功能的内容。
❷覆盖的应用：
可以用于功能的扩展。
❸覆盖的前提：
子类覆盖父类，必须保证子类权限不小于父类权限；静态只能覆盖静态。
❹覆盖的格式：
子父类函数的定义要一模一样，包括修饰符、函数名、参数列表。
⑥子类的实例化过程：
❶系统在加载子类之前会先加载其父类，并逐级上溯。
❷子类对象在创建时，会先加载父类的内容，再加载自己的内容，包括静态代码块、构造代码块、构造函数。子父类的内容同时存在。
⑦关键字final：
含义是最终，可以修饰变量（包括成员变量和局部变量）、函数和类。表示变量只能被赋值一次，之后以常量的形式存在；表示方法不能被重写；表示类不能有子类。
❶内部类被定义在局部位置上时，只能访问被final修饰的局部变量。
❷final的应用：
当描述事物时，有一些数据的值是固定的，为了增强阅读性，都会给这些值起个名字，然后用final修饰，如：final PI=3.1415926；。
⑧抽象类：
❶关键字abstract：
抽象方法、抽象类的修饰符。抽象的方法没有方法体，直接以分号结尾。只要该类中有一个抽象的方法，则该类必须声明为抽象类。抽象类不能用new创建对象。抽象类中可以没有抽象的方法，只是用来限制该类不能够创建对象。
❷抽象类中功能的实现方式：
抽象类只有被其子类继承，并且将其所有的抽象方法都覆盖之后，通过创建其子类的对象，来调用子类自身的方法，从而实现该抽象类的功能。
❸抽象类的应用：
当在描述事物时，如果出现了有明确的功能，却拥有不确定的实现方式时，就可以通过定义抽象类来进行描述。
抽象类可以强制其子类必须覆盖它的抽象方法，否则无法创建对象。
❹模板设计模式：
当定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而且确定的部分在使用不确定的部分。那么，就可以将不确定的部分以抽象的方式暴露出去，由该类的子类去完成。
⑨接口：
可以理解为，接口是一种特殊的抽象类。接口中的所有方法都是抽象的，同时，接口中只有常量。
❶关键字interface：
用于定义接口，功能同class。接口中的常量(全局常量)和方法都有固定的格式，若是修饰符出现空缺，系统会为其自动补齐。
常量：public static final 数据类型 常量名=常量值；
方法：public abstract 返回值类型 方法名(参数列表)；
❷关键字implements：
用于实现接口，功能同extends(is a)类似,可以理解为：like a。
一个类可以多实现，也可以在继承的同时再多实现，多实现时各个接口间以逗号隔开。若是子类中没有将接口中的抽象方法全部覆盖，则此类是一个抽象类。
接口与接口间是继承关系，可以多继承。接口的多继承会有风险，有可能会包含返回值不同的同名函数，此时编译会失败。
❸实现与继承的区别：
继承表示子类必须是父类中的一员，实现表示子类可以拥有接口的功能，不是必须的。继承是一个体系，接口是一种扩展。
❹接口的特点：
接口是对外暴露的规则(降低了耦合性)；接口是程序的功能扩展；接口可以被多实现；接口间可以多继承。
十二、面向对象的三大特征之一：多态
多态，可以理解为事物的存在拥有多种表现形态。
由于继承的存在，可以让事物从属于一个体系。这个事物本身既是一个特殊的个体，又是其所属体系中的一个成员，从而可以拥有多种表现形态。
①多态的体现：
❶将父类的引用指向子类的对象，或者说父类的引用可以接收子类的对象。
❷函数中也存在多态，函数的重载和重写(覆盖)，就是同名函数拥有不同的表现形式，也是一种多态的体现。
②多态的前提：
类与类之间有关系，要么继承，要么实现。
③多态的好处：
提高了程序的扩展性和后期的可维护性。
④多态的弊端：
❶父类的引用只能访问父类的成员。
❷调用时，对于成员变量和静态成员函数，指向的是父类的数据；对于非静态成员函数，调用的是子类的非静态成员函数(存在函数覆盖的就调用子类的成员函数，没有被覆盖的成员函数子父类共享)。
⑤多态中对象的类型转换：
❶当父类引用指向子类对象时，子类对象会被系统自动提升为父类的类型，即向上转型。
❷若想将被提升了类型的子类对象还原成自己的类型，需要进行强制转换，即向下转型。
❸引用数据类型的转换方式，与基本数据类型的转换方式相同。
❹不能够将一个父类对象强制转换成它的子类的类型。
❺不能够将一个非本类类型的对象，转换成本类的类型。
❻对于多态而言，其时自始至终都是子类对象在做类型的转换。
⑥关键字instanceof：
测试一个对象是否是某个类的实例。
❶当判断一个对象是否属于某个类时，若是需要多重判断的话，应将最抽象的类(该体系中最父类的类)写在最后面。
❷instanceof一般应用于两种情况下：一是子类的类型是有限的；二是只使用有限的子类类型。
⑦多态中的非静态成员函数的特点：
❶在编译时期，参阅引用型变量所属的类中，是否有被调用的方法，如果有则编译通过，如果没有则编译失败。
❷在运行时期，执行对象所属的类中，该对象自己的方法。
❸非静态成员函数在多态中调用时，编译看左边，运行看右边。也就是说，编译看父类，运行用子类。
⑧多态中的静态成员函数的特点：
无论编译还是运行，都看左边。因为，静态随着类的加载而加载，只要父类的引用还在，则必指向父类的静态成员函数。
⑨多态中成员变量的特点：
无论编译还是运行，都看左边(引用型变量所属的类，即父类)。
⑩多态的应用：
当接口实现多态时，既可以实现接口自身的功能扩展，又可以实现其调用者的程序扩展。
⑪Object['ɔbdʒikt]类：
Object类是类层次结构的根类。每个类都使用Object作为超类。所有对象(包括数组)都可以实现这个类的方法。
调用Object类中的方法，也是多态应用中的一种。
❶equals['i:kwəlz]方法：
public boolean equals(Object obj)
比较其它某个对象是否与此对象相等，对于引用对象比较的是地址值。
通常一个类会对Object类的equals方法进行覆盖，但是，如果比较中用到了该类中的特有数据，那么就需要进行类型判断以及类型转换(向下转型)才可以继续比较。
❷toString['tu:ˌstriŋ]方法：
public String toString()
返回该对象的字符串表示形式(类名@哈希值)。
其另一表现形式为：
getClass().getName()+’@’+Integer.toHexString(hashCode())
(['getˌkla:s]['getˌneim][æt]['intidʒə]['tu:ˌheks][striŋ]['hæʃˌkəud])
通常一个类会对Object类的toString方法进行覆盖，返回自己定义的表示信息，便于理解。
❸getClass方法：
public final Class<?> getClass()
返回此对象运行时该类的Class对象。该类的Class对象是由表示该类的static synchronized方法锁定的对象，即该类的字节码文件。
返回形式为：Class 类名
Class<T>：T表示由此Class对象建模的类的类型，即类名。
例如：String.class的类型是Class<String>。如果将被建模的类未知，则使用Class<?>。
❹hashCode方法：
public int hashCode()
返回该对象的哈希码值。一般是通过将该对象的内部地址转换成一个整数来实现的。
❺wait方法(只用于同步)
public final void wait()
throw InterruptedException([intə'rʌptid][ik'sepʃn])
当前线程等待，一直持续到到其它线程调用此对象的notify()方法或者notifyAll()方法。
如果当前线程在等待通知之前或者正在等待通知时，任何线程中断了当前线程，抛出中断异常。
当前线程必须拥有此对象监视器(即同步锁)。
❻notify(['nəutifai])方法(只用于同步)
public final void notify()
唤醒在此对象监视器(同步锁)上等待的单个线程。如果所有线程都在此监视器(同步锁)上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。
❼notifyAll方法(只用于同步)
public final void notifyAll()
唤醒在此对象监视器(同步锁)上等待的所有线程。
