抽象类和抽象方法（Java）

1、abstract：抽象的 2、abstract 关键字可以用来修饰类和方法

abstract class AbstractClass{  //abstract修饰类
    //这个区域写方法体
}

abstract class AbstractClass1{   
    public void add(){   
        System.out.println("普通方法");
    }
    
    public abstract void show();  //抽象方法
}

注：抽象方法所在的类必须是抽象类，抽象方法没有“{ }”方法体部分，直接以分号结束

3、什么是抽象类：

  随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

4、abstract关键字的使用（好好阅读这一点后面的代码） 1、abstract修饰类：抽象类

1、此类不能实例化

2、抽象类中一定有构造器，便于子类实例化时调用（涉及子类实例化的全过程，其实，所有类都有构造器）

3、开发中，都会提供抽象类的子类，让子类对象实例化，完成相关 *** 作，不然抽象父类如果没有子类实例化就没有意义了

2、abstract修饰方法：抽象方法

1、抽象方法只有方法的声明，没有方法体

2、包含抽象方法的类，一定是一个抽象类；然而，抽象类中可以没有抽象方法的

3、若子类重写了父类中的所有抽象方法后，此子类方可实例化

若其子类没有重写父类中的所有抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

public class AbstractLearn {   //测试类
    public static void main(String[] args) {
        //利用子类对象实例化造对象
        SubAbstractClass a1 = new SubAbstractClass();
        a1.AbstractMethods();
        a1.CommonMethods();
        System.out.println("******************");
        //运用了多态
        AbstractClass a2 = new SubAbstractClass();
        a2.AbstractMethods();
        a2.CommonMethods();
    }
}
​
abstract class AbstractClass{   //抽象父类
    /**
     * 定义该类的三个基本属性
     */
    int age = 18;
    String name = "KangKang";
    char sex = 1;
//*******************************************************
    /**
     * 说明抽象方法有构造器
     */
    public AbstractClass() {  //定义抽象方法中的构造器
​
    }
    public AbstractClass(int age, String name, char sex) {  //定义有参构造器
        this.age = age;
        this.name = name;
        this.sex = sex;
    }
//*******************************************************
    /**
     *定义该抽象类的普通方法和抽象方法
     */
    public void CommonMethods(){  //定义一个普通(非抽象)方法
        System.out.println("普通方法");
    }
    abstract void AbstractMethods();   //定义一个抽象方法
}
//*******************************************************
/**
 * 构造一个子类来继承抽象类，并重写抽象类的抽象方法
 * 如果子类重写了父抽象类的所有抽象方法，即可实例化
 * 反之，则必须在类名前声明abstract,即该类仍然为抽象类
 */
class SubAbstractClass extends AbstractClass{
    @Override
    void AbstractMethods() {
        System.out.println("重写了抽象父类的抽象方法");
    }
}

5、abstract使用上的注意点

1、abstract不能用来修饰，属性、构造器等结构

2、abstract不能用来修饰私有方法、静态方法、final方法、final类

6、抽象类的匿名子类

1、 这个我暂时不过多描述，之后单独出一篇。

7、模板方法的设计模式TemplateMethod（多态的应用）

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式

1、当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现

2、举个例子：在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变的部分可以抽象出来，供不同子类实现。这就是一种模板模式

/**
 * 模板方法的设计模式
 */
public class TemplateMethod {  //测试类
    public static void main(String[] args) {
        Template t = new SubTemplate();
        t.spendTime();
        System.out.println("*************");
        SubTemplate t1 = new SubTemplate();
        t1.spendTime();
    }
}
​
abstract class Template {     //定义一个抽象父类
    
    public void spendTime(){  //父类把整个流程写下来，不确定（多变）的方法就先抽象，造子类重写，该父类就像一个子类一样
        long start = System.currentTimeMillis();
        code();   //>>>>>>>>>>>>>>>>>>> 不确定的部分，可能有变动，所有造子类重写
        long end = System.currentTimeMillis();
        System.out.println("花费的时间为： " + (end - start));
    }
    public abstract void code();
}
class SubTemplate extends Template{    //定义一个子类继承抽象父类
​
    @Override
    public void code() {         //重写抽象父类中所不确定的子类抽象方法
        for(int i = 2;i <= 1000;i++){
            boolean isFlag = true;
            for (int j = 2;j <= Math.sqrt(i);j++){
                if(i % j ==0){
                    isFlag = false;
                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }
    }
}