JAVA基础-接口与抽象类

接口

接口的作用：用于团队开发，确定好功能后，设定接口，通过接口确定属性和方法，将一个整体项目解耦成实现不同功能的接口。

接口的组成：由全局常量和公共的抽象方法所组成。

接口的语法格式：

[public] interface interface_name [extends interface1_name[, interface2_name,…]] {
    // 接口体，其中可以包含定义常量和声明方法
    [public] [static] [final] type constant_name = value;    // 定义常量
    [public] [abstract] returnType method_name(parameter_list);    // 声明方法
}

接口的特征：

• public 修饰的接口，允许任何类使用；没有指定 public 的接口，其访问将局限于所属的包。

• 接口中声明的方法隐式地声明为public abstract，这种方法是不能有具体代码实现的。特别地，接口中可以创建static和default方法，而且要有具体代码实现，由static修饰的方法可以不用重写，default修饰的方法不能重写。代码如下：

public interface Student {

    public static final  String NAME="小红";
    
    public abstract void study() ;
    void st1();//不写就默认为抽象方法
    static void st2() {};//static方法
    default void st3() {};//default方法
}

public class ImpStudent implements Student{
    
    @Override
    public void study() {
        // TODO Auto-generated method stub
        
    }

    @Override
    public void st1() {
        // TODO Auto-generated method stub
        
    }
    static void st2() {
        System.out.println("我是static方法");
    };
}

• 接口中声明的变量隐式地声明为public static final

• 由static修饰的变量所有对象都会共享，如果修改多次值，各对象都只记录最后一次赋值。而普通的常量一个对象保存一份变量值，各对象修改互不干扰。代码如下：

public class Test {
    public static int Const=10;
    public static void main(String[] args) {
        Test t1=new Test();
        t1.Const=20;
        Test t2=new Test();
        t2.Const=30;
        System.out.print("t1:"+t1.Const+","+"t2:"+t2.Const);
    }
}
//运行结果：t1:30,t2:30

• 由final定义的常量，不能被修改。由final修饰的方法不能被重写，不能被继承

• 接口没有构造方法，不能被实例化

• 类可以在继承某个类的同时实现多个接口，继承在前，实现在后。

• <public> class <class_name> [extends superclass_name] [implements interface1_name[, interface2_name…]]{}

• 一个接口不能够实现另一个接口，但它可以继承多个其他接口。这里要注意因为该接口继承了父接口所有的抽象方法，那么如果有类实现该接口，该接口以及该接口的父接口所有的抽象方法要全部重写。

• 例如接口Student继承了ActionListener，MouseListener两个接口，当类ImpStudent实现接口Student时，就不能只重写Student接口内的抽象方法，ActionListener，MouseListener两个接口的抽象方法全都要重写，否则会报错。代码如下：

---

抽象类

抽象类的作用：和接口类似，用来定义对象的公共行为。如果一个类中不能包含一个具体的对象，这样的类就称为抽象类。

抽象类的语法格式：

<abstract>class<class_name> {
    <abstract><type><method_name>(parameter-iist);
}

抽象类的特征：

• 抽象类和抽象方法都要使用abstract 关键字声明

• 抽象类中的属性可以被任何修饰符修饰，普通方法的修饰符无限制，抽象方法不能使用private

• 抽象类中可以包含抽象方法，同时可以有具体方法

• 抽象类不能实例化，不能使用new创建对象，只能被继承

抽象类的实现：

public abstract class AbstractExample {
//普通变量
    int count=2;
    //私有变量
    private static int total=10;
    //抽象方法
    public abstract void method();
    //普通方法
    public void method1() {
        System.out.println("我是普通方法");
    };
}

抽象类被继承：

public class Abstractmethod extends AbstractExample{

    @Override
    public void method() {
        System.out.println("我是抽象方法");
        
    }
    public static void main(String[] args) {
        Abstractmethod abstractMethod=new Abstractmethod();
        abstractMethod.count=1;
        abstractMethod.method1();
        abstractMethod.method();
    }
    
}//运行结果：我是普通方法 我是抽象方法

---

接口与抽象类的区别：

• 定义的关键字不同：接口使用关键字 interface 来定义。 抽象类使用关键字 abstract 来定义

• 子类继承或实现关键字不同：接口使用 implements 关键字定义其具体实现。 抽象类使用 extends 关键字实现继承。

• 类型扩展不同：抽象类是单继承，而接口是多继承

• 方法的修饰符：抽象类无限制，只是抽象类中的抽象方法不能被 private 修饰；而接口有限制，接口默认的是 public (stract)修饰

• 属性的修饰符：抽象类无限制，而接口有限制，接口默认的是 public (static final)修饰

• 方法实现不同：抽象类中的普通方法必须有实现，抽象方法不能有实现；而接口中普通方法（也就是抽象方法）不能有实现，但 static 和 defualt 方法必须有实现

• 静态代码块的使用不同：抽象类可以有静态代码块，而接口不能有