设计模式、代码设计

泛型、模板模式

public interface IBaseTestService {
    void test();
    default void test2(){
       this.test();
    };
}
public class BaseTestServiceImpl<T> implements IBaseTestService {
    @Autowired
    private T t;
    @Override
    public void test() {
        System.out.println("BaseTestServiceImpl test");
    }
    public T getBaseHandle() {
        return t;
    }
}
public interface ITestService {
    void testXmh();
}
@Service
public class TestServiceImpl extends BaseTestServiceImpl<AbilityManager> implements ITestService {
    @Override
    public void testXmh() {
        /**
         *在基础实现类BaseTestServiceImpl中注册了T泛型，本类只需要调用getBaseHandle()方法即可获取到AbilityManager实例
         */
        this.getBaseHandle().testAbilityManager();
        //接口中的test2方法调用接口test()，实现类中实现test()   行为模式-Template模板模式
        this.test2();
    }
    public void test() {
        System.out.println("TestServiceImpl test");
    }
}

@Component
public class AbilityManager {
    public void testAbilityManager(){
        log.info("AbilityManager11****************"+this);
    }
}

创建模式-单例

创建模式-工厂方法
Sample sampleA=Factory.creator(1); 返回不同的子类实体

创建模式-抽象工厂
这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2.
那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){ ......... return new SampleA }
public Sample2 creator(String name){ ......... return new Sample2A }
}

public class BombFactory extends Factory{
public Sample creator(){ ...... return new SampleB }
public Sample2 creator(String name){ ...... return new Sample2B }
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2? 抽象工厂还有另外一个关键要点，
是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，
比如：制造工艺比较简单，所以名称叫SimpleFactory。

创建模式-Builder模式
是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到.
是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦过程和部件. 因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮方向盘
发动机还有各种小零件等等,部件很多,
但远不止这些,如何将这些部件装配成一辆汽车,这个装配过程也很复杂(需要很好的组装技术),Builder模式就是为了将部件和组装过程分开.
案例：首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部件的创建分别开来,分别用Builder类和Director类来表示.
首先,需要一个接口,它定义如何创建复杂
对象的各个部件:

public interface Builder {
//创建部件A 比如创建汽车车轮
void buildPartA();
// 创建部件B 比如创建汽车方向盘
void buildPartB();
// 创建部件C 比如创建汽车发动机
void buildPartC();
// 返回最后组装成品结果 (返回最后装配好的汽车)
// 成品的组装过程不在这里进行,而是转移到下面的Director类中进行.
// 从而实现了解耦过程和部件
Product getResult();
}

// 用Director构建最后的复杂对象,而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的),也就是说Director的内容
是如何将部件最后组装成成品:
public class Director {
private Builder builder;
public Director( Builder builder ) { this.builder = builder;
}
// 将部件partA partB partC最后组成复杂对象
// 这里是将车轮 方向盘和发动机组装成汽车的过程
public void construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
}
}
// Builder的具体实现ConcreteBuilder: 通过具体完成接口Builder来构建或装配产品的部件; 定义并明确它所要创建的是什么具体东西; 
提供一个可以重新获取产品的接口:
public class ConcreteBuilder implements Builder {
Part partA, partB, partC;
public void buildPartA() {
//这里是具体如何构建partA的代码
};
public void buildPartB() {
//这里是具体如何构建partB的代码
};
public void buildPartC() {
//这里是具体如何构建partB的代码
};
public Product getResult() {
//返回最后组装成品结果
};
}
//复杂对象:产品Product:
public interface Product { };
//复杂对象的部件:
public interface Part { };
//我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );
director.construct();
Product product = builder.getResult();

结构模式-适配器模式
实际上这是将组合方法(composition)和继承(inheritance)方法综合运用.
1，现在有一个应用,需要既打方形桩,又打圆形桩.那么我们需要将这两个没有关系的类综合应用.假设RoundPeg我们没有源代码,或源代码我们不想修改,
那么我们使用Adapter来实现这个应用:

public class PegAdapter extends SquarePeg{ 
private RoundPeg roundPeg; 
public PegAdapter(RoundPeg peg)(this.roundPeg=peg;) 
public void insert(String str){ roundPeg.insertIntoHole(str);} 
}

2，进一步使用上面的PegAdapter是继承了SquarePeg,如果我们需要两边继承，即继承SquarePeg 又继承RoundPeg,因为Java中不允许多继承，
但是我们可以实现(implements)
两个接口(interface)

结构模式-Proxy(代理)
1.授权机制不同级别的用户对同一对象拥有不同的访问权利

public class ForumProxy implements Forum {
public void setName(String name)ForumAlreadyExistsException {
 //只有是系统或论坛管理者才可以修改名称 
if (permissions.isSystemOrForumAdmin()) {
 forum.setName(name); 
}else { 
throw new UnauthorizedException();
 }
 }

结构模式-Facade外观模式
facade实际上是个理顺系统间关系,降低系统间耦合度的一个常用的办法

结构模式-Composite组合模式
上面调用的方法netPrice()或discountPrice()，实际上Composite使用Iterator遍历了整个树形结构,寻找同样包含这个方法（super.netPrice()）的对象并实现调用执行.
Composite是个很巧妙体现智慧的模式，在实际应用中，如果碰到树形结构，我们就可以尝试是否可以使用这个模式。

结构模式-Bridge桥模式
定义：将抽象和行为划分开来,各自独立,但能动态的结合。
1，在面向对象设计的基本概念中，对象这个概念实际是由属性和行为两个部分组成的，属性我们可以认为是一种静止的，是一种抽象，一般情况下，
行为是包含在一个对象中，但是，
在有的情况下，我们需要将这些行为也进行归类，形成一个总的行为接口，这就是桥模式的用处。
2，抽象和行为，其中抽象为：中杯和大杯；行为为：加奶不加奶（如加橙汁加苹果汁）.
1、中杯和大杯来自一个抽象类，其中一个方法来定义是大杯、小杯
2、加奶和不加奶的行为来自一个抽象类，其中一个方法来定义加奶不加奶
3、单例中静态变量来确定加奶和不加奶的行为，中杯和大杯来的抽象类中使用该单例

行为模式-Strategy策略模式
是属于设计模式中对象行为型模式,主要是定义一系列的算法,把这些算法一个个封装成单独的类.
实际整个Strategy的核心部分就是抽象类的使用,使用Strategy模式可以在用户需要变化时,修改量很少,而且快速.
理解：具体算法逻辑由抽象类的继承者实现，达到灵活切换算法的目的

行为模式-Observer观察者模式
Java的API还为我们提供现成的Observer接口Java.util.Observer我们只要直接使用它就可以
类似于监听，被观察者加入多个观察者，被观察者的一些操作触发观察者行动

行为模式-Template模板模式
抽象类中有一个方法a，方法中调用主体方法b，而方法b要在子类中实现

行为模式-Mediator中介者模
各个对象之间的交互操作非常多;每个对象的行为操作都依赖彼此对方,修改一个对象的行为,同时会涉及到修改很多其他对象的行为,如果使用Mediator模式,
可以使各个对象间的耦合松散,
只需关心和 Mediator的关系,使多对多的关系变成了一对多的关系,可以降低系统的复杂性,提高可修改扩展性.
理解：多个业务对象聚合在一个中介类中，进行相互调用，外部只需跟中介类交互
　　

posted @ 2022-02-20 18:20 XUMT111 阅读(30) 评论(0) 收藏举报

刷新页面返回顶部

xingminghui111

设计模式、代码设计