抽象类与接口

目录

1. 抽象类

1.1 抽象类概念

1. 2🐔抽象类特性

1.3 抽象类的作用

2. 接口

2.1 接口是什么

2.2 语法规则

2.3 方法的使用

2.4 接口特性

2.5 实现接口 VS 继承类

2.6 抽象类 VS 接口（总结）

2.6 接口间的继承

---

🐓 随着多态的结束，今天让我们继续学习java，看看java中的抽象类和接口到底是什么？

1. 抽象类

既然我们叫抽象类为:类，那么它一定具有类的特征。

1.1 抽象类概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 比如：

举个🌰

  

   

    

     

    
    

     

      // 抽象类和抽象方法需要被 abstract 关键字修饰
     
    
   

    

     

    
    

     

      abstract 
      class 
      Shape {
     
    
   

    

     

    
    

     
    
      // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
     
    
   

    

     

    
    

     
    
      abstract void draw();
     
    
   

    

     

    
    

     
    
      // 抽象类也是类，也可以增加普通方法和属性
     
    
   

    

     

    
    

     
    
      public double getArea(){
     
    
   

    

     

    
    

     
        
      return area;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      protected 
      double area; 
      // 面积
     
    
   

    

     

    
    

     

      }
     
    
  

貌似draw（）方法啥都没有干，但是存在即合理，它一定有它自己的特殊意义。

1. 2🐔 抽象类特性

🐔1. 抽象类不能直接实例化对象

 在main方法内报错，告诉我们抽象类无法实例化对象。

那既然一个类不能实例化，那这种抽象类存在的意义是什么呀？

抽象类存在的意义：

🐤 抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态。

🐔2. 抽象方法不能是 private 修饰的

🐤 因为被private修饰过后就与继承相违背了，private 的权限只能在本类使用，出了本类就无法调用被修饰的方法和继承，这里又体现了封装的思想。

🐔 3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写

🐤抽象类作为父类时本身的抽象方法就没有任何东西，如果被final和static修饰就无法在子类中进行重写。

  

   

    

     

    
    

     

      public 
      abstract 
      class 
      Shape {
     
    
   

    

     

    
    

     
    
      abstract final void methodA();
     
    
   

    

     

    
    

     
    
      abstract public static void methodB();
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      // 编译报错：
     
    
   

    

     

    
    

     

      // Error:(20, 25) java: 非法的修饰符组合: abstract和final
     
    
   

    

     

    
    

     

      // Error:(21, 33) java: 非法的修饰符组合: abstract和static
     
    
  

🐔 4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰。

🐤 继承以后不对抽象类的方法进行重写是会报错的。

🐔 5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
🐔 6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

好,到现在为止我们对抽象类有个基本的认识了,那么抽象类的具体作用是啥呢？

1.3 抽象类的作用

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。

有些同学可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?

确实如此. 但是使用抽象类相当于多了一重编译器的校验。
使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。

2. 接口

2.1 接口是什么

🐔 抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的“抽象类”——接口（Interface）。

接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。

如何定义一个接口呢？下面我们来看一个例子：🌰🌰：

  

   

    

     

    
    

     

      //接口的定义格式与定义类的格式基本相同，
     
    
   

    

     

    
    

     

      //将class关键字换成 interface 关键字，就定义了一个接口
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      public interface 接口名称{
     
    
   

    

     

    
    

     

      // 定义变量
     
    
   

    

     

    
    

     

      int 
      a 
      = 
      10;      
      // 接口当中的成员变量默认都是public static final
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      // 抽象方法
     
    
   

    

     

    
    

     

      public 
      abstract 
      void 
      method1
      (); 
     
    
   

    

     

    
    

     

      // public abstract 是固定搭配，可以不写
     
    
   

    

     

    
    

     

      void 
      method2
      ();  
     
    
   

    

     

    
    

     

      // 接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
     
    
   

    

     

    
    

     

      }
     
    
  

接口的实现与类的继承非常得相似，一个是通过extends来继承，一个是通过implements来实现。

2.2 语法规则

  

   

    

     

    
    

     

      public interface 接口名称{
     
    
   

    

     

    
    

     

      // 抽象方法
     
    
   

    

     

    
    

     

      public 
      abstract 
      void 
      method1
      (); 
      // public abstract 是固定搭配，可以不写
     
    
   

    

     

    
    

     

      public 
      void 
      method2
      ();
     
    
   

    

     

    
    

     

      abstract 
      void 
      method3
      ();
     
    
   

    

     

    
    

     

      void 
      method4
      ();
     
    
   

    

     

    
    

     

      // 注意：在接口中上述写法都是抽象方法
     
    
  

提示:
1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 "形容词" 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

2.3 方法的使用

🐤接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法

  

   

    

     

    
    

     

      public 
      class 类名称 
      implements 接口名称{
     
    
   

    

     

    
    

     
    
      // ...
     
    
   

    

     

    
    

     

      }
     
    
  

举例：

请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口：包含打开设备、关闭设备功能
2. 笔记本类：包含开机功能、关机功能、使用USB设备功能
3. 鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能

 首先实现一个接口叫做IUSB，包涵了openDevice方法和closeDevice方法。

Mouse类实现了接口，并具备点击功能。

 KeyBoard类实现了IUSB接口，并具备输入功能，

 Computer包含开机功能、关机功能，并提供了usbUsb方法使用USB设备功能。

 主方法通过computer访问鼠标和键盘方法。

2.4 接口特性

🐔 接口类型是一种引用类型，但是不能直接new接口的对象

🐔接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错）

🐔接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

🐔重写接口中方法时，不能使用默认的访问权限

🐔接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

🐔接口中不能有静态代码块和构造方法

🐔接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

🐔 在jdk7.0前接口里的所有方法都没有方法体，即都是抽象方法。 jdk8.0后接口可以有静态方法，默认方法，即接口有方法的具体实现。

🐔 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

2.5 实现接口 VS 继承类

案例：

  

   

    

     

    
    

     

      public 
      class 
      Monkey {
     
    
   

    

     

    
    

     
    
      private 
      String name;
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      public 
      Monkey(
      String name) {
     
    
   

    

     

    
    

     
        
      this.
      name = name;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      public 
      String 
      getName(
      ) {
     
    
   

    

     

    
    

     
        
      return name;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      public 
      void 
      setName(
      String name) {
     
    
   

    

     

    
    

     
        
      this.
      name = name;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      public 
      void 
      climbing(
      ) {
     
    
   

    

     

    
    

     
        
      System.
      out.
      println(
      "猴子爬树");
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  
 

  
 

  

   

    

     

    
    

     

      public 
      interface 
      Fishable {
     
    
   

    

     

    
    

     
    
      public void swimming();
     
    
   

    

     

    
    

     

      }
     
    
  

  

   

    

     

    
    

     

      public 
      class 
      LittleMonkey 
      extends 
      Monkey 
      implements 
      Fishable{
     
    
   

    

     

    
    

     
    
      public 
      LittleMonkey(
      String name) {
     
    
   

    

     

    
    

     
        
      super(name);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      @Override
     
    
   

    

     

    
    

     
    
      public 
      void 
      swimming(
      ) {
     
    
   

    

     

    
    

     
        
      System.
      out.
      println(
      this.
      getName() + 
      "努力学习，学会游泳");
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      public 
      void 
      flying(
      ) {
     
    
   

    

     

    
    

     
        
      System.
      out.
      println(
      this.
      getName() + 
      "努力学习，学会飞");
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      }
     
    
  

  

   

    

     

    
    

     

      public 
      class 
      Main {
     
    
   

    

     

    
    

     
    
      public 
      static 
      void 
      main(
      String[] args) {
     
    
   

    

     

    
    

     
        
      LittleMonkey littleMonkey = 
      new 
      LittleMonkey(
      "悟空");
     
    
   

    

     

    
    

     

              littleMonkey.
      climbing();
     
    
   

    

     

    
    

     

              littleMonkey.
      swimming();
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  

 小结：

🐤当子类继承了父类，就自动拥有了父类的功能。

🐤当子类需要拓展功能，就可以通过实现接口的方式来拓展。

🐤相当于实现接口是对Java单继承机制的补充。

接口和继承解决问问题不同

🐤 继承的价值主要在于：解决代码的复用性和可维护性。

🐤 接口的价值主要在于：设计。设计好各个规范（方法），来让其他类去实现，使之更灵活。

接口在一定程度上实现了解耦【接口的规范性 + 动态绑定机制】

2.6 抽象类 VS 接口（总结）

🐔 默认的方法实现

抽象类：它可以有默认的方法实现

接口：接口完全是抽象的。它根本不存在方法的实现

🐔 实现

抽象类：子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。

接口：子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现

🐔 构造器

抽象类：抽象类可以有构造器

接口：接口不可以有构造器

🐔 与正常Java类的区别

抽象类：除了你不能实例化抽象类之外，它和普通Java类没有任何区别

接口：除了你不能实例化抽象类之外，它和普通Java类没有任何区别

🐔 访问修饰符

抽象类：抽象方法可以有public、protected和default这些修饰符

接口：接口方法默认修饰符是public。你不可以使用其它修饰符

🐔 main方法

抽象类：抽象方法可以有main方法并且我们可以运行它

接口：接口没有main方法，因此我们不能运行它。

🐔 多继承

抽象类：抽象方法可以继承一个类和实现多个接口

接口：接口只可以继承一个或多个其它接口

🐔 添加新方法

抽象类：如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。

接口：如果你往接口中添加方法，那么你必须改变实现该接口的类。

2.6 接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字
例如：

  

   

    

     

    
    

     

      interface 
      IRunning {
     
    
   

    

     

    
    

     
    
      void run();
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      interface 
      ISwimming {
     
    
   

    

     

    
    

     
    
      void swim();
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      // 两栖的动物, 既能跑, 也能游
     
    
   

    

     

    
    

     

      interface 
      IAmphibious 
      extends 
      IRunning, 
      ISwimming {
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

      }
     
    
   

    

     

    
    

     

      class 
      Frog 
      implements 
      IAmphibious {
     
    
   

    

     

    
    

     

          ...
     
    
   

    

     

    
    

     

      }
     
    
  

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.
接口间的继承相当于把多个接口合并在一起.

转载：https://blog.csdn.net/weixin_67807492/article/details/127882075