Java基础学习记录（一）

之前从头开始学习了一遍Java基础，记录一下，（主要学习途径是观看黑马程序员视频，如果有需要，可以留言。）

---

Java语言是一种完全面对对象，安全可靠，与平台无关的语言。

Java的跨平台性是指：通过Java语言编写的应用程序在不同的系统平台上都可以运行。
Java跨平台性的原理是：只要在需要运行Java应用程序的操作系统上，先安装一个Java虚拟机（JVM Java Virtual Machine）即可。由JVM来负责Java程序在该系统中的运行。
JRE（Java Runtime Environment）Java的运行环境
包括Java虚拟机（JVM）和Java程序所需的核心类库等，如果需要运行一个开发好的Java程序，计算机只需要安装JRE即可。
JDK（Java Development Kit）Java 开发工具包
JDK是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就不用再单独安装JRE了。
其中包含的开发工具有：编译工具（javac.exe）、打包工具（jar.exe）等
（使用JDK开发完成的java程序，交给JRE去运行。）

JDK、JRE、JVM及其他开发工具包的关系：

配置环境变量：
1.永久设置：
在电脑/属性/高级系统设置/环境变量中，可将常使用的执行文件的目录添加进Path中，如下载好的JDK/bin的路径，若担心多次改变新添的路径，误操作了原来的电脑设置，可新建变量=路径，然后在path中使用%新建变量%来动态获取路径。
2.临时设置：
在dos命令行中使用set path = //*，可临时设置环境变量，但在关闭该dos后该设置失效。

使用dos命令行编译运行java程序的操作流程。
1.将Java代码编写到扩展名为.java的文件中。
2.通过javac命令对该java文件进行编译。
3.通过java命令对生成的class文件进行运行

java命令的寻址规则：
如果未曾设置classpath，则java命令寻找当前目录下的.class文件运行。
如果设置了classpath，则java命令首先寻找classpath下的目标文件，若classpath = *后有‘；’，则若是未能在classpath寻到目标文件，继续到当前目录寻找，若不在classpath后加‘；’，则在classpath中寻找后不再到当前目录寻找。

Path与Classpath的寻找优先级区别：
Path首先在当前目录下寻找目标文件，再到设置的环境变量中寻找。
Classpath首先寻找设置的Classpath，再到当前目录寻找（若classpath的末尾不加‘；’，则不再寻找当前路径）

若是在文件夹中选择了隐藏已知文件扩展名，可能看见的是一个.java实际上该文件却是一个txt文件。

Java中注释：
用于注解说明解释程序的文字就是注释
提高了代码的阅读性
Java中的注释格式
1.单行注释 // …
2.多行注释 /* … /
3.文档注释 /* … /
（注意多行注释要避免嵌套多行注释）
在开始一个编程前，要理好思绪，规划好了再写代码，注意注释不同分块和关键代码。在程序的顶部应是一块分析。
/
需求： …
思路： …
步骤： …
*/

关键字的定义和特点：
定义：被Java语言赋予了特殊含义的单词
特点：关键字中所有字母都为小写

标识符
在程序中自定义的一些名称。
由26个英文字母大小写，数字：0-9 ，符号：_ $组成
定义合法标识符规则：
1.数字不可以开头
2.不可以使用关键字
Java中严格区别大小写。
注意：在起名字的时候，为了提高阅读性，要尽量有意义

编写代码的规范：
包名：多单词组成时所有字母都小写。xxxyyyzzz
类名接口名：多单词组成时，所有单词的首字母大写。XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

常量表示不能改变的数值
Java中常量的分类：
1.整数常量，所有整数
2.小数常量，所有小数
3.布尔型常量。较为特有，只有两个数值。True flase
4.字符常量。将一个数字字母或者符号用单引号（‘’）标识
5.字符号常量。将一个或多个字符用双引号标识。
6.Null常量，只有一个数值就是null。

八进制：0-7，满8进1，用0开头表示。
十六进制：0-9，A-F，满16进1，用0x开头表示。

变量的概念：
内存中一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）
该区域的数据可以在同一类型范围内不断变化
为什么要定义变量：
用来不断的存放同一类型的常量，并可以重复使用

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同的内存空间

整数默认：int型，小数默认：double型
不同数据类型运算，内存空间小的向内存空间大的提升，但运算后可能报错损失精度。
Int和float都是四个字节的类型，int+float = float
ASCII码。字符与数字的差异，char类在ASCII中有数字表示，所以char类型支持计算。
运算 范例 结果
自增（前） a = 2 ; b = ++a a = 3 ; b = 3
自增（后） a = 2 ; b = a++ a = 3 ; b = 2

取模运算，负号只关注被模数。
字符串数据和任何数据都是使用+连接，最终都会变成字符串
System.out.print和System.out.println中ln表示换行。
转义字符：通过\来转变后面字母或者符号的含义
\n ：换行
\b ：退格 相当于backspace
\r ：相当于按下回车键 window系统中，回车符是由两个字符表示的：\r\n
\t ：制表符。相当于tab键

一个汉字占两个字节，而char型也是占两个字节，所以将汉字赋值给char型是可以的。
short s = 3;
s = s + 2 ; <–> s += 2 ;
s = s + 2 ;编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
s += 2 ; 编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
逻辑运算符用于连接boolean类型的表达式。

&&跟&的特点：
&：无论左边是true或false，右边都运算。
&&：当左边为false时，右边不运算。
|：两边都参与运算。
||：当左边为true时，右边不运算。

位运算符：
<< 左移：相当于乘以2的倍数

右移：相当于除以2的倍数
移n位，就是对乘以或者除以2的n次幂

位运算的运算速度较快

:最高位补什么由原有数据的最高位值而定。
如果最高位为0，右移后，用0补空位。
如果最高位是1，右移后，用1补空位。

: 无论最高位是什么，右移后，都用0补空位。

异或^：不同为1，相同为0.一个数异或一个数两次，结果还是那个数。
（异或可以进行简易的加密）

交换两个变量的值： int n = 3 , m = 8;
方法一：通过第三方变量。
int temp;
temp = n;
n = m;
m = n
方法二：不用第三方变量
n = n + m;
m = n - m;
n = n - m;
（受限于int的最大值，易损失精度）
方法三：
n = n ^ m;
m = n ^ m; // (n^m) ^ m;
n = n ^ m; // (n^m)(n^m)m
实际开发中使用方法一，易读性高。

十进制转十六进制：
int num = 60;
//获取60的二进制最低4位，通过&15;
int n1 = num & 15;
//要获取下一组四位，将60右移4位。
int temp = 60 >> 4;
//对temp的值进行最低四位的获取。
int n2 = temp & 15;

使用>>>右移，可防止负数补上的有效位无法移光的问题。
三元运算符
（条件表达式）？表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；

If else 结构的简写格式：变量 = （条件表达式）？表达式1：表达式2；
三元运算符：
好处：可以简化if else 代码。
弊端：因为是一个运算符，所以运算完必须要有一个结果。

Switch语句特点：
A：switch语句选择的类型只有四种：byte，short，int，char。
B：case之间与default没有顺序，先执行第一个case，没有匹配的case执行default。
C：结束switch语句的两种情况：遇到break或者执行到switch语句结束。
D：如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

if和switch语句很像。
具体什么场景下，应用哪个语句呢？
如果判断的具体数值不多，并且符合byte short int char这四种类型。
虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更加广泛

While：先判断条件，只有条件满足才执行循环体。
Do while ： 先执行循环体，再判断条件，条件满足，再继续执行循环体。
： 无论条件是否满足，循环体至少执行一次。

变量有自己的作用域，对于for来讲，如果将用于控制循环的增量定义在for语句中。For语句执行完毕。该变量在内存中被释放。
For和while可以进行互换，如果需要定义循环增量。用for更为合适。
总结：当要对某些语句执行很多次时，就使用循环结构。

for语句的格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
无限循环的最简单表现形式
1.for(;😉{}
2.while(true){}

流程控制语句
Break（跳出） continue（继续）
Break语句：应用范围：选择结构和循环结构
Continue语句：应用于循环结构。
注：
a.这两个语句离开应用范围，存在是没有意义的。
b.这两个语句单独存在时，下面不能有语句，因为执行不到
c.Continue语句时结束本次循环继续下次循环。
d.标号的出现，可以让这两个语句作用于指定的范围。
Break跳出当前循环（内循环）

函数的定义：函数就是定义在类中的具有特定功能的一段独立小程序。
函数也称为方法。
函数的格式：
修饰符 返回值类型 函数名（参数类型 形参1，参数类型 形式参数2）
{
执行语句；
return 返回值；
}
为了提高代码的复用性，可以对重复的代码进行抽取，定义成一个独立的功能。

主函数是静态的所以也必须调用静态的方法。

函数的特点：
定义函数可以将功能代码进行封装。
便于对该功能进行复用。
函数只有被调用才能执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。（return;）
注意：
函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。

函数的重载
重载的概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的特点：与返回值类型无关，只看参数列表。
重载的好处：方便于阅读，优化了程序设计。
重载的使用：当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区分重载和返回值类型无关。

数组的定义：
概念:同一种类型数据的集合。其实数组就是一个容器。
数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
元素类型[] 数组名 = new 元素类型[元素，元素,…];

内存结构
Java程序在运行时，需要在内存中分配空间。为了提高运算效率，对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

内存分为了五个内存区：堆内存，栈内存，方法区，本地方法区，寄存器

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值
实体不再被使用，会在不确定的时间内被垃圾回收器回收。
方法区，本地方法区，寄存器
各种数据类型的默认值（default）：
int : 0 、 double: 0.0 、float:0.0f 、 boolean:false

ArrayIndexOutOfBoundException:操作数组时，访问到了数组中不存在的角标
NullPointerException:空指针异常，当引用没有任何指向，值为null的情况，该引用还用于操作实体

冒泡排序：相邻的两个元素进行比较，如果符合条件换位。
堆内存操作消耗资源大，可在栈内记录，最后再一起执行。
折半查找，提高效率，但是要求数组有序。

转换进制–查表法：将所有的元素临时存储起来。建立对应关系。
打印出来出来显示是倒序，解决方法

字符数组一经定义，初始化值是’\u0000’相当于空格

数组中的数组—二维数组
格式1： int[][] arr = new int[3][2]
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别是arr[0],arr[1],arr[2]
给第一个一维数组1角标位赋值为78写法是：arr[0][1] = 78
格式2： int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值为null

一维数组和二维数组的定义方式
int[] x;
int x[];

Int[][] y;int y[][];int[] y[];

理解面向对象
*面向对象是相对面向过程而言
*面向对象和面向过程都是一种思想
*面向过程
*强调的功能行为
*面向对象
*将功能封装进对象，强调具备了功能的对象
*面向对象是基于面向过程的。

面向过程到面向对象。从执行者到指挥者，从自己实现每一个功能，到寻找一个对象，来完成这些功能。
自己的理解：可以将所有物体都视为对象，每个对象都有自己的功能可以去跟别的对象产生联系，功能可以看作连着两个对象的那条线。这样整个环境就视作一张图，面向过程，关注线，面向对象，关注点。

成员变量与局部变量的不同
作用域不同：成员变量作用于整个类中，局部变量作用于函数或语句中。
在内存中的位置不同：
成员变量在堆内存中，因为对象的存在，才在内存中存在
局部变量，存在栈内存中

允许在本类中创建本类对象。

匿名对象
*匿名对象是对象的简化形式
*匿名对象两张使用情况
*当对对象方法仅进行一次调用的时候
*匿名对象可以作为实际参数进行传递

下一句开始，前一句就成为垃圾了。
匿名对象调用属性没有意义，调用方法有意义

构造函数
特点
1.函数名与类名相同
2.不用定义返回值类型
3.不可以写return语句
作用：
给对象进行初始化
注意：
1.默认构造函数的特点
2.多个构造函数是以重载的形式存在的。

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
*将变化隔离
*便于使用
*提高重用性
*提高安全性
封装原则：
*将不需要对外提供的内容都隐藏起来
*把属性都隐藏，提供公共方法对其访问。

类中的属性被直接访问就容易出现安全隐患。
关键字Private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）
私有只在本类中有效
私有仅仅是封装的一种表现形式，并不等于封装
之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句
对访问的数据进行操作。提高代码的健壮性
对象一建立就会调用与之对应的构造函数
构造函数的作用：可以用于给对象进行初始化。
构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数
构造函数和一般方法在写法上有不同
在运行上也有不同
构造函数是在对象一建立就运行，给对象添加对象具备的功能
一个对象建立，构造函数只运行一次
而一般方法可以被该对象执行多次

什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中

构造代码块
作用：给对象进行初始化
对象一建立就运行，而且优先于构造函数执行
与构造函数的区别：
构造代码块是给所有对象进行统一初始化。
而构造函数是给对应的对象初始化。

将所有对象的共性写在构造代码块中，构造代码块中定义的是不同对象共性的初始化内容

局部变量在局部范围内屏蔽外部变量
This关键字：是用于区分局部变量和成员变量同名的情况
This代表它所在函数所属对象的引用
简单来说，哪个对象在调用this所在的函数，this就代表哪个对象
This的应用:当定义类中功能时，该函数内部要用到该函数的对象时，这时用this来表示这个对象。
This语句用于构造函数之间的互相调用。
This语句只能定义在构造函数的第一行，因为初始化要先执行。

Static关键字
用于修饰成员（成员变量和成员函数）
被修饰后的成员具备以下特点：

• 随着类的加载而加载
• 优先于对象存在
• 被所有对象所共享
• 可以直接被类名调用
  使用注意
• 静态方法只能访问静态成员
• 静态方法中不可以写this.super关键字
• 主函数是静态的

类名调用静态修饰的成员，随着类的消失而消失，说明它的生命周期最长。
成员变量是实例变量
静态的成员变量是类变量
实例变量和类变量的区别：
1.存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中
2.生命周期：
类变量生命周期最长，随着类的消失而消失
实例变量生命周期随着对象的消失而消失

静态使用的注意事项：
1.静态方法只能访问静态成员
非静态方法既可以访问静态也可以访问非静态
2.静态方法中不可以定义this，super关键字
因为静态优先于对象存在。所以静态方法中不可以出现this
3.主函数是静态的

主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用
主函数的定义：
Public：代表着该函数访问权限是最大的。
Static：代表着主函数随着类的加载就已经存在了。
Void：主函数没有具体的返回值
Main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
（String[] arr）：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串的数组。
JVM在调用主函数时，传入的是new String[]
静态有利有弊
利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中存储一个。可以直接使用类名调用。
弊：生命周期过长，访问出现局限性（只能访问静态）

什么时候定义静态变量（类变量）呢？
当对象中出现共享数据时（不是共享属性），该数据被静态所修饰，对象中的特有数据要定义成非静态存在堆内存中

什么时候定义静态函数？
当功能内没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

静态的应用
每一个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。

虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。
发现了问题：
1.对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
2.操作数组的每一个方法没有用到ArrayTool对象中的特有数据
这时就考虑，让程序更严谨，是不需要对象的。
可以将ArrayTool中的方法都定义成静态的，直接使用类名调用。

将方法都静态后使用，可以方便使用，但是该类，还是可以被其他程序建立对象的，为了更为严谨，强制让该类不能建立对象。
可以将构造函数私有化。

能隐藏的全隐藏起来，减少暴露。

编译说明文档使用javadoc，需要将类设置成public

一个类中默认会有一个空参数的构造函数。
这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数也带public修饰符。
默认构造函数的权限是随着类的变化而变化的

静态代码块的特点：随着类的加载而执行，只执行一次。
普通代码块，是最常见的代码块，在方法里用一对“{}”扩起来的数据，就是普通的代码块
构造代码块：是在类中直接定义的，用“{}”扩起来的代码。每次调用构造方法前执行，都会先执行构造代码块，给对象初始化的
静态代码块：他在类中的成员位置，用“{}”扩起来的代码，只不过他用了static修饰，且执行一次，并优先于主函数，给类初始化的

构造函数是用于给对应对象初始化的
Person p = new Person(“zhangsan”,20)
这句话都做了什么
1.因为new用到了Person.class所以会找到Person.class文件并加载到内存中
2.执行该类中的static代码块，如果有的话，给Person.class类进行初始化
3.在堆内存中开辟空间，分配内存地址
4.在堆内存中建立对象的特有属性，并进行默认初始化。
5.对属性进行显示初始化
6.对对象进行构造代码块初始化
7.对对象进行对应的构造函数初始化
8.将内存地址赋给栈内存中的p变量

设计模式：解决某一类问题最行之有效的方法
Java中有23种设计模式
单例设计模式：解决一个类在内存中只存在一个对象，想要保证对象唯一
1.为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2.还为了让其他程序可以访问到该类对象，要在本类中，自定义一个对象
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式

使用代码体现
1.将构造函数私有化
2.在类中创建一个本类对象
3.提供一个方法可以获取该对象

这个是先初始化对象，称为：饿汉式
Single类一进内存，就已经创建好对象。

一般使用饿汉式，安全简单，懒汉式多人同时使用方法可能出现问题

继承的作用：
1.提高代码的复用性
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性

Java只支持单继承，不支持多继承
因为多继承容易带来安全隐患，当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个
但是java保留这种机制，并用另一种体现形式来完成，单继承多实现

java支持多层继承，也就是一个继承体系。
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中共性功能，通过了解共性功能，就可以知道该体系的基本功能。
那么在具体调用时，要创建最子类的对象。一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
那么在具体调用时，要创建最子类的对象，为什么呢？一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。
总结：查阅父类功能，创建子类对象使用功能。
Super.*父类对象的引用。

子父类出现后，类成员的特点
类中成员：
1.变量
2.函数
3.构造函数
1.变量
子类中出现非私有的同名变量时，
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super
Super和this的使用几乎一致
This代表的是本类对象的引用
Super代表的是父类对象的引用

子类可以继承父类的所有属性和方法，但是在父类中被private修饰的属性和方法在子类中不允许访问
2.子父类中的函数
当子类出现和父类一模一样的函数时
当子类对象调用该函数，会运行子类函数的内容
如同父类的函数被覆盖一样

这种情况是函数的另一个特性：重写（覆盖）

当子类继承父类，沿袭父类的功能，到子类中
但是子类虽具备该功能，但是功能的内容和父类不一致，
这时。没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容

覆盖：
1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败
2.静态只能覆盖静态

重载：只看同名函数的参数列表
重写：子父类方法要一模一样

This（）；Super（）；调用本类/父类的构造函数

3.子父类的构造函数
在对子类对象进行初始化时，父类的构造函数也会运行
那是因为子类的构造函数默认第一行有一条隐式的语句，super（）；
super（）；会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super（）；

为什么子类一定要访问父类的构造函数
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，
所以子类在对象初始化时，要先访问一下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super的构造函数

*super语句要放置在子类构造函数的第一行
构造函数中要么有super语句要么有this语句，只能有一种

子类的实例化过程

结论：子类的所有构造函数，默认都会访问父类中空参数的构造函数
因为子类每一个构造函数内的第一行都有一句隐式的super（）
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类的构造函数
当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，
子类中至少有一个构造函数会访问父类中的构造函数

Final关键字
*final可以修饰类，方法，变量
*final修饰的类不可以被继承
*final修饰的方法不可以被覆盖
*final修饰的变量是一个常量，只能被赋值一次
*内部类只能访问被final修饰的局部变量

当多个类中出现相同功能，但是功能主体不同，
这时可以进行向上抽取，这时，只抽取功能定义，而不抽取功能主体。

抽象：
抽象类的特点
1.抽象方法一定在抽象类中
2.抽象方法和抽象类都必须被abstract关键字修饰
3.抽象类不可以用new创建对象，因为调用抽象方法没意义。
4.抽象类中的方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用
如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

抽象类和一般类没有太大的不同
该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。
这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。
通过抽象方法来表示

抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法。
抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

接口：
格式interface{}
接口中的成员修饰符是固定的：
-成员变量：public static final
-成员函数：public abstract
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”

接口的初期理解可以认为是一个特殊的抽象类，当抽象类中的方法是抽象的，
那么该类可以通过接口的形式来表示。

接口定义时，格式特点：
1.接口中常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符

常量：public static final       （interface中默认自加，可以省略不写 ）
方法：public abstract 			（interface中默认自加，可以省略不写 ）

记住：接口中的成员都是public

接口：不可以创建对象，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化
否则子类是一个抽象类

接口可以被类多实现，也是对多继承不支持的转换形式。

类与类：继承
类与接口：实现
接口与接口：继承，多继承

接口的特点
*接口是对外暴露的规则
*接口是程序的功能扩展
*接口可以用来多实现
*类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
*接口与接口之间可以有继承关系

多态：可以理解为事物存在的多种体现形态
1.多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接受自己的子类对象
2.多态的前提
必须是类与类之间有关系，要么继承，要么实现。
通常还有一个前提：存在覆盖
3.多态的好处
多态的出现大大的提高程序的扩展性
4.多态的弊端
提高了扩展性，但是只能使用父类引用访问父类的成员

在多态中成员函数非静态的特点：
在编译时期：参阅引用型变量所属的类中是否有调用方法。如果有，编译通过，如果没有编译失败
在运行时期：参阅对象所属的类中是否有调用方法。
简单总结：成员函数在多态调用时，编译看左边，运行看右边

在多态中，成员变量的特点：
无论编译和运行，都参考左边（引用型变量所属的类）

在多态中，静态成员函数的特点：
无论编译和运行，都参考左边