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

本文链接：https://blog.youkuaiyun.com/L_Jun0112/article/details/76048685

- 抽象类
- 接口

抽象类

抽象类：用abstract关键字来修饰一个类时，该类叫做抽象类。

abstract class 类名 {
    属性定义;
    方法定义; = 抽象方法+非抽象方法
}

抽象类可以用于声明，但不允许创建对象。

    abstract class MyClass{ } //抽象类
     MyClass m1; //正确
     m1 = new MyClass(); //错误

抽象类必须被继承，从而创建子类对象。

     abstract class MyClass{
         int value;
             public void test(){
                 System.out.println("this is test()");
            }
            public abstract void test1();
     }
    class MySubClass extends MyClass{    }

    MyClass mc;
    mc = new MySubClass(); //正确

抽象类只能作为其他类的超类，这一点与final类正好相反。

抽象类的定义规范

含有抽象方法的类必须被定义成抽象类；
抽象类中不一定要有抽象方法；
构造方法耍有avstract；

抽象方法

用abstract来修饰一个方法时，该方法叫做抽象方法。
- 抽象方法必须被重写；
- 抽象方法只有声明，不能有实现。
- 定义了抽象方法的类必须是抽象类。
- 语法：
  - abstract返回值类型方法名（参数列表）；

抽象方法特点

抽象方法由子类实现：

abstract class MyClass{
    int value ;
    public abstract void test();
}
class MySubClass extends MyClass{
    public void test(){
    System.out.println(" this is test() ");
    }
}
/*
 * 抽象类的子类要么实现所有的抽象方法，要么就也声明为抽象类。
 *  abstract class MySubClass extends MyClass{ *  
 *  }
 * /
------------------------
public class TestAbstract {
     public static void main(String args[]){
       MyClass m = new MySubClass();
       m.test(); //按照多态的特点 执行子类覆盖的方法 
     }
}

抽象类的应用

这里写图片描述

抽象类的好处

描述抽象的概念
抽象类的抽象方法约定了多个子类共用的方法声明
不同的子类可以有不同的抽象方法实现,这样体现了OO的多态性

接口

在构建问题的类过程中，我们经常会遇到一种特殊的情况，在表述某个类的各个方法时，对每个方法我们只能给其他功能实现的要求（原形声明）但不能给出具体的功能实现（函数定义体）。以为我们所处理的问题只是一个泛泛的功能说明，并没有针对某一具体类型的问题来说明。

接口的定义

类似于类的定义格式，只是以 interface作为定义符；

格式：

[public] interface 接口名
{}
或者
[public] interface 派生的接口名 extends 父接口名类表
{}

接口中的成员

接口是一个特殊的抽象类

[public] interface 接口名 [extends 父接口]
{
[public] [static] [final] 类型 追中变量名 = value;  //常量名
......;
[public] [abstract] 返回值类型 方法名 (参数表);//抽象方法说明
......;
}

这里写图片描述

接口的实现

implements 关键字

class MyClass implements MyInterface{
        public void m1(){}
        public void m2(){}
}
MyClass m1=new MyClass();
MyInterface m2=new MyClass();//多态

接口的特点

接口的继承，接口继承接口使用extends关键字

interface IA{
    void m1();
}
interface IB extends IA{
    void m2();
}
public class MyClass implements IB{
    public void m1(){}
    public void m2(){}
}

接口的多继承

interface IA{
     void m1();
}
interface IB {
     void m2();
}
interface IC extends IA,IB {
     void m3();
}

子类的多实现

interface IA {
   void m1();
}

interface IB {
   void m2();
}

class MyClass implements IA, IB {
        public void m1() {
            System.out.println("this is m1()");
        }
         public void m2() {
             System.out.println("this is m2()");
        }
}

子类的多实现的同时还可以继承一个父类

interface IA {
  void m1();
}

interface IB {
      void m2();
}

class CC{
      void m3(){};  
}
class MyClass extends CC  implements IA,IB {
   public void m1(){
        System.out.println("this is m1()");
     }
      public void m2(){
           System.out.println("this is m2()");  
     }
    //方法的覆盖
      public void m3(){
          System.out.println("this is m3()");
     }
}

使用接口的好处

增加程序的通用性（多态作用）
- 声明引用时要使用接口类型
- 方法的参数要声明成接口类型
- 方法的返回值要声明成接口类型
接口的方法约定了多个实现类共用的方法声明（定义规范）
不同的实现类可以有不同的接口方法实现，这样体现了OO的多态性
面向接口编程降低了程序之间的耦合度（高内聚、低耦合）–汽车vs发动机
接口实现了特殊的多继承

接口和抽象类

相同点
- 都包含抽象方法
- 都不能被实例化
- 都是引用数据类型
不同点
- 约定
  - 抽象类：约定了多个子类共同使用的方法
  - 接口：约定了多个互不相关的类之间共同使用的方法
- 继承性
  - 抽象类与子类之间采用单继承机制
  - 一个类实现多个接口则可以实现多继承
- 结构
  - 抽象类中可以包含非抽象方法，也可以声明构造方法
  - 接口中的方法全是抽象方法，不能声明构造方法
- 访问权限
  - 抽象类具有和普通类一样的访问权限
  - 接口和类也是一样的访问权限，但是成员只能是public权限
- 成员变量
  - 抽象类中可以声明成员变量，子类可以对成员变量赋值
  - 接口只能是常量