所有回答(1)
这个可能是回调函数在起作用吧，
可以看看这个大神的帖子
&&&您需要以后才能回答，未注册用户请先。[精彩] 新手问：java中的Serializable接口到底是做什么用的？ - ChinaUnix.net
[精彩] 新手问：java中的Serializable接口到底是做什么用的？
http://www.chinaunix.net 作者:&&发表于： 10:55:13
我看了JAVADOCS里的Serializable的文档，没看明白是怎么回事啊。由于初学，没有找到相应的例子看看是怎么用的。
请各位老大指点：
1。能详细讲解一下序列化的概念和这个接口一般在什么情况下使用。
2。能给一个非常简单但能充分展现Serializable的本质的程序。
& 回复于： 12:34:19
序列化是把一个对象的状态写入一个字节流的过程，它执行RMI，RMI允许一台机器上的JAVA对象调用不同机器上的JAVA对象方法，对象可以作为参数提供给那个远程方法，发送机序列化该对象并传送它，接收机执行反序列化。
序列化和反序列化的关系图表可形成包含循环引用的顺序图表。这是整个序列化的总体思想。
而Serializable接口属于支持序列化的一个接口，只有一个实现它的对象可以被序列化工具存储和回复，Serializable接口没有定义任何成员，只用来表示一个累可以被序列化，若该类可以序列化，那么它的所有子类都可以。
下面是关于序列化的一个实例：
程序名称：SerializationDemo.java
程序主题：实现对象的序列化和反序列化
程序说明：该程序由实例化一个MyClass类的对象开始，该对象有三个实例变量，类型分别为String、int、double，是希望存储和恢复的信息。
import&java.io.*;
public&class&SerializationDemo{
&&&&&&&&public&static&void&main(String&args[]){
//Object&serialization
try{
MyClass&object1=new&MyClass("Hello",-7,2.7e10);
System.out.println("object1:"+object1);
FileOutputStream&fos=new&FileOutputStream("serial");
ObjectOutputStream&oos=new&ObjectOutputStream(fos);
oos.writeObject(object1);
oos.flush();
oos.close();
}
catch(Exception&e){
System.out.println("Exception&during&serialization:"+e);
System.exit(0);
//Object&deserialization
try{
MyClass&object2;
FileInputStream&fis=new&FileInputStream("serial");
ObjectInputStream&ois=new&ObjectInputStream(fis);
object2=(MyClass)ois.readObject();
ois.close();
System.out.println("object2:"+object2);
}
catch(Exception&e){
System.out.println("Exception&during&deserialization:"+e);
System.exit(0);
class&MyClass&implements&Serializable{
public&MyClass(String&s,int&i,double&d){
public&String&toString(){
return&"s="+s+";i="+i+";d="+d;
程序运行结果：object1和object2的实例变量是一样的，输出如下：object1:s=Hi=-7;d=2.7E10
object2:s=Hi=-7;d=2.7E10
& 回复于： 09:57:53
hehe
未必是RMI啦
持久化也是Serializable的重点...
& 回复于： 16:17:01
//agree
持久化是Serializable开始的目的。
楼主有什么心得，是不是也response一下？
& 回复于： 16:01:53
现在知道是怎么回事了-----Thank&Bruce&Eckel&a&million&times&for&his&excellent&&&Think&in&java(Second&Edition)&&;&;.书里面讲的好清楚啊。
一。猫小写的不大全，可能是因为我的帖子里写的“一般在什么情况下用”这话作怪。
我补充一下：
Object&serialization的定义：
Object&serialization&允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。&
serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序（用Unix下的c开发过网络编程的人应该知道这个概念，我就容易在这上面犯错）等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。
Object&serialization主要用来支持2种主要的特性：
1。Java的RMI(remote&method&invocation).RMI允许象在本机上一样操作远程机器上的对象。当发送消息给远程对象时，就需要用到serializaiton机制来发送参数和接收返回直。
2。Java的JavaBeans.&&&Bean的状态信息通常是在设计时配置的。Bean的状态信息必须被存起来，以便当程序运行时能恢复这些状态信息。这也需要serializaiton机制。
二。sakulagi和rollingpig说的持久化我也说一下。
我觉得你们说的应该是英文里的persistence.但是Java语言里现在只支持lightweight&persistence,就是轻量级持久化，这是通过serialization机制来实现的。
persistence是指一个对象的生命周期不由程序是否执行来决定，即使是在程序终止时这个对象也存在。它把一个serializable的对象写到磁盘（本机或其他机器上的非RAM存储器），并在程序重新调用时再读取对象到通常的RAM存储器。
为什么说Java的serialization机制实现的是lightweight&persistence?因为你必须显式的序列化和反序列化程序里的对象；而不是直接由一个关键词来定义一个对象是序列化的然后由系统做相应的处理。&&如果以后的Java版本出现一个新的关键字来实现这种机制，比如就是persistence,如果我用
persistence&&(String&s="chinaunix")
然后系统自动做猫小程序里的那些处理，那么Java就实现了persistence.
第一次写这么多，而且是刚看了书不久写的，错误和行文不当之处多包涵。
再次感谢猫小,sakulagi和rollingpig给的提示。
& 回复于： 14:49:39
Joshua&Bloch&的&"Effective&Java&Programming&Language&Guide"&里面关于&Serializable&的部分讲得也很好，尤其是什么时候该用，什么时候不该用。
& 回复于： 17:46:00
&关于序列化处理Bean的状态信息能不能说的详细具体一些呢，谢谢！
& 回复于： 10:55:13
这儿我没有写过，我想是通过序列化bean，进行writeObject方法可以将数据写入数据库的一个表。
oracle对这点有支持。
原文链接：
转载请注明作者名及原文出处中国领先的IT技术网站
51CTO旗下网站
详细介绍Java接口的作用
本文介绍的是JAVA接口的作用，希望对你有帮助，一起来看。
作者：佚名来源：互联网| 16:55
今天和同事好好的讨论了java接口的原理和作用，发现原来自己的对接口的理解仅仅是局限在概念的高度抽象上，觉得好像理解了但是不会变化应用其实和没有理解差不多。以前看一个帖子说学习一个东西不管什么时候都要带着&这个东西是什么？&、&这个东西有什么作用？&和&这个东西怎样用？&三个问题，这三个问题回答上来了说明你对这个事物的理解达到了一定的高度。
今天还有一个比较深的经验是要学习到知识就要多和人交流。就像以前某个管理人员说得&要疯狂的交流&。
现在对于今天学到的接口部分做一个详细地总结：
接口的概念其实并不难理解，接口关键字Interface，在使用时可以只定义函数体而不需要具体的实现。再类的继承过程中可以实现多个接口而取代了类的多继承。使用接口其实就有点像实现虚函数的调用一样，用继承接口的子类实例化声名得借口就可以通过接口调用子类内部接口定义的函数。使用这种接口方式编程，如果业务逻辑发生变化需要新增类多方法，就可以再不改变原来已经写好的代码基础上新增一个类来实现接口中定义的函数来实现。具体方法请看下面两个例子：
1、JAVA多态接口动态加载实例
用来计算每一种交通工具运行1000公里所需的时间，已知每种交通工具的参数都是3个整数A、B、C的表达式。现有两种工具：
Car 和Plane，其中Car 的速度运算公式为：A*B/C
Plane 的速度运算公式为：A+B+C。
需要编写三类：ComputeTime.java,Plane.java,Car007.java和接口Common.java，要求在未来如果增加第3种交通工具的时候，不必修改以前的任何程序，只需要编写新的交通工具的程序。其运行过程如下，从命令行输入ComputeTime的四个参数，第一个是交通工具的类型，第二、三、四个参数分别时整数A、B、C，举例如下：
计算Plane的时间：&java ComputeTime Plane 20 30 40&
计算Car007的时间：&java ComputeTime Car007 23 34 45&
如果第3种交通工具为Ship,则只需要编写Ship.java，运行时输入：&java ComputeTime Ship 22 33 44&
提示：充分利用接口的概念，接口对象充当参数。
实例化一个对象的另外一种办法：Class.forName(str).newInstance（）；例如需要实例化一个Plane对象的话，则只要调用Class.forName(&Plane&).newInstance()便可。
Java代码：
import&CalTime. &import&java.lang.*; &public&interface&Common&...{ &double&runTimer(double&a,&double&b,&double&c); &} &public&class&Plane&implements&Common&...{ &public&double&runTimer(double&a,&double&b,&double&c)&...{ &return&(a+&b&+&c); &} &} &public&class&Car&implements&Common&...{ &public&double&runTimer(double&a,&double&b,&double&c)&...{ &return&(&a*b/c&); &} &} &public&class&ComputeTime&...{ &public&static&void&main(String&args[])&...{ &System.out.println(&交通工具:&&+args[0]); &System.out.println(&&参数A:&&+args[1]); &System.out.println(&&参数B:&&+args[2]); &System.out.println(&&参数C:&&+args[3]); &double&A=Double.parseDouble(args[1]); &double&B=Double.parseDouble(args[2]); &double&C=Double.parseDouble(args[3]); &double&v,t; &try&...{ &Common&d=(Common)&Class.forName(&CalTime.vehicle.&+args[0]).newInstance(); &v=d.runTimer(A,B,C); &t=1000/v; &System.out.println(&平均速度:&&+v+&&km/h&); &System.out.println(&运行时间：&+t+&&小时&); &}&catch(Exception&e)&...{ &System.out.println(&class&not&found&); &} &} &}&
以前看过一个求形状的题目就是有两个圆形求交集现在定义了两种情况问要是扩展大别的情况应当怎么设计，想了很久不得其解，现在忽然觉得接口通杀矣~
2、JAVA接口作为参数传递
可以将借口类型的参数作为方法参数，在实际是使用时可以将实现了接口的类传递给方法，后方法或按照重写的原则执行，实际调用的是实现类中的方法代码体，这样便根据传进屋的参数的不同而实现不同的功能。重要的是，当我以后徐要林外一个对象并且拥有接受说生命的方法的时候的时候，我们不必须原类，只需新的类实现借口即可。
Java代码：
import&java.lang.*; &interface&Extendbroadable&...{ &public&void&inPut(); &} &class&KeyBroad&implements&Extendbroadable&...{ &public&void&inPut()&...{ &System.out.println(&&hi,keybroad&has&be&input&into&then&mainbroad!&&); &} &} &class&NetCardBroad&implements&Extendbroadable&...{ &public&void&inPut()&...{ &System.out.println(&&hi,netCardBroad&has&be&input&into&then&mainbroad!&&); &} &} &class&CheckBroad&...{ &public&void&getMainMessage(Extendbroadable&ext)...{ &ext.inPut(); &} &} &public&class&InterfaceTest01&...{ &public&static&void&main(String&[]args)&...{ &KeyBroad&kb=new&KeyBroad(); &NetCardBroad&ncb=new&NetCardBroad(); &CheckBroad&cb=new&CheckBroad(); &cb.getMainMessage(kb); &cb.getMainMessage(ncb); &} &}&
希望本文的介绍，能给你带来帮助。
【编辑推荐】
【责任编辑： TEL：（010）】
大家都在看猜你喜欢
原创热点头条头条热点
24H热文一周话题本月最赞
讲师：27428人学习过
讲师：119859人学习过
讲师：125544人学习过
精选博文论坛热帖下载排行
本书是目前所能找到的最实用、最全面的Linux指南和参考手册，也是唯一一本提供以下全部内容的书籍：
更好更实用的示例覆盖了实际工作中需...
订阅51CTO邮刊Java 中的接口有什么作用？
来源：互联网
【例如我定义了一个接口，但是我在继承这个接口的类中还要写接口的实现方法，那我不如直接就在这个类中写实现方法岂不是更便捷，还省去了定义接口？接口在java中的作用是什么？个人觉得只是一种规范。大家的看法呢？】
能问这个问题，说明（1）你很会思考（2）编程水平还是处于起步阶段。“接口是个规范”，这句没错。“不如直接就在这个类中写实现方法岂不是更便捷”，你怎么保证这个接口就一个类去实现呢？如果多个类去实现同一个接口，程序怎么知道他们是有关联的呢？既然不是一个类去实现，那就是有很多地方有用到，大家需要统一标准。甚至有的编程语言（Object-C）已经不把接口叫 interface，直接叫 protocol。统一标准的目的，是大家都知道这个是做什么的，但是具体不用知道具体怎么做。比如说：我知道 Comparable 这个接口是用来比较两个对象的，那么如何去比较呢？数字有数字的比较方法，字符串有字符串的比较方法，学生（自己定义的类）也有自己的比较方法。然后，在另外一个负责对象排序（不一定是数字喔）的代码里面，肯定需要将两个对象比较。这两个对象是什么类型呢？Object a,b？肯定不行，a & b 这样的语法无法通过编译。int a,b？也不行？一开始就说了，不一定是数字。....所以，Comparable 就来了。他告诉编译器，a b 两个对象都满足 Comparable 接口，也就是他们是可以进行比较的。具体怎么比较，这段程序不需要知道。所以，他需要一些具体的实现，Comparable 接口有一个方法，叫 compareTo。那么这个方法就是用来取代 &、& 这样的运算符。因为运算符是编译器保留给内置类型（整数、浮点数）进行比较用的，而不是一个广义的比较运算。如果你可以明白 JDK 自身库里面诸如 Comparable 这样已经有的接口，那么就很容易理解自己在开发程序的时候为什么需要用到接口了。
这是一个初学者非常常见的问题。例如我定义了一个接口，但是我在继承这个接口的类中还要写接口的实现方法，那我不如直接就在这个类中写实现方法岂不是更便捷，还省去了定义接口？接口就是个招牌。比如说你今年放假出去杭州旅游，玩了一上午，你也有点饿了，突然看到前面有个店子，上面挂着KFC，然后你就知道今天中饭有着落了。KFC就是接口，我们看到了这个接口，就知道这个店会卖炸鸡腿（实现接口）。那么为神马我们要去定义一个接口涅，这个店可以直接卖炸鸡腿啊（直接写实现方法），是的，这个店可以直接卖炸鸡腿，但没有挂KFC的招牌，我们就不能直接简单粗暴的冲进去叫服务员给两个炸鸡腿了。要么，我们就要进去问，你这里卖不卖炸鸡腿啊，卖不卖汉堡啊，卖不卖圣代啊（这就是反射）。很显然，这样一家家的问实在是非常麻烦（反射性能很差）。要么，我们就要记住，中山路108号卖炸鸡，黄山路45号卖炸鸡（硬编码），很显然这样我们要记住的很多很多东西（代码量剧增），而且，如果有新的店卖炸鸡腿，我们也不可能知道（不利于扩展）。
大家说的都很对，我再补充一点。接口在开发过程中可以快速分离工作内容。比如调用者在写业务逻辑的时候需要一个功能，可能是数据库访问，或者复杂计算，但是他的工作专注于实现业务逻辑，不想分开精力去做底层实现，那么他只需要先实现一个接口，定义了规范，然后就可以继续他的业务逻辑代码了。而实现者可以根据这个接口规范，做具体的实现。这样通过使用接口就可以快速的分离工作内容，达到团队并行工作的目的。此外，如果规范是通过接口定义的，那么当你这个功能有多个实现时，你只要实现了这个接口，那么可以快速的替换具体实现，做到代码层面的完全可以分离。总结起来就一句话：接口或者规范可以在开发过程中做到分离。
nonesuccess:
你写接口你写实现，就不用写接口了。我写接口你实现，接口不就用上了。我不给你规定好了，你怎么知道该实现哪些内容呢。更进一步，我写接口你实现，你今天不在，我明天出差，程序后天交工，那我今天必须把调用这个接口的代码写好。所以就需要接口中有函数，有明确的函数签名。我写个接口，再把调用函数写好，明天你把接口实现了，传个实例进来，交工。interface换个叫法就是contract，有点合同的意思。A实现了这个接口，代表A承诺能做某些事情。B需要一些能做某些事情的东西，于是B要求，必须实现了A接口，才能被我调用。实际上也就是个“规范”。
上面都偏技术化了，我用通俗的语言解释一下。假设你去公司面试，一般都会对学历有要求，比如大学本科、硕士研究生等。“对学历有要求”，这就好比是程序的接口。因为公司招聘是有规章制度的，因此需要有这么一个进人的规范。对“学历要求”具体不同的内容，这就是接口的实现。比如HR要求人力资源或行政相关专业，Java开发工程师可能要求计算机相关专业。高级行政管理人员可能要求MBA学历等等。简单来说，就是不同部门、不同岗位对学历的定义（或者说具体实现）是不同的。因此如果你在一开始就把学历的具体内容规定死了（比如：计算机专业统招本科），这样一来会有以下几个问题产生：1、如果人力部门招这个专业很可能和自己部门的业务不对口，此时如果因此而修改学历要求可能暂时可以满足人力的要求，但是业务部门却又该出麻烦了。2、同一部门的不同职位对于专业学历高低要求不同。比如部门经理要求是研究生、普通员工要求是本科生，如果你直接写死，那么水平高的人招不进来对公司不就是损失吗？软件开发中很重要的一个理念就是“解耦”，接口和接口实现就是在干这件事定好规范，任你实现，效率可高、可低，实现内容也可随时间变化而变化，但是调用关系是不变的（也就是说公司在选拔人才时，无论如何学历还是必须的一环，这一点是不会变的）不知道这么解释大家觉得如何？
接口就是吉祥馄饨的招牌。你进去，都会在墙上挂着菜单，都会从冰箱里拿出一个个方便盒装的冷冻馄饨……但至于味道是不是完全一样（尤其是汤的味道），服务是不是好，卫生够不够格，就看各家店铺的具体实现了。
接口的作用对于很多新手来说很不容易理解，我给大家举个例子。接口只是一个规范，所以里面的方法都是空的。假如我开了一个宠物粮店，声明所有宠物都可以来我这里买粮食，这就相当于一个接口，public interface PetRestaurant { public void buy();}当一只狗看到了，知道自己是宠物，所以它去实现这个接口public class DogPet implements PetRestaurant { @Override public void buy() {
System.out.println("我是狗，我要买狗粮"); }}当一只猫看到了，知道自己也是宠物，所以也去实现这个接口public class CatPet implements PetRestaurant { @Override public void buy() {
System.out.println("我是猫，我要买猫粮"); }}当狗和猫来我的店之前，我是不知道他们到底是什么，但是当他们来到我的店，我就知道一个要猫粮食，一个要狗粮食。因为他们都实现了 我这个接口，都可以买。下面这个类相当于一个接待顾客的类，即店小二，他接待所有实现了我这个宠物店接口的动物，传进来一个PetRestaurant 类型的宠物，注意，这个PetRestaurant 是接口public class test { public void buy(PetRestaurant pet) {
pet.buy(); }}好了，这个时候我这个老板出现了，我可以给他们卖粮食了，相当于测试类public class Tests { public static void main(String[] args) {
PetRestaurant dog = new DogPet();
//实例化一个狗，相当于把狗顾客实例化
PetRestaurant cat = new CatPet();//实例化一个猫，相当于把猫顾客实例化
test t = new test();
//实例化一个店小二
t.buy(cat);
//把猫交给店小二
t.buy(dog); //把狗交给店小二 }}这样运行的结果就是我是猫，我要买猫粮我是狗，我要买狗娘你知道吗，整个过程我这个店主其实根本不知道来的到底是猫是狗还是其他什么，我只要有一个店小二，把这些来的不知什么动物都全部交给店小二，店小二就知道怎么去卖了，因为这些狗啊猫啊都实现了我这个宠物店的接口，而店小二就负责接待所有实现了我这个接口的动物。这就有一个好处，假如明天来了一头小猪，只要它实现了我这个接口，我只管交给店小二处理就OK了，我这个店小二根本不需要变化，我这个店主也只需要实例化一下这个动物就OK你想，假如没有接口，会怎么办，来一个猫，我要去创造一个猫，还要实例化，来一只狗，我要创建一只狗，同样要实例化，还要配备专门的店小二去接待，就会相当麻烦
接口就是抽象。面向对象唯一的核心就是抽象。一切都要基于抽象，也就是基于接口。抽象是什么呢？抽象就是一个概念。举个栗子，就好比说我现在写的这些废话，对于“知乎”来说，所有的文字、格式什么的加在一起，叫做“答案”。“答案”就是一个抽象。具体到代码里就是一个interface UserAnswer之类的东西。如果有点帮助但还有疑问，欢迎评论。
如果你一个接口，只有一个实现类对应的话，其实你享受不到接口的好处，而且还会觉得制造了很多麻烦。但你如果有一组类有类似的“行为”，需要对他们进行约束的话，接口就必不可少了，会发现不再考虑具体的实现，大大减少了编程的复杂度。PS：楼上各位解释了一堆接口的作用，但我觉得楼主不是纠结于接口的使用，而是没有亲身体会到它带来的好处。
最近打算对Java进行细致总结，看到这个问题，就说说我对接口的见解。如果有说的不妥的地方，请指出。主要是结合Java的继承、多态谈谈。目前得票最多的答案呢，说明了一个问题：编程时要面向抽象（接口）进行编程。这么做的好处很多，在得票最多的例子中也有体现，即程序是可拓展的。你在修改你具体的实现的类（或增加新的实现类）的时候呢，不需要去修改调用它的类；这个呢，是Java编程时候强调的”对拓展开放，对修改关闭“原则。在设计模式里面，很多都需要使用接口的。当然，这个也算是Java多态性的体现。第二呢，就是Java通过Interface实现多继承。继承的一个好处呢，就是代码的复用，减少代码错误。在这个当中，接口等同于一种规范，就是要实现这个接口，你就必须实现接口的方法，完成相应的功能。如果没有接口，那么在实现的时候，很可能遗漏方法、或者定义的方法不统一。
两个完全无关的类，实现同一个方法。比如电视机可以open.窗户也可以open.这种情况怎么定义父类？只能使用接口。
菜鸟来强答一个。我是从事android应用开发的，接口在回调中用的比较多。拿android中一个比较常用的接口OnClickListener举例，实现此接口是为了响应点击事件，点击事件具体要做什么，在onClick方法里自己实现。因为它是不知道调用者是要干什么，所以如果写成具体的类是没必要的。有点语无伦次的感觉，还是希望能帮助题主吧。
感觉接口最大的作用还是实现多态。而多态让程序结构的设计更加的优雅。比如java并发中的两个重要接口Runnable和Callable 就是非常好的例子。比如我们要设计一个执行线程的容器（java中已有实现好的线程池机制），要接收一个任务做参数，我们不可能给每一个任务去设计一个方法。接口就为所有的任务类型提供了一种标准，意思是你的任务只要符合这个标准，我的程序就可以处理。---------------------------------------------------于是开发者就可以自由开发了创建一个任何属于自己的任务 Runnable myTask = new MyTask();只要告诉执行器我这是一个runnable就好了，具体执行JVM去动态处理XXXExecutor.execut(myTask)。。。。。-------------------------------------------------------------------回顾这个例子，我觉得既可以说接口是一种标准，亦可以说是类抽象上的又一层抽象写到这，我觉得java爽爆了。。。
说白了就是抽象，规范，回调！接触过框架设计就懂了，当设计大的应用框架时，难免会出现代码耦合，而我们要做的就是让耦合出现在接口上，这样有利用框架的拓展和维护！也就所谓的面向接口编程。看看设计模式也可以加深你的认识！
这个问题是很多刚接触java的朋友常见的问题，为什么要“画蛇添足”的搞一个接口，然后再来个实现类，直接用一个类搞定不好吗？要回答这个问题，其实用教科书的方式是效果最差的，比如举个什么洗衣服的接口，然后有洗衣机，妈妈去实现接口之类的···啊喂，你们在说什么呢！谁遇到过什么洗衣机和妈妈实现个洗衣服的接口？你们程序员宅男都是这么忽悠人的吗？（内心咆哮···）咱们还是举个实际的例子，大家就明白它有什么用了。这个例子来自于我之前做的一个系统，一个web电子地图，就像百度地图那样。其中一个类，要把浏览器传给web层的参数拿过去，请求对应的地图数据。按照谷歌的墨卡托投影，切片之后的图片，表示方式由四个参数决定：name（地图名），x（横向编号），y（纵向编号），z（缩放等级）。一开始，我写了一个类，叫TileFetcher，其中的getTile（String name, int x, int y, int z）方法，是获取地图数据的方法。一切很自然对吧···好，系统做好之后，用户使用了一段时间，表示很好用，不过他们有了一个新的需求：他们希望接入第三方的数据。这里补充一下，我们的数据是存在关系数据库里，第三方的数据，是用rest提供的，用户通过地图名name来区分应该访问我们的数据还是第三方的数据。这时候第一种改造方案，实现一个TileFetcher2，然后再web层判断name之后，调用不同的类来获取地图数据。ok，没问题。但是，如果过一段时间客户又要再加一个第三方数据呢？得···又改web层的代码···加一个数据来源，改一次代码···是不是很讨厌？这叫什么？紧耦合了···更极端的情况，产品卖出去了，客户说“我们要接的这个数据密级特别高，你们不能接触，甚至不能知道是什么协议，怎么接入，我们要自己写代码···”得，这下连我们的源代码都得给客户了，还得让客户看懂我们的代码，这是不是很蛋疼？所以不能这么玩，这种改造方案不可行。于是乎：当当当当！接口的作用就体现出来的！！首先我们定义一个interface ITileFetcher，里面一个方法getTile(````)参数我就不列了，还是那四个。接着，我们搞两个实现类：我们自己的数据：OwnTileFetcher，第三方的数据：SBTileFetcher(不要在意这些细节····)。然后，我们做一个xml配置文件，&TileFetcher mapName="xxx" class="com.niubi.xxx.yyy.zzTileFetcher"&，web层初始化的初始化的时候，根据这个xml文件，搞一个HashMap，key是地图名name，value是ITileFetcher某个实现类的单例，Class.forName的方式实例化。在web层需要获取地图数据时，根据当前请求的地图名name，在HashMap中拿到对应的ITileFetcher的实现类，然后调用getTile方法：ITileFetcher fetcher = fetcherMap.get(name);data = fetcher.getTile(``````);就酱，web层完全不关心到底调用了那个类，直接使用接口方法就ok了。好处是什么呢？再也不用改web层了对吧？有新的数据？没问题，写一个ITileFetcher的实现类，然后配置一下xml文件，搞定。用户想自己开发？没问题，写好实现类，打个jar扔进去，配置一下xml文件，搞定。这是什么？解耦。这就是接口的用法，实际用法。现在明白为什么要接口了吗？这里说明一下：name和实现类是多对一的；如果name可能重合，那是业务规则问题，可以通过不同的xml规则来解决，不影响interface的用法。说明：本答案严禁转载到任何第三方平台，包括但不限于微博，朋友圈等非技术类社交网站。
瞄瞄十八摸:
面向对象无非是研究实体与行为，接口是对于一组行为的抽象。对于一个对象，其在一个环境上下文下面会表现其特性，这个也是为什么C++要有多重继承的原因。C++的多重继承包括了对象的属性+行为方法，但是Java认为对象在大多数情况，其行为会表现出各种多样性，而属性本身变化的很少，于是更加工程化一些，所以就会有接口这个东西的出现了（只有行为）。另外，所有分类都是有领域边界的。举个例子，如果对于一个问题域，我只想研究针对会写程序的这一组行为动作，可以定义一个接口叫做Programable（写程序的接口），里面包括了coding，debugging两种行为，那么我只需要针对这个Programmable接口进行编程就行了，而我压根不关心到底是哪一个对象实现了这个接口，是A公司的程序员，还是B公司的一台自动编程机器对象，对于解决这个问题来说，压根不关心，它只需要知道，最后传进来的一个对象，是实现了这个接口的就行，否则编译器就会报错。上面是从解决问题的角度，来看接口，下面来看看从对象的角度来看接口。一个对象可以implements很多个接口，我们从上述问题域角度分析出发，一个接口是用来面向解决一个问题域行为建模问题的，那么可以认为，一个对象放在不同的问题域里面，其实人关注这个对象的角度是不一样的。我们可以这么看，一个对象是一个球，不同的问题域对于这个对象的诉求是不同的，每一个问题域仅仅是需要一个对象的一个切面而已（也就是接口）。而对于程序员或者OO建模者来说，如果把一个对象看成是一个大象，那么我们永远只需要关心某个大象的局部，而不需要关心这个大象的所有，我们也不可能构建一个完美的大象，就好比我们不可能写一个类叫Person，这个Person能够把所有环境下（活上下文或问题领域）中的行为都包含清楚。这也是为什么我们需要接口的原因。
jason christ:
所以jdk1.8开始，接口可以有默认实现了
定义接口和直接写在类里面最大的区别，是接口可以定义关注局部的类型。这点在静态类型的语言中非常重要。这种对局部的关注，在接口隔离原则中可以体现：
代码即文档的表现形式之一。一种抽象代码级别的约束思想。给编译器提供的约束文档。合作开发中说明必须实现的方法。项目中避免直接类写时方法名笔误或某方法没实现等问题。
同意上面一些人说的，接口是一种协议。如果你想遵从（implement）某个协议，完成这个协议中要求的操作（实现接口时必须要时间接口下的方法）。
免责声明：本站部分内容、图片、文字、视频等来自于互联网，仅供大家学习与交流。相关内容如涉嫌侵犯您的知识产权或其他合法权益，请向本站发送有效通知，我们会及时处理。反馈邮箱&&&&。
学生服务号
在线咨询，奖学金返现，名师点评，等你来互动}