阿里Java学习路线：阶段 1：Java语言基础－Java面向对象编程：第20章：接口的定义与使用：课时87：接口基本定义

当你可以灵活的使用抽象类和接口进行设计的时候，那么基本上就表示你面向对象的概念理解了。这一步是需要大量的程序代码累积而成的。

接口的基本定义

抽象类与普通类相比最大的优势在于：可以实现对子类覆写方法的控制，但是在抽象类里面可能依然会保留有一些普通方法，而普通方法里面可能会涉及到一些安全或者隐私的操作问题，那么这样在进行开发的过程之中，如果要想对外部隐藏全部的实现细节，则就可以通过接口来进行描述。
接口可以理解为一个纯粹的抽象类（最原始的定义接口之中是只包含有抽象方法与全局常量的），但是从JDK1.8开始引入了Lambda表达式的概念，所以接口的定义也得到了加强，除了抽象方法与全局常量之外，还可以定义普通方法或静态方法。如果从设计本身的角度来讲，接口之中的组成还是应该以抽象方法和全局常量为主。
在Java中接口主要使用interface关键字来进行定义。
范例：定义一个接口

// 由于类名称与接口名称的定义要求相同，所以为了区分出接口名称前往往会加入字母I（interface的简写）
interface IMessage { // 定义了一个接口
	public static final String INFO = "www.mldn.cn" ; // 全局常量
	public abstract String getInfo() ; // 抽象方法
}

但是现在很明显的问题出现了，此时的接口肯定无法直接产生实例化对象，所以对于接口的使用原则如下：
1.接口需要被子类实现（implements），一个子类可以实现多个父接口；
2.子类（如果不是抽象类）那么一定要覆写接口之中的全部抽象方法；
3.接口对象可以利用子类对象的向上转型进行实例化。
范例：定义接口子类

// 由于类名称与接口名称的定义要求相同，所以为了区分出接口名称前往往会加入字母I（interface的简写）
interface IMessage { // 定义了一个接口
	public static final String INFO = "www.mldn.cn" ; // 全局常量
	public abstract String getInfo() ; // 抽象方法
}
class MessageImpl implements IMessage{ // 实现了接口
	public String getInfo() {
		return "得到一个消息，秘密的消息，有人胖了（不是我）。" ;
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IMessage msg = new MessageImpl() ;
		System.out.println(msg.getInfo()) ;
		System.out.println(IMessage.INFO) ; // 直接输出全局常量
	}
}

以上是接口的基本使用，但是在Java里面之所以使用接口主要的目的是一个子类可以实现多个接口，利用接口可以实现多继承的概念。
范例：观察子类实现多个父接口

// 由于类名称与接口名称的定义要求相同，所以为了区分出接口名称前往往会加入字母I（interface的简写）
interface IMessage { // 定义了一个接口
	public static final String INFO = "www.mldn.cn" ; // 全局常量
	public abstract String getInfo() ; // 抽象方法
}
interface IChannel {
	public abstract boolean connect() ; // 定义抽象方法
}
class MessageImpl implements IMessage,IChannel{ // 实现了接口
	public String getInfo() {
		if (this.connect())	{
		return "得到一个消息，秘密的消息，有人胖了（不是我）。" ;
		}
		return "通道创建失败，无法获取消息。";
	}
	public boolean connect() {
		System.out.println("消息发送通道已经成功建立。");
		return true ;
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IMessage msg = new MessageImpl() ;
		System.out.println(msg.getInfo()) ;
	}
}

但是这个时候就需要考虑一个实际的情况了，关于对象的转型问题了。

此时MessageImpl子类的对象可以任意的实现父接口的转换。
范例：观察转换

public class JavaDemo {
	public static void main(String args[]) {
		IMessage msg = new MessageImpl() ;
		IChannel chl = (IChannel) msg ;
		System.out.println(chl.connect()) ;
	}
}

由于MessageImpl子类实现了IMessage 与IChannel两个接口，所以这个子类可以是这两个接口任意一个接口的实例，那么就表示此时这两个接口实例之间是可以转换的。
在java程序里面接口是不允许去继承父类的，所以接口绝对不会是Object的子类，但是根据之前的分析可以发现，MessageImpl是Object子类，所以接口一定可以通过Object接收。
范例：观察Object与接口转换

public class JavaDemo {
	public static void main(String args[]) {
		IMessage msg = new MessageImpl() ;
		Object obj = msg ; // 向上转型
		IChannel chan = (IChannel) obj ;
		System.out.println(chan.connect());
	}
}

Object 类对象可以接收所有数据类型，包括基本数据类型、类对象、接口对象、数组。
由于接口描述的是一个公共的定义标准，所以在接口之中所有的抽象方法的访问权限都为public，也就是说写与不写是一样的，例如：下面的两个接口本质是完全相同的：
完整定义：

interface IMessage { // 定义了一个接口
	public static final String INFO = "www.mldn.cn" ; 
	public abstract String getInfo() ;
}

简化定义：

interface IMessage { // 定义了一个接口
	String INFO = "www.mldn.cn" ;
	String getInfo() ;
}

方法不写访问权限也是public，不是default，所以覆写的时候只能够使用public。
接口虽然已经可以成功的进行了定义，但是千万不要忽略，在实际的开发过程之中，实现接口的有可能是抽象类，一个抽象类可以实现多个接口，而一个普通类只能够继承一个抽象类并且可以实现多个父接口，但是要求先继承后实现。
范例：子类继承抽象类并且实现接口

interface IMessage { // 定义了一个接口
	public static final String INFO = "www.mldn.cn" ;
	public abstract String getInfo() ;
}
interface IChannel {
	public abstract boolean connect() ; // 定义抽象方法
}
abstract class DatabaseAbstract { //定义一个抽象类
	// 接口中的abstract可以省略，抽象类中不允许省略
	public abstract boolean getDatabaseConnection() ;
}
class MessageImpl extends DatabaseAbstract implements IMessage,IChannel{ // 实现了接口
	public String getInfo() {
		if (this.connect())	{
			if (this.getDatabaseConnection()) {
				return "数据库中到一个消息，秘密的消息，有人胖了（不是我）。" ;
			} else {
				return "数据库消息无法访问。";
			}
		}
		return "通道创建失败，无法获取消息。";
	}
	public boolean connect() {
		System.out.println("消息发送通道已经成功建立。");
		return true ;
	}
	public boolean getDatabaseConnection() {
		return true ;
	}
}
public class JavaDemo {
	public static void main(String args[]) {
		IMessage msg = new MessageImpl() ;
		System.out.println(msg.getInfo());
	}
}

虽然接口无法去继承一个父类，但是一个接口却可以通过extends继承若干个父接口，此时称为接口多继承。
范例：实现接口多继承

interface IMessage {
	public abstract String getInfo() ;
}
interface IChannel {
	public boolean connect() ;
}
// extends在类继承上只能够继承一个父类，但是接口上可以继承多个
interface IService extends IMessage,IChannel { // 接口多继承
	public String service() ;
}
class MessageService implements IService {
	public String getInfo() {
		return null ;
	}
	public boolean connect() {
		return true ;
	}
	public String service() {
		return "获取消息服务";
	}
}

在实际的开发之中，接口的使用往往有三种形式：
1.进行标准设置；
2.表示一种操作的能力；
3.暴露远程方法视图，这个一般都在RPC分布式开发中使用。