本篇文章探讨了JAVA从入门到精通之接口，希望阅读本篇文章以后大家有所收获，帮助大家对相关内容的理解更加深入。

"

1.接口的定义

1.1.接口的基本定义

 1 interface IClassName{ 2     public String getClassName(); 3 } 4 class Company implements IClassName{ 5     public String getClassName() { 6         return ""classname""; 7     } 8 } 9 public class interface_01 {10     public static void main(String[] args) {11         IClassName comp = new Company();12         System.out.println(comp.getClassName());13     }14 }

1.2.接口的继承

1.MessageImpl子类的对象可以任意的实现父接口的转换。
2.Object类对象可以接收所有的数据类型，包括基本数据类型、类对象、接口对象、数组。 
3.由于接口描述的是一个公共的定义标准，所以在接口中所有的抽象方法的访问全县都为public，所以写与不写都是一样的。

1.2.接口中的抽象方法abstract写于不写都一样。 在实际开发过程中，实现接口的又可能是抽象类，一个抽象类可以实现多个接口。
3.

 1 interface IMessage{ 2     public static final String INFO=""www.sina.com.cn"";//全局常量 3     public abstract String getInfo();//抽象方法 4     //3.由于接口描述的是一个公共的定义标准，所以在接口中所有的抽象方法的访问全县都为public，所以写与不写都是一样的。 5     //String INFO=""www.sina.com.cn"";//方法不写访问权限也是public，不是default，所以覆写的时候只能够使用public。 6     //String getInfo();//abstract写于不写都一样。 在实际开发过程中，实现接口的又可能是抽象类，一个抽象类可以实现多个接口， 7     //一个普通类只能够继承一个抽象类并且可以实现多个父接口，但是要求先继承后实现。 8 } 9 abstract class DatabaseAbstract{10     public abstract boolean getDatabaseAbstract();11 }12 interface IChannel{13     public abstract boolean connect();14 }15 class MessageImpl extends DatabaseAbstract implements IMessage, IChannel{//一个子类可以实现多个接口16     public String getInfo() {17         if(this.connect()) {18             if(this.getDatabaseAbstract()) {19                 return ""数据库得到一个消息：房价又跌了！"";20             }else {21                 return ""数据库消息无法访问！"";22             }23         }24         return ""通道建立失败!"";25     }26     public boolean connect() {27         System.out.println(""通道建立成功！"");28         return true;29     }30     public boolean getDatabaseAbstract() {31         return true;32     }33 }34 public class interface_02 {35     public static void main(String[] args) {36         IMessage msg = new MessageImpl();37         System.out.println(msg.getInfo());38         //System.out.println(IMessage.INFO);39         40         //IChannel chnl = (IChannel) msg;  //1.MessageImpl子类的对象可以任意的实现父接口的转换。41         //System.out.println(chnl.connect());42         43         //Object obj = msg;44         //IChannel chan = (IChannel)obj;45         //System.out.println(chan.connect());//2.Object类对象可以接收所有的数据类型，包括基本数据类型、类对象、接口对象、数组。 46     }47 }

1.3.接口的多继承

需要覆写接口中的所有抽象方法：包括本接口中的方法和继承的所有方法。

 1 interface IMessage{ 2     public abstract String getInfo(); 3 } 4 interface IChannel{ 5     public boolean connect(); 6 } 7 //extends在类继承上只能够继承一个父类，但是接口上可以继承多个父接口。 8 interface IService extends IMessage, IChannel{//接口多继承 9     public String service();10 }11 class MessageService implements IService{12     public String getInfo() {13         return """";14     }15     public boolean connect() {16         return true;17     }18     public String service() {19         return ""获取消息服务。"";20     }21 }22 public class interface_03 {23     public static void main(String[] args) {24         MessageService msg = new MessageService();25         System.out.println(msg.service());26     }27 }

在实际的开发中，接口的使用往往有三种形式：

1.进行标准设置；

2.表示一种操作的能力；

3.暴露远程方法试图，这个一般都在RPC分布式开发中使用。

1.4.接口定义加强

接口最早的主要特点是全部由抽象方法和全局变量所组成，但是如果你的项目设计不当，就有可能出现一种非常严重的问题。

自从JDK1.8之后开始，为了解决接口设计的缺陷，在接口中允许开发者使用default定义普通方法。

 1 interface IMessage{ 2     public String message(); 3     public default boolean connect() { 4         System.out.println(""建立消息的连接通道。""); 5         return true; 6     } 7 } 8 class MessageImpl implements IMessage{ 9     public String message() {10         return ""www.sina.com.cn"";11     }12 }13 public class interface_04 {14     public static void main(String[] args) {15         IMessage msg = new MessageImpl();16         System.out.println(msg.connect());17     }18 }

接口中的普通方法必须追加default声明，但是需要提醒的是，该操作属于挽救功能，所以如果不是必须的情况下，不应该作为设计的首选。

除了可以追加普通方法之外，接口里面也可以定义static方法，而static方法就可以通过接口直接调用。

举例：在接口中定义static方法

 1 interface IMessage{ 2     public String message(); 3     public default boolean connect() { 4         System.out.println(""建立消息的连接通道。""); 5         return true; 6     } 7     public static IMessage getInstance() { 8         return new MessageImpl(); 9     }10 }11 class MessageImpl implements IMessage{12     public String message() {13         if(this.connect()) {14             return ""www.sina.com.cn"";15         }16         return ""消息没有发送！"";17     }18 }19 public class interface_04 {20     public static void main(String[] args) {21         IMessage msg = IMessage.getInstance();22         System.out.println(msg.connect());23     }24 }

 如果现在真的可以在接口里面定义普通方法或者static方法，那么这个功能就已经可以取代抽象类了，但是不应该将这两个组成作为接口的主要设计原则。我们缩写的代码里面还是应该奉行：接口就是抽象方法。

1.5.使用接口定义标准

　　对于接口而言，在开发制作最为重要的应用就是进行标准的制定，实际上在日常的生活中也会听到许多关于接口的名词，例如USB接口、PCI接口、鼠标接口等，那么这些实际上都是属于标准的应用。

　　电脑上可以插入各种USB的设备，所以电脑上认的是USB标准，而不关心这个标准的具体实现类。

　　举个例子：

 1 interface IUSB{ 2     public boolean check(); 3     public void work(); 4 } 5 class Computer{ 6     public void plugin(IUSB usb) { 7         if(usb.check()) { 8             usb.work(); 9         }else {10             System.out.println(""硬件设备安装出现问题！"");11         }12     }13 }14 class Keyboard implements IUSB{15     public boolean check() {16         return true;17     }18     public void work() {19         System.out.println(""开始进行码字任务。"");20     }21 }22 class Printer implements IUSB{23     public boolean check() {24         return false;25     }26     public void work() {27         System.out.println(""开始进行照片打印。"");28     }29 }30 public class interface_05 {31     public static void main(String[] args) {32         Computer computer = new Computer();33         computer.plugin(new Keyboard());34         computer.plugin(new Printer());35     }36 }

1.6.工厂设计模式

 　　对于接口而言，已经可以明确的是，必须有子类，而且子类可以通过对象的向上转型来获取接口的实例化对象。但是在进行对象实例化的过程中，也有可能存在设计问题。

 举个例子：

 1 interface IFood{ 2     public void eat(); 3 } 4 class Bread implements IFood{ 5     public void eat() { 6         System.out.println(""吃面包。""); 7     } 8 } 9 public class interface_06 {10     public static void main(String[] args) {11         IFood food = new Bread();12         food.eat();13     }14 }

在本程序中根据接口定义来子类的定义，并且利用对象的向上转型进行接口对象实例化处理。

现在出现了问题：客户端需要明确的知道具体的哪一个子类，如果现在面包吃腻了，需要牛奶了，那么客户端就要作出相应的修改。

 1 interface IFood{ 2     public void eat(); 3 } 4 class Bread implements IFood{ 5     public void eat() { 6         System.out.println(""吃面包。""); 7     } 8 } 9 class Milk implements IFood{10     public void eat() {11         System.out.println(""喝牛奶。"");12     }13 }14 public class interface_06 {15     public static void main(String[] args) {16         IFood food = new Milk();17         food.eat();18     }19 }

所以，此时的程序就出现了耦合的问题，而造成耦合最直接的元凶是“关键字new”。

以Java的设计为例，Java实现可移植性的关键是JVM，而JVM的核心原理：利用一个虚拟机来运行Java程序，所有的程序并不与具体的操作系统有任何关联，而是由JVM来进行匹配。所以得出结论：良好的设计应该避免耦合。

举个例子：

          Bread                System.out.println(""吃面包。""    Milk                System.out.println(""喝牛奶。""                  (""bread""                       } (""milk""              <span style=""color: #"
      本文由职坐标整理发布，学习更多的相关知识，请关注职坐标IT知识库！