JAVA抽象类和接口-CSDN博客

本文链接：https://blog.csdn.net/hellokikiqiqi/article/details/121864895

抽象类：

在面向对象中，所有对象都是通过类来描述的，但并不能通过类来描述所有对象，如果这个类不能很好地描述对象，就说这个类是抽象类。

很典型的例子就是：一个形状抽象类，然后它的子类有三角形类，圆形类，矩形类等，这些子类可以很好地描述具体的对象三角形，圆形，矩形，包括其具有的特征，三角形有三条边等，但是形状抽象类没有这些特征，因为只有三角形才有三条边，所以这个形状类是抽象类。

关键字：abstract

用法：在定义类时，class前加上关键字abstract就是定义一个抽象类

例如：public abtract class Shape{}

抽象方法：

谈到抽象类就一定要说到抽象方法，抽象方法是抽象类的核心。

抽象方法只有方法头，没有方法主体，例如：public abtract void getArea(){}

非抽象子类必须实现抽象方法（可以理解为重写父类的方法，但更合适的是实现因为父类的方法没有什么意义，为空），否则会报错。抽象方法用来确保子类会实现这个方法。

当然，抽象类可以有普通方法，也可以没有抽象方法，但不论有抽象方法与否，该抽象类都不允许实例化，只能作为其他类的基类。

下面通过设计者模式中的观察者模式来体会抽象类和抽象方法的使用：

（可以将Subject理解为拍卖场的拍卖官，Observer理解为买主）

1.创建Subject类

import java.util.ArrayList;
import java.util.List;
 
public class Subject {
   
   private List<Observer> observers 
      = new ArrayList<Observer>();  //存放观察者
   private int state;
 
   public int getState() {  获得状态
      return state;
   }
 
   public void setState(int state) {  //设置状态
      this.state = state;
      notifyAllObservers();
   }
 
   public void attach(Observer observer){  //注册观察者
      observers.add(observer);      
   }
 
   public void notifyAllObservers(){  //通知观察者
      for (Observer observer : observers) { 
         observer.update();
      }
   }  
}

2.创建Observer类

public abstract class Observer {  //抽象类
   protected Subject subject;
   public abstract void update();  //抽象方法，需要被实现
}

3.创建实体Observer类

public class BinaryObserver extends Observer{
 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);  //注册到Subject类中，使自己能接收到通知
   }
 
   @Override
   public void update() {  //重写抽象类的抽象方法
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}

public class OctalObserver extends Observer{
 
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}

public class HexaObserver extends Observer{
 
   public HexaObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
      System.out.println( "Hex String: " 
      + Integer.toHexString( subject.getState() ).toUpperCase() ); 
   }
}

4.使用主题类和观察者实例

public class ObserverPatternDemo {
   public static void main(String[] args) {
      Subject subject = new Subject();
      //将所有观察者注册到主题
      new HexaObserver(subject);
      new OctalObserver(subject);
      new BinaryObserver(subject);
      
      System.out.println("First state change: 15");   
      subject.setState(15);
      System.out.println("Second state change: 10");  
      subject.setState(10);
   }
}

5.输出

First state change: 15
Hex String: F
Octal String: 17
Binary String: 1111
Second state change: 10
Hex String: A
Octal String: 12
Binary String: 1010

接口：

Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。为了提供统一标准，接口就很重要了。接口与抽象类很相似，在C++中接口可以用抽象类来实现，即抽象类的所有方法都为抽象方法。在Java中提出了接口这个概念，方便程序员使用。

举个例子：如果没有接口（统一标准），每个城市直接的轨道交通信号不相同，而且列车不可能出自同一厂家，列车无法跨区域通行，那么每到一座城市，你就必须换乘，这是没效率的，因此需要制定统一标准，即接口来保证列车的通行。

关键字：interface

用法：public interface 接口名{}，接口中的属性都为public，final，static，方法都为抽象方法

类实现接口：

public+class+类名+关键字implements+接口名

下面通过设计模式中的代理模式来体会接口：

1.创建接口

public interface Image {
   void display();
}

2.创建实现接口的实体类

public class RealImage implements Image {  //火车站售票点（12306）
 
   private String fileName;
 
   public RealImage(String fileName){
      this.fileName = fileName;
      loadFromDisk(fileName);
   }
 
   @Override
   public void display() {
      System.out.println("Displaying " + fileName);
   }
 
   private void loadFromDisk(String fileName){
      System.out.println("Loading " + fileName);
   }
}

public class ProxyImage implements Image{  //代理的火车票售票点（携程）
 
   private RealImage realImage;
   private String fileName;
 
   public ProxyImage(String fileName){
      this.fileName = fileName;
   }
 
   @Override
   public void display() {
      if(realImage == null){
         realImage = new RealImage(fileName);
      }
      realImage.display();
   }
}

3.当被请求时，使用 ProxyImage 来获取 RealImage 类的对象

public class ProxyPatternDemo {
   
   public static void main(String[] args) {
      Image image = new ProxyImage("test_10mb.jpg");
 
      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   }
}

4.输出

Loading test_10mb.jpg
Displaying test_10mb.jpg

Displaying test_10mb.jpg

联系：

1.若抽象类的方法都为抽象方法，其本质就是接口。

2.接口也有继承，也表达了“is a”的逻辑

3.接口同抽象类一样都不能被实例化

4.抽象方法必须被实现（重写）

区别：

抽象类是许多子类的父类，这说明两者之间有DNA联系，其本质是相同的。但接口只是说明一个标准，两者之间的本质可以不同，只要实现接口的那个类能够实现接口中的抽象方法即可。

例子：萤火虫会亮，灯泡也会亮，但两者没有什么本质的联系，我们不能给这两个定义一个抽象类和在里面定义一个会亮的抽象方法，只能通过定义一个接口，实现不同对象对该接口中抽象方法。

比较点	抽象类	接口
关键字	abtract class	interface
字段	无限制	public、final、static
方法	可以有普通方法和抽象方法	只能有抽象方法且public
实现	子类使用extends关键字来继承抽象类，并重写父类的抽象方法	子类使用关键字implements来实现接口，并重写父类的抽象方法
继承	不支持多继承	支持多继承