Java中的抽象类和接口

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、什么是抽象类（abstract ）

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}

抽象类是一种不能被实例化的类，它只能被用作其他类的基础类或作为接口的一部分。抽象类通常包含抽象方法，这些方法只有声明，而没有实现。

子类必须实现这些抽象方法才能被实例化。

抽象类可以包含具体的方法和属性，但它们不一定需要这些。它们主要是为了提供一种共同的接口，以便子类可以实现自己的功能，并在需要时覆盖父类中的方法。

抽象类是面向对象编程中的重要概念之一，它有助于实现代码的重用和扩展性。

抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态。

// 抽象类和抽象方法需要被 abstract 关键字修饰
abstract class Shape {
    // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体
    abstract void draw();
}
// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法
class Cycle extends Shape {
    @Override
    void draw() {  // 重写抽象类中的draw方法
        System.out.println("画一个圆圈");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        //Shape shape = new Shape();  抽象类虽然不能直接实例化
        // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
        Shape shape = new Cycle(); // 这称作：向上转型
        
        /*Cycle cycle = new Cycle();
          Shape shape = cycle // 这是向上转型的另一种写法
         */
        shape.draw();         // 通过父类引用调用被子类重写的方法
    }
}

向上转型：父类引用指向子类对象。

向上转型后的变化
关于方法：父类引用可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），但子类特有的方法无法调用。
关于属性:
父类引用可以调用父类的属性，不可以调用子类的属性向上转型的作用

减少一些重复性的代码，对象实例化的时候可以根据不同需求实例化不同的对象

通过子类对抽象类的继承和重写

抽象类实现多态

abstract class Shape {
    public abstract void draw(); // 抽象方法不能里有具体的语句
}
// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法
class Cycle extends Shape {  
    @Override              // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
 
public class Test4 {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();   // 子类引用cycle
        Flower flower = new Flower(); // 子类引用flower
        Square square = new Square();
        
        // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
        // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写
        Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
        for (int i = 0; i < shapes.length; i++) {
            Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
 
            shape.draw();  // 通过父类引用调用子类重写的draw方法
        }
 
    }
}

多态三个要素

1. 继承（我们刚才的Cycle类继承Shape抽象类）
2. 重写（我们子类对draw方法的重写）
3. 父类指向子类对象（就是shape1[0] = cycle -->也可以称作向上转型)

总结

1. 使用abstract修饰的类或方法，就是抽象类或者抽象方法
2. 抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
3. 抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
4. 当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）
5. 但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
6. final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌）
7. 抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写）
8. 抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。

二、什么是接口（interface）

接口是一种定义了系统中各种不同部分之间交互方式的协议。

在编程中，接口指定了一个类或对象所支持的方法、属性和事件，其他类或对象可以通过调用这些方法、属性和事件来与它进行交互。接口提供了一种结构化的、清晰的、可扩展的方式来描述组件之间的交互，降低了代码之间的耦合度。

接口也常用于描述不同系统之间的通信协议和数据格式，例如 Web API。

定义接口

//接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口
 
public interface 接口名称{
// 定义变量
int a = 10;      // 接口当中的成员变量默认都是public static final
 
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
}

通过接口实现多态

接口可以看成是一种特殊的类，只能用 interface 关键字修饰
interface IShape {
    int a = 10;   接口当中的成员变量默认都是public static final
    int b = 23;
    void draw();  接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前）
  
    default void show() {
        System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰
    }
    public static void test() {
        System.out.println("这是接口当中的一个静态的方法");
    }
}
 
// 一个普通的类要想实现接口，可以用implement, 
//因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法
class Cycle implements IShape {
 
    @Override
    public void draw() {
        System.out.println("画一个圆圈");
    }
}
class Square implements IShape {
    @Override
    public void draw() {
        System.out.println("画一个正方形");
    }
}
class Flower implements IShape {
 
    @Override
    public void draw() {
        System.out.println("画一朵花");
    }
}
public class Test4 {
    public static void main(String[] args) {
        // IShape iShape = new IShape(); 接口也不能直接实例化
        Cycle cycle = new Cycle();
        Square square = new Square();
        Flower flower = new Flower();
        // 这里的IShape接口就相当与抽象类中父类，接口类型也是一种引用类型
 
        IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型
 
        for (IShape iShape : iShapes) { // 增强型的for—each循环，也可以写成普通的for循环形式
            iShape.draw();              // 通过重写实现了多态
        }
    }
}
引用变量cycle和square都赋值给了Shape类型的引用变量shape,
但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，
就看此时接口引用的是那个对象的，是shape的、还是cycle的

三、抽象类和接口的区别

Java中接口和抽象类的定义语法分别为interface与abstract关键字。
相同点：

都不能被实例化 ，接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。

不同点

抽象类中的抽象方法的修饰符只能为public或者protected，默认为public；接口中的方法默认使用public修饰。
接口成员变量默认为public static final，必须赋初值，不能被修改。
抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；
实现接口的关键字为implements，继承抽象类的关键字为extends。
一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
接口强调特定功能的实现，而抽象类强调所属关系。
抽象类可以包含方法、构造方法，方法可以实现，但是构造方法不能用于实例化，主要用途是被子类调用。
接口只有定义，不能有方法的实现，java1.8中可以定义default方法体