java 面向对象（二十三）：关键字：abstract以及模板方法的设计模式

Posted 2020-12-11 秋华

abstract

abstract: 抽象的
1.可以用来修饰：类、方法
2.具体的：
abstract修饰类：抽象类
* > 此类不能实例化
* > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
* > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 --->抽象的使用前提：继承性

abstract修饰方法：抽象方法
* > 抽象方法只方法的声明，没方法体
* > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
* > 若子类重写了父类中的所的抽象方法后，此子类方可实例化
* 若子类没重写父类中的所的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
3.注意点：
* 1.abstract不能用来修饰：属性、构造器等结构
* 2.abstract不能用来修饰私方法、静态方法、final的方法、final的类

4.abstract的应用举例：
举例一：

举例二：
abstract class GeometricObject{
public abstract double findArea();
}
class Circle extends GeometricObject{
private double radius;
public double findArea(){
return 3.14 * radius * radius;
};
}
举例三：IO流中设计到的抽象类：InputStream/OutputStream / Reader /Writer。在其内部
定义了抽象的read()、write()方法。

 模板方法的设计模式

1. 解决的问题

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

2. 举例

abstract class Template{
    
    //计算某段代码执行所需要花费的时间
    public void spendTime(){
        
        long start = System.currentTimeMillis();
        
        this.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;
                    break;
                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }

    }
    
}

3. 应用场景

 

package atguigu.basic.day15.java;

/*
 * abstract关键字的使用
 * 1.abstract:抽象的
 * 2.abstract可以用来修饰的结构：类、方法
 *
 * 3. abstract修饰类：抽象类
 *         > 此类不能实例化
 *      > 抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
 *      > 开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作
 *
 *
 * 4. abstract修饰方法：抽象方法
 *         > 抽象方法只有方法的声明，没有方法体
 *         > 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
 *      > 若子类重写了父类中的所有的抽象方法后，此子类方可实例化
 *        若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
 */
public class AbstractTest {
    public static void main(String[] args) {

        //一旦Person类抽象了，就不可实例化
//        Person p1 = new Person();
//        p1.eat();
    }
}

abstract class Creature{
    public abstract void breath();
}

abstract class Person extends Creature{
    String name;
    int age;

    public Person(){

    }

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    //不是抽象方法：
//    public void eat(){
//
//    }
    //抽象方法
    public abstract void eat();

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

}


class Student extends Person{
    public Student(String name,int age){
        super(name,age);
    }
    public Student(){

    }

    public void eat(){
        System.out.println("学生多吃有营养的食物");
    }

    @Override
    public void breath(){
        System.out.println("学生应该呼吸新鲜的没有雾霾的空气");
    }
}

package atguigu.basic.day15.java;

/*
 * abstract使用上的注意点：
 * 1.abstract不能用来修饰：属性、构造器等结构
 *
 * 2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类
 *
 */
public class AbstractTest1 {
}

 

package atguigu.basic.day15.java;

public class TemplateTest {
    public static void main(String[] args) {
        SubTemplate t = new SubTemplate();
        t.spendTime();
    }
}

abstract class Template{
    //计算某段代码执行所需要花费的时间
    public void spendTime(){
        long start = System.currentTimeMillis();

        this.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;
                    break;
                }
            }
            if(isFlag){
                System.out.println(i);
            }
        }
    }
}

 

package atguigu.basic.day15.java;

public class TemplateMethodTest {
    public static void main(String[] args) {
        BankTemplateMethod btm = new DrawMoney();
        btm.process();

        BankTemplateMethod btm2 = new ManageMoney();
        btm2.process();

    }
}

abstract class BankTemplateMethod{
    // 具体方法
    public void takeNumber(){
        System.out.println("取号排队");
    }

    public abstract void transact();

    public void evaluate(){
        System.out.println("反馈评分");
    }

    // 模板方法，把基本操作组合到一起，子类一般不能重写
    public final void process(){
        this.takeNumber();
        this.transact();
        this.evaluate();
    }


}

class DrawMoney extends BankTemplateMethod{
    public void transact(){
        System.out.println("我要取款！！！");
    }
}

class ManageMoney extends BankTemplateMethod{
    public void transact(){
        System.out.println("我要理财！我这里有2000万美元!!");
    }
}