不就是Java吗之抽象类

一、抽象类

1.1 抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 比如：

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

1.2 抽象类的语法

被关键字abstract修饰的类，叫做抽象类

被关键字abstract修饰的方法，叫做抽象方法

//抽象类：在class前面加上abstract
abstract class Shape {
    //抽象方法：abstract可以放在public前后，不用具体实现
    //public abstract void draw();
    abstract public void draw();
}

抽象类也是类，也可以有自己的成员属性和成员方法以及构造方法

abstract class Shape {
    //成员属性
    public int area;
    
    //成员方法
    public int getArea() {
        return area;
    }
    
    //构造方法
    public Shape() {
        System.out.println("Shape带有一个参数的构造方法");
    }
    //抽象方法
    abstract public void draw();
}

1.3 抽象类的特性

1. 抽象类不能够实例化，即不能new 抽象类名();

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

   public class TestDemo1 {
       public static void main(String[] args) {
           Shape shape = new Shape();//抽象类不能够进行实例化
       }
   }
   

   

   但是可以实例化别的对象(多态)

   abstract class Shape {
       abstract public void draw();
   }
   
   class Cycle extends Shape {
       @Override
       public void draw() {
           System.out.println("●");
       }
   }
   public class TestDemo1 {
       public static void main(String[] args) {
           Shape shape = new Cycle();
       }
   }
   

   

2. 当一个普通的类继承这个抽象类之后，那么这个普通类，必须重写这个抽象类当中所有的抽象方法

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

   

   我们还需要把print方法进行重写

   abstract class Shape {
       abstract public void draw();
       abstract public void print();
   }
   
   class Cycle extends Shape {
       @Override
       public void draw() {
           System.out.println("●");
       }
   
       @Override
       public void print() {
           System.out.println("打印●");
       }
   }
   

   

3. 抽象类存在的最大意义，就是为了被继承

4. 抽象类也可以发生向上转型，进一步实现多态

   abstract class Shape {
       abstract public void draw();
   }
   
   class Cycle extends Shape {
       @Override
       public void draw() {
           System.out.println("●");
       }
   }
   
   class Rect extends Shape {
       @Override
       public void draw() {
           System.out.println("◆");
       }
   }
   
   class Triangle extends Shape {
       @Override
       public void draw() {
           System.out.println("▲");
       }
   }
   
   public class TestDemo1 {
       public static void draw(Shape shape) {
           shape.draw();
       }
       public static void main(String[] args) {
           Cycle cycle = new Cycle();
           Rect rect = new Rect();
           Triangle triangle = new Triangle();
           
           draw(cycle);
           draw(rect);
           draw(triangle);
       }
   }
   

   

5. 当一个抽象类A继承了抽象类B，此时抽象类A可以不重写抽象类B当中的方法

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

   

6. 如果一个普通的类C继承了上一条里面的类A，那么就需要重写所有的抽象方法！

   abstract class Shape {
       abstract public void draw();
   }
   
   abstract class A extends Shape {
       abstract public void func();
   }
   
   class B extends A {
       
   }
   

   

   如果想要不报错的话,我们就需要重写A与B的方法

   abstract class Shape {
       abstract public void draw();
   }
   
   abstract class A extends Shape {
       abstract public void func();
   }
   
   class B extends A {
       @Override
       public void draw() {
           System.out.println("重写之后的draw()");
       }
       @Override
       public void func() {
           System.out.println("重写之后的func()");
       }
   }
   

   

7. final、private、static不能修饰抽象类和抽象方法

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

   

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

   

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

   

8. 抽象类中不一定有抽象方法，但是如果这个方法是抽象方法，那么它对应的类一定是抽象类

   abstract class A {
       //抽象类里面可以没有抽象方法
       //abstract public void func();
   }