abstract与interface的区别

abstract的用法：

 //通过abstract 关键字修饰的类叫抽象类。
 abstract class Animal
 {
     String name;
     String color;

     abstract public void run ();//抽象方法是没有主体，没有方法的具体实现。

     public void eat (){

        System.out.println("动物在吃东西");
     }

 }

 //一非抽象的类继承了抽象类，必须实现抽象类中的所有方法。
 class Dog extends Animal
 {

     //需要重写父类中的run方法

     public void run(){

        System.out.println(name + "跑的很快");
     }
 }
 class a
 {
     public static void main(String[] args)
     {

       Dog dog = new Dog();
       dog.name = "阿旺";
       dog.run();

     }
 }

运行结果：

interface的用法：

/*
  接口 ： Java开发中比较常用。
  接口作用 ： 用来添加拓展功能。
   为什么不用类呢？因为在java中是单继承的，有时候类是不能够满足 需求的
 接口定义模式：
     用interface关键字来表示接口
     结构：
     interface 接口名{};

     //如何实现接口中的方法。需要用实现来完成。
     结构：
       class 类 implements 接口名1,接口名2...{

       }

      java中是支持多实现，一个类可以实现多个接口。

       接口作用 ：
          1.用来拓展功能
          2.让程序解耦
          3.定义约束

       接口的使用注意事项：
          1.接口是一个特殊的类，是可以定义属性和方法。
          2.属性默认是用final修饰的  ： public static final 实际上是一个常量。
          3.方法都是抽象的 ： abstract public
          4.接口不能创建对象。
          5.接口没有构造方法。
          6.接口是给类去实现的，非抽象类实现接口时，必须将接口中的方法都实现了。

*/

//定义一个橡皮擦的接口
interface Eraser
{
   int a = 10; // 在接口定义的变量必须初始化。接口中的变量默认是final修饰的
   static int b=0;   //这样也是可以的，只要有数值
   // int c;   //这个没有初始化，会报错
   //定义擦字行为
   //定义在接口中的方法是不需要实现的
   //接口中的方法都是抽象方法。
   public void clear(); //默认是用abstract修饰的

}

interface Pancil
{
    public void write();
}

class EraserAndPencil implements Pancil , Eraser
{

    //一个类如果实现了一个接借口，需要将所有的抽象方法都实现
    //写字的方法
    public void write() {

        System.out.println(a+"铅笔可以写字");
    }
    //擦字的方法
    public void clear(){

       System.out.println("铅笔还可以擦字");
    }

}

class a
{
    public static void main(String[] args)
    {
        EraserAndPencil ep = new EraserAndPencil();
        ep.write();
        ep.clear();
    }
}

运行效果图上：

在多态中接口的形式

 /*
     所谓金矿： 父类指针指向子类对象
     多态的另一种表现形式：
         接口的引用类型指向实现类。  // 多态的另一种表现形式。

      实现关系下多态：
          接口  变量 = new  接口实现类对象。

 */
 //定义一个接口 可以做增删改查的功能
 interface Dao
 {

     public void add();
     public void del();
     public void upDate();
     public void search();
 }

 class UserDao implements Dao
 {

     public void add(){
       System.out.println("添加");
     }
     public void del(){
       System.out.println("删除");
     }
     public void upDate(){
       System.out.println("修改");
     }
     public void search(){

       System.out.println("查找");
     } 

 }

 class a
 {
     public static void main(String[] args)
     {
         //实现下的多态的表现
        // Dao 接口 ， 接口是不能过创建对象的。
        Dao d = new UserDao(); // 在Java中用的比较多。 比如：List就是接口
        d.add();
        //多态的形式。  Java实际的例子
        //List list = new ArrayList(); 

     }
 }

效果图：

结论：

两者的区别：

　　1.abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。

　　2.在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据

成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。

　　3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，

interface表示的是"like-a"关系。

　

4.接口一般用于在抽象类中没有可供继承的默认实现时（即没有实例变量和默认方法实现）代替该类。
    
    5.abstract class是另一种契约形式,是设计对实现的要求；而接口是服务器对客户端的要求。
    
    6.abstract class是一个基类，不能被实例化；接口是个声明，每个对应接口的类都要实现方法。

7. 一个子类如果implements一个接口，就必须实现接口中的所有方法（不管是否需要）；如果是继承一个抽象类，只需要实现需要的方法

即可，这是抽象类的一个优点

8. 如果一个接口中定义的方法名改变了，那么所有实现此接口的子类显然将无法通过编译，因为它们所实现的方法名已经不存在了，这是

接口的一个缺点；而抽象类中如果有个非抽象方法改了，就不存在这个问题，只是为子类添加了一个新的方法。

9. 看前面两点，似乎抽象类要比接口有着更多的优点，但它却有着一个难以弥补的缺点：就是一个子类只能有一个父类。A extends B 。

这样A就拥有了B的所有方法和功能，但当A还想拥有C的功能的时候。就不能通过 A extends C 来实现，而需要走一些弯路。目前系统架构

的趋势就是由针对抽象（借口，抽象类）而不是具体编程，并且将功能尽可能的细分。这就需要通过实现多个接口的方式来实现，显然，抽

象类无法提供这样的功能。从系统重构的角度来说，一个具体类抽象出接口是十分方便的。只需要写一个接口，里面定义具体类的所有方法，

然后在为这个具体类implement这个接口就可以了。而抽象类就要复杂的多，比如说 B extends A , C extends B 如果想要为c抽象出一个抽象

类D的话，就需要找到它的最顶层A来从头做起,因为无法做到C extends D