Java基础(四)--接口和抽象类

接口和抽象类能够体现OOP的抽象，而接口和抽象类也是日常开发中经常用到的

抽象方法：

抽象方法就是被abstract修饰的方法，只有声明，没有实现，也就是没有方法体

public abstract void f1();

在接口中修饰符和abstract都可以不写，因为会被编译器隐式的指定

抽象类：包含抽象方法的类

1、抽象类可以有抽象方法和非抽象方法，甚至可以没有抽象方法，但是这样没有意义

public abstract class MyAbstractClass {
    abstract void add();
    void del(){

    };
}

2、可以有构造器，但不能实例化去创建对象，你只能这样写

public static void main(String[] args) {
    MyAbstractClass myAbstractClass = new MyAbstractClass() {
        @Override
        void add() {
            System.out.println("add()");
        }
    };
    myAbstractClass.add();
}

PS：这样本身不是实例化，而是重写方法，否则会报错。这只是创建了一个匿名内部类。

3、抽象方法的修饰符不能是private，因为需要被实现的。默认情况下是default，个人认为不是public

package com.it.nine;
public abstract class MyAbstractClass {
    public MyAbstractClass() {

    }
    abstract void add();
}

原因如下：

上面抽象类中定义了一个默认的add()

　　1、在另一个包继承这个类，是无法实现add()，而把add()修饰符改成public就可以了

　　2、同包下去继承这个类，实现add()，修饰符也是默认，而不是public，这个类并不是抽象类，public和默认肯定不一样吧

public class Test extends MyAbstractClass{
    @Override
    void add() {

    }
}

4、如果一个类继承抽象类，必须实现抽象类中所有的抽象方法，除非这个类也是抽象类

public abstract class Test extends MyAbstractClass{

}

接口：更加抽象的抽象类

public interface Interface1 {
    public String s = "";
    void f1();
    void f2();
}

上面就是接口的一般形式

1、接口里都是抽象方法，默认被public修饰，无论是否显式指明

2、不能有构造器，原因基于第一条

3、成员变量默认是public static final修饰，IDE中可以看到s是斜体(static)，而且必须有初始值(final)，否则编译报错

4、如果一个类实现接口，必须实现接口中所有的方法，除非这个类也是抽象类

相同点：

　　接口和抽象类的修饰符都是public，无论是否声明

接口和抽象类的区别：

除了上面写的区别之外，接口和抽象类还有一些语法层面的不同：

1、抽象类可以有非抽象方法，而接口中的方法只能是public

2、抽象类的成员变量可以是各种类型，而接口中的成员变量只能是public static final类型的

3、接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法

4、一个类只能继承一个抽象类，而一个类却可以实现多个接口

5、抽象类可以有构造函数，接口中没有构造函数

6、抽象类可以有代码块和静态块，接口不可以

设计层面的差别：

　　继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是

有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口

举个栗子：

abstract class Door {
    public abstract void open();
    public abstract void close();
}

或者：

interface Door {
    public abstract void open();
    public abstract void close();
}

现在添加报警alarm( )的功能，那么该如何实现？下面提供两种思路：

　　1、将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

　　2、将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

　　从这里可以看出，Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将

报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

interface Alram {
    void alarm();
}

abstract class Door {
    void open();
    void close();
}

class AlarmDoor extends Door implements Alarm {
    void oepn() {
      //....
    }
    void close() {
      //....
    }
    void alarm() {
      //....
    }
}

接口实现多继承

java中只能实现单继承，而我们可以通过接口进行多继承（接口肯定不能implements）

public interface Interface1 {
    void f1();
    void f2();
}
public interface Interface2 {
    void f3();
    void f4();
}
public interface Interface3 {
    void f5();
    void f6();
}
public interface ExtendInterface extends Interface1, Interface2, Interface3{ //多继承
    void extend();
}
public class MyInterface implements ExtendInterface{
    @Override
    public void extend() {

    }
    @Override
    public void f1() {

    }
    @Override
    public void f2() {

    }
    @Override
    public void f3() {

    }
    @Override
    public void f4() {

    }
    @Override
    public void f5() {

    }
    @Override
    public void f6() {

    }
} 

PS：当类实现这个多继承的接口ExtendInterface，需要实现之前所有接口的方法

PS：抽象类可以实现接口，可以选择是否实现接口的方法，如果不实现的话，抽象类的实现类需要实现抽象类和接口中的方法

问题：为什么抽象类有构造函数，接口中却没有？

　　首先抽象类虽然有构造函数，但是不能被实例化的。构造函数这里的作用，在子类被初始化的时候，必须初始化父类(抽象类)数据，而不是生成一个父类对象

，因为子类初始化有可能要用到父类的数据。

　　而接口中都是抽象方法，没有实现的，所有的属性都是常量(final修饰)，编译器直接生成ConstantValue属性，需要赋初值。

所以接口不需要构造函数。

jdk8+接口定义的变化：

1、可以定义static方法、默认方法

public interface MyInterface {

    void f();

     static void f2() {
        System.out.println("interface f2");
    }

     default void f3() {
        System.out.println("interface f3");
    }

}

public class Test implements MyInterface {

    @Override
    public void f() {

    }

    @Override
    public void f3() {
        MyInterface.super.f3();
    }

    public static void main(String[] args) {
        new Test().f3();
        MyInterface.f2();
    }
}

static和default修饰符为public，可以省略。static方法可以通过interface直接调用，而default方法只能上面那种方式去实现

内容参考：<Java编程思想>和https://www.cnblogs.com/dolphin0520/p/3811437.html