模板⽅法设计模式
- 抽象模板(Abstract Template): 定义⼀个模板⽅法,这个模板⽅法⼀般是⼀个具体⽅法,给出⼀个顶级算法⻣架,
- ⽽逻辑⻣架的组成步骤在相应的抽象操作中,推迟到⼦类实现
- 模板⽅法:定义了算法的⻣架,按某种顺序调⽤其包含的基本⽅法
- 基本⽅法:是整个算法中的⼀个步骤,包括抽象⽅法和具体⽅法
- 抽象⽅法:在抽象类中申明,由具体⼦类实现。
- 具体⽅法:在抽象类中已经实现,在具体⼦类中 可以继承或重写它
代码实现 每天早上日常
/**
* 模板⽅法设计模式
* 抽象模板(Abstract Template): 定义⼀个模板⽅法,这个模板⽅法⼀般是⼀个具体⽅法,给出⼀个顶级算法⻣架,
* ⽽逻辑⻣架的组成步骤在相应的抽象操作中,推迟到⼦类实现
* 模板⽅法:定义了算法的⻣架,按某种顺序调⽤其包含的基本⽅法
* 基本⽅法:是整个算法中的⼀个步骤,包括抽象⽅法和具体⽅法
* 抽象⽅法:在抽象类中申明,由具体⼦类实现。
* 具体⽅法:在抽象类中已经实现,在具体⼦类中 可以继承或重写它
* @author zhou
*/
public abstract class AbstractTemplate {
/**
* 模版⽅法 : 每日日常
*/
public void dailyRoutineTemplateMethod(){
getUp();
wash();
changeClothesAbstractMethod();
haveMealAbstractMethod();
commuteAbstractMethod();
}
/**
* 具体⽅法:默认实现的方法
*/
public void getUp() {
System.out.println("6点起床");
}
/**
* 具体⽅法
*/
public void wash() {
System.out.println("洗漱");
}
/**
* 抽象⽅法 换衣服
*/
public abstract void changeClothesAbstractMethod();
/**
* 抽象⽅法 吃饭
*/
public abstract void haveMealAbstractMethod();
/**
* 抽象⽅法 通勤
*/
public abstract void commuteAbstractMethod();
}
/**
* 周一
* @author zhou
*/
public class Monday extends AbstractTemplate{
@Override
public void changeClothesAbstractMethod() {
System.out.println("今天很热啊 穿短袖吧");
}
@Override
public void haveMealAbstractMethod() {
System.out.println("早饭吃麦当劳");
}
@Override
public void commuteAbstractMethod() {
System.out.println("坐地铁去上班");
}
}
/**
* 周末
* @author zhou
*/
public class Weekend extends AbstractTemplate{
@Override
public void getUp() {
System.out.println("今天12点起床");
}
@Override
public void changeClothesAbstractMethod() {
System.out.println("不换了");
}
@Override
public void haveMealAbstractMethod() {
System.out.println("叫外卖");
}
@Override
public void commuteAbstractMethod() {
System.out.println("下午继续睡,不同勤了");
}
}
public class Test {
public static void main(String[] args) {
// 周一
Monday monday = new Monday();
monday.dailyRoutineTemplateMethod();
System.out.println("==============================");
// 周末
Weekend weekend = new Weekend();
weekend.dailyRoutineTemplateMethod();
}
}
如何在spring中使用
/**
* 业务层
* 数据层同理
* @author zhou
*/
public interface MyService {
void test();
}
import org.springframework.stereotype.Service;
/**
* @author zhou
*/
@Service
public class MyServiceImpl implements MyService {
@Override
public void test() {
System.out.println("业务");
}
}
子类
/**
* 周一
* @author zhou
*/
@Component
public class Monday extends AbstractTemplate{
@Override
public void changeClothesAbstractMethod() {
System.out.println("今天很热啊 穿短袖吧");
}
@Override
public void haveMealAbstractMethod() {
System.out.println("早饭吃麦当劳");
}
@Override
public void commuteAbstractMethod() {
System.out.println("坐地铁去上班");
}
}
父类使用构造方法和ApplicationContext 来注入Bean
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class SpringContextHolder implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Autowired
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextHolder.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
public static Object getBean(String name) {
return getApplicationContext().getBean(name);
}
/**
* 通过class获取Bean.
*
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(Class<T> clazz) {
return getApplicationContext().getBean(clazz);
}
/**
* 通过name,以及Clazz返回指定的Bean
*
* @param name
* @param clazz
* @param <T>
* @return
*/
public static <T> T getBean(String name, Class<T> clazz) {
return getApplicationContext().getBean(name, clazz);
}
}
/**
* 模板⽅法设计模式
* 抽象模板(Abstract Template): 定义⼀个模板⽅法,这个模板⽅法⼀般是⼀个具体⽅法,给出⼀个顶级算法⻣架,
* ⽽逻辑⻣架的组成步骤在相应的抽象操作中,推迟到⼦类实现
* 模板⽅法:定义了算法的⻣架,按某种顺序调⽤其包含的基本⽅法
* 基本⽅法:是整个算法中的⼀个步骤,包括抽象⽅法和具体⽅法
* 抽象⽅法:在抽象类中申明,由具体⼦类实现。
* 具体⽅法:在抽象类中已经实现,在具体⼦类中 可以继承或重写它
* @author zhou
*/
public abstract class AbstractTemplate {
private MyService myService;
public AbstractTemplate () {
this.myService= SpringContextHolder.getBean(MyService.class);
}
/**
* 模版⽅法 : 每日日常
*/
public void dailyRoutineTemplateMethod(){
myService.test();
getUp();
wash();
changeClothesAbstractMethod();
haveMealAbstractMethod();
commuteAbstractMethod();
}
/**
* 具体⽅法
*/
public void getUp() {
System.out.println("6点起床");
}
/**
* 具体⽅法
*/
public void wash() {
System.out.println("洗漱");
}
/**
* 抽象⽅法 换衣服
*/
public abstract void changeClothesAbstractMethod();
/**
* 抽象⽅法 吃饭
*/
public abstract void haveMealAbstractMethod();
/**
* 抽象⽅法 通勤
*/
public abstract void commuteAbstractMethod();
}
import com.zm.demo4.Monday;
import com.zm.demo4.Weekend;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class Demo01ApplicationTests {
// 这里可以结合实际场景将策略和工厂模式应用
@Autowired
Monday monday;
@Autowired
Weekend weekend;
@Test
void contextLoads() {
monday.dailyRoutineTemplateMethod();
weekend.dailyRoutineTemplateMethod();
}
}
使用模板方法实现一个省 市 区 乡镇 不同级别的统计
待续~
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/133907.html