学到JAVA接口

现在学完了JAVA的面向对象，有点晕，最主要就是接口，它没方法实现那有什么作用呢？

解决方案 »

免费领取超大流量手机卡，每月29元包185G流量+100分钟通话, 中国电信官方发货

接口是为了实现松散耦合，以及在分层开发的时候例如表现层专人开发，  业务层专人开发，而这个时候就需要使用接口。约束参数及返回类型。                                                             java-木子[1]群 40110165
decouple impove the code reuse ability
只能举个连接数据库的例子，我们JAVA程序员肯定会经常和数据库打交道，所以SUN公司肯定会给我们提供链接和操作数据库的方法吧，但是我们再仔细想想，全世界的数据库厂商不止一家吧！它里面的实现原理肯定也大有不同吧！那么SUN公司给你们每个数据库厂商都要写上一大堆的方法去连接和操作你，如果真的那么做了，SUN公司肯定会疯的，再说了谁知道以后还有什么新的数据库会出现，所以那样做肯定是相当不现实的，这时接口可就要发威了，SUN公司会提供大量的接口，里面会写好多空方法，SUN还会给这些方法起个比较有意义的名字，作用就是要让实现我这接口的类明白你要做什么事，但具体怎么做我就不管了，然后SUN会把这些接口都装到一个大盒子里（JDBC），如果哪家数据库厂商想跟我连接那你就去实现我这些接口然后你们自己去写大量的代码来实现我的所有的方法，这就是你们数据库厂商的事了，比如说SQLserver和oracle它们分别用不同的方法实现了SUN给的那些接口，然后把这些类再打成jar包（驱动类），我们就可以通过这些包对相应的数据库进行操作了。这是我以前在学习JAVA时QQ空间的一篇日志，只是接口的一个方面而已。
三流的产品。
二流的服务。
一流的接口。   sun实现了一系列的数据库接口。具体实现不用操心，只要哪个产家想用就去实现。
给楼主举个例子，比如USB，国际组织只是负责USB产品的传输协议等的制定，具体各个厂家如何生产，用什么样的电路与芯片都是厂家的事情。它们生产出来的商品只需要满足USB产品的标准就可以达到通用化。
这就是Java中的接口，定义某些标准让不同的类去实现。
看第六章，第七章
http://www.cnblogs.com/healerkx/category/136925.html
简单的讲就是实现多继承。
否则EXTEND只能继承一个父类，这是万万不行地
为什么使用接口
　　两个类中的两个类似的功能，调用他们的类动态的决定一种实现，那他们提供一个抽象父类，子类分别实现父类所定义的方法。
　　问题的出现：Java是一种单继承的语言，一般情况下，哪个具体类可能已经有了一个超类，解决是给它的父类加父类，或者给它父类的父类加父类，只到移动到类等级结构的最顶端。这样一来，对一个具体类的可插入性的设计，就变成了对整个等级结构中所有类的修改。
　　接口是可插入性的保证。
　　在一个等级结构中的任何一个类都可以实现一个接口，这个接口会影响到此类的所有子类，但不会影响到此类的任何超类。此类将不得不实现这个接口所规定的方法，而其子类可以从此类自动继承这些方法，当然也可以选择置换掉所有的这些方法，或者其中的某一些方法，这时候，这些子类具有了可插入性(并且可以用这个接口类型装载，传递实现了他的所有子类)。
　　我们关心的不是那一个具体的类，而是这个类是否实现了我们需要的接口。
　　接口提供了关联以及方法调用上的可插入性，软件系统的规模越大，生命周期越长，接口使得软件系统的灵活性和可扩展性，可插入性方面得到保证。
　　类型
　　使用Java接口将软件单位与内部和外部耦合起来。使用Java接口不是具体的类进行变量的类型声明，方法的返还类型声明，参量的类型声明，以及数据类型的转换。
　　在理想的情况下，一个具体的Java类应当只实现Java接口和抽象Java类中声明的方法，而不应当给多余方法。
　　类型等级结构
　　Java接口(以及抽象类)一般用来作为一个类型的等级结构的起点。
　　如果一个类已经有了一个主要的超类型，那么通过实现一个接口，这个类可以拥有另一个次要的超类型，这种次要的超类型叫做混合类型。
[编辑本段]Java接口常用方法
　　单方法接口
　　以下是引用片段：
　　public interface Actionlistener{
　　public abstract void actionPerformed(ActionEvent event);
　　}
　　仅且只有一个方法，只有实现了这个接口(重写这个接口中的唯一一个方法)，你才有资格去事件监听器列表里注册(参数为Actionlistener类型)，当事件源变动时，自动调用这个唯一的actionPerformed方法.
　　标识接口
　　是没有任何方法和属性的接口。标识接口不对实现它的类有任何语意上的要求，它仅仅表明了实现它的类属于一个特定的类型(传递)。
　　不推荐过多的使用标识接口。
　　常量接口
　　用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量(以前在做画板的时候这么干过)。建议不要模仿这种常量接口的做法。
1, Java语言不支持一个类有多个直接的父类(多继承),但可以实现（implements）多个接口,间接的实现了多继承.2, 与Java接口相关的设计模式:1, 定制服务模式设计精粒度的接口,每个Java接口代表相关的一组服务,通过继承来创建复合接口2, 适配器模式当每个系统之间接口不匹配时,用适配器来转换接口3, 默认适配器模式为接口提供简单的默认实现4, 代理模式为Java接口的实现类创建代理类,使用者通过代理来获得实现类的服务5, 标识类型模式用接口来标识一种没有任何行为的抽象类型6, 常量接口模式在接口中定义静态常量,在其它类中通过import static语句引入这些常
比较抽象类与接口1, 抽象类与接口都位于继承树的上层相同点1, 代表系统的抽象层,当一个系统使用一颗继承树上的类时,应该尽量把引用变量声明为继承树的上层抽象类型,这样可以提高两个系统之间的送耦合2, 都不能被实例化3, 都包含抽象方法,这些抽象方法用于描述系统能提供哪些服务,但不提供具体的实现不同点:1, 在抽象类中可以为部分方法提供默认的实现,从而避免在子类中重复实现它们,这是抽象类的优势,但这一优势限制了多继承,而接口中只能包含抽象方法.由于在抽象类中允许加入具体方法,因此扩展抽象类的功能,即向抽象类中添加具体方法,不会对它的子类造成影响,而对于接口,一旦接口被公布,就必须非常稳定,因为随意在接口中添加抽象方法,会影响到所有的实现类,这些实现类要么实现新增的抽象方法,要么声明为抽象类2, 一个类只能继承一个直接的父类,这个父类可能是抽象类,但一个类可以实现多个接口,这是接口的优势,但这一优势是以不允许为任何方法提供实现作为代价的三, 为什么Java语言不允许多重继承呢?当子类覆盖父类的实例方法或隐藏父类的成员变量及静态方法时,Java虚拟机采用不同的绑定规则,假如还允许一个类有多个直接的父类,那么会使绑定规则更加复杂,
学习java的基本，再去看看java模式，低耦合高内聚，我想你应该就会有所体会。
简单来说，要针对接口编程，不要针对实现编程
举个例子来说吧，我们的插座和插头吧，他们分别来至不同的厂商吧，但是他们有共同的接口，也就是有共同的标准，插头的各个厂商只要按照这个标准也即是实现这个接口来生产插头，同样插座也是如此，这样看来，插头厂商就不用关心插座的厂商是如何设计实现的，反之亦然。而且不同厂商之间也相互独立，没有依赖，所以市面上有各种各样的插座及插头，但是他们都是通用的……
放在程序中说既是。如果一个类不能确定它最后的类型，就是说不知道它以后要被实现成什么样，就可以采用面向接口的编程。所有需要这个类的地方都设成一个接口，而让这个类实现这个接口。后期要更改的时候只用实现这个接口就可以了，这样有很好的扩展性.
简单点:
定义个接口,不妨叫做流行明星PopStar.现在要举办**汇演,请这些明星来参加,明星们最拿手的就是唱歌了。
这样PopStar就有一个叫做singSong的方法,唱歌
interface PopStar{

    void singSong(String songName);
}假如你就是这些明星的老大,或者经纪公司.你向举办方提供一批明星的名单:
List<PopStar>singerList;
这些明星一个个都去实现PopStar这个接口,也就是实现唱歌这个抽象方法.好了,到了汇演现场,你手下的这些明星依次上场表演:
PosStar currentStar = null;
currentStar = ("曾哥")singerList.iterator.next();
currentStar.singSong("...");currentStar = ("春哥")singerList.iterator.next();
currentStar.singSong("...");
（本人对超女不熟悉,具体唱什么也不知道,用省略号代替吧,意思到了即可）
.....
一个个明星自己唱歌.OK,举办方不用关心你这个明星怎么唱歌的,只要我知道你是明星而且来了就会给我唱歌。我只管调用你的singSong就可以了.回到java接口编程:你是程序员,就是上面的经纪公司,举办方就是你的程序使用者.明星名单就是接口,明星就是你一个个具体的业务方法。
你把程序设计好了,只需把接口提供给程序使用者,暴露必要的方法.调用方不必关心你具体怎么实现的.
JAVA的接口也可以理解成是标准，大公司的高明之处就在这里，不管你服务怎么提供都得遵循我的准则。
為了定義可以共用的 interface
楼主可以参考引自 thinking in java 37.5 接口
“interface”（接口）关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。接口也包含了基本数据类型的数据成员，但它们都默认为static和final。接口只提供一种形式，并不提供实施的细节。
接口这样描述自己：“对于实现我的所有类，看起来都应该象我现在这个样子”。因此，采用了一个特定接口的所有代码都知道对于那个接口可能会调用什么方法。这便是接口的全部含义。所以我们常把接口用于建立类和类之间的一个“协议”。有些面向对象的程序设计语言采用了一个名为“protocol”（协议）的关键字，它做的便是与接口相同的事情。
为创建一个接口，请使用interface关键字，而不要用class。与类相似，我们可在interface关键字的前面增加一个public关键字（但只有接口定义于同名的一个文件内）；或者将其省略，营造一种“友好的”状态。
为了生成与一个特定的接口（或一组接口）相符的类，要使用implements（实现）关键字。我们要表达的意思是“接口看起来就象那个样子，这儿是它具体的工作细节”。除这些之外，我们其他的工作都与继承极为相似。下面是乐器例子的示意图：

具体实现了一个接口以后，就获得了一个普通的类，可用标准方式对其进行扩展。
可决定将一个接口中的方法声明明确定义为“public”。但即便不明确定义，它们也会默认为public。所以在实现一个接口的时候，来自接口的方法必须定义成public。否则的话，它们会默认为“友好的”，而且会限制我们在继承过程中对一个方法的访问——Java编译器不允许我们那样做。
在Instrument例子的修改版本中，大家可明确地看出这一点。注意接口中的每个方法都严格地是一个声明，它是编译器唯一允许的。除此以外，Instrument5中没有一个方法被声明为public，但它们都会自动获得public属性。如下所示：//: Music5.java
// Interfaces
import java.util.*;interface Instrument5 {
  // Compile-time constant:
  int i = 5; // static & final
  // Cannot have method definitions:
  void play(); // Automatically public
  String what();
  void adjust();
}class Wind5 implements Instrument5 {
  public void play() {
    System.out.println("Wind5.play()");
  }
  public String what() { return "Wind5"; }
  public void adjust() {}
}class Percussion5 implements Instrument5 {
  public void play() {
    System.out.println("Percussion5.play()");
  }
  public String what() { return "Percussion5"; }
  public void adjust() {}
}class Stringed5 implements Instrument5 {
  public void play() {
    System.out.println("Stringed5.play()");
  }
  public String what() { return "Stringed5"; }
  public void adjust() {}
}class Brass5 extends Wind5 {
  public void play() {
    System.out.println("Brass5.play()");
  }
  public void adjust() {
    System.out.println("Brass5.adjust()");
  }
}class Woodwind5 extends Wind5 {
  public void play() {
    System.out.println("Woodwind5.play()");
  }
  public String what() { return "Woodwind5"; }
}public class Music5 {
  // Doesn't care about type, so new types
  // added to the system still work right:
  static void tune(Instrument5 i) {
    // ...
    i.play();
  }
  static void tuneAll(Instrument5[] e) {
    for(int i = 0; i < e.length; i++)
      tune(e[i]);
  }
  public static void main(String[] args) {
    Instrument5[] orchestra = new Instrument5[5];
    int i = 0;
    // Upcasting during addition to the array:
    orchestra[i++] = new Wind5();
    orchestra[i++] = new Percussion5();
    orchestra[i++] = new Stringed5();
    orchestra[i++] = new Brass5();
    orchestra[i++] = new Woodwind5();
    tuneAll(orchestra);
  }
} ///:~代码剩余的部分按相同的方式工作。我们可以自由决定上溯造型到一个名为Instrument5的“普通”类，一个名为Instrument5的“抽象”类，或者一个名为Instrument5的“接口”。所有行为都是相同的。事实上，我们在tune()方法中可以发现没有任何证据显示Instrument5到底是个“普通”类、“抽象”类还是一个“接口”。这是做是故意的：每种方法都使程序员能对对象的创建与使用进行不同的控制。7.5.1 Java的“多重继承”
接口只是比抽象类“更纯”的一种形式。它的用途并不止那些。由于接口根本没有具体的实施细节——也就是说，没有与存储空间与“接口”关联在一起——所以没有任何办法可以防止多个接口合并到一起。这一点是至关重要的，因为我们经常都需要表达这样一个意思：“x从属于a，也从属于b，也从属于c”。在C++中，将多个类合并到一起的行动称作“多重继承”，而且操作较为不便，因为每个类都可能有一套自己的实施细节。在Java中，我们可采取同样的行动，但只有其中一个类拥有具体的实施细节。所以在合并多个接口的时候，C++的问题不会在Java中重演。如下所示：

在一个衍生类中，我们并不一定要拥有一个抽象或具体（没有抽象方法）的基础类。如果确实想从一个非接口继承，那么只能从一个继承。剩余的所有基本元素都必须是“接口”。我们将所有接口名置于implements关键字的后面，并用逗号分隔它们。可根据需要使用多个接口，而且每个接口都会成为一个独立的类型，可对其进行上溯造型。下面这个例子展示了一个“具体”类同几个接口合并的情况，它最终生成了一个新类：//: Adventure.java
// Multiple interfaces
import java.util.*;interface CanFight {
  void fight();
}interface CanSwim {
  void swim();
}interface CanFly {
  void fly();
}class ActionCharacter {
  public void fight() {}
}class Hero extends ActionCharacter
    implements CanFight, CanSwim, CanFly {
  public void swim() {}
  public void fly() {}
}public class Adventure {
  static void t(CanFight x) { x.fight(); }
  static void u(CanSwim x) { x.swim(); }
  static void v(CanFly x) { x.fly(); }
  static void w(ActionCharacter x) { x.fight(); }
  public static void main(String[] args) {
    Hero i = new Hero();
    t(i); // Treat it as a CanFight
    u(i); // Treat it as a CanSwim
    v(i); // Treat it as a CanFly
    w(i); // Treat it as an ActionCharacter
  }
} ///:~从中可以看到，Hero将具体类ActionCharacter同接口CanFight，CanSwim以及CanFly合并起来。按这种形式合并一个具体类与接口的时候，具体类必须首先出现，然后才是接口（否则编译器会报错）。
请注意fight()的签名在CanFight接口与ActionCharacter类中是相同的，而且没有在Hero中为fight()提供一个具体的定义。接口的规则是：我们可以从它继承（稍后就会看到），但这样得到的将是另一个接口。如果想创建新类型的一个对象，它就必须是已提供所有定义的一个类。尽管Hero没有为fight()明确地提供一个定义，但定义是随同ActionCharacter来的，所以这个定义会自动提供，我们可以创建Hero的对象。
在类Adventure中，我们可看到共有四个方法，它们将不同的接口和具体类作为自己的自变量使用。创建一个Hero对象后，它可以传递给这些方法中的任何一个。这意味着它们会依次上溯造型到每一个接口。由于接口是用Java设计的，所以这样做不会有任何问题，而且程序员不必对此加以任何特别的关注。
注意上述例子已向我们揭示了接口最关键的作用，也是使用接口最重要的一个原因：能上溯造型至多个基础类。使用接口的第二个原因与使用抽象基础类的原因是一样的：防止客户程序员制作这个类的一个对象，以及规定它仅仅是一个接口。这样便带来了一个问题：到底应该使用一个接口还是一个抽象类呢？若使用接口，我们可以同时获得抽象类以及接口的好处。所以假如想创建的基础类没有任何方法定义或者成员变量，那么无论如何都愿意使用接口，而不要选择抽象类。事实上，如果事先知道某种东西会成为基础类，那么第一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类。7.5.2 通过继承扩展接口
利用继承技术，可方便地为一个接口添加新的方法声明，也可以将几个接口合并成一个新接口。在这两种情况下，最终得到的都是一个新接口，如下例所示：//: HorrorShow.java
// Extending an interface with inheritanceinterface Monster {
  void menace();
}interface DangerousMonster extends Monster {
  void destroy();
}interface Lethal {
  void kill();
}class DragonZilla implements DangerousMonster {
  public void menace() {}
  public void destroy() {}
}interface Vampire
    extends DangerousMonster, Lethal {
  void drinkBlood();
}class HorrorShow {
  static void u(Monster b) { b.menace(); }
  static void v(DangerousMonster d) {
    d.menace();
    d.destroy();
  }
  public static void main(String[] args) {
    DragonZilla if2 = new DragonZilla();
    u(if2);
    v(if2);
  }
} ///:~DangerousMonster是对Monster的一个简单的扩展，最终生成了一个新接口。这是在DragonZilla里实现的。
Vampire的语法仅在继承接口时才可使用。通常，我们只能对单独一个类应用extends（扩展）关键字。但由于接口可能由多个其他接口构成，所以在构建一个新接口时，extends可能引用多个基础接口。正如大家看到的那样，接口的名字只是简单地使用逗号分隔。
interface Callable<T> {
    public T execute(Object obj);
}class Bussiness {
    public void pay(Callble<T> callable) {
        //支付之前的一些操作
         callable.execute();
        //支付之后的一些操作
    }
}public class Test {
    public static void main(String[] args) {
        Bussiness b = new Bussiness();
        b.pay(new Callble<Dollar>() {
            public Dollar execute(Object obj) {
                //执行用美元支付的过程.
            }
        });
        b.pay(new Callble<RMB>() {
            public RMB execute(Object obj) {
                //执行用人民币支付的过程.
            }
        });
        //至此, 是否觉得自己可以做的事更多了呢?
        //用接口去规范运行的流程, 具体谁去担任流程中的角色, 运行的时候才知道.
        //上面的代码是回调机制, 在hibernate中随处可见
    }
}