在抽象方法跟接口的比较中，看过这么两句话： 接口需要被实现，而且可以多实现；接口定义的方法不能实现，而抽象类可以实现部分方法。这两句话都对吗？总觉得矛盾！我能理解第一句话，理解不了第二句？呜呜。。

理解这两句话必须搞清楚两个问题：
第一个就是抽象类 接口 和抽象方法的关系；
           抽象类： 即有抽象方法又有具体方法（特殊情况：可以没有抽象方法）
           接口：    只有抽象方法，没有具体方法
第二个是方法实现和接口实现的含义。

楼上答得很详细

接口和抽象类的概念不一样。接口是对动作的抽象，抽象类是对根源的抽象。

抽象类表示的是，这个对象是什么。接口表示的是，这个对象能做什么

抽象类：abstract。当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。，分析事物不确定时，就抽象特点1.抽象方法只能定义在抽象类中。2.抽象方法和抽象类必须被abstract修饰3.抽象类不可以用new 创建对象，
因为创建对象没有意义4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象方法，
那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。抽象类和一般类没有太大的区别，当事物出现不确定的功能，
需要明确指出，但是无法定义主体，通过抽象方法来表示。抽象类比一般类多了个抽象方法，抽象类不可以实例化，抽象类中还可以定义非抽象方法，目的是不让该类建立对象
。抽象类可以包含 普通方法 成员变量 构造方法
例子：
abstract class enmployee{
                private String name;
                private int id;      
               private double money;
                public enmployee(String name, int id, double money) {
                super();
               this.name = name;
               this.id = id;
               this.money = money;
       }
       public abstract void work();}class yuangong extends enmployee{
                public yuangong(String name, int id, double money) {
               super(name, id, money);                     
  }
        public void work(){
           //员工工作        }        }
class jingli extends enmployee{
                double jiangjin;
       public jingli(String name, int id, double money,double jiangjin) {
                super(name, id, money);
                this.jiangjin=jiangjin;
                }
       public void work(){
           //经理工作        }        }
模板方法模式：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，而确定的部分在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。
将确定的部分final修饰 ，禁止修改。
接口：interface，如果抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。接口定义的一组规范，实现现实世界中这样的逻辑 ：如果你是。。。则必须能。。。class用于定义类，
interface用于定义接口接口的特点：
1.接口中常见定义：常量，抽象方法。
2.接口中的成员都有固定修饰符常量  public static final方法  public abstract接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类。
接口可以被类多实现。也是对。多集成不支持的转换形式，JAVA支持多实现。类与类之间是继承，只能单继承类与接口之间是实现，可以多实现接口与接口之间是继承，
可以多继承。
接口：借口是对外暴露的规则，借口是程序的工恩那个扩展，接口可以原来多实现，类与接口之间是实现关系，而且类的消失可以继承一个类的同时实现多个接口，
接口与接口之间可以有继承关系。基本功能定义在类中，扩展功能定义在接口中。

1. //方法实现一个是方法即函数有具体的函数体，接口实现，是一个类implements 接口
   
2. //接口：
   
3. 
   
4. interface interfaceA{        //接口中的方法一定是被public abstract修饰的，即便你省略不写
   
5.         public abstract void methodA1();//接口方法不能被实现指这里不能定义方法功能 {    }
   
6.          void methodA2();//注意，这样写跟上面是一样的，public abstract会被自动加上
   
7.                
   
8.         
   
9. }
   
10. interface interfaceB{
    
11.         
    
12.         public abstract void methodB1();//接口方法不能被实现指这里不能定义方法功能 {    }
    
13.         public abstract void methodB2();//因为接口中的 方法 全部是抽象的所以接口定义的 方法 不能被实现
    
14.                                                                         //但 接口 能被类实现
    
15. }
    
16. 
    
17. abstract class absClassC{              //另外抽象类中可以没有抽象方法
    
18.         public abstract void methodC1();//抽象类方法不能被实现指这里不能定义方法功能
    
19.                                                                         
    
20.         
    
21.         public void methodC2(){//抽象类方法部分实现指的是这里，没有被abstract修饰的方法
    
22.                 //写上实现的代码，这个方法被子类继承，可以直接用，也可以复写
    
23.         }
    
24. }
    
25. 
    
26. //下面是类的单继承和实现多接口的多实现
    
27. class someClassD extends absClassC implements interfaceA,interfaceB{
    
28.         public  void methodA1(){//子类后面跟的类或接口中的抽象方法全部要复写
    
29.                
    
30.         }
    
31.         public  void methodA2(){
    
32.                
    
33.         }
    
34.         public  void methodB1(){
    
35.                
    
36.         }
    
37.         public  void methodB2(){
    
38.                
    
39.         }
    
40.         public  void methodC1(){
    
41.                
    
42.         }
    
43.         
    
44. }
    
45. 
    
46. public class InterfaceTest {
    
47. 
    
48. }
    
复制代码

接口定义的方法不能实现，而抽象类可以实现部分方法。
接口是一个特殊的抽象类 其中的所有方法都是抽象的，“接口定义的方法不能实现”这句话的意思是，你在定义接口的时候，不能在接口中实现它的方法，要在别的类继承该接口时实现。