1. 什么是接口
（1）在生活中：
接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。
人类与电脑等信息机器或人类与程序之间的接口称为用户界面。电脑等信息机器硬件组件间的接口叫硬件接口。电脑等信息机器软件组件间的接口叫软件接口。
在计算机中，接口是计算机系统中两个独立的部件进行信息交换的共享边界。这种交换可以发生在计算机软、硬件，外部设备或进行操作的人之间，也可以是它们的结合。
（2）在Java中：
- 接口是interface，相当于抽象类，在继承关系中充当父类的角色，在接口中通过定义抽象方法来指定规范，子类去实现接口，要实现接口中的所有抽象方法。
2.接口有什么作用
在Java中，类是单继承的，怎么才能让类多继承呢？
家里房檐上的那只燕子是会飞的，天上的那架飞机也是会飞的，他们有相同的行为，但是他们是毫不相关的两个子类，是否需要让让多个子类继承同一个抽象类？
此时，可以通过接口，定义一个飞的接口，燕子能实现，飞机也能实现，实现了相同的接口。
所以接口解决的问题是
- 多继承
- 不同子类实现相同的行为
3.定义和实现一个简单的接口
接口的定义与类的定义是相似的。
public interface 接口名 {
//接口成员
}
- 和类不同的是，定义接口用的是interface修饰符
- 接口的访问权限是public和默认权限，与类的访问权限类似
- 一个接口可以继承其他父接口。它将继承父接口中声明的常量和抽象方法
接口实现语法格式
class 类 implements 接口 {
重写接口中方法
}
实现一个简单的接口
interface IShout extends IFly{
class Rabbit implements IShout{
//实现shout()方法
@Override
public void shout() {
}
//实现fly()方法
@Override
public void fly() {
}
}
实现接口就是遵循接口的规范
- 实现接口使用implements关键字
- 一个类可以实现多个接口，各接口之间用逗号分隔
- 实现接口的类必须实现接口定义的所有抽象方法，即使类中不使用某个抽象方法也必须实现它，通常空方法体实现子类不需要的抽象方法，如果抽象方法有返回值，可使用默认值。
- 接口的实现类允许包含普通方法
- 在实现抽象方法时需要指定public权限，否则会产生编译错误
- 接口和类，抽象类是同一层次的概念，命名规则相同
接口的成员特点：
- 成员变量：只能是常量 默认有修饰符：public static final
- 构造方法：接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在。
- 成员方法： 只能是抽象方法 默认修饰符：public abstract
4. 接口的多实现
接口最重要的体现：解决多继承的弊端。将多继承这种机制在java中通过多实现完成了。
interface Fu1
{
void show1();//接口定义规范show1()
}
interface Fu2
{
void show2();//接口定义规范show2()
}
class Zi implements Fu1,Fu2// 多实现。同时实现多个接口。
{
public void show1(){}//子类实现show1()规范
public void show2(){}//子类实现show2()规范
}
多继承的弊端是什么？
- 在多继承时，当父类之中有相同的功能时，子类调用这个功能会产生不确定性
- 核心问题在于父类之中有主方法体，导致了调用运行的时候不确定运行哪个主体。
多实现是怎么解决的这个弊端？
- 在接口之中的功能都是没有方法体的，由子类来实现。
5.类继承类的同时也可以实现接口
在子类继承父类的同时，也可以实现接口，方法如下
class Father{
public void getOne(){ }
}
interface Inter {
void getTwo();
}
interface Outer{
void getThree();
}
class Son extends Father implements Inter,Outer{
@Override
public void getTwo() {
}
@Override
public void getThree() {
}
}
接口的出现避免了单继承的局限性。父类中定义的事物的基本功能。接口中定义的事物的扩展功能。
- 接口和类之间可以通过实现（implements）产生关系
- 类与类之间可以通过继承（extends）产生关系
- 当一个类已经继承了一个父类，它又需要扩展额外的功能，这时接口就派上用场了。
- 子类通过继承父类扩展功能，通过继承扩展的功能都是子类应该具备的基础功能。如果子类想要继续扩展其他类中的功能呢？这时通过实现接口来完成。
6. 接口和接口之间的继承
接口和接口之间也是可以继承的
public interface IFu1 {
void show1();
}
public interface IFu2 {
void show2();
}
public interface IZi extends IFu1,IFu2{
void show3();//接口继承了IFu1,IFu2两个父类接口
}
public class Demo implements IZi{
@Override
public void show3() {
}
@Override
public void show1() {
}
@Override
public void show2() {
}
}
接口与接口之间的继承是可以多继承的
在开发中如果多个接口中存在相同方法，这时若有个类实现了这些接口，那么就要实现接口中的方法，由于接口中的方法是抽象方法，子类实现后也不会发生调用的不确定性。
7. 接口的规定
- 接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。
- 接口中可以定义方法，方法也有固定的修饰符，public abstract（写代码时可以省略，默认有public abstract）
- 接口不可以new，即不可以实例化。
- 子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
- 接口不能继承类，接口可以继承接口
- 接口没有最高层，类的最高层是Object
- 接口中不允许有普通方法，所以接口中的方法都是抽象（jdk1.8后可以有default方法和static方法）
- 接口不是类，所以没有构造
8. jdk1.8接口的新特性
在1.8版本之后，接口内不只可以定义抽象方法，还能定义static以及default修饰的实例方法。
static方法：
public interface IDemo {
public static void demo1(){
System.out.println("static方法...");
}
}
public static void main(String[] args) {
IDemo.demo1();//直接使用接口名.方法名使用
}
}
default方法
public interface IDemo {
default void demo2(){
System.out.println("default方法......");
}
}
public class Demo implements IDemo{
public static void main(String[] args) {
Demo demo = new Demo();
demo.demo2();
}
}
public class Demo implements IDemo{
@Override
public void demo2() {//子类可以直接使用，也可以重写
System.out.println("重写后的default方法...");
}
public static void main(String[] args) {
Demo demo = new Demo();
demo.demo2();
}
}
9.面向接口编程
接口有多种用法：
- 接口可以作为子类的实现
- 接口可以作为类的属性
- 接口可以作为方法的参数
- 接口可以作为方法的返回值
（1） 接口可以作为子类的实现
public interface IFu1 {
void show1();
}
public class Demo1 implements IFu1{
@Override
public void show1() {
System.out.println("demo1 is running...");
}
}
(2) 接口作为类的属性
创建接口
public interface IFu1 {
void show1();
}
创建两个子类实现接口
public class Demo1 implements IFu1{
@Override
public void show1() {
System.out.println("demo1 is running...");
}
}
public class Demo2 implements IFu1{
@Override
public void show1() {
System.out.println("demo2 is running ...");
}
}
将接口作为属性
public class Demo {
private IFu1 iFu1;
public IFu1 getiFu1() {
return iFu1;
}
public void setiFu1(IFu1 iFu1) {
this.iFu1 = iFu1;
}
}
使用接口的属性
public class Test {
public static void main(String[] args) {
Demo demo = new Demo();
IFu1 iFu1 = new Demo1();//创建IFu1接口的子类Demo1对象
demo.setiFu1(iFu1);//将IFu1接口的子类Demo1对象传入Demo的属性iFu1
demo.getiFu1().show1();//调用的是Demo1的show1()
}
}
结果：demo1 is running...
(3)接口可以作为方法的参数
public interface IFu1 {
void show1();
}
public class Demo1 implements IFu1{
@Override
public void show1() {
System.out.println("demo1 is running...");
}
}
public class Demo2 implements IFu1{
@Override
public void show1() {
System.out.println("demo2 is running ...");
}
}
public class Demo {
public void testInterface(IFu1 iFu1){
iFu1.show1();
}//接口作为方法的参数
}
public class Test {
public static void main(String[] args) {
Demo demo = new Demo();
IFu1 iFu1 = new Demo1();//创建IFu1接口的子类Demo1对象
demo.testInterface(iFu1);//使用的Demo1的方法
iFu1 = new Demo2();
demo.testInterface(iFu1);//使用的Demo2的方法
}
}
结果为：
demo1 is running...
demo2 is running ...
(4)接口可以作为方法的返回值
public interface IFu1 {
void show1();
}
public class Demo1 implements IFu1{
@Override
public void show1() {
System.out.println("demo1 is running...");
}
}
public class Demo {
public IFu1 testInterface(String type){
IFu1 iFu1 = null;//定义接口对象
if(type==null){
throw new RuntimeException("非法参数异常");
}
if(type.equalsIgnoreCase("demo1")){
return new Demo1();
}else if(type.equalsIgnoreCase("demo2")){
return new Demo2();
}else{
return null;
}
}//接口作为方法的返回值
}
public class Test {
public static void main(String[] args) {
Demo demo = new Demo();
IFu1 iFu1 = demo.testInterface("demo1");
iFu1 = demo.testInterface("demo2");
}
}
- 接口作为属性、方法的参数、方法返回值时，可以返回任何实现了该接口的子类实例，接口对象调用方法时，调用的是传入子类的方法。
- 这种设计的原理是里氏替换原则，即父类引用指向子类实例。
面向接口编程的核心是：父类引用指向子类对象，换个角度来理解就是凡是使用父类的地方都可以使用子类替换父类。
面向接口编程的好处
- 降低了程序的耦合性，其能够最大限度的解耦，所谓解耦既是解耦合的意思，它和耦合相对。耦合就是联系，耦合越强，联系越紧密。在程序中紧密的联系并不是一件好的事情，因为两种事物之间联系越紧密，你更换其中之一的难度就越大，扩展功能和debug的难度也就越大。
- 易扩展，我们知道程序设计的原则是对修改关闭,对新增开放.面向接口编程扩展功能只需要创建新实现类重写接口方法进行升级扩展就可以,达到了在不修改源码的基础上扩展的目的.
- 易维护
