抽象类与普通类相比最大的特点是约定了子类的实现要求，但是抽象类有一个缺点：单继承局限，如果要想约定子类的实现要求以及避免单继承的局限就需要使用接口。在你以后的开发设计之中：接口优先。在一个操作既可以使用抽象类又可以使用接口的时候，请优先考虑接口。
一. 接口的基本概念
接口就是一个抽象方法和全局常量的集合，在Java中接口可以使用interface关键字来进行定义。如果子类要想使用接口，那么就必须利用implements关键字来实现接口，同时一个子类可以同时实现多个接口，也就是说可以利用接口来实现多继承的概念。对于接口的子类（如果不是抽象类）则必须覆写接口中的全部抽象方法。随后可以利用子类对象的向上转型通过实例化子类来得到接口的实例化对象。
当一个子类继承了多个接口之后，并且接口对象通过子类进行实例化，那么这多个父接口之间是允许互相转换的。
二. 接口使用限制
1. 接口定义完成之后，就需要对其有一个核心的说明，那么首先需要说明的是：接口里面只允许存在有public权限，也就是说不管是属性还是方法其权限只能是public。
在以后编写接口的时候，99%的接口里面只会提供有抽象方法，很少在接口里面看见有许多的全局常量。所以很多时候为了防止避免一些开发者出现混乱，所以接口的方法上往往都会加上pubLic。
2. 当一个子类需要实现接口又需要继承抽象类的时候，请先使用extends继承一个抽象类，而后再使用implements实现多个接口。
3. 一个抽象类可以使用implements实现多个接口，但是接口不能够去继承抽象类。
4. 一个接口可以使用extends来继承多个父接口。
5. 接口可以定义一系列的内部结构，包括：内部的普通类、内部抽象类、内部接口，其中使用static定义的内部接口就相当于一个外部接口。
对于内部的结构依然不是你们的首选，而且要想清楚接口的实际开发意义，需要大量的项目来验证。
三. 使用接口定义标准
对于接口在实际的开发之中有三大核心应用环境：
①定义操作标准；
②表示能力；
③在分布式开发之中暴露远程服务方法。
class TestDemo {
public static void main(String args[]) {
Computer com = new Computer() ;
com.plugin(new Flash()) ;
com.plugin(new Print()) ;
}
}
interface USB {
public void setup() ; // 安装USB驱动
public void work() ; // 进行工作
}
class Computer {
public void plugin(USB usb) {//只能够插入USB设备
usb.setup() ;
usb.work() ;
}
}
class Flash implements USB {
public void setup() {
System.out.println("安装U盘驱动！") ;
}
public void work() {
System.out.println("进行数据传输！") ;
}
}
class Print implements USB {
public void setup() {
System.out.println("安装打印机驱动！") ;
}
public void work() {
System.out.println("进行文件打印！") ;
}
}
发现使用接口和对象多态性的概念结合之后，对于参数的统一更加明确了。而且可以发现接口是在类之上的设计抽象。
四. 工厂设计模式（Factory） 【重点】
首先来看一个简单的程序范例: 在进行类设计的时候，要求首先需要有接口，而后接口要通过子类才可以进行对象的实例化处理。
此时的程序实现的关键是：“IFruit fruit = new Apple() ;”，如果没有此语句，接口对象将无法进行实例化的操作处理。但是最大的败笔也在此。主方法是一个客户端，那么对于程序的修改不应该影响到客户端。
这个时候new是整个开发过程之中最大的耦合元凶，而我们在开发之中要想进行解耦合的关键就在于要引入一个第三方，所以这个类可以使用Factory来描述。
范例：
class TestDemo {
public static void main(String args[]) {
if(args.length != 1) { // 没有传递一个参数
System.out.println("对不起，程序执行错误，正确的格式：java TestDemo 类名称") ;
System.exit(1) ; // 退出程序执行
}
System.out.println("hello world !\n") ;
Computer com = new Computer() ;
com.plugin(new Flash()) ;
com.plugin(new Print()) ;
//IFruit fruit = new Apple() ;
// 利用第三方来进行解耦合
IFruit fruit = Factory.getInstance(args[0]) ;
fruit.eat() ;
}
}
class Factory {
// 因为此时Factory产生实例化对象没有意义
public static IFruit getInstance(String className) {
if("apple".equals(className)) {
return new Apple() ;
}
if("orange".equals(className)) {
return new Orange() ;
}
return null ;
}
}
interface USB {
public void setup() ; // 安装USB驱动
public void work() ; // 进行工作
}
class Computer {
public void plugin(USB usb) { //只能够插入USB设备
usb.setup() ;
usb.work() ;
}
}
class Flash implements USB {
public void setup() {
System.out.println("安装U盘驱动！") ;
}
public void work() {
System.out.println("进行数据传输！") ;
}
}
class Print implements USB {
public void setup() {
System.out.println("安装打印机驱动！") ;
}
public void work() {
System.out.println("进行文件打印！") ;
}
}
interface IFruit {
public void eat() ;
}
class Apple implements IFruit {
public void eat() {
System.out.println("\n削皮吃苹果！") ;
}
}
class Orange implements IFruit {
public void eat() {
System.out.println("\n剥皮吃橘子！") ;
}
}
当更换使用的IFruit子类的时候主方法没有任何的变化就可以实现了子类的变更，这样的设计就成为工厂设计模式。
总结：以后只要是你编写的接口如果要想取得接口的实例化对象，第一反应：写工厂类。
五. 代理设计模式（Proxy）【重点】
所谓的代理严格来讲就是两个子类共同实现一个接口，其中一个子类负责真实的业务实现，而另外的子类负责辅助真实业务主题的操作。
class TestDemo {
public static void main(String args[]) {
if(args == null) {
System.out.println("命令行参数为null") ;
}
if(0 == args.length) {
System.out.println("命令行参数个数为0") ;
}
if(args.length != 1) { // 没有传递一个参数
System.out.println("对不起，程序执行错误，正确的格式：java TestDemo 类名称") ;
System.exit(1) ; // 退出程序执行
}
System.out.println("hello world !\n") ;
Computer com = new Computer() ;
com.plugin(new Flash()) ;
com.plugin(new Print()) ;
//IFruit fruit = new Apple() ;
// 利用第三方来进行解耦合
IFruit fruit = Factory.getInstance(args[0]) ;
fruit.eat() ;
//ISubject sub = new ProxySubject(new RealSubject()) ;
ISubject sub = Factory.getInstance() ;
// 通过代理类对象发出，利用代理类来实现真实业务调用
sub.save() ;
}
}
class Factory {
// 因为此时Factory产生实例化对象没有意义
public static IFruit getInstance(String className) { //通过普通类去操作
if("apple".equals(className)) {
return new Apple() ;
}
if("orange".equals(className)) { //通过代理类去操作
return new Orange() ;
}
return null ;
}
public static ISubject getInstance() {
return new ProxySubject(new RealSubject()) ;
}
}
interface USB {
public void setup() ; // 安装USB驱动
public void work() ; // 进行工作
}
class Computer {
public void plugin(USB usb) { //只能够插入USB设备
usb.setup() ;
usb.work() ;
}
}
class Flash implements USB {
public void setup() {
System.out.println("安装U盘驱动！") ;
}
public void work() {
System.out.println("进行数据传输！") ;
}
}
class Print implements USB {
public void setup() {
System.out.println("安装打印机驱动！") ;
}
public void work() {
System.out.println("进行文件打印！") ;
}
}
interface IFruit {
public void eat() ;
}
class Apple implements IFruit {
public void eat() {
System.out.println("\n削皮吃苹果！") ;
}
}
class Orange implements IFruit {
public void eat() {
System.out.println("\n剥皮吃橘子！") ;
}
}
interface ISubject {
public void save() ; // 核心功能是救人
}
class RealSubject implements ISubject {
public void save() {
System.out.println("真正的制止了暴力事件！") ;
}
}
class ProxySubject implements ISubject { // 代理实现
private ISubject subject ; // 真正的操作业务
// 在创建代理类对象的时候必须设置要代理的真实主题
public ProxySubject(ISubject subject) {
this.subject = subject ;
}
public void broke() {
System.out.println("1、破门而入！") ;
}
public void get() {
System.out.println("2、得到见义勇为奖！") ;
}
public void save() {
this.broke() ; // 真实操作前的准备
this.subject.save() ; // 调用真实的业务
this.get() ; // 操作后的收尾
}
}
代理的本质：所有的真实业务操作都会有一个与之辅助的功能类共同完成。
六. 抽象类与接口的区别（面试题）
抽象类和接口都属于常用的类结构设计，在开发之中都会出现，不过如果按照优先选择来讲，接口一定要比抽象类更方便。
除了单继承的局限之外，实际上使用抽象类和接口都是类似的，但是在实际的开发之中，抽象类的设计要比接口复杂。
1. 接口是Java的核心，慢慢需要学习到接口的更多使用以及设计；
2. 开发之中优先考虑接口，以避免单继承局限；
