设计模式

于 2021-04-08 11:32:08 发布
阅读量69 收藏
点赞数
文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A95_27/article/details/114872247
版权

文章目录


前言
设计模式分类
创建型（创建一个对象）：单例模式、工厂模式、抽象工厂模式
结构型（将几个对象组织成一个结构）：桥接模式、外观模式、代理模式
行为型（多个对象间的通信）：观察者模式、策略模式

一、单例模式？

1.饿汉式

public class SingletonDemo1 {
    /**饿汉式
     * 类加载时对象创建
     * 线程安全,无法解决反射创建对象
     * */
    private static SingletonDemo1  instance= new SingletonDemo1();
    //私有化构造方法
    private SingletonDemo1(){
    }
    public static SingletonDemo1 getInstance(){
        return instance;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Constructor<SingletonDemo1> constructor = SingletonDemo1.class.getDeclaredConstructor();
        constructor.setAccessible(true); //取消访问检查
        SingletonDemo1 demo1 = constructor.newInstance();
        SingletonDemo1 demo2 = SingletonDemo1.getInstance();
        System.out.println(demo1==demo2);
    }

}

2.懒汉式

public class SingletonDemo2 {
    /**懒汉事
     * 类加载时对象创建
     * 线程不安全
     * */
    private static SingletonDemo2 instance= null;
    //私有化构造方法
    private SingletonDemo2(){
    }
    public static SingletonDemo2 getInstance(){
        if (instance==null){
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

在这里插入图片描述
3.加锁双重校验

public class SingletonDemo3 {
    /**懒汉事 双重同步锁
     * 类加载时对象创建
     * 线程安全
     * 存在 指令重排的线程安全问题 new SingletonDemo3() 不是原子操作,1分配地址 2初始化对象 3 对象指向地址
     * 所以当线程A获得锁创建对象先执行3,cpu切换到线程A,第一个if判断就通过了,那么线程A就获取了一个未初始化的对象
     * volatitle 不许重排
     * */
    private volatile static SingletonDemo3 instance= null;
    //私有化构造方法
    private SingletonDemo3(){
    }
    public static SingletonDemo3 getInstance(){
        if (instance==null){
            synchronized (SingletonDemo3.class){
                if (instance ==null){
                    instance = new SingletonDemo3();
                }
            }
        }
        return instance;
    }

}

在这里插入图片描述

4.枚举

public enum SingletonDemo4 {
    instance;
}

二、策略模式?

链接: 策略模式.
在这里插入图片描述
继承能复用,但是修改父类局部,会影响所以子类

在这里插入图片描述
抽出接口,可以实现某一些子类具有飞的功能,但是每个子类都需要实现,无法复用

1.抽出要加的fly方法
public interface Flyable {
    void fly();
}
2.提供不同的实现策略
public class Fly1 implements Flyable {
    @Override
    public void fly() {
        System.out.println("横着飞");
    }
}
public class Fly2 implements Flyable {
    @Override
    public void fly() {
        System.out.println("仰着飞");
    }
}
3.fly关联超类
public abstract class Duck {
	//关联飞的属性
    Flyable flyable;
    
	//表示不同的鸭子
    public abstract void display();
    public void performFly(){
        flyable.fly();
    }
    //设置fly
    public void setFlyable(Flyable flyable) {
        this.flyable = flyable;
    }
}
4.不同鸭子
public class Duck1 extends Duck {

    @Override
    public void display() {
        System.out.println("我是黑鸭");
    }
}
public class Duck2 extends Duck {
    @Override
    public void display() {
        System.out.println("我是白鸭");
    }
}
5.客户端测试,黑鸭横着飞,白鸭不能飞
public class client {
    public static void main(String[] args) {
        Duck1 duck1 = new Duck1();
        //设置飞
        duck1.setFlyable(new Fly1());
        //什么鸭子
        duck1.display();
        //能不能飞
        duck1.performFly();
        System.out.println("========================");
        Duck2 duck2 = new Duck2(); //没有设置飞
        duck2.display();
        duck2.performFly();
    }
}

在这里插入图片描述

三、工厂模式?

链接: 工厂模式
1.简单工厂(一个工厂里根据参数返回不同对象)

1.抽象手机
public interface Phone {
    void make();
}

2.不同具体手机
public class Iphone implements Phone {
    public Iphone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("苹果手机");
    }
}

public class MiPhone implements Phone{
    public MiPhone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("小米手机");
    }
}
3.加工手机的工厂
public class PhoneFactory {
    public Phone getInstance(String type){
        if ("小米".equals(type)){
            return new MiPhone();
        }else if ("苹果".equals(type)){
            return new Iphone();
        }else {
            return null;
        }
    }
}
3.客户
public class Client {
    public static void main(String[] args) {
        PhoneFactory phoneFactory = new PhoneFactory();
        phoneFactory.getInstance("苹果");
    }

}
//执行结果
 苹果手机

2.方法工厂(工厂细化)

1.抽象手机
public interface Phone {
    void make();
}

2.不同具体手机
public class Iphone implements Phone {
    public Iphone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("苹果手机");
    }
}

public class MiPhone implements Phone{
    public MiPhone() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("小米手机");
    }
}
3.制作手机的抽象工厂
public interface AbstractFactory {
    Phone makePhone();
}
4.不同产品的不同工厂
public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}
public class IFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new Iphone();
    }
}
5.客户
public class Client {
    public static void main(String[] args) {
        AbstractFactory miFactory = new MiFactory();
        miFactory.makePhone();
        AbstractFactory iFactory = new IFactory();
        iFactory.makePhone();
    }
}
//结果 实现不同工厂生产不同产品
小米手机
苹果手机

3.抽象工厂(一个工厂需要生产不同类型的产品,就需要不同的流水线)

1.抽象PC
public interface PC {
    void make();
}
2.具体PC
public class IPC implements PC {
    @Override
    public void make() {
        System.out.println("苹果PC");
    }
}
public class MiPc implements PC {

    public MiPc() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("小米PC");
    }
}
3.抽象加工厂定义流水线
public interface AbstractFactory {
	//手机流水线
    Phone makePhone();
    //pc流水线
    PC makePC();
}
4.具体加工厂
public class MiFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }

    @Override
    public PC makePC() {
        return new MiPc();
    }
}
public class IFactory implements AbstractFactory {
    @Override
    public Phone makePhone() {
        return new Iphone();
    }

    @Override
    public PC makePC() {
        return new IPC();
    }
}
5.客户
public class Client {
    public static void main(String[] args) {
        //手机流水线
        AbstractFactory miFactory = new MiFactory();
        miFactory.makePhone();
        //PC流水线
        MiFactory miFactory = new MiFactory();
        miFactory.makePC();

    }
}

四、代理模式?

链接: 代理模式.
在这里插入图片描述

1.静态代理
代理类程序员自己写

1.公共接口
public interface Parent {
    void go();
}
2.目标类
public class Real implements Parent {
    @Override
    public void go() {
        System.out.println("真实对象执行代码");
    }
}
3.代理类
public class Proxy implements Parent {
    private Real real;

    @Override
    public void go() {
        if (real == null)
            real = new Real();
        System.out.println("前置增强");
        real.go();
        System.out.println("后置增强");


    }
}
4.客户端
public class Client {
    public static void main(String[] args) {
        Proxy proxy = new Proxy();
        proxy.go();
    }
}

在这里插入图片描述
2.动态代理
jdk动态代理,编写动态处理器,jdk动态生产代理类

1.动态代理处理器
public class MyInvocationHandler implements InvocationHandler {

    //真实对象
    private Object object;

	// 有参构造获取代理对象时要
    public MyInvocationHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置增强");
        // 真实对象执行
        Object result = method.invoke(object, args);
        System.out.println("后置增强");
        return result;
    }
}
2.客户端
public class Client {
    public static void main(String[] args) {
        Real real = new Real();
        //第一参数是目标对象类加载器,app
        //第一个参数是公共接口数组
        //第三个是代理处理器,有参构造的用处
        Parent realProxy=(Parent) Proxy.newProxyInstance(Real.class.getClassLoader(),new Class[]{Parent.class},new MyInvocationHandler(real));
        realProxy.go();
    }
}

在这里插入图片描述
2.Cglib动态代理
没有接口的代理,继承,动态生成子类代理类

1.真实对象
public class CReal {
    public void go(){
        System.out.println("真实对象执行了...");
    }
}
2.动态增强器
public class CglibProxyEnhance implements MethodInterceptor {
    private Object object;

    public CglibProxyEnhance(Object object) {
        this.object = object;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("前置增强");
        Object result = method.invoke(object, args);
        System.out.println("后置增强");
        return result;

    }
}
3.客户端
public class Client {
    public static void main(String[] args) {
        CReal cReal = new CReal();
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(cReal.getClass());
        //设置增强器
        enhancer.setCallback(new CglibProxyEnhance(cReal));
        CReal cReal1 = (CReal) enhancer.create(); //生成代理子类
        cReal1.go();
    }
}

在这里插入图片描述

五、适配器模式?

链接: 适配器模式.
1.类适配器
把适配类的api转成目标api,继承关系连接源api

1.目标api
public interface Target {
    //想要封装成这样的方法
    void request();
}
2.源api
public class Adaptee {
	//这个方法不兼容,需要转换成request
    public void sourceRequest(){
        System.out.println("源方法执行...");
    }
}
3.适配器
public class Adapter extends  Adaptee implements Target {
	//souceRequest适配成request
    @Override
    public void request() {
        this.sourceRequest();
    }
}
4.客户端
public class Client {
    public static void main(String[] args) {
        Adapter adapter = new Adapter();
        //目标api能执行源api的东西,转换成功
        adapter.request();
    }
}

在这里插入图片描述
2.对象适配器
关联关系连接源api

1.关联关系连接源api
public class Adapter1 implements Target {
    //关联关系
    private Adaptee adaptee;

    public Adapter1(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
       this.adaptee.sourceRequest();
    }
}
2.客户端
public class Client {
    public static void main(String[] args) {
        Adapter1 adapter1 = new Adapter1(new Adaptee());
        adapter1.request();
    }
}

在这里插入图片描述

六、设计原则？

1.单一原则: 一个类只负责一个职能
问题:如果一个T类有两个职责p1,p2,那么当只需要修改p1职责时,p2职责也可能被影响.
2.里氏替换原则: 继承时尽量不要重写父类已经实现好的方法
3.依赖倒置原则:高层不要依赖底层,最好依赖底层抽象,
问题: a类依赖b类,现在修改成依赖c类,那就要修改a类代码,存在风险,
解决: a类依赖b c的抽象
4.接口隔离原则:接口臃肿,实现类需要空实现,拆分接口
5.迪米特法则:最少知道原则(直接关系,成员,入参,输出)
6.开闭原则:对扩展开放,对修改闭合

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

95遇见27
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值