抽象类与模板方法

最新推荐文章于 2023-05-10 16:05:36 发布
最新推荐文章于 2023-05-10 16:05:36 发布
阅读量758 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： java 模板方法 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43990804/article/details/121312956
版权

目录

如何学习本文

  • 先对"概念(理论)“有大概印象，再将大量的"案例(实践)“看懂，如果看不懂可以抄写，多抄几遍就懂了。代码案例弄懂了之后倒回去看概念，你会发现概念描述的很清晰很准确。然后自己给自己提出一个需求，用本文的知识实现这个需求。自己写一篇关于"抽象类和模板方法设计模式"的博客或者笔记，最好是"脑图+文字+画图+代码”，笔记上传到云端，代码上传到github，将github作为自己的"代码片段仓库”，以后工作中需要这块知识，直接去自己的github上下载代码来使用即可。经常翻看关于这块知识的笔记与代码。

1. 概念

  • 明确一点：接口的作用是提供能力、提供规范，抽象类定义模板。

  • 模板方法设计模式 概述1：

    • 模板方法是一个抽象类，里面的模板方法先把通用部分写好，然后声明一个钩子方法，让子类去实现，new的子类对象调用模板方法时，就会自动调用钩子方法了。

  • 模板方法设计模式 概述2：

    • 模板方法定义了算法（一段代码逻辑）的程序框架（先执行啥、后执行啥、怎么执行）。子类可以覆盖一个或多个算法步骤，以允许不同的行为，同时确保仍然遵循总体算法。
    • 通常，此模式由两个或多个类组成，一个是提供模板方法（非抽象）的抽象类，该模板方法具有对由一个或多个具体子类实现的抽象方法的调用。
    • 模板抽象类和具体实现通常位于同一项目中，但是根据项目范围，这些具体对象将被实现到另一个项目中。

  • 模板方法设计模式 概述3：

    • 定义一个操作中的算法框架，而将具体的实现细节推迟到子类中实现。这样可以使子类不改变算法结构来重新定义算法的某些特定逻辑。

  • 模板方法设计模式角色：

    • 抽象类：实现模板方法，定义算法框架。
    • 具体类：实现抽象类中的抽象方法，完成完整的算法逻辑。

  • 钩子方法：这种方法像一个钩子，抽象类下面挂哪个子类对象，就调用那个子类实现的钩子方法。

2. 案例

2.1 实现计算代码执行时间的抽象

  • 涉及类

    • cn.king.demo01.AbstractAClass 抽象类
    • cn.king.demo01.AClass 抽象类的实现
    • cn.king.demo01.Demo 作为测试类

  • cn.king.demo01.AbstractAClass

    public abstract class AbstractAClass {

    public Integer process() {
        long start = System.currentTimeMillis();
        Integer result = this.doProcess();
        long end = System.currentTimeMillis();
        System.out.println("花费时间为 " + (end - start) + " 毫秒");
        return result;
    }

    public abstract Integer doProcess();

}

  • cn.king.demo01.AClass

    public class AClass extends AbstractAClass{

    @Override
    public Integer doProcess() {
        int result = 0;
        for (int i = 0; i < 100000; i++) {
            result += i;
        }
        return result;
    }
    
}

  • cn.king.demo01.Demo

    public class Demo {

    // 实际开发会使用这种方式
    @Test
    public void test01() throws Exception {
        AClass aClass = new AClass();
        System.out.println(aClass.process());
        /*
         * 输出：
         * 花费时间为 2 毫秒
         * 704982704
         */
    }

    @Test
    public void test02() throws Exception {
        AClass aClass = new AClass();
        System.out.println(aClass.doProcess());
        /*
         * 输出：
         * 704982704
         */
    }

    @Test
    public void test03() throws Exception {
        AbstractAClass aClass = new AClass();
        System.out.println(aClass.process());
        /*
         * 输出：
         * 花费时间为 1 毫秒
         * 704982704
         */
    }

    @Test
    public void test04() throws Exception {
        AbstractAClass aClass = new AClass();
        System.out.println(aClass.doProcess());
        /*
         * 输出：
         * 704982704
         */
    }

}

2.2 实现before()和after()的抽象

  • 涉及类

    • cn.king.demo01.AbstractAClass 抽象类
    • cn.king.demo01.AClass 抽象类的实现
    • cn.king.demo01.Demo 作为测试类

  • cn.king.demo01.AbstractAClass

    public abstract class AbstractAClass {

    public void process() {
        before();
        doProcess();
        after();
    }

    // 直接在抽象父类中实现 前置处理
    protected void before() {
        System.out.println("执行AbstractAClass的before()方法");
    }

    // 子类中实现
    public abstract void doProcess();

    // 直接在抽象父类中实现 后置处理
    protected void after() {
        System.out.println("执行AbstractAClass的after()方法");
    }

}

  • cn.king.demo01.AClass

    public class AClass extends AbstractAClass {

    // 如果觉得父类实现的before()或after()方法不满足自己需求，可以在子类中覆盖
    @Override
    protected void before() {
        System.out.println("执行AClass的before()方法");
    }

    @Override
    public void doProcess() {
        System.out.println("执行AClass的doProcess()方法");
    }

}

  • cn.king.demo01.Demo

    public class Demo {

    @Test
    public void test01() throws Exception {
        AClass aClass = new AClass();
        aClass.process();
        /*
         * 输出：
         * 执行AClass的before()方法
         * 执行AClass的doProcess()方法
         * 执行AbstractAClass的after()方法
         */
    }

}

2.3 实现异步处理的抽象

  • 涉及类

    • cn.king.demo01.AbstractAClass 抽象类
    • cn.king.demo01.AClass 抽象类的实现
    • cn.king.demo01.Demo 作为测试类

  • cn.king.demo01.AbstractAClass

    public abstract class AbstractAClass<T> {

    // 异步处理
    public void asyncProcess(T request) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                T t = before(request);
                doAsyncProcess(t);
            }
        }).start();
    }

    // 前置方法，可以对参数进行一些前置处理
    protected abstract T before(T request);

    // 需要异步处理的代码
    protected abstract void doAsyncProcess(T request);

}

  • cn.king.demo01.AClass

    public class AClass extends AbstractAClass<Integer> {

    @Override
    protected Integer before(Integer request) {
        if (request == null || request <= 0) {
            return 100000;
        }
        return request;
    }

    @Override
    protected void doAsyncProcess(Integer request) {
        int result = 0;
        for (int i = 0; i < request; i++) {
            result += i;
        }
        System.out.println("结果为 " + result);
    }

}

  • cn.king.demo01.Demo

    public class Demo {

    public static void main(String[] args) {
        AClass aClass = new AClass();
        aClass.asyncProcess(null);
        // 输出：结果为 704982704
    }

}

2.4 案例4

  • 需求：①打开链接 => ②处理数据 => ③关闭链接

  • 分析：在抽象类中定义一个模板方法规定逻辑处理步骤为①②③。经常变动的是步骤②，将其抽取为抽象方法，不同的处理方式创建不同的实现类实现该方法。

  • 抽象类

    public abstract class URLProcessorBase {

    public void process(URL url) throws IOException {
        URLConnection urlConnection = url.openConnection();
        InputStream input = urlConnection.getInputStream();

        try{
            processURLData(input);
        } finally {
            input.close();
        }
    }

    protected abstract void processURLData(InputStream input) throws IOException;

}

  • 实现类

    public class URLProcessorImpl extends URLProcessorBase {

    @Override
    protected void processURLData(InputStream input) throws IOException {
        int data = input.read();
        while(data != -1){
            System.out.println((char) data);
            data = input.read();
        }
    }
  
}

  • 测试

    URLProcessorImpl urlProcessor = new URLProcessorImpl();
urlProcessor.process(new URL("http://wjl.king.cn"));

2.5 短信发送案例1

  • 短信发送系统，两层抽象，一层通用发短信，一层针对特定业务场景发短信。

  • 涉及类

    • cn.king.demo01.SmsHandler 接口
    • cn.king.demo01.AbstractSmsHandler 抽象类
    • cn.king.demo01.DefaultSmsHandler 实现类 通用场景发短信
    • cn.king.demo01.XxxSmsHandler 实现类 针对Xxx业务场景发短信
    • BaseRequest、SmsReq、XxxSmsReq；BaseResponse、SmsResp、XxxSmsResp 参数和返回值
    • cn.king.demo01.Demo 作为测试类

  • cn.king.demo01.SmsHandler

    /**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 短信处理器接口。定义功能、定义规范。
 */
public interface SmsHandler<T, R> {

    // 前置方法。可以对参数进行处理
    T before(T t);

    // 同步发送
    R send(T t) throws Exception;

    // 异步发送
    R asyncSend(T t) throws Exception;

    // 查询发送详情
    R querySendDetail(T t) throws Exception;

}

  • cn.king.demo01.AbstractSmsHandler

    /**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 短信处理器抽象类。定义模板。
 * 抽象类中的泛型进一步限制了泛型的范围，
 * 如果某个实现类实现了接口，那么两个泛型类型可以是任意，
 * 如果某个实现类继承了抽象类，那么两个泛型类型必须是BaseRequest或其子类 和 BaseResponse或其子类。
 * <p>
 * 抽象类不实现任何业务相关的方法，只是定义模板、实现通用方法。
 */
public abstract class AbstractSmsHandler<TT extends BaseRequest, RR extends BaseResponse> implements SmsHandler<TT, RR> {

    // 子类可以不实现前置方法，因此在此空实现。
    @Override
    public TT before(TT tt) {
        return tt;
    }

    @Override
    public RR send(TT tt) throws Exception {
        TT req = before(tt);
        return doSend(req);
    }

    // 子类可以不实现同步发送的方法，因此在此空实现。
    protected RR doSend(TT tt) {
        return null;
    }

    @Override
    public RR asyncSend(TT tt) throws Exception {
        new Thread(() -> {
            TT req = before(tt);
            doAsyncSend(req);
        }).start();
        return null;
    }

    // 子类必须实现异步发送的方法，因此搞成抽象方法。
    protected abstract void doAsyncSend(TT tt);

    // 查询方法没有模板。子类可以不实现查询方法，因此在此空实现。
    @Override
    public RR querySendDetail(TT tt) throws Exception {
        return null;
    }

}

  • cn.king.demo01.DefaultSmsHandler

    /**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 默认的短信处理器。通用场景的短信处理器。
 */
public class DefaultSmsHandler extends AbstractSmsHandler<SmsReq, SmsResp>  {

    @Override
    protected SmsResp doSend(SmsReq smsReq) {
        System.out.println("同步发短信");
        return new SmsResp();
    }

    @Override
    protected void doAsyncSend(SmsReq smsReq) {
        System.out.println("异步发短信");
    }

    @Override
    public SmsResp querySendDetail(SmsReq smsReq) throws Exception {
        System.out.println("查询某条短信的发送详情");
        return new SmsResp();
    }

}

  • cn.king.demo01.XxxSmsHandler

    /**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 针对Xxx业务场景的短信处理器。
 */
public class XxxSmsHandler extends AbstractSmsHandler<XxxSmsReq,XxxSmsResp>{

    @Override
    protected void doAsyncSend(XxxSmsReq xxxSmsReq) {
        System.out.println("针对Xxx业务实现的短信发送方法");
    }

}

  • Req、Resp

    /**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 所有请求参数的基类
 */
public class BaseRequest {
}

/**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 所有响应的基类
 */
public class BaseResponse {
}

/**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 通用的短信请求参数
 */
public class SmsReq extends BaseRequest{
}

/**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 通用的短信返回值
 */
public class SmsResp extends BaseResponse{
}

/**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 针对Xxx业务场景的短信请求参数
 */
public class XxxSmsReq extends SmsReq{
}

/**
 * @author: wjl@king.cn
 * @version: 1.0.0
 * @description: 针对Xxx业务场景的短信返回值
 */
public class XxxSmsResp extends SmsResp {
}

  • cn.king.demo01.Demo

    public class Demo {

    public static void main(String[] args) throws Exception {
        XxxSmsHandler smsHandler = new XxxSmsHandler();
        smsHandler.asyncSend(new XxxSmsReq());
    }

}

2.6 短信发送案例2

  • 和【2.5】需求相同。结合Spring。

  • 涉及类

    • com.king.handler.sms.SmsHandler 接口 定义功能、规范
    • com.king.handler.sms.AbstractSmsHandler 抽象类 定义模板
    • com.king.handler.sms.DefaultSmsHandler 默认实现 处理通用场景
    • com.king.handler.sms.InactiveUserSmsHandler 专门处理”给未激活用户发短信“的场景
    • com.king.application.SmsApplication 聚合业务层 聚合短信业务
    • com.king.controller.SmsApiControllerImpl 接口实现层
    • com.king.controller.SmsApiController 接口层 供接口实现层实现、Feign实现

  • com.king.controller.SmsApiController

    @Api(tags = "短信接口")
@RequestMapping("/king/sms/api")
public interface SmsApiController {

    @PostMapping("/inactive/send")
    @ApiOperation(value = "向未激活用户发送短信", notes = "向未激活用户发送短信", hidden = false)
    AjaxResult<Void> inactiveUserSmsSend(InactiveUserSmsReq req);

}

  • com.king.controller.SmsApiControllerImpl

    @Slf4j
@RestController
public class SmsApiControllerImpl extends BaseController implements SmsApiController {

    @Resource
    private SmsApplication smsApplication;

    // 此处Controller的实现写法可以忽略，无非也是模板模式，对smsApplication.inactiveUserSmsSend(req);的返回值进行了处理后响应给客户端而已
    @Override
    public AjaxResult<Void> inactiveUserSmsSend(InactiveUserSmsReq req) {
        return executeWithLogContext(req, new BaseController.BizCallbackWithoutResult<InactiveUserSmsReq>() {
            @Override
            protected void doInTransactionWithoutResult(InactiveUserSmsReq req) throws Exception {
                smsApplication.inactiveUserSmsSend(req);
            }
        });
    }

}

  • com.king.application.SmsApplication

    @Slf4j
@Component
public class SmsApplication {

    // AcsResponse为阿里云短信发送API的返回值
    @Resource(name = "inactiveUserSmsHandler")
    private SmsHandler<SmsReq, AcsResponse> smsHandler;
    @Resource
    private SmsAService smsAService;
    @Resource
    private SmsBService smsBService;

    /**
     * @author: wjl@king.cn
     * @param: req
     * @return: void
     * @description: 向未激活用户发送短信
     */
    public void inactiveUserSmsSend(InactiveUserSmsReq req) throws Exception {
        if (req == null || CollectionUtils.isEmpty(req.getPhoneList())) {
            return;
        }
        smsHandler.asyncSend(req);
    }

}

  • com.king.handler.sms.SmsHandler

    public interface SmsHandler<T, R> {

    /**
     * 前置处理
     *
     * @param t
     * @throws Exception
     */
    T before(T t) throws Exception;

    /**
     * 同步发送
     *
     * @param t
     * @return
     * @throws Exception
     */
    R send(T t) throws Exception;

    /**
     * 异步发送
     *
     * @param t
     * @return
     * @throws Exception
     */
    void asyncSend(T t) throws Exception;

    /**
     * 查询发送结果详情
     *
     * @param t
     * @return
     * @throws Exception
     */
    R query(T t) throws Exception;

}

  • com.king.handler.sms.AbstractSmsHandler

    // AcsResponse 为阿里云短信发送API的返回值。不要被名字吓到，只不过是一个返回值而已。
@Slf4j
public abstract class AbstractSmsHandler<T extends BaseRequest, R extends AcsResponse> implements SmsHandler<T, R> {

    @Override
    public T before(T t) {
        return t;
    }

    @Override
    public void asyncSend(T t) throws Exception {
        CommonAsyncExecutor.execute(() -> {
            T req = this.before(t);
            this.doAsyncSend(req);
        });
    }

    protected abstract void doAsyncSend(T t);

    @Override
    public R send(T t) throws Exception {
        T req = this.before(t);
        return this.doSend(req);
    }

    protected R doSend(T t) {
        return null;
    }

    @Override
    public R query(T t) throws Exception {
        return null;
    }

}

  • com.king.handler.sms.DefaultSmsHandler

    @Slf4j
@Component
public class DefaultSmsHandler extends AbstractSmsHandler<SmsReq, AcsResponse> {

    // 阿里云短信发送工具类
    @Resource
    private AliSmsHelper aliSmsHelper;

    @Override
    protected void doAsyncSend(SmsReq req) {
        if (req == null || CollectionUtils.isEmpty(req.getPhoneList())) {
            return;
        }
        aliSmsHelper.sendSms(req.getPhoneList(), req.getSignName(), req.getTemplateCode(), req.getTemplateParam());
    }

    @Override
    protected AcsResponse doSend(SmsReq req) {
        if (req == null || CollectionUtils.isEmpty(req.getPhoneList())) {
            return null;
        }
        return aliSmsHelper.sendSms(req.getPhoneList(), req.getSignName(), req.getTemplateCode(), req.getTemplateParam());
    }

    @Override
    public AcsResponse query(SmsReq req) throws Exception {
        if (req == null || CollectionUtils.isEmpty(req.getPhoneList())) {
            return null;
        }
        return aliSmsHelper.querySendDetail(req.getPhoneList(), req.getBizId());
    }

  • com.king.handler.sms.InactiveUserSmsHandler

    @Slf4j
@Component
public class InactiveUserSmsHandler extends AbstractSmsHandler<InactiveUserSmsReq, AcsResponse> {

  	// 阿里云短信发送工具类
    @Resource
    private AliSmsHelper aliSmsHelper;
    @Resource
    private OpenApiProperties openApiProperties;
    @Resource
    private UserRemote userFeign;

    @Override
    protected void doAsyncSend(InactiveUserSmsReq req) {
        if (req == null || CollectionUtils.isEmpty(req.getPhoneList())) {
            return;
        }

        // 短信签名
        String smsSignName = openApiProperties.getSmsSignName();
        // 短信模板
        String smsTemplateCodePromotion = openApiProperties.getSmsTemplateCode();

        List<String> phoneList = req.getPhoneList();
        for (String phone : phoneList) {
          	// 业务处理。。。
            aliSmsHelper.sendSms(phone, smsSignName, smsTemplateCode, templateParam);
        }

    }
  
}

3. 回过头来看概念

  • 见【1.概念】
localhost65535
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
抽象类定义
h111tangtang的博客
11-25 3062
1)抽象类 在定又一个类的时候,经常会碰到这样的情况:些方法对于所有的对象都是合适的，但 有些方法只对某个特定类型的对象才有意义。这些方法在这个类中是不能实现的，把这种类 定义为抽象类。 某些类在现实世界中不能直接找到对应的实例。如动物类，不可能为它找到一个对应的 事物，因为现实世界中只有猫、鸟、青蛙等具体动物，而它们都是动物的子类，这样的类称为抽 象类。 抽象类一般没有足够的信息来描述一一个具体的对象。抽象类只用于继承，不能用于创建 对象。一个抽象类一般包括-一个或多个抽象方法(只有方法说明，没有方法体)
抽象类的介绍
m0_46613341的博客
12-13 2882
收集的题目
抽象类的用法--（模板方法模式）
qq_46030254的博客
05-10 255
比如A类和B类都有sing()方法，sing()方法的开头和结尾都是一样的，只是中间一段内容不一样。我们可以写一个抽象类C类，在C类中写一个doSing()的抽象方法。2.反过来用，我们不知道系统未来具体的业务实现时，我们可以先定义抽象类，将来让子类去实现，以方便系统的扩展。1.用抽象类可以把父类中相同的代码，包括方法声明都抽取到父类，这样能更好的支持多态，一提高代码的灵活性。接着，再写一个B类继承C类，也复写doSing()方法，代码如下。然后，写一个A类继承C类，复写doSing()方法，代码如下。
什么是抽象类？（简述）
m0_50414588的博客
04-02 7023
1. 抽象类概述 我们创建一个动物类，并且在这个类中创建动物对象，但是当你提到动物类，你并不知道我说的是什么动物，只有看到了具体的动物，你才知道这是什么动物，所以说动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物，同理我们也可以推理不同的动物，他们的行为习惯应该是不一样的，所以我们不应该在动物类中给出具体体现，而是给出一个声明即可。 抽象类定义：在 Java 中一个没有方法体的方法应该定义为抽象方法 而类中如果有抽象方法，则必须定义为抽象类 2. 抽象类的特点 抽象类
抽象类和模板方法设计模式
chenxingxu1999的博客
04-16 367
抽象方法和抽象类 抽象类：用abstract修饰符修饰的类，如： public abstract class GeneralService { } 抽象方法：用abstract修饰符修饰的方法，抽象方法不能有方法体，如： public abstract void service()...
Java抽象类的构造模板模式用法示例
08-25
本文将详细介绍Java抽象类的构造模板模式用法，包括抽象类和模板模式的概念、特点、优点和应用场景，并通过实例代码来讲解如何使用抽象类和模板模式来解决实际问题。 一、抽象类和模板模式的概念 在Java中，抽象类...
Java抽象类与模板设计模式相关知识点常考面试题源代码
02-08
10.6抽象类 10.6.1问题引入 10.6.2解决之道-抽象类快速入门 10.6.3抽象类的介绍 ...10.7抽象类最佳实践-模板设计模式 10.7.1基本介绍 10.7.2模板设计模式能解决的问题 10.7.3最佳实践 10.7.4模板设计
基于模板方法与抽象工厂的复合模式
05-06
因此将抽象工厂模式嵌入到模板方法模式形成一个复合模式, 复合模式的设计核心是为每一个延迟到子类的可变的步骤提供一个创建对象的接口, 该接口对一个完整的产品族进行了定义. 复合模式既保证了算法结构的稳定性, ...
Abstract抽象类用作模板的事例
04-12
本资源是抽象类在实际应用中的一个例子，列举了学生写作文的例子进行详细的说明！
PHP抽象类 介绍
12-19
在自然语言中，我们理解抽象的概念是，一个物体的一种大的描述，这种描述对某类物体来说是共有的特性。那么在PHP中也是一样的，我们把一个类进行抽象，可以指明类的一般行为，这个类应该是...在子类实现抽象类的方法时
JAVA抽象类的定义
热门推荐
dove_dove_1802的博客
08-25 4万+
抽象类的基本概念 抽象方法，只声明而未实现的方法我们称为抽象方法，所有的抽象方法都需要用abstract关键字声明，包含抽象方法的类也需要使用abstract关键字声明，抽象类和普通类相比，区别在于抽象类带有抽象方法，抽象方法可以只声明，而不需要方法体。 代码演示： package demo; public abstract class People{ private S...
抽象类的应用知识：模板方法模式
XW_c_h_e_n的博客
12-10 96
模板方法模式知识点
从抽象类到模板方法模式
huangshanchun的专栏
10-30 1933
当多个类出现相同功能时候，但是功能主体不同。这时可以进行向上抽取，这时只抽取功能定义而不抽取功能主体。这时候就产生了抽象方法，含有抽象方法类叫做抽象类。 抽象类的特点 1.抽象方法一定在抽象类中 2.抽象方法和抽象类都必须被abstract关键字修饰 3.抽象类不可以new创建对象。因为调用抽象方法没有意义（抽象方法没有方法体）。 4.抽象类中的方法要被使用，必须由子类覆写所有的抽象方法
抽象类（以及模板方法设计模式）
aihuai2731的博客
07-14 464
总结理解的模板方法设计模式及抽象类 （菜鸟一只，若有什么侵权或者不足之处，请指出，谢谢） 模板方法设计模式： 在父类中定义一个总体的算法骨架，而将一些具体的实现步骤放在到子类中，因为不同的子类实现细节不同 模板方法使得子类可以在不改变算法框架的情况下，只需要重新定义算法的某些实现步骤（借助于抽象类实现） 模板方法：一种统一的处理方式，...
抽象类的模板方法设计模式
qq_36249824的博客
08-03 161
java抽象类和模板方法模式
qq_33734094的博客
03-01 7861
一.抽象类的基本概念：类中包含有抽象方法的类为抽象类。什么叫做抽象方法呢？抽象方法是指被关键字abstract修饰，且没有方法体的方法为抽象方法。抽象类使用的几个要点：1.抽象类不能进行实例化，因为在抽象类中存在抽象方法，抽象方法没有方法体，无法被调用，抽象类的对象需要依靠子类向上转型的方式得到。2.抽象方法必须为public或者protected，因为抽象方法需要子类来实现。3.抽象类需要子类来...
c++中的抽象类是怎么定义的
weixin_39845780的博客
11-03 4016
在c++中含有纯虚函数的类是抽象类，纯虚函数是是在函数的原型后添加=0 在面向对象的概念中，我们知道所有的对bai象都是通过du类来描绘的，但是反过来却不是这样。zhi并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”。[cpp] view plaincopyprint?virtual void funtion
Java面向对象（高级）- 抽象类与抽象方法(或abstract关键字)
最新发布
11-25
"Java中的抽象类与抽象方法是面向对象编程中的高级概念，它们主要用于处理具有共同特性但具体实现不同的类之间的继承关系。抽象类不能被实例化，而是作为其他类的父类，提供公共接口供子类继承。抽象方法在父类中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值