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

原文地址:https://www.cnblogs.com/huigelaile/p/11004597.html