java:抽象类与接口

1、抽象类

class Shape{
    public void draw(){
        //啥都不用干
    }
}

class Cycle extends Shape{
    @Override
    public void draw() {
        System.out.println("o");
    }
}

class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("□");
    }
}

class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("♣");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape shape1=new Flower();
        Shape shape2=new Cycle();
        Shape shape3=new Rect();
        drawShape(shape1);
        drawShape(shape2);
        drawShape(shape3);
    }

    public static void drawShape(Shape shape){
        shape.draw();
    }
}
//结果：♣ o □

在刚才的打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract method), 包含抽象方法的类我们称为抽象类(abstract class).

abstract class Shape{
    abstract public void draw();
}

• 在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码).
• 对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类.

注意事项：

1. 抽象类不能直接实例化.

Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

2. 抽象方法不能是 private 的

abstract class Shape {
 abstract private void draw();
}
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

3. 抽象类中可以包含其他的非抽象方法, 也可以包含字段. 这个非抽象方法和普通方法的规则都是一样的, 可以被重写,
   也可以被子类直接调用

abstract class Shape {
    abstract public void draw();
    void func() {
        System.out.println("func");
    }
}
class Rect extends Shape {
 ...
}
public class Test {
    public static void main(String[] args) {
        Shape shape = new Rect();
        shape.func();
    }
}
// 执行结果
func

2、抽象类的作用

1）抽象类存在的最大意义就是为了被继承.
2）抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.

问：普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢？
答：使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了,使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.

3 、接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量.

语法规则
在刚才的打印图形的示例中, 我们的父类 Shape 并没有包含别的非抽象方法, 也可以设计成一个接口

interface IShape{
    void draw();
}

class Cycle implements IShape{
    @Override
    public void draw() {
        System.out.println("○");
    }
}

public class Test{
    public static void main(String[] args) {
        IShape shape=new Cycle();
        shape.draw();
    }
}
结果：○

• 使用 interface 定义一个接口
• 接口中的方法一定是抽象方法, 因此可以省略 abstract
• 接口中的方法一定是 public, 因此可以省略 public
• Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
• 在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
• 接口不能单独被实例化.

接口中只能包含抽象方法. 对于字段来说, 接口中只能包含静态常量(final static).

interface IShape {
   void draw();
   public static final int num = 10;
}

其中的 public, static, final 的关键字都可以省略. 省略后的 num 仍然表示 public 的静态常量.