定义一个接口
interface test{
void go();
}实现接口
class exe implements test{
public void go()
{
System.out.println("exe");
}
}
//-----------------
问题来了
定义这个接口有什么用？就看实现类而言，去掉implements test和原来的没有区别。
比如实现多线程
用Runnable接口 class testthread1 implements Runnable{
public void run(){
for(;;)
{
System.out.println("interface");
}
}}
//----
class testthread2{//没有用接口
public void run(){
for(;;)
{
System.out.println("no interface");
}
}}
//-----
public class exec{
public static void main(string[] args){
Thread t1 = new Thread(new threadtest1());
Thread t2 = new Thread(new threadtest2());
t1.start();
t2.start();
}}
//--------
程序执行正常，但是threadtest2并没有用到Runnable接口啊。
糊涂
另外，在一篇文章中看到接口的作用，是如下定义的：
封装的一种方式是通过使用接口(Interface)实现的。接口提供一种途径，使类隐藏其处理的特定事物的细节，仅对外公布它必须支持的属性。对于编程所涉及的，你可以修改类的实现，而不修改它的调用，因为属性本身没有改变，修改的仅仅是类的实现。
//-----
根本理解不上去，感觉接口没有什么作用的说
interface test{
void go();
}实现接口
class exe implements test{
public void go()
{
System.out.println("exe");
}
}
//-----------------
问题来了
定义这个接口有什么用？就看实现类而言，去掉implements test和原来的没有区别。
比如实现多线程
用Runnable接口 class testthread1 implements Runnable{
public void run(){
for(;;)
{
System.out.println("interface");
}
}}
//----
class testthread2{//没有用接口
public void run(){
for(;;)
{
System.out.println("no interface");
}
}}
//-----
public class exec{
public static void main(string[] args){
Thread t1 = new Thread(new threadtest1());
Thread t2 = new Thread(new threadtest2());
t1.start();
t2.start();
}}
//--------
程序执行正常，但是threadtest2并没有用到Runnable接口啊。
糊涂
另外，在一篇文章中看到接口的作用，是如下定义的：
封装的一种方式是通过使用接口(Interface)实现的。接口提供一种途径，使类隐藏其处理的特定事物的细节，仅对外公布它必须支持的属性。对于编程所涉及的，你可以修改类的实现，而不修改它的调用，因为属性本身没有改变，修改的仅仅是类的实现。
//-----
根本理解不上去，感觉接口没有什么作用的说
public interface Runnable
The Runnable interface should be implemented by any class whose instances are intended to be executed by a thread. The class must define a method of no arguments called run. This interface is designed to provide a common protocol for objects that wish to execute code while they are active. For example, Runnable is implemented by class Thread. Being active simply means that a thread has been started and has not yet been stopped. In addition, Runnable provides the means for a class to be active while not subclassing Thread. A class that implements Runnable can run without subclassing Thread by instantiating a Thread instance and passing itself in as the target. In most cases, the Runnable interface should be used if you are only planning to override the run() method and no other Thread methods. This is important because classes should not be subclassed unless the programmer intends on modifying or enhancing the fundamental behavior of the class. 大意是，如果你要执行一个线城，就必定要扩展或implements Runnable这个接口，这个接口里面定义了thread的run()方法，至于你的thread2已经默认扩展了Runnable了，因为继承了thread.而你第一个例子，你根本就是多余的，interface里面有你需要的方法，但是你却没使用，反而自己重新定义了一个
由于java 只支持单继承，而之前你已经有一个父类了，还想继承别的的时候就只能用接口来实现！
是面向对象语言里一个重要特性(机制),用处狠大,在java里多继承要靠接口来完成"接口是对可插入性的保证",软件的可扩展性,易维护性都是通过接口实现,能通过接口很好的完成.接口有狠多用法:
a.单方法接口
b.标识接口
c.常量接口
上面回复很多提及到类可以继承多个接口。
其实我的疑问是：接口中定义的方法都是抽象方法，在实现类中还需要override一遍，那么和直接在实现类中定义一个方法有什么区别呢。
基于一个类implements了一个接口，就必须实现这个接口的全部方法这一点来说，把接口理解成一种规范勉强还可以。
interface test{
void go();
}class testaaa implements test{
public void go()
{
System.out.println("exe");
}
}
-------------------
class TestFactory {
...
public test getTest(){
....
return testaaa;
}
}
--------------------------------------example.java
test t = TestFactory.getTest();
t.go();如果testaaa发声变化或者给作者修改，对于这部分代码，可能永远都不需要修改。
甚至可以不必知道有testaaa这个东东的存在。
从这个例子你应该知道接口的用途了吧????接口是一种声明, 它声明了一些类里面实现了的功能, 而这种声明对于使用它的类来说, 是至关重要的.上例中, 一个没有实现Runnable接口的类, 无法做为一个线程来启动. 因为new Thread()的参数只认Runnable.还有很多这样的例子. 比如, 没有实现临听器的类无法监听事件, 没有实现Comparable的类无法参与比较等等.
原来我理解的流程是：定义借口--〉写这个接口的实现类--〉调用实现类
其实使用接口的流程应该是这样滴：
定义接口--〉写这个接口的实现类--〉调用有这个接口属性的实体（实现类提供）--〉获得接口定义的由实现类实现了的方法（实现了封装的功能）
不知道这样理解对不对。
其实上来学Java，我感觉不是很好
不如多接触接触C,C++，COM这样会对Java的体会更深刻一些
类似这样的问题会有很多
很多你都会想不通，不过如果真的要搞还是可以的
可以看GOF的设计模式
再简单一点的就是设计模式精解
能看英文版的就看英文版，至少我觉得看这两本书完全不用字典
接口的作用不是“获得”是什么，而是“给出”什么。
不像继承父类，子类就有了父类的方法，参数。
而是一个类implements了一个接口，就表示把本类中的某些方法（接口中包括的）放出给外界调用。
-------------------------------------------------------------------------
接口不是一定是为了一个类写的，如果你的项目很大的话接口中的方法在别的类中也要实现！------------------------------------------
定义接口--〉写这个接口的实现类--〉调用有这个接口属性的实体（实现类提供）--〉获得接口定义的由实现类实现了的方法（实现了封装的功能）
不知道这样理解对不对。---------------------------
对的！因为接口具有通用性！
接口的作用不是“获得”是什么，而是“给出”什么。
不像继承父类，子类就有了父类的方法，参数。
而是一个类implements了一个接口，就表示把本类中的某些方法（接口中包括的）放出给外界调用。//////////////////////
上面我只是分析你给出程序的问题，但是就我目前所知，接口最重要的就是“给出”和“分离”的作用，当你要写一个很大的程序，而某些单元需要手动更改，或作为参数被重复使用时，如io地址，ip地址，引参等等，如果写在程序里每次改动要重新编译，和修改源程序，这是多么不方便啊，所以我习惯用n多的接口来完成这方面的工作
接口的作用不是“获得”是什么，而是“给出”什么。
不像继承父类，子类就有了父类的方法，参数。
而是一个类implements了一个接口，就表示把本类中的某些方法（接口中包括的）放出给外界调用。//////////////////////
上面我只是分析你给出程序的问题，但是就我目前所知，接口最重要的就是“给出”和“分离”的作用，当你要写一个很大的程序，而某些单元需要手动更改，或作为参数被重复使用时，如io地址，ip地址，引参等等，如果写在程序里每次改动要重新编译，和修改源程序，这是多么不方便啊，所以我习惯用n多的接口来完成这方面的工作
interface test
{int a;
run(arguments list);}class a implements test
class b implements test
....
....是否test接口被重用了，如果写在类里面则每次需要重写，修改也不方便
当你要写一个很大的程序，
而某些单元需要手动更改，或作为参数被重复使用时，如io地址，ip地址，引参等等，
如果写在程序里每次改动要重新编译，和修改源程序，这是多么不方便啊，所以我习惯用n多的接口来完成这方面的工作
//---------------------对上面的话不理解，尤其是
而某些单元需要手动更改，或作为参数被重复使用时，如io地址，ip地址，引参等等，
如果写在程序里每次改动要重新编译，和修改源程序，这是多么不方便啊，所以我习惯用n多的接口
//////
恕小弟愚钝
未能理解上面这段话的具体含义，或则说表达的坏境
//-----------------------------------------------------------------------------------
大多数教材上都有这样的说法，
我以为这样的说法不太贴切，某种程度上还有对新手误导的嫌疑（象偶这样迷糊的）
因为：
1、类的继承，使获得父类的属性。是从父类获取一些信息。
类的实现是实现本类的一些机制（将接口定义的方法给外界调用），谓语是“实现”，他并没有从接口获取什么属性（接口里都是抽象方法，拿来干什么），总结起来说就是：接口给出一个规范，实现类照这个要求做。
2、对于外界调用来说，继承，外界直接调用子类。而接口，外界调用的是接口。
-----
-------思路清晰一些了，吼吼
接口是用来多重继承的--〉比如class a implements interface-->a获得了一些抽象的方法
接着就开始糊涂了--〉class a只是获得一些抽象的方法，有什么用？有什么用？
接着更糊涂-------〉class a extends b,a就有b的所用属性。之所以取消多重继承，是为了避免属性的混乱-----〉用接口实现这一功能，那只是搞一堆空的方法过来，有什么用啊。
死机当中。。呵呵，以前偶得思路就是这样滴。。:(