# 最彻底的抽象类：接口
[TOC]
## 概述
如果在一个类中，一个实现的方法都没有，或者都是抽象方法，那么，这样的类，成为接口。
接口定义使用 `interface` 关键词定义
语法：
~~~
[修饰符] interface 接口名 extends 父接口1, 父接口2... {
0-N 个常量;
0-N个抽象方法;
}
~~~
* 接口中所有的成员在定义的时候访问控制修饰符只能是 public 或者是 default；
* 接口的命名规范同类的命名规范；
* 在接口中，成员变量必须是静态的常量，方法必须是抽象方法，所以可以省略相关的修饰符。
## 接口的继承
接口的继承和类的继承不一样，接口支撑多继承，使用 extends 关键字，之间用逗号隔开，继承的内容包含了，常量和方法
Inter1.java
~~~
public interface Inter1 {
static final String C1 = "c1"; // 常量定义的命名规范是全部大写，两个单词之间用 _
void Inter1fun1();
void Inter1fun2();
}
~~~
Inter2.java
~~~
public interface Inter2 {
static String C2 = "c2"; // 常量定义的命名规范是全部大写，两个单词之间用 _
void Inter2fun1();
void Inter2fun2();
}
~~~
Inter3.java
~~~
public interface Inter3 extends Inter1, Inter2{
static String C3 = "c3"; // 常量定义的命名规范是全部大写，两个单词之间用 _
void Inter3fun1();
void Inter3fun2();
}
~~~
InterImpl.java
~~~
public class InterImpl implements Inter3{
@Override
public void Inter1fun1() {
System.out.println("Inter1fun1");
}
@Override
public void Inter1fun2() {
System.out.println("Inter1fun2");
}
@Override
public void Inter2fun1() {
System.out.println("Inter2fun1");
}
@Override
public void Inter2fun2() {
System.out.println("Inter2fun2");
}
@Override
public void Inter3fun1() {
System.out.println("Inter3fun1");
}
@Override
public void Inter3fun2() {
System.out.println("Inter3fun2");
}
public static void main(String[] args) {
InterImpl ii = new InterImpl();
System.out.println(ii.C1);
System.out.println(ii.C2);
System.out.println(ii.C3);
ii.Inter1fun1();
ii.Inter2fun1();
ii.Inter2fun2();
ii.Inter1fun2();
ii.Inter3fun1();
ii.Inter3fun2();
}
}
~~~
InterImpl2.java
~~~
public class InterImpl2 implements Inter1, Inter2{
@Override
public void Inter2fun1() {
// TODO Auto-generated method stub
}
@Override
public void Inter2fun2() {
// TODO Auto-generated method stub
}
@Override
public void Inter1fun1() {
// TODO Auto-generated method stub
}
@Override
public void Inter1fun2() {
// TODO Auto-generated method stub
}
}
~~~
## 接口的使用
接口是抽象类一样，是不能被实例化的，但是接口可以用于声明引用类型的变量，当使用接口来声明变量时，该变量的运行时类型必须是该接口的实现类。
接口的作用：
* 用于定义实现类的行为规范；
* 定义变量
* 定义一些常量
* 被其他类实现
一个类是可以实现多个接口的，使用 implements 关键字，多个接口之间用逗号隔开。
一个完整的类定义的语法：
> 在一个 java 文件中，是可以定义多个类的，但是只允许有一个 public 类型的类存在。定义的 public 类型的类必须和文件名一致。
~~~
[修饰符：public、final] class 类名 extends 父类 implements 接口1,接口2...{
....
}
~~~
## 接口和抽象类
**相同点：**
* 都不能被实例化，位于继承树的顶端，是用于被其他类继承或者实现的；
* 都可以包含抽象方法，子类都必须要实现抽象方法；
在实际的开发中，都是接口先行，一般都是先定义接口，然后开发人员实现接口，完成具体方法的实现。
抽象类是个半成品，可以作为一个模板去使用。
**不同点：**
* 抽象类中可以定义普通方法，但是接口中都是抽象方法和静态变量；
* 在抽象类是可以定义静态方法的，接口中不能定义静态方法的；
* 在抽象中可以定义构造器的，但是在接口中是不存在构造器这个概念的；
* 一个类最多只能有一个直接的父类或者抽象类，但是可以有多个接口的实现。
## 练习
**在设计LOL的时候，进攻类英雄有两种，一种是进行物理系攻击，一种是进行魔法系攻击 这时候，就可以使用接口来实现这个效果。 接口就像是一种约定，我们约定某些英雄是物理系英雄，那么他们就一定能够进行物理攻击**
1. **设计物理攻击接口**
2. **设计一类英雄，能够使用物理攻击**
3. **魔法攻击接口**
4. **设计一类英雄，只能使用魔法攻击**
5. **设计一类英雄，既能进行物理攻击，又能进行魔法攻击**
6. **设计辅助英雄接口**
~~~java
/**
* 英雄基类
* @author 一教室
*
*/
public class Hero {
public String name;
public int hp;//生命值
public int mp;//魔法值
public double speed;//移动速度
public int defense;//防御值
public int attackPower;//攻击力
public Hero(String name, int hp, int mp, double speed, int defense, int attackPower) {
super();
this.name = name;
this.hp = hp;
this.mp = mp;
this.speed = speed;
this.defense = defense;
this.attackPower = attackPower;
}
public Hero() {
super();
}
}
/**
* 物理系攻击接口
* @author 一教室
*
*/
public interface AD {
//物理伤害方法
public void physicalAttack();
}
/**
* 物理系英雄
* @author 一教室
*
*/
public class ADHero extends Hero implements AD {
@Override
public void physicalAttack() {
System.out.println("正在使用物理攻击");
}
}
/**
* 魔法系攻击接口
* @author 一教室
*
*/
public interface AP {
/**
* 魔法攻击方法
*/
public void magicAttack();
}
public class APHero extends Hero implements AP {
@Override
public void magicAttack() {
System.out.println("正在进行魔法攻击");
}
}
public class ADAPHero extends Hero implements AD, AP{
@Override
public void magicAttack() {
System.out.println("又进行魔法攻击");
}
@Override
public void physicalAttack() {
System.out.println("又进行物理攻击");
}
}
/**
* 辅助英雄接口
* @author 一教室
*
*/
public interface SUP {
public void support();
}
~~~
