Question

给讲讲java接口的概念！

在java中接口到底是个什么？要怎么用呢？
我对interFace的理解，
我建立了两个接口，一个是A1，一个是A2
代码如下：
interface A1 //声明一个接口
{

public void A1_Print();
}

interface A2
{
public void A2_Print();
}

////

然后使用一个测试类来测试接口，在Test类中我这样写得：

public class Test implements A1,A2
{
public void A1_Print()
{
System.out.println("A1_Print");
System.out.println("A2_Print");
}

public void A2_Print()
{
System.out.println("A2_Print");
}
}

可是这样一来我觉得代码反而多了啊。比如说我又建立了n个接口，同样在每个类中我都需要这样的接口，是不是都的把他的方法实现了呢？？？

上边的代码无法测试，因为我没有写main方法，因为我不知道怎么使用接口，比如说我已经实现了两个接口中的方法，要怎么使用呢？？？因为我是新手，可能描述的也不正确，如果那里大侠们看不明白，请提出来，我会改正的！

Answer 1

希望你仔细阅读。对初学者来说，接口不是很好理解。我教过的学生也都提出过这个问题。

我们来看一个类

class A {
private int a;
public int getA() {
return a;
}
}

这个类的属性是私有的，外界不能访问，而外界可以通过公有方法来访问这个类。我们说一个类的公有方法就是这个类的对外接口。通常

一个类的属性都是私有的，方法大多是公有的。外界只能过个这些公有方法来访问类。这也是Java封装性的体现。如果一个类没有公有属性，

也没有公有方法，这个类就是无法使用的类了。所以我们需要为一个类提供对外接口。
一个类中的方法，不只是说明了它要“做什么”，而且方法的内容也说明了“怎么做”。打个不太恰当的例子，一个杀人方法。从名字上

看，你知道了“做什么”，但没有办法看到“怎么做”。而方法的内容说明了“怎么做”。

class killer {
private String name;
private int age;
private String phone;
private String addr;

......

public void kill(Person p) {
Qiang qiang = new Qiang("ak47");
qiang.fire(p);
}
}

这个类的kill方法内容说明了杀人的过程。如果你不想用这种方式杀人。因为你很BT，你想用毒药杀人。那么这个类的内容就需要改。但

是，还有很多其它的“客户”，需要用不同的方式杀人。怎么办呢？一个很好的办法就是，我们只定义“做什么”，而不定义“怎么做”。

interface Killer {
public void kill(Person p);
}

接口说明了“做什么”，而实现这个接口的类，也就是实现类需要说明“怎么做”。

class Killer1 implements Killer {
public void kill(Person p) {
Qiang qiang = new Qiang("ak47");
qiang.fire(p);
}
}

class Killer2 implements Killer {
public void kill(Person p) {
Bane bane = new Bane();
p.eat(bane);
}
}

public class Test {
public static void main(String[] args) {
Killer jingKe = new Killer1();
Person yingZheng = new Person();
jingKe.kill(yingZheng);
}
}

接口可以把“做什么”和“怎么做”分离开来。这给Java带来了很多好处。虽然代码量增加了，可我们的程序的可维护性加强了。我们的程序是可以拆分的。就象电脑一样，可以拆分成很多组件。我一直在想，如果我的MP3耳机可以拆分就好了，那样在耳机只坏掉一个的时候就不用重新买一个了。
不过上面的例子看不到什么太大的好处。你可能会说，如果你

的目的是为了不修改代码，那么，如果我想使用Killer2来完成任务，还是需要修改main方法为：Killer jingKe = new Killer2();。没有错，

不过你可以通过一个工厂来完成上面的任务。也就是说，不通过new语句来获得Killer对象，而是通过工厂来获得Killer对象。

public class KillerFactory {
public static killer getKiller() {
return new Killer1();
}

public static Killer getKiller(String path) throws Exception {
Properties prop = new Properties();
prop.load(new FileInputStream(path));
String className = prop.getProperty("killer");
Class clazz = Class.forName(className);
return (Killer)clazz.newInstance();
}
}

代码确实增加了很多，可是这对后期的系统维修和系统升级带来了很多好处。

水龙头与出水管的关系，我们需要把水龙头安装到出水管上。如果有一天我们需要更换水龙头时，只需要把老的水龙头拆卸下来，把新的

水龙头安装到出水管上既可。如果水龙头与出水管是一体的，就是无法拆卸的怎么办呢？或是说出水管只能安装水龙头，而不能安装淋浴器，

这就使我们生活很不方便。我们可以理解为出水管的连接方法，连接的对象是“出水设备”，而这个“出水设备”是一个接口。而水龙头与淋

浴器都是这个接口的实现类。但是接口在哪里呢？它长什么样子？我们没看到。它是一个标准，连接处的内径与外径。螺丝抠的密度等。这就

和你的电脑上为什么可以连接USB设备一样。如果电脑和某一个USB设备电焊到一起，那么其它的USB设备就无法使用了。电脑使用的是实现了

USB接口的电子设备，而我们的U盘、MP3、移动硬盘及鼠标都是USB接口的实现类。
用Java写出来的程序也和我们现实生活中的设备一样。如电脑，我们希望电脑的所有部件都可以更换，如果主板上的内存插槽与内存条不

附。我们说，内存条没有实现某某接口。Java是完全面向对象的，而面向对象是我们最为熟悉的东东。面向对象并不简单，而是我们太熟悉它

了。所以我们学习Java会很方便。在现实社会中，所有的标准到了Java中都是接口。一盒香烟多少支烟，烟的长度等都是标准。一个光盘的大

小。Java中的JDBC就是一个标准，而各大数据库厂商及第三方厂商实现了这一标准。JDBC只说明了目的，没有说明怎么完成的目的。
面向对象就在我们眼前，不过我们有时不太注意它。希望你在今后学习Java时，多与现实社会联系。这样可以有利与你的理解。
代码量加大了，但对后期的维护与升级提供了方便。软件公司卖给客户的是class文件，而不是java文件。如果你的客户需要更换Killer对

象，只需修改资源文件既可。

下面我们来看一个定时器类。现在什么都是自动化的，如空调、电视、洗衣机等等。都要用到定时器这个类。对了，还有定时炸弹也要用

它。那我们可不可以只写一个定时器类，应用到所有的需要定时器的设备上呢？答案是肯定的，我们需要这个类。
好了，我们来分析一下定时器需要完成什么工作吧。定时器应该有启动、停止方法。定时器启动之后，每过一定时间就执行某个动作。其

中时间间隔为long型，而要执行的动作可能是输出一个字符串，也可能是打印作业。具体要干什么由使用定时器的用户来完成。而定义定时器

时，根本就不知道要干什么。

public class Timmer {
private long time;
private Action action;

public Timmer() {}

public Timmer(long time, Action action) {
this.time = time;
this.action = action;
}

public void start() {
state = START;
if(th == null) {
th = new Thread() {
public void run() {
while(state == START) {
try {
Thread.sleep(time);
action.action();
} catch(Exception e) {
}
}
}
};
}
th.start();
}

public void stop() {
state = STOP;
}

public void setTime(long time) {
this.time = time;
}

public void setAction(Action action) {
this.action = action;
}

public long getTime() {
return (this.time);
}

public Action getAction() {
return (this.action);
}
}

Action是一个接口，它只有一个方法，就是要完成的任务。我们在定时器启动时调用这个接口的方法。而这个Action接口的对象，代表一

个动作，这个动作就是用户要完成的动作。

public interface Action {
public void action();
}

public static void main(String[] args) {
Timer t = new Timer(2000, new Action() {
public void action() {
System.out.println("Hello World!");
}
});
t.start();
javax.swing.JOptionPane.showMessageDialog(null, "点击确定按钮停止定时器");
t.stop();
System.exit(0);
}

这是一个典型的回调方法例子。在AWT中，java使用了大量的监听器。这些监听器都是回调方法。在XML解析器SAX中，也使用了回调方法来解析XML文档。

接口要比抽象类还要抽象。抽象类需要子类继承，而Java是单继承，所以抽象类被限制了。而接口不同，一个类可以实现多个接口。好比人类与程序员类之间的关系。可以说程序员是人类的子类，如果程序员是一个接口。用人类的子类来实现它就会更好。这个子类还可以去实现会计接口、音乐家接口等等。

在struts2.0、spring、hibernate等框架中，都大量使用接口。我们关心的是某个接口与另一个接口之间的关系。而不关心某个实现类与另一个接口实现类的关系。在客观世界中，我们交谈时都大量使用接口，只是我们没有注意罢了。如：我公司需要一个程序员(一个实现了程序员接口的对象)。上课时，讲师有一台计算机，用白板笔在白板上写字(计算机是接口，白板及白板笔也是接口)。讲师希望学生能学会所有的知识(讲师及学生都是接口)。

就说这么多了，还有什么不明白可以与我联系。QQ:51038648

我在北京中科院计算所培训中心做兼职java讲师。我的经验是，要想学好Java，一定要多打代码、吃透代码。如果不勤奋，就一定学不好。看来你是刚刚开始学习Java，你后面的路还很长，而且不是很好走。

Answer 2

好的面向对象编程要求类设计人员隐藏那些不需要类的使用人员了解的信息。对于 Java 编程语言，这样的访问可以通过使用关键字 private, protected, 和 public来控制。这些关键字控制类内部的变量和方法是否可见，但是不好的类设计导致太多的可见信息和方法没有被很好的封装。
封装的一种方式是通过使用接口(Interface)实现的。接口提供一种途径，使类隐藏其处理的特定事物的细节，仅对外公布它必须支持的属性。对于编程所涉及的，你可以修改类的实现，而不修改它的调用，因为属性本身没有改变，修改的仅仅是类的实现。

一个接口被经常用得到的地方是Collection Framework。这个框架定义了一组非常重要的接口，它们是由一组多个类实现的。通过仅仅研究主要的接口，你可以有效的掌握整个框架，因为特别的实现类一般不影响设计的整体。

例如，List接口定义了一个有序的元素集合。可用地实现包括ArrayList和LinkedList，它们都实现了List接口。当你的程序需要处理List时，不必考虑它是ArrayList还是LinkedList，只要知道所选用的类的属性即可。这个属性就是接口。

通过实现类的接口，并且在类设计时仅对外公布接口，你就有效的封装了类的定义，这样后台实现的变动将对系统其它部分的影响最小。

以ArrayList和LinkedList为例。将ArrayList看作一个可增长的数组对象（指是存储对象，而不是原始数据）。当类实现了List的全部接口时，它的特性在特定条件下是可以优化的。

例如，如果你的程序是要队列表中的数据进行频繁的随机访问，（例如，显示第3，12，2，和25项数据）ArrayList类提供对列表中每一个数据快速查询。快速查询是以在列表中间添加和删除数据的速度为代价的。如果后一种行为是你需要的，那么LinkedList类是一个好的选择。它提供快速的顺序访问、添加和删除，但是，代价是慢速随机查询。

在处理ArrayList和LinkedList时，有两种方式创建对象：

List cityList = new ArrayList() ;

LinkedList peopleList = new LinkedList() ;

两个代码段都是正确的，但是这两行代码之间存在的显著的差别。第一行表示我们要创建一个ArrayList，但是我们只需要把它作为一个List来访问。第二行正好相反。是，LinkedList项目被创建了，ArrayList也一样。但是，声明部分说明它只能作为LinkedList来访问，这就数它的最大区别。

理解接口真正变的重要是在这两行代码的用户确定“查询项目n”比在位置m处删除（或添加）项目更为重要时。

PeopleList变量被声明为LinkedList类型。这不是它本身的问题，因为你研究的更深层次的内容，你将发现peopleList在任何地方都被作为LinkedList对象处理。在你对peopleList使用LinkedList特有的方法的同时，如果你想把它作为ArrayList来处理，将会出现问题。

List peopleList = new ArrayList() ;

通过学习仅使用接口来处理任何对象，你将发现在设计完成之后修改实现，你需要修改的仅仅是声明部分，除此之外，没有任何代码改动。这就是接口的绝妙之处。因为类的最初声明是LinkedList，当类型变为List时意味着象addFirst或addLast这样的方法是无效的，因为新的peopleList的类型是List，它没有这些方法。

这种基于接口设计的代码，就像Collection Framework所向大家承诺的那样，任何人编写的代码是以循环构造方式进行的，而无需知道使用的是哪个Collection。创建的类是被限制为提供接口的完全实现。除此之外，新代码将不能被编译。

作为实例，下面的程序创建一组集合。每个集合提供一个系统定义的Iterator这样集合的每个元素可以被访问。这个iterator将被传递到帮助例程，在这里集合的独立元素将被打印。

import java.util.*;

public class Interfaces {

public static void main(String args[]) {
Properties props = System.getProperties();
Set keySet = props.keySet();
dumpIterator(keySet.iterator());

List list = Arrays.asList(args);
dumpIterator(list.iterator());
}

private static void dumpIterator(Iterator itor) {
// System.out.println(itor.getClass().getName());
while (itor.hasNext()) {
System.out.println(">> " + itor.next());
}
System.out.println("----");
}
}

类Iterator的类型是unknown，这正是接口的绝妙之处，而不是问题。真正的事实是iterator方法返回的是一个真实的Iterator对象。然而，dumpIterator通常提供接口的完全实现。

如果你去掉dumpIterator中的println行的注释，你将发现真实的iterator类名，对Properties是Hashtable.Enumerator而List是AbstractList.Itr。这个事实不必知道，也不会对你的程序有任何帮助。真正重要的是List和Properties的iterator方法所返回的任何对象，必须实现java.util.Iterator:hasNext, next和remove方法。没有这三种方法中任何两种，dumpIterator方法将永远不能工作。

Answer 3

接口可以看成是特殊的抽象类。即只包含抽象方法和常量的抽象类。可以通过interface关键字来定义接口。看如下代码：
interface Runner {
public static int DEFAULT_SPEED = 100;
public void run();
}
注意，run()方法，此处可以省略public abstract。因其默认就是public abstract的。

实现接口
与继承不同，一个类可以实现多个接口，实现的接口直接用逗号分隔。当然，该类需要实现这些接口中定义的所有方法；
一个类可以通过implements关键字”实现”接口。一个类实现了某个接口后必须实现该接口中定义的所有方法。看下面的代码，类实现了接口并实现了方法：
class AmericanCurl implements Runner , … {
public void run() {
System.out.println("run...");
}
}
另外需要说明的一点，接口可以作为一种类型声明变量，一个接口类型的变量可以引用实现了该接口的类的对象；通过该变量可以调用该接口中定义的方法（具体的实现类提供了方法的实现）。代码如下所示：
Runner runner = new AmericanCurl();

此句代码为，一个接口类型变量，引用了子类的对象。调用时，调用的是子类对象的具体的实现。

接口的继承
接口间可以存在继承关系，一个接口可以通过extends关键字继承另外一个接口。子接口继承了父接口中定义的所有方法。代码如下所示：
interface Runner {
public void run();
}
interface Hunter extends Runner {
public void hunt();
}
class AmericanCurl implements Hunter {
public void run() {… … …}
public void hunt() {… … …}
}
说明：AmericanCurl实现了Hunter，必须实现Hunter接口中的hunt方法以及其父接口Runner中的run方法。

接口和抽象类的区别
一个类只能继承一个抽象类，但可以实现多个接口。

抽象类中可以包含抽象方法和非抽象方法，而接口中的所有方法均为抽象的。
子类继承抽象类必须实现抽象类中所有抽象方法，否则子类也必须是抽象类。而子类实现接口则必须实现接口中的所有抽象方法。

Answer 4

拷贝的就别发了！接口就是个抽象类，里面只需要定义方法名，不需要实现方法。他是为一个继承他的类做准备的，他里面定义的方法名都要被继承他的类来实现里面所有的方法、如果没有实现接口里所有定义的方法名，那这个类也是一个抽象类，一般小项目都用不到接口，到大公司里方法写的多了，都要用到接口，这样可以节省资源

Answer 5

用面向对象来说吧
你可以把接口看做一种行为，比如说：猎食、吃东西就是两种不同的行为，但几乎每种动物都有这种行为，但猎食和吃东西的具体方法就不一样了。
放到程序里来，你就可以把这两种行为作为方法放到一个接口里了。假如你的程序是来描述动物猎食和吃东西，那么无论你要new多少个对象，虽然是不同的动物，只要实现这个接口就行了，而具体的不同点，你就只要在方法里加以描述就行了。
这样就有利于程序的扩展。
而接口的目的就在于此！