Java面向对象之接口和抽象类的区别一目了然

介绍

相信对于Java面向对象部分，很多人很长一段时间对于接口和抽象类的区别，使用场景都不是很熟悉，同是作为抽象层重要的对象，工作中到底什么情况下使用抽象类，不是很清楚。本文就一次性把这些概念一次性说清楚，不用再烦恼了，哈哈！

核心概念

1. 接口与抽象类最明显的区别可能就是使用上的惯用方式。接口的典型使用是代表一个类的类型或一个形容词，如 Runnable 或 Serializable，而抽象类通常是类层次结构的一部分或一件事物的类型，如 String 或 ActionHero。

2. java8开始增加默认方法的极具说服力的理由是它允许在不破坏已使用接口的代码的情况下，在接口中增加新的方法。默认方法有时也被称为守卫方法或虚拟扩展方法。

3. 抽象类仍然是一个类，在创建新类时只能继承它一个。而创建类的过程中可以实现多个接口。

4. 有一条实际经验：尽可能地使用接口而不是抽象类。只有当必要时才使用抽象类。除非必须使用，否则不要用接口和抽象类。大多数时候，普通类已经做得很好，如果不行的话，再移动到接口或抽象类中。

5. 任何抽象性都应该是由真正的需求驱动的。当有必要时才应该使用接口进行重构，而不是到处添加额外的间接层，从而带来额外的复杂性。恰当的原则是优先使用类而不是接口。从类开始，如果使用接口的必要性变得很明确，那么就重构。接口是一个伟大的工具，但它们容易被滥用。

接口和抽象类的区别

接口和抽象类都是Java中定义行为的方式，但它们之间存在一些重要的区别。

1. 定义与实现

接口：接口是一种完全抽象的类型，它只包含抽象方法和常量。接口不能被实例化，只能被类实现。一个类可以实现多个接口。

抽象类：抽象类是一个不完全的类，它可以包含抽象方法和非抽象方法。抽象类不能被直接实例化，需要通过子类来继承并实现所有抽象方法。一个类只能继承一个抽象类。

1. 方法与变量

接口：接口中只能定义抽象方法（从Java 8开始也可以定义默认方法和静态方法），所有方法默认都是public的。接口中定义的变量默认是public static final的。

抽象类：抽象类中可以定义普通方法、抽象方法、静态方法、构造方法等，方法默认是public或protected的。抽象类中的变量可以是任何访问修饰符。

1. 继承与实现

接口：一个类可以实现多个接口，通过关键字implements。

抽象类：一个类只能继承一个抽象类，通过关键字extends

代码示例

接口

package com.demo.java.test.javacore;

interface CanFight {
    void fight();
}

interface CanSwim {
    void swim();
}

interface CanFly {
    void fly();
}

class ActionCharacter {
    public void fight2(){
        System.out.println("ActionCharacter fighting");
    }
}

class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly {
    public void swim() {
        System.out.println("swiming");
    }

    public void fly() {
        System.out.println("flying");
    }

    @Override
    public void fight() {
        System.out.println("fighting");
    }
}

public class Adventure {
    public static void t(CanFight x) {
        x.fight();
    }

    public static void u(CanSwim x) {
        x.swim();
    }

    public static void v(CanFly x) {
        x.fly();
    }

    public static void w(ActionCharacter x) {
        x.fight2();
    }

    public static void main(String[] args) {
        Hero h = new Hero();
        t(h); // Treat it as a CanFight
        u(h); // Treat it as a CanSwim
        v(h); // Treat it as a CanFly
        w(h); // Treat it as an ActionCharacter
    }
}

• 输出：

fighting
swiming
flying
ActionCharacter fighting

抽象类

以乐器类抽象举例，请看继承关系图：

package com.demo.java.test.javacore;
// 音符枚举
enum Note{
    MIDDLE_C
}

/**
 *  乐器
 */
abstract class Instrument {
    private int i; // Storage allocated for each

    public abstract void play(Note n);

    public String what() {
        return "Instrument";
    }

    public abstract void adjust();
}

/**
 *  管乐器
 */
class Wind extends Instrument {
    @Override
    public void play(Note n) {
        System.out.println("Wind.play() " + n);
    }

    @Override
    public String what() {
        return "Wind";
    }

    @Override
    public void adjust() {
        System.out.println("Adjusting Wind");
    }
}

/**
 *  打击乐器
 */
class Percussion extends Instrument {
    @Override
    public void play(Note n) {
        System.out.println("Percussion.play() " + n);
    }

    @Override
    public String what() {
        return "Percussion";
    }

    @Override
    public void adjust() {
        System.out.println("Adjusting Percussion");
    }
}

/**
 *  有弦乐器
 */
class Stringed extends Instrument {
    @Override
    public void play(Note n) {
        System.out.println("Stringed.play() " + n);
    }

    @Override
    public String what() {
        return "Stringed";
    }

    @Override
    public void adjust() {
        System.out.println("Adjusting Stringed");
    }
}

/**
 *  铜管乐器
 */
class Brass extends Wind {
    @Override
    public void play(Note n) {
        System.out.println("Brass.play() " + n);
    }

    @Override
    public void adjust() {
        System.out.println("Adjusting Brass");
    }
}

class Woodwind extends Wind {
    @Override
    public void play(Note n) {
        System.out.println("Woodwind.play() " + n);
    }

    @Override
    public String what() {
        return "Woodwind";
    }
}

/**
 *  音乐组合类
 */
public class Music4 {
    static void tune(Instrument i) {
        i.play(Note.MIDDLE_C);
    }

    static void tuneAll(Instrument[] e) {
        for (Instrument i: e) {
            tune(i);
        }
    }

    public static void main(String[] args) {
        // 向上转型
        Instrument[] orchestra = {
            new Wind(),
            new Percussion(),
            new Stringed(),
            new Brass(),
            new Woodwind()
        };
        // 演凑
        tuneAll(orchestra);
    }
}

• 输出：

Wind.play() MIDDLE_C
Percussion.play() MIDDLE_C
Stringed.play() MIDDLE_C
Brass.play() MIDDLE_C
Woodwind.play() MIDDLE_C