什么是接口？

　　Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，
因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为(功能)。
接口的两种含义：一，Java接口，Java语言中存在的结构，有特定的语法和结构;二，一个类所具有的方法的
特征集合，是一种逻辑上的抽象。前者叫做“Java接口”，后者叫做“接口”。

　　在Java语言规范中，一个方法的特征仅包括方法的名字，参数的数目和种类，而不包括方法的返回类
型，参数的名字以及所抛出来的异常。在Java编译器检查方法的重载时，会根据这些条件判断两个方法是
否是重载方法。但在Java编译器检查方法的置换时，则会进一步检查两个方法(分处超类型和子类型)的返
还类型和抛出的异常是否相同。

　　接口继承和实现继承的规则不同，一个类只有一个直接父类，但可以实现多个接口。
　　Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java
抽象类更抽象化。
　　Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public，静态的和
final属性。
　　接口把方法的特征和方法的实现分割开来。这种分割体现在接口常常代表一个角色，它包装与该角色
相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。一个角色由不同的演员来演，而不同
的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。
为什么使用接口？
　　两个类中的两个类似的功能，调用他们的类动态的决定一种实现，那他们提供一个抽象父类，子类分
别实现父类所定义的方法。
　　问题的出现：Java是一种单继承的语言，一般情况下，哪个具体类可能已经有了一个超类，解决是给
它的父类加父类，或者给它父类的父类加父类，只到移动到类等级结构的最顶端。这样一来，对一个具体
类的可插入性的设计，就变成了对整个等级结构中所有类的修改。
　　接口是可插入性的保证。
　　在一个等级结构中的任何一个类都可以实现一个接口，这个接口会影响到此类的所有子类，但不会影
响到此类的任何超类。此类将不得不实现这个接口所规定的方法，而其子类可以从此类自动继承这些方法
，当然也可以选择置换掉所有的这些方法，或者其中的某一些方法，这时候，这些子类具有了可插入性(
并且可以用这个接口类型装载，传递实现了他的所有子类)。
　　我们关心的不是那一个具体的类，而是这个类是否实现了我们需要的接口。
　　接口提供了关联以及方法调用上的可插入性，软件系统的规模越大，生命周期越长，接口使得软件系
统的灵活性和可扩展性，可插入性方面得到保证。
　　类型
　　使用Java接口将软件单位与内部和外部耦合起来。使用Java接口不是具体的类进行变量的类型声明，
方法的返还类型声明，参量的类型声明，以及数据类型的转换。
　　在理想的情况下，一个具体的Java类应当只实现Java接口和抽象Java类中声明的方法，而不应当给多
余方法。

　　类型等级结构

　　Java接口(以及抽象类)一般用来作为一个类型的等级结构的起点。
　　如果一个类已经有了一个主要的超类型，那么通过实现一个接口，这个类可以拥有另一个次要的超类型，
这种次要的超类型叫做混合类型。
Java接口常用方法

　　单方法接口

　　以下是引用片段：

1
2
3

　　public interface Actionlistener{ 
　　public abstract void actionPerformed(ActionEvent event); 
　　}

　　仅且只有一个方法，只有实现了这个接口(重写这个接口中的唯一一个方法)，你才有资格去事件监听
器列表里注册(参数为Actionlistener类型)，当事件源变动时，自动调用这个唯一的actionPerformed方
法.
　　## 标识接口 ##
　　是没有任何方法和属性的接口。标识接口不对实现它的类有任何语意上的要求，它仅仅表明了实现它
的类属于一个特定的类型(传递)。
　　不推荐过多的使用标识接口。
　　## 常量接口 ##
　　用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量。

接口提供了规范和标准，接口不能被实例化，接口不包含任何构造器，接口中的所有方法都是抽象的，
接口可以定义静态常量，是异构集合.
一个接口能继承多个接口 public class b extends A
一个类可以实现多个接口
声明一个接口关键字是public interface A
实现一个接口的方法用public class H implements A,B,C

为什么使用接口:

抽象中有2个缺陷.
1抽象是单项继承————接口是多项实现
2抽象而破坏了安全性————而接口保证了安全性
抽象——[标准]——接口
抽象方法——[安全]——抽象方法
抽象是指向子类对象——不能被实例——而接口指向实现对象
总结：
Java中的接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，

多态：

对于父类而言他的子类有独特的行为和特征，
多态体现在2个方面静态多态和动态多态—静态多态是编译时多态.

抽象：

abstartic关键字在public 修饰符和void返回值中间
abstartic 不能产生当前对象，重写父类抽象的方法在子类中实现重写父类这个抽象方法
抽象的方法必须位于抽象类中，但抽象中也有不抽象的方法。
抽象如果子类继承了父类父类中的抽象方法在子类中实现

其实，我们如果要全面了解多态，我觉得只要把握好以下几个方面就可以：多态是什么，他的具体表现是什么，多态使用的前提，多态使用好处，多态具体如何应用。
首先，何谓多态，我们可以有两方面理解，就属性而言，他是事物存在的多种形态。就方法而言，它是一种方法，多种实现，如重写。
其次，如果父类的引用指向了子类的对象 ，这就是其表现形式。
再者，我们在什么时候使用多态呢，这个就体现在类与类之间的关系上，要么是子类与父类关系，要么类与接口的关系。
再次，如何实现呢，他具体涉及两个方面内容，第一是静态多态，在编译的是时候系统就知道要指执行那个方法，主要体现在方法重载。第二是动态多态，系统在运行是才知道要调用哪个方法，主要的实现方式是方法重写。还有个体现是动态绑定。动态绑定是动态多态的技术基础之一。运行时根据父类的变量引用所指向的实际类型执行相应子类方法，从而实现多态性。还有两个技术基础，分别是向上转型和instancof关键字的使用。多态绑定还可以这么理解：在多态中，如果成员方法非静态，在编译时，参阅引用引用变量是否有调用方法，如果有编译通过，否则一定失败。如果运行，就看子类，子类如果有，就运行子类，子类没有就运行父类，父类没有就运行失败。但是如果方法都是静态的，无论运行还是编译都参考左边，其特点跟成员变量是相通得。
最后，多态有何好处，多态可以大大的提高扩展性。

一、多态的概念

多态即“一个接口，多种实现”，在父类中声明的方法，可以在子类中进行覆盖（声明为finial的除外），这样，父类的引用在引用子类对象的时候可以做出不同的响应。所以，多态也可以说成是：相同的消息被发送到子类或父类对象上，将导致完全不同的行为。
多态允许将子类的对象当作父类的对象使用，某父类型的引用指向其子类型的对象,调用的方法是该子类型的方法。这里引用和调用方法的代码编译前就已经决定了,而引用所指向的对象可以在运行期间动态绑定。

二、多态存在的条件

1、必须存在继承关系。
2、子类必须覆盖父类中声明过的方法。

三、java多态的实现机制

java多态是由动态绑定技术来实现的，动态绑定即运行时绑定（以之对应的有静态绑定，即编译时绑定），在java语言中，除了声明为finial的方法外（声明为private的方法默认为finial）其余都是采用动态绑定来调用的，过程如下：
当程序运行时，需要动态的调用方法时，则是虚拟机的工作，虚拟机将依照具体环境首先拟定出一张方法表，列举出可能的方法调用，继而在实现调用的时候，可以节省寻找函数方法所带来的时间开销，其将调用最合适及最合理的方法，在派生类中能调用相应的重名函数的则调用该新方法，不能则调用超类（父类）方法，同时应注意一点，若虚拟机放弃对本类的相应方法调用，那么虚拟机将搜索超类的方法表，依次类同，若都没有相应的处理来响应，则程序运行出错，一般来说在编译阶段，编译器将作出相应的控制。
 下面我们来看看动态绑定的内部实现机制。
JAVA虚拟机调用一个类方法时，它会基于对象引用的类型(通常在编译时可知)来选择所调用的方法。相反，当虚拟机调用一个实例方法时，它会基于对象实际的类型(只能在运行时得知)来选择所调用的方法，这就是动态绑定。

封装：

java为类中的成员提供了四种访问级别，按照访问权限由大到小排列
分别是：公用的（public）私有的(private)受保护的（protected）和默认的（default无访问修饰符）
通过用private 访问修饰符隐藏类中成员变量 称为封装，通过方法访问属性称为封装set[设置]/get[获取]

静态：

Static修饰符属于类的，用类名直接调用get或set
静态块：如果不加Static就用对象调用，如果加了Static就是用类调用set或get方法

总结：

封装 封装就是通过方法访问属性
静态 静态就是访问静态成员变量的时候用类名访问二不是用对象访问
静态块 静态块就是实例初始化块时在构造器之前执行

继承：

我们由员工类Employee派生出2个新类:计时工Hourly和合同工Salary,使用extends关键字让它们继承自Employee
我们称Employee为父类(基类),Hourly和Salary为Employee的子类(派生类)
可以通过扩展一个已有的类，并继承该类的属性和行为，来创建一个新的类，这种方式称为继承使用extends关键字

单继承与多继承：

一个java类中只能有一个父类
某些OOP语言（例如C++）允许子类有多个父类。
但在Java中这是不允许的。在Java中，一个类只能有一个父类。

方法重写：

1子类可以重写从父类继承的方法，从而允许子类添加或者改变父类中方法的行为。这称为方法重写，是OOP的特征之一。
2当子类重写父类的方法时，必须遵循如下的规则：
子类的方法的返回值的类型、方法名和形式参数列表，必须和父类中的是相同的。如果子类中的方法与父类中的方法同名，但是子类的方法改变了形式参数列表，那么这是方法重载，而不是方法重写。不要混淆这两个概念，二者的用法是完全不同的。
访问修饰符必须不小于父类中的访问修饰符。例如，如果父类的方法是public，那么子类的必须是public。如果父类的方法是protected，那么子类必须是protected或public（public比protected访问权更大）。
子类中重写的异常不能抛出比父类更多的异常
2方法的重写：子类中的方法与父类中的方法相同（方法名称、参数列表、返回类型）
3方法重载：一个类中的方法与另一个方法相同，参数列表不同
2重写体现的是父类与子类方法之间的关系；重载体现的是一个类的内部方法之间的关系。
4构造方法与继承
不象一个超类的成员，超类的构造方法不能被它的子类继承.
你必须为一个子类定义构造方法，或者使用缺省的构造方法.

super关键字:

super的两种用法：

1:super.或super.()代表每个类中指向父类对象部分的引用.
2:super()代表调用父类中指定的构造器。
注意：
super()只能放在构造器的第一句！
super关键字执行过程：
super 先调用父类构造方法，再调用子类构造方法.
子类构造方法的名称与类的名称相同.

final关键字：

我们可以使用一个叫final的修饰符来实现。
public final class Test{
}
本类使用final修饰符修饰，表示不可以有继承的子类，所以称为终态类。
final 1变量不能修改 2类不可被继承 3方法不能被重写。

总结：

继承：子类继续父类的属性和行为
单继承和多继承：java中只能有一个父类C++中可以有多个父类
方法的重写：子类中的方法与父类中的方法相同（方法名称、参数列表、返回类型）
super: 代表每个类中指向父类对象部分的引用，代表调用父类中指定的构造器
final: final 变量不能修改 类不可被继承 方法不能被重写

1 this：

表示当前对象同时注意事项

2 方法调用栈

1
2
3
4
5
6
7
8
9
10
11
12

主方法先进入栈，后进先出：
┌──────────┐
│ name4              │↖name1方法第四个先进  ↘后进来的name4在内存栈中先出去依次    ↙
│──────────│↑                                                 
│ name3              │↖name1方法第三个先进   ↘依次在出去name3               ↙    
│──────────│ ↑
│ name2              │↖name1方法第二个先进   ↘依次在出去name2         ↙
│──────────│  ↑
│ name1              │↖name1方法第一个先进   ↘依次在出去name2     ↙
│──────────│   ↑                  
│ main()             │↖第一个先进入的主方法  ↘返回main方法结束↙
└──────────┘

3方法的重载：

方法的名称相同参数列不同就构成方法重载. 体现参数列：表示 个数不同–类型不同–顺序不同.

顺序不同类型：

public void name(int a long b) // 2个形式参数
↖这样就构成2个方法名称相同参数 顺序不同 就构成方法重载成功
↙
public void name(long a int b) // 2个形式参数

个数不同类型

public void name(int a long b) // 2个形式参数
↖这样就构成2个方法名称相同参数 个数不同 就构成方法重载成功
↙
public void name(long a) // 1个形式参数

类型不同类型

public void name(String a int b) // 2个形式参数
↖这样就构成2个方法名称相同参数 类型不同 就构成方法重载成功
↙
public void name(long a short b) // 2个形式参数

4访问修饰符：

访问修饰符有3种修饰符类型：

public 公共修饰符的作用：最大权限在任何地方都可以访问这个方法或属性。
private 似有修饰符的作用：只有在类的方法中访问，如果不在同一个类中是无法访问的权限是只有在这个类中才能访问这个方法或属性。
protected 受保护修饰符作用：权限是在同一个包下才能访问，如果不在同一个包就不能访问权限不够因为他是受保护的。
default 默认修饰符的作用：默认修饰符权限跟受保护修饰符是一样的必须在同一个包里面才能调用这个方法或属性，但是权限没有受保护权限高。

5形参和实参

当你在定义一个方法的时候,比如 void setter(int i){};
其中的参数i就是形参 形参是这个方法的局部变量 只能在方法体中使用
当你调用这个方法的时候,比如setter(a);
此时a就是实参 实参a把他的值传递给形参i
基本数据类型实参传递给形参的是值
对象实参传递给形参的是对象的引用

6构造器

构造器是类中的一个特殊的方法，该方法在对象实例化时被调用，构造器的用途是当对象实例化时，初始化对象中的成员变量
构造器的名称必须要和类的名称相同.
不能有返回值，void也不行.
构造器的参数可有可无，可有一个也可有多个参数

总结：

this引用：
2 方法调用栈：
3方法的重载：
4访问修饰符：
5形参和实参：
6构造器：