一篇文章让你完全理解java中抽象类和接口

时间 2019-11-20

标签一篇文章让你完全理解 java 抽象接口栏目 Java 繁體版

原文原文链接

目录javascript

相信你们都有这种感受：抽象类与接口这二者有太多类似的地方，又有太多不一样的地方。每每这两者可让初学者摸不着头脑，不管是在实际编程的时候，仍是在面试的时候，抽象类与接口都显得格外重要！但愿看完这篇博客文章各位都能从容地明了两者...java

@程序员

一、我所理解的抽象类

一、1 抽象类和类的相样韵味

一、抽象类和类同样，都是能够用来继承的
二、类能够有的成分，抽象类均可以拥有【包括构造方法、static静态修饰成分等】面试

抽象类正如这个名字定义同样，它也是一个类编程

一、2 抽象方法

讲不一样样韵味以前颇有必要要先深知的抽象方法：
一、抽象方法没有方法体
二、抽象方法必须用abstract关键字修饰
三、有抽象方法的类必然是抽象类
四、抽象方法必须为public或者protected，缺省状况下默认为publiceclipse

抽象类不必定有抽象方法ide

一、3 抽象类和类的异样韵味

一、抽象类必须用abstract关键字进行修饰，有abstract修饰的类就是抽象类！
二、抽象类无关紧要抽象方法
三、抽象类虽然有构造方法但不能用来直接建立对象实例
四、抽象类不能用final、private修饰
五、外部抽象类不能用Static修饰，但内部的抽象类可使用static声明。这句话理解代码以下：学习

//定义一个抽象类A
abstract class A{
   //定义一个内部抽象类B
    static abstract class B{  //static定义的内部类属于外部类
        public abstract void saoMethod();
    }
}

class C extends A.B{

    public void saoMethod(){
        System.out.println("======saoMethod方法执行了======");
    }
}
public class StaticDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.saoMethod();
    }

}

运行结果：  ======saoMethod方法执行了======

有的童鞋就看懵逼了， C extends A.B是啥骚操做啊，还能这样玩？是的，当使用static声明的内部抽象类至关于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。这种骚操做属实是稳中带皮。设计

抽象类是一个特殊的类，抽象类和普通类有着本质区别code

一、4 掌握抽象类

抽象类就是为了继承而存在的，定义了一个抽象类，却不去继承它，建立的这个抽象类就毫无心义!

抽象类虽然有构造方法但不能直接被实例化，要建立对象涉及向上转型，主要是用于被其子类调用

还有对于抽象类能够没有抽象方法这句话，这只是一个要记住的重要概念，必定要记住！实际开发中抽象类通常都有抽象方法，否则该抽象类就失去存在乎义，和普通类没啥两样！

一个普通类A继承一个抽象类B，则子类A必须实现父类B的全部抽象方法。若是子类A没有实现父类B的抽象方法，则必须将子类A也定义为为abstract类，也就是抽象类。

二、我所理解的接口

接口（interface）能够说成是抽象类的一种特例，抽象类与接口这二者有太多类似的地方，又有太多不一样的地方。相对的，接口更像是一种行为的抽象！

二、1 接口特性

一、接口中的方法默认为public abstract类型，接口中的成员变量类型不写默认为public static final。
二、接口没有构造方法
三、接口能够实现“多继承”，一个类能够实现多个接口，实现写法格式为直接用逗号隔开便可。

二、2 接口必知

接口中只能含有public static final变量，不写默认是public static final，用private修饰会编译失败。

接口中因此的方法会被隐式地指定为public abstract方法且只能是public abstract方法，用其余关键字，好比private、protected、static、 final等修饰会编译失败。

二、3 接口误区

网上不少文章说接口中的全部方法都是抽象方法，博主回去研究了一下发现，实际上这样说是不够严谨的，直接看个简单程序吧

package InterfaceDemo;

interface AA{   //接口AA
   default void hh(){
       System.out.println("123");
   };
}

class BB implements AA{  //实现接口
    
}

public class InterfaceDesign {

    public static void main(String[] args) {
        AA a=new BB(); //经过实现类建立实例
        a.hh();
    }
}
运行结果： 123

显然hh方法并非抽象方法，可是这样设计就失去接口的意义了，实际开发中不会出现这样的代码，确实有点专牛角尖的韵味,因此我也不否定网上的言论，只是以为不够严谨，我以为你们仍是注意一下比较好...若是面试官听到你这样的回答，可能对你另眼相看，会认为你是一个对知识极度向往、探索以及有我的思惟想法的学习者 ~说白了，就是杠精，这里杠精是褒义词~

三、抽象类和接口本质区别

抽象类和接口本质区别主要从语法区别和设计思想两方面下手

三、1 语法区别

1.抽象类能够有构造方法，接口中不能有构造方法。

2.抽象类中能够有任何类型成员变量，接口中只能有public static final变量

3.抽象类中能够包含非抽象的普通方法，接口中的能够有非抽象方法，好比deaflut方法

4.抽象类中的抽象方法的访问类型能够是public，protected和（默认类型,虽然 eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，而且默认即为public abstract类型。

5.抽象类中能够包含静态方法，接口中不能包含静态方法

6.抽象类和接口中均可以包含静态成员变量，抽象类中的静态成员变量的访问类型能够任意，但接口中定义的变量只能是public static final类型，而且默认即为public static final类型。

7.一个类能够实现多个接口，但只能继承一个抽象类。

三、2 设计思想区别

对于抽象类，若是须要添加新的方法，能够直接在抽象类中添加具体的实现（至关于写普通类的普通方法并添加方法体的实现代码），子类能够不进行变动；而对于接口则不行，若是接口进行了变动，则全部实现这个接口的类都必须进行相应的改动。这一点应该很好理解。

从设计角度来说抽象类是对一种对类抽象，抽象类是对整个类总体进行抽象，包括属性、行为。而接口是对行为的抽象，接口是对类局部（行为）进行抽象。从某一角度来说，接口更像是抽象的抽象！

怎么理解上面这段话呢？

理解两者设计思想的区别从程序员宜春和花姑娘（一头可爱的小母猪）的故事开始，程序员宜春天天过着三点一线的生活，不是吃就是睡觉，闲暇之余还会敲敲代码，而花姑娘就厉害了，天天都是一点一线的生活，不是吃就是睡觉，闲暇之余不是吃就是睡觉。程序员宜春和花姑娘都过着幸福安逸的生活，忽然有一天，风起云涌，天射大便~天色大变~，万恶的产品经理来需求了，要设计一个程序员宜春和花姑娘的一个程序，要求使用抽象类或者接口去设计，这个时候你会怎么去设计，下面给出两个设计方案...

方案一：使用抽象类设计，分别设计eat、sleep、qiaoDaiMa方法，具体代码以下：

abstract class Myclass{
    public abstract void eat();
    public abstract void sleep();
    public abstract void qiaoDaiMa();
  }

方案二：使用接口设计，分别设计eat、sleep、qiaoDaiMa方法，具体代码以下：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
    public abstract void qiaoDaiMa();
  }

显然，无论是哪一个类继承抽象类或者实现上面的接口，都会出现一样的情况：重写它们的抽象方法。
若是有一百个程序员宜春，上面的设计都是很好地获得解决。可是到花姑娘身上就无论用了，花姑娘不会敲代码这种高端操做啊！一百个花姑娘都重写的qiaoDaiMa方法都没有意义啊，显然这样设计有问题。

从上面能够看出，eat、sleep对于qiaoDaiMa方法不是同一范畴内的行为（方法）。实际上咱们能够这样设计：定义一个抽象类，包含eat、sleep方法，再定义一个接口包含qiaoDaiMa方法，具体代码以下：

abstract class Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

interface MyclassTwo{
    public abstract void qiaoDaiMa();
  }
  
class YiChun extends Myclass implements MyclassTwo{

          @Override
          public void eat() {
              
          }

          @Override
          public void sleep() {

          }

          @Override
          public void qiaoDaiMa() {

          }
      }

咱们只要让一百个程序员宜春继承抽象类并实现接口就行了，而花姑娘就直接继承抽象类就行了。这样一设计，堪称完美...

一样的，这样讲述是很不负责的，为啥捏？由于你会发现，这样设计无论是抽象类仍是接口好像没有什么区别，刚才的抽象类换成接口，接口换成抽象类，实现效果也一致，代码以下：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

abstract class MyclassTwo{
    public abstract void qiaoDaiMa();
  }

因此，为了讲解清晰设计思想区别，程序员宜春和花姑娘的故事不得不继续讲下去...

咱们都知道，可爱的小母猪通常都是粉色的对吧，这个时候咱们的产品经理又改需求了。啥？产品经理家中一百只小猪有一只是黑白sai的，额...

万恶的产品经理只会无理改需求，但是产品经理永远不会知道他一味逼程序员，程序员本身都不知道本身有多优秀！

咱们都知道，可爱的小母猪通常都是粉色的对吧，这个时候咱们的产品经理又改需求了。啥？产品经理家中一百只小猪有一只是黑白sai的，额...

万恶的产品经理只会无理改需求，但是产品经理永远不会知道他一味逼程序员，程序员本身都不知道本身有多优秀！

那么这个时候，咱们都知道,抽象类和接口都是能够有成员变量的，只不过接口比较苛刻只能是public static final正是由于这一点！抽象类和接口的设计精髓就在这里了，这个时候咱们这样设计：

interface Myclass{
    public abstract void eat();
    public abstract void sleep();
   }

abstract class MyclassTwo{
    String color="red";
    public abstract void qiaoDaiMa();
  }

让宜春类这样设计

package AbstractTest;

interface Myclass {
    public abstract void eat();

    public abstract void sleep();
}

abstract class MyclassTwo {
    String color = "red";

    public abstract void qiaoDaiMa();
}

class YiChun extends MyclassTwo implements Myclass {

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void qiaoDaiMa() {

    }
}

public class AbstractDemo {
    public static void main(String[] args) {
        YiChun yc = new YiChun();
    }

}

然而宜春对于color这个属性能够是不理睬的，能够当作不存在，除非宜春不嫌弃本身也是一只红sai佩奇哈哈哈....

而花姑娘类就要注意了！而后让产品经理家中的100只小猪设计代码以下;

package AbstractTest;

interface Myclass {
     public abstract void qiaoDaiMa();
}

abstract class MyclassTwo {
    String color = "red";

    public abstract void eat();
    public abstract void sleep();
  
}

class Pig extends MyclassTwo {

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

}

public class AbstractDemo {
    public static void main(String[] args) {
        Pig p = new Pig ();
        String color = "blackWhite";
        System.out.println(color);
    }

}

其他的99只花姑娘就直接不用动了也就是不须要String color = "blackWhite";这一句代码，它的color属性默认是red了...

这个时候抽象类和接口就不能更换了，从而抽象类和接口的设计思想就很清晰了，你何识着咩啊~

若是本文对你有一点点帮助，那么请点个赞呗，谢谢~

最后，如有不足或者不正之处，欢迎指正批评，感激涕零！

欢迎各位关注个人公众号，一块儿探讨技术，向往技术，追求技术