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 static修饰，无论是否显式指明

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

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

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

接口和抽象类的区别：

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

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

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

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

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

设计层面的差别：

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

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

举个栗子：

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，需要实现之前所有接口的方法

 

内容参考：<Java编程思想>和https://www.cnblogs.com/dolphin0520/p/3811437.html ，部分内容完全来自后者，加了个人的看法

转载于:https://www.cnblogs.com/huigelaile/p/11004597.html