Java篇-抽象类abstract关键字

一 : abstract关键字

abstract : 解释为抽象的,可以用来修饰类,方法

• abstract 修饰类 -->抽象类

当我们设计一个类,不需要创建此类的实例的时候,就可以考虑将其设置为抽象的,由其子类实现这个类的抽象方法以后,进行实例化.
①不可被实例化

abstract class A{
}

调用

public class TestAbstract {
    public static void main(String [] args) {
        /*
          不能实例化报错
         */
        A a = new A();
        
    }
}

② 抽象类有构造器,凡是类都有构造器

 abstract class B{
    public B() {
        
    }
}

③抽象方法所在的类,一定是抽象类

报错

 class Creator{
    abstract void breath();
}

正确

abstract class Creator{
    abstract void breath();
}

解析原因 :
若 Creator 不是抽象的,则可被实例化,但是方法却是抽象的,所以依然不可调用其抽象方法,所以规定抽象方法所在的类,一定是抽象类.

④ 抽象类中可以没有抽象方法

• abstract 修饰方法-->抽象方法

① 格式:没有方法体.

abstract class Creator{
    abstract void breath();
}

②抽象方法只保留方法的功能,而具体的执行,交给子类重写抽象方法.

abstract class Person extends Creator {
    String name;

    public abstract void eat();

    public abstract void walk();
    
 public Person(String name) {
        this.name = name;
    }
    
    public Person() {
        
    }
    
    void breath() {

        System.out.println("人呼吸");
    }
}

子类 实现了 eat和 walk 方法

class Student extends Person {

    public void eat() {

        System.out.println("学生吃饭");
    }

    public void walk() {
        System.out.println("学生走路");
    }


}

解析 :
若子类继承抽象类,并重写了所有的抽象方法,则此类是一个"实体类"即可实例化

③若子类继承抽象类,没有重写所有的抽象方法,意味着此类中仍有抽象方法,则此类必须声明为抽象的

abstract class Worker extends Person {

    public void eat() {
        System.out.println("工人吃饭");
    }
    
//  public void walk() {
//      System.out.println("工人走路");
//  }

}

• abstract 不能修饰属性,构造器,private,final,static

① 修饰属性
报错

class A {
    abstract  int name;
    
}

解析 : 不允许这样使用.

②修饰构造器
报错

class A {
  public abstract A(){
  }
}

解析 : 不允许这样使用,abstract 修饰的方法希望被重写,但是构造器不能被重写.

③修饰 private
报错

class A {
  private abstract void metho1();
}

解析 : 不允许这样使用,abstract 修饰的方法希望被重写,而private修饰的只能是本类方法,不能被重写,相矛盾.

④修饰 final
报错

class A {
  public abstract final void metho2() ;
}

解析 : 不允许这样使用,abstract 修饰的方法希望被重写,而final 修饰的方法不能被重写,相矛盾.

⑤ 修饰static
报错

class A {
  public abstract static void method3();
}

解析 : 不允许这样使用,static 修饰类可以调用此方法,而abstract 修饰则没方法体,不能实现,相矛盾.

二 : 抽象类应用例子

模板方法设计模式
解决问题:当功能内部一部分实现是确定的,一部分实现是不确定的.这是可以把不确定的部分暴露出去,让子类去实现.

编写一个抽象父类,父类提供了多个子类的通用方法,并把一个或多个方法留给其子类实现,就是一种模板式.

abstract class Template{
        //抽象方法
    public abstract void code();
    
    public void spendTime() {
        long start = System.currentTimeMillis();
        this.code();
        long end = System.currentTimeMillis();
        System.out.println("花费时间 = :"+(end - start));
    }
    
}

子类实现抽象方法,功能具体化

class SubTemplate extends Template{
    public void code() {
        
        //求素数
        boolean flag = false;
        for (int i = 2; i < 1000; i++) {
            for (int j = 2; j < Math.sqrt(i); j++) {
                if (i % j == 0) {
                    flag = true;
                    break;
                }
            }
            if(!flag) {
                System.out.println("素数为 : "+i);
            }
            flag = false; 
        }
    }
    
}