java基础 ===========抽象类和接口区别

抽象类和接口的总结

在Android开发中接口和抽象类是很常见的，虽然知道怎么用，但是如果问到接口和抽象类的区别，你会想到哪些，我第一次学习java到抽象类和接口这一模块的时候，并不知道这个到底有什么实际的用处，下面就来说说我的看法。
参照的博客https://blog.csdn.net/m366917/article/details/52107466，写的很详细，我是通过看完这篇博客，加上自己的实现总结了一下。

抽象类（abstract）

什么是抽象类呢，就是把一些具体类中相同的属性，方法单独提出来提供其他类调用的，那为什么叫做抽象的呢，因为这个类中的方法并不实现它，只是定义一个方法而已。如下：

public abstract class fat{
   public abstract void show();
}

如果要标明是抽象类，必须要使用关键字abstract，当然抽象类中，如果想定义抽象方法，也要标明abstract，总之，如果想定义为抽象的事务，就必须使用关键字abstract。

• 抽象类的特点
  1.不能被实例化（如果想要实例化，有两种方法，第一种就是定义一个子类，实现其中的抽象方法；第二种方法就是用匿名内部类实现 ）

匿名内部类的方法实现
    new fat(){
            @Override
            public void show() {        
            }            
         };
        // 这个相当于new了一个匿名的对象，然后通过这个匿名对象来实现抽象方法。

2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
3.如果不想重写抽象方法，该子类是一个抽象类。 重写所有的抽象方法，这个时候子类是一个具体的类。
接下来就是看代码
定义一个抽象类（fat.java）

public abstract class fat{
   public int weight = 100;
   public final int num1 = 200;
   public abstract void show();
   public fat(String name,int age){}
   public fat(){}
 }

定义一个子类（man.java）

public class man extends fat{
//这里注意，如果不实现抽象类中的方法的话，那么这个子类就必须也是抽象类，加个关键字abstract
    @Override
    public void show() {
        if(weight>100){
            System.out.println("A fat Man");    
        }else{
            System.out.println(" fat child");
        }   
    }
}

测试一下

    public static void main(String[] args) {
        // TODO Auto-generated method stub
      man m = new man();
      m.show();
      //多态
      fat a = new man();
         a.show();
    }
//输出结果为:
 fat child
 fat child

接口（interface）

定义接口要使用的关键字就是interface，而且子类要实现接口的话要通过关键字implements。
这里要说一句，java只支持单继承，但是可以多实现，这也是接口的好处。

接口跟抽象类有些类似，但是却有一些区别
区别一：就是接口的成员变量只能是常量，并且是静态的
下面给个例子：
定义一个接口（A.java）

public interface A {
    public int num = 10;
    public int num1 =20;
    public static int num2 = 30;
    public void show(); //默认Abstract
}

定义一个子类来实现接口(B.java)

public class B implements A {
    public static void main(String[] args) {
       //多态
       A a = new B();
       a.show();
       System.out.println(a.num);
       System.out.println(a.num1);
       System.out.println(a.num2);
       //正常子类的创建
       B b = new B();
       b.show();
       System.out.println(a.num);
       System.out.println(a.num1);
       System.out.println(a.num2);
    }
    @Override
    public void show() {
        System.out.println("实现了接口");

    }
}

//输出结果:
实现了接口
10
20
30
实现了接口
10
20
30

这里如果我要修改num的值为5，试试看会怎么样。
接口中的成员变量只能是常量，并且是静态的，默认修饰符是public static final，但是上面的代码中A接口的成员变量，我定义的是int，static int，这些都是变量，其实，如果定义成接口，接口里的成员变量就是public static final，只是没写全给自动添加上了，不信可在B类中直接调用A的成员变量

       System.out.println(A.num);
       System.out.println(A.num1);
       System.out.println(A.num2);

这样也是对的。

下面就是类，接口，抽象类之间的关系了

我们看一下下面的代码
定义一个接口A

public interface A {
    public void showA(); //默认Abstract
}

定义一个接口B

public interface B{
   public void showB();
}

定义一个接口C

public interface C extends A,B{
    public void showC();
}

然后定义一个子类D

public class D implements C{

    @Override
    public void showA() {
        // TODO Auto-generated method stub

    }

    @Override
    public void showB() {
        // TODO Auto-generated method stub

    }

    @Override
    public void showC() {
        // TODO Auto-generated method stub

    }

}

这里就说明了接口与接口之间可以单继承，也可以多继承
类与接口之间，可以单实现，也可以多实现
类与类之间只能单继承，但可以多层继承（就是C继承B，B继承A，那么C就有A的属性和方法）

接下说说接口和抽象类中具体的区别

• 成员区别
  1.抽象类：成员变量可以使常量也可以是变量；接口：成员变量只可以为常量
  2.抽象类有构造方法，接口没有构造方法
  3.抽象类中的成员方法可以抽象，也可以非抽象，接口中的成员方法只可以抽象
• 其他区别
  抽象类说到底也是一个类，只能单继承，继承体系的共性功能，但是接口不一样，可以多实现，可以扩展功能。