JAVA抽象与接口详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_66768178/article/details/124520554

本文主要探讨了JAVA中的抽象类和接口。抽象类不能被直接实例化，包含抽象方法的类必须是抽象类，而接口作为完全抽象的引用数据类型，只支持常量和抽象方法，且接口可以多继承。此外，还介绍了匿名内部类的使用和面向对象设计原则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、抽象类

是不是

例如小狗是动物，那么小狗就继承父抽象类动物，再比如黑白打印机是打印机，那么黑白打印机就是继承抽象类打印机。

一个类中如果存在抽象方法，那么他必须要是抽象类

抽象类VS普通类

抽象类不能被直接实例化

但可以创建一个引用变量，其类型是一个抽象类，指向非抽象的子类实例

普通类可以被实例化，

抽象方法必须存在于抽象类当中，抽象类其实就是相当于“是不是”，比如，小狗是动物，那么小狗就是继承父抽象类动物，再比如：黑白打印机是打印机，那么黑白打印机就继承抽象类打印机。

由于世界上不存在一个真正单纯是“动物”的东西，那只能说狗是动物，猫是动物，但你不会真的实例化出以后个所谓的“动物”，所以动物就是抽象类。打印机同理，黑白打印机就是打印机，你可以创造出一台黑百打印机，但一般情况下，你不会去创造一个“打印机”。

“白马非马”

“我们定一个个规则，所有的“马”都不能进城，那我只要

“你是人，我是人，但是没有“人是人””

 //抽象方法打印
  public abstract class Printer{
      public abstract void print();
  }
  
  //重写打印方法的彩色打印机类
  public class CPrinter extends Printer{
      @Override
      public void print(){
          System.out.println("这是一个彩色打印机，打印了彩色的文案");
      }
  }
  
  //重写打印方法的黑白打印机类
  public class BWPrinter extends Printer{
      @Override
      public void print(){
          System.out.println("这是一个黑白打印机，打印了黑白的文案");
      }
  }
  
  //测试类
  public static void main(String[] args){
      Scanner input=new Scanner(System.in);
      while(true){
          System.out.println("请问你要选择什么打印机打印？1、黑白打印机，2、彩色打印机");
          int flag=input.nextInt();
          Printer printer;
          if(1==flag){
              printer=new BWPrinter();
          }else{
              printer=new CPrinter();
          }
          printer.print();
          System.out.println("——————————————————————")
      }
  }

1、抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定位为抽象类

2、如果子类没有实现父类的所有抽象方法，子类必须被定位为抽象类

3、没有抽象构造方法，也没有抽象静态方法

4、抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用。

2、接口

能不能？

2.1 接口也是一种“引用数据类型”，编译之后也是class文件

2.2 接口是完全抽象

2.3 接口定义

 public interface Xxx{
      
  }

2.4 接口中只支持常量+抽象方法。

2.5 接口中所有元素都是public关键字修饰的。

2.6 接口中抽象方法的public anstract可以省略。

2.7 接口中常量的public static final可以省略。

2.8 接口支持多继承并且接口只可以继承接口。

 public interface Xxx extends A,B{
      
  }

例如：

 
  public static void main(String[] args){
      LockDoor lockDoor=new LockDoor();
      lockDoor.colseDoor();
      lockDoor.openDoor();
      lockDoor.lock();
      lockDoor.unlock()
  }
  public static void main(String[] args){
      ELockDoor eLockDoor=new ELockDoor();
      //      eLockDoor.colseDoor();
      //      eLockDoor.openDoor();
      //      eLockDoor.lock();
      //      eLockDoor.unlock();
      Phone phone = new Phone();
      //      MenuUtil.openELock(eLockDoor);
      //      MenuUtil.openLock(Phone);
      MenuUtil.open(Phone);
      MenuUtil.open(eLockDoor);
      
  }
  //锁接口，当一个物体可以上锁，则实现这个接口
  //各种们可以上锁可以实现这个接口
  //手机也能上锁，可以实现这个接口
  public interface Lock{
      void lock();
      void unlock();
  }
  //电子锁
  public interface ELock extends Lock{
  }
  //门
  public abstract class Door{
      public abstract void openDoor();
      public abstract void closeDoor();
  }
  //普通防盗门
  public class LockDoor extends Door implement Lock{
      @Override
      public void openDoor(){
          System.out.println("防盗门打开了")；
      }
      
       @Override
      public void colseDoor(){
          System.out.println("防盗门关闭了")；
      }
      
       @Override
      public void lock(){
          System.out.println("防盗门上锁了")；
      }
      
       @Override
      public void unlock(){
          System.out.println("防盗门开锁了")；
      }
  }
  //电子防盗门
  public class ELockDoor extends LockDoor implement ELock，Display{
      @Override
      public void openDoor(){
           System.out.println("电子防盗门打开了")；
      }
      
      @Override
      public void closeDoor(){
           System.out.println("电子防盗门关上了")；
      }
      
      @Override
      public void lock(){
           System.out.println("电子防盗门的锁锁上了")；
      }
      
      @Override
      public void unlock(){
           System.out.println("电子防盗门的锁打开了")；
      }
      
      @Override
      public void open(){
           System.out.println("电子安全门开门了")；
      }
  }
  
  //菜单工具类
  public class MenuUtil{
      //通过物理打开一个普通的锁
      public static void openLock(Lock lock){
          lock.unlock();
      }
      //通过菜单可以远程打开电子锁
      public static void openELock(Elock elock){
          eLock.unLock();
      }
      
      public static void open(Display display){
          if(display instanceof Object){
              SYstem.out.println("123123123")
          }
          display.open();
      }
  }
  //显示器
  public interface Dispaly{
      void open();
  }
  //手机类
  public class Phone implements Lock,Dispaly{
      @Override
      public void lock(){
          System.out.println("手机的锁被锁上了")；
      }
      
      @Override
      public void unlock(){
          System.out.println("手机的锁被打开了")；
      }
      
      @Override
      public void open(){
          System.out.println("手机的屏幕打开了")；
      }
  }

3、匿名内部类

  public interface Lock{
      void lock();
      void unlock();
  }

 Lock l=new Lock(){
              @Override
              public void lock(){
                  System.out.println("1");
              }
      
               @Override
              public void unlock(){
                  
              }
          };
  //此时lock方法调用的是第4行代码所重写的方法——输出1
  l.lock();
  
  Lock l2=nex Lock(){
               @Override
               public void lock(){
                        System.out.println("2");
                  }
      
               @Override
              public void unlock(){
                  
              }
  }
  //此时lock方法调用的是第18行代码所重写的方法——输出2
  l2.lock();

由于抽象方法没有具体实现（无方法体），所以若被实例化，无法具体调用该方法，所以使用匿名内部类方法，将为抽象的方法重写（具体方法），此时实例化出的对象就可以用该重写调用具体方法，允许被此类方法实例化实例化。