java中abstract 和interface的区别与相似之处？

package test;
class TestAbstract{
  /**
   * 抽象
   * 类
   *    抽象类，只能声明引用，不能创建对象(即抽象类不能实例化
   * 方法
   *    抽象方法，只有声明，没有实现
   * 
   * @param args [description]
   */
  public static void main(String[] args) {
    Super s;
    //抽象类，只能声明引用，不能创建对象
    //s = new Super();  
    s = new Sub(); 
    //多态第二条：只能对引用调用其引用类型中声明的方法
    s.method();   
  }
}   
abstract  class Super{
  //抽象方法，只有声明，没有实现
  public abstract void method();
    // 空
}
class Sub extends Super{
  public void method(){
    System.out.println("Sub()");
  }
}

    package test;
      public class TestInterface{
        /**
         * 接口：  特殊的抽象类
         *1，所有的属性都是公开静态常量
         *2，所有的方法都是公开抽象方法
         *3，没有构造方法 
         * 不能创建对象，可以声明引用
         * 
         * @param args [description]
         */
        public static void main(String[] args) {
          IA a = new Impl();
          a.m1();
          a.m2();
          Impl i = new Impl();
          IA a1 = i;
          IB b = i;
          IC c = i;
          ID d = i;
          ClassE e = i;
          a1.m();
          a1.m1();
          a1.m2();
          b.mb();
          c.mc();
          d.mb();
          d.mc();
          d.md();
          e.me();
        }
      }
      /*
      为什么要定义抽象类
        留给子类继承
        子类需要继承抽象类，实现里面的抽象方法，这样子类可以创建对象；
       */
      interface IA{
        public static final int M = 10;
        //public static final可以不写，默认有
        int M1 = 10;
        double N = 2.78;
        public abstract void m();
        //public abstract也可以省略不写，默认有
        void m1();
        void m2();
      } 
      abstract class ClassA{
        abstract void ma();
      }
      interface IB{
         void mb();
      }
      interface IC{
         void mc();
      }
      interface ID extends IB,IC{
        void md();
      }
      abstract class ClassE{
        public abstract void me();
      }
      //实现类
      //一个类去实现接口，如果这个类不希望也成为抽象类，就必须实现接口中所有方法
      //否则这个类也是抽象类
      class Impl extends ClassE implements IA,ID{
        //public 必须要写，不写的话是默认default
        public void m1(){
          System.out.println("1111");
        }
        public void m2(){
          System.out.println("22222");
        }
        @Override
        public void m() {
          // TODO Auto-generated method stub
        }
        @Override
        public void me() {
          // TODO Auto-generated method stub
        }
        @Override
        public void mb() {
          // TODO Auto-generated method stub
        }
        @Override
        public void mc() {
          // TODO Auto-generated method stub
        }
        @Override
        public void md() {
          // TODO Auto-generated method stub
        }
      }

package test;
public class TestInterface2 {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    //创建一个台灯对象
    Lamp l = new Lamp();
    //创建一个黄灯泡对象
    YellowLight light = new YellowLight();
    //将黄灯泡传入到台灯的setLight方法中
    l.setLight(light);
    //然后执行台灯的开灯方法
    l.powerOn(); 
    /*
     * 思考一个问题：
     * 这只能传入一个黄灯泡对象，如果想要再传入其他灯泡呢，这种方式就不行了
     * setLight方法中传入的是YellowLight对象，所以要想再传入其他灯泡就得重新写一个方法
     * 这样程序的耦合度就太高了，
     *例如： 
     */
    RedLights redLight = new RedLights();
    //将黄灯泡传入到台灯的setLight方法中
    //l.setLight(redLight**);//所以这里台灯Lamp没有传入红灯泡 的方法
    //然后执行台灯的开灯方法
    //l.powerOn(); 
  }
}
class Lamp{
  YellowLight light = null;
  public void setLight(YellowLight light){
    this.light = light;
  }
  //台灯的开灯方法
  public void powerOn(){
    light.LightOn();
  }
}
class YellowLight {
  public void LightOn(){ 
     System.out.println("黄灯泡发黄光");
  }
}
class RedLights {
  public void RedLightOn(){ 
     System.out.println("红灯泡发红光");
  }
}

package test;
//接口的解耦合作用
public class TestInterface3 {
  /**
   * 为解决上面提到的程序无法解耦的问题，这就引入了interface 的作用，
   * 利用interface可以很好的使程序达到弱耦合的效果，
   * 就是在台灯和灯泡之间加一个统一的标准，
   * 
   * * 接口中所有方法都是抽象方法
   * Java中的弱耦合，遵循同一标准；
   *   
   * 解耦合的工具，  标准
   * 把标准的使用者和标准的实现者分离
   * 
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    //创建台灯对象
    Lamps l = new Lamps();
    //创建黄灯泡对象
    YellowLights light = new YellowLights();
    //创建红灯泡对象
    RedLight r = new RedLight();
    //台灯里面传入什么就调用什么，不用再更改Lamp程序中的代码，达到弱耦合效果
    l.setLight(light);
    l.setLight(r);
    //再调用开灯方法
    l.powerOn(); 
  }
}
class Lamps{
  private Light light = null;
  //传入接口对象；
  public void setLight(Light light){
    this.light = light;
  }
  //开灯方法
  public void powerOn(){
    light.On();
  }
}
//创建灯泡的接口
interface Light{
  public void On();
}
class YellowLights implements Light{
  public void On(){ 
     System.out.println("黄灯泡发黄光");
  }
}
class RedLight implements Light{    
  public void On(){
    System.out.println("红灯泡发红光！");
  }
}

static 和 abstract  不能同时出现
  静态方法的覆盖没有多态
private 和 abstract 不能同时出现；
  私有方法不能继承给子类