接口是否能调用方法啊？接口里面的方法不都是抽象的吗？怎么能调用呢？
import java.util.*;

class Demo
{
        public static void main(String[] args)
        {
               
                Vector arr1=new Vector();
                arr1.add("java1");
                arr1.add("java2");
                arr1.add("java3");
                arr1.add("java4");
                Enumeration e=arr1.elements();//这是个接口。
                while (e.hasMoreElements())//这里怎么可以调用方法，虽然我也知道可以，但是为什么啊。
                {
                        sop(e.nextElement());
                }       
        }
        public static void sop(Object o)
        {
                System.out.println(o);
        }
}

不是非常明白你的意思,接口实际上就是一个比抽象类还高度抽象的类.一个实体类并不一定非要继承自抽象类,也可以直接实现接口.

Java codepublic interface InterfaceE {
   public void doIt();
}
public abstract class AbstractE implements InterfaceE {
   protected String content;  
  public void doIt() {     
   System.out.println(content);  
}
   public abstract void setContent(String content);}
public class ClassE extends AbstractE {
  public ClassE(Object content)
{      
setContent(content.toString());  
  }  
  public void setContent(String content) {  
      this.content = content;    }}
public class Main {   
public static void main(String[] args) {     
   InterfaceE clazz = new ClassE("This is a test.");      
  clazz.doIt();    }}

接口里定义的方法 必须是没有方法体！ 否则将会编译错误。
接口的方法都没有方法体 ， 所以都是抽象方法！
接口的实现类必须都要重写接口中的方法！
一般情况下都是用接口去 new 出一个实现类 的对象， 然后用接口去调同实现类里面的方法，这样的话在接口里面都是Public的修饰。
在接口中可以定义变量， 但是必须在前面修饰 静态的 常量的，  变量名 全大写。  

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为改类声明方法，但不能在改类中实现改类的情况。不能创建abstract类的实例。然而可以创建一个变量，其类型是一个抽象类，并让他指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类。取而代之，在子类中实现改方法。知道其行为的其他类可以在类中实现这些方法。
接口(interface)是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这些接口而获得。接口中的所有方法都是抽象的，没有一个程序体。接口只可以定义static final 成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义(即将程序体给予)所有这种接口的方法。然后，他说可以在实现了该接口的类中的任何对象上调用接口的方法。

  Enumeration e=arr1.elements();//这是个接口。//我觉得这里用的应该是多态原理，arr1.elements()返回的应该是接口的子类对象               while (e.hasMoreElements())//这里怎么可以调用方法，虽然我也知道可以，但是为什么啊。
                {
                        sop(e.nextElement());
                }        

import java.util.*;

class Demo
{
         public static void main(String[] args)
        {
                 
                Vector arr1=new Vector();
这是枚举类在创建对象，引用名为arr1            
                 arr1.add("java1");
                 arr1.add("java2");
                 arr1.add("java3");
                 arr1.add("java4");
                 //它是接口Enumeration e=arr1.elements();arr1调用Vector的elements方法，返回类型是一个接口类型而已。 //这是个接口。
                 while (e.hasMoreElements()) //所以这里并不是接口在调用，而是实现了Enumeration接口的类的对象，在调用接口Enumeration的方法hasMoreElements())这里怎么可以调用方法，虽然我也知道可以，但是为什么啊。
                 {
                         sop(e.nextElement());
                 }        
        }
         public static void sop(Object o)
         {
                 System.out.println(o);
         }
}

这个你可以参考迭代器的原理

这个地方可以调用方法是因为在代码执行arr1.elements()方法时已经实现了这个类，以下是java中elements的源代码，你看一下就明白了
public Enumeration<E> elements() {
        return new Enumeration<E>() {
            int count = 0;

            public boolean hasMoreElements() {
                return count < elementCount;
            }

            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException("Vector Enumeration");
            }
        };
    }

关于接口，有一下总结。
格式：interface{}
表现特点：
1、里面的方法都是抽象的。
2、接口中的成员都有固定的修饰符，最常见的成员：全局常量抽象方法。只是最常见，不代表只有它们没有其他的，
       全局常量，共有的不需要对象，直接用接口调用的，不可变的。
        表现形式：Public static final
           抽象方法：public abstract
3、接口的成员都是public的。
4、接口是不可以创建对象的。就相当于是抽象的特殊表达形式。（但是有区别和抽象类）
5、类与类之间是继承关系，类与接口之间是实现关系。
6、接口的出现可以多实现，避免了单继承的局限性。
7、一个类在继承一个类的同时，还可以实现多个接口、
8、接口与接口之间是继承关系，而且可以多继承，以为接口的方法都没有主体。
思想特点：
1、对外暴露的规则。
      外设要介入计算机中，因为计算机外面提供了接口，这就是规则。
2、程序的功能扩展
3、降低了耦合性
4、用来多实现
结合电脑主板的思想进行阐述，它是个规则，。对外提供的规则
它提高了我们功能的扩展性，降低了耦合性。
主板和声卡：主板使用规则，声卡实现规则。

与抽象类的区别：抽象类有单继承的局限性，接口没有
希望对楼主有帮助。

这个地方可以调用方法是因为在代码执行arr1.elements()方法时已经实现了这个类，以下是java中elements的源代码，你看一下就明白了
public Enumeration<E> elements() {
        return new Enumeration<E>() {
            int count = 0;

            public boolean hasMoreElements() {
                return count < elementCount;
            }

            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException("Vector Enumeration");
            }
        };
    }

{:soso_e179:}