共同点：

1. 都不能被实例化：接口和抽象类都无法直接创建实例。它们是用来被其他类实现或继承的。

// 不能实例化接口
InterfaceExample example = new InterfaceExample(); // 错误

// 不能实例化抽象类
AbstractClassExample example = new AbstractClassExample(); // 错误

2. 都可以包含抽象方法：这使得接口和抽象类可以定义一些必须在子类中实现的方法。

interface InterfaceExample {
    void method();
}

abstract class AbstractClassExample {
    abstract void method();
}

3. 都可以有默认实现的方法：从 Java 8 开始，接口中可以使用 default 关键字定义默认方法，抽象类则一直可以包含具体方法。

interface InterfaceExample {
    default void defaultMethod() {
        System.out.println("This is a default method in an interface.");
    }
}

abstract class AbstractClassExample {
    void concreteMethod() {
        System.out.println("This is a concrete method in an abstract class.");
    }
}

区别：

1. 目的和用途：

接口主要用于定义一组规范和行为约束，实现类必须实现接口中的所有方法。这种方式实现了行为的多态性。

抽象类主要用于代码复用和定义通用的属性和方法。子类可以继承抽象类并实现或覆盖其方法。

interface Animal {
    void eat();
    void sleep();
}

abstract class Mammal {
    abstract void eat();
    void breathe() {
        System.out.println("Breathing...");
    }
}

4. 继承和实现：

一个类只能继承一个抽象类。

一个类可以实现多个接口。

class Dog extends Mammal implements Animal {
    void eat() {
        System.out.println("Dog is eating...");
    }

    public void sleep() {
        System.out.println("Dog is sleeping...");
    }
}

5. 成员变量：

接口中的成员变量默认是 public static final，即常量，必须有初始值，不可更改。

抽象类中的成员变量可以有各种访问修饰符，可以被子类重新定义或赋值。

interface Constants {
    int MAX_VALUE = 100; // public static final int MAX_VALUE = 100;
}

abstract class Shape {
    protected String color;
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("Drawing a circle");
    }
}

实例与应用场景

接口的实际应用：

接口常用于定义一组通用行为，以实现不同类的多态性。例如，Java 中的 List、Set 和 Map 接口，它们提供了集合的行为，而具体实现则有 ArrayList、HashSet 和 HashMap 等。

java

List<String> list = new ArrayList<>();
list.add("Hello");
list.add("World");

for (String s : list) {
    System.out.println(s);
}

抽象类的实际应用：

抽象类常用于创建一组具有共同特性的类。比如，定义一组不同形状的类，它们具有共同的属性（如颜色）和方法（如计算面积）。

java

abstract class Shape {
    String color;

    abstract double area();
    
    public String getColor() {
        return color;
    }
}

class Circle extends Shape {
    double radius;

    Circle(String color, double radius) {
        this.color = color;
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    double length;
    double width;

    Rectangle(String color, double length, double width) {
        this.color = color;
        this.length = length;
        this.width = width;
    }

    @Override
    double area() {
        return length * width;
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle("Red", 5);
        Shape rectangle = new Rectangle("Blue", 4, 6);

        System.out.println("Circle Area: " + circle.area());
        System.out.println("Rectangle Area: " + rectangle.area());
    }
}

性能比较

在大多数情况下，接口和抽象类的性能差异并不显著。然而，接口方法调用略慢于抽象类方法调用，因为接口方法需要通过动态分派，而抽象类方法则是通过虚方法表（vtable）调用的。这个差异在现代 JVM 中已经被大大优化，因此实际应用中很少成为瓶颈。