Java抽象类

• • Java中的抽象类
  • • 抽象类概念
    • 抽象类特性
    • 抽象类的作用

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

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

class Shape{
    public void draw(){
        System.out.println("画图形!");
    }
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("♦");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("⚪");
    }
}
public class TestDemo2 {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main1(String[] args) {
        //使用多态情况下
        Rect rect = new Rect();
        drawMap(rect);
        Cycle cycle = new Cycle();
        drawMap(cycle);
    }
}

1.使用abstract修饰的方法,叫做抽象方法

//父类 Shape 中的 draw 方法好像并没有什么实际工作可以设为抽象类
//抽象类
abstract class Shape{
    //抽象方法
    public abstract void draw();
}

2.包含抽象方法的类,必须设计为抽象类,使用abstract修饰这个类.但是抽象类中不一定包含抽象方法

3.抽象类是不能进行实例化的

4.抽象类当中,可以有和普通类一样的方法,成员.构造方法. 和普通类不一样的最突出地方就是抽象类不可以实例化.

//抽象类
abstract class Shape{
    public int a; // 可以有普通成员
    public static int b; //可以有静态成员
    public void func(){}; //可以有普通方法
    public Shape(int a) {
        this.a = a;//可以有构造方法
    }
    //抽象方法
    public abstract void draw();
}

5.抽象类虽然不能实例化,但是可以被继承(可以说抽象类就是为了被继承而来的)

6.当一个普通类继承这个抽象类之后,如果这个抽象类当中包含抽象方法,那么需要重写这个抽象方法,否则代码不能编译通过.

//抽象类
abstract class Shape{
    //抽象方法
    public abstract void draw();
}
class Rect extends Shape {
    @Override
    public void draw() {
        //重写这个抽象方法
        System.out.println("♦");
    }
}

7.如果一个抽象类A继承另一个抽象类B,那么此时这个抽象类A可以不重写B当中的抽象方法.但是后者是一个非抽象类C继承了B,那么他要把A和B的抽象方法都要重写了

abstract class A{
    //抽象方法
    public abstract void A();
}
abstract class B extends A{
    //抽象类B继承另一个抽象类A,可以不从写A的抽象方法
    public abstract void B();
}
class C extends B{
    //需要把A,B的抽象方法都重写了
    @Override
    public void A() {
    }
    @Override
    public void B() {
    }
}

8.抽象方法不能被private, static, final 修饰.因为抽象方法要被子类重写

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.(换句话说使用抽象类相当于多了一重编译器的校验.)