[java] 设计模式

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

资料链接
在这里插入图片描述
单例模式：某个类只能有一个实例，提供一个全局的访问点。

简单工厂：一个工厂类根据传入的参量决定创建出那一种产品类的实例。

工厂方法：定义一个创建对象的接口，让子类决定实例化那个类。

抽象工厂：创建相关或依赖对象的家族，而无需明确指定具体类。

建造者模式：封装一个复杂对象的构建过程，并可以按步骤构造。

原型模式：通过复制现有的实例来创建新的实例。

适配器模式：将一个类的方法接口转换成客户希望的另外一个接口。

组合模式：将对象组合成树形结构以表示“”部分-整体“”的层次结构。

装饰模式：动态的给对象添加新的功能。

代理模式：为其他对象提供一个代理以便控制这个对象的访问。

亨元（蝇量）模式：通过共享技术来有效的支持大量细粒度的对象。

外观模式：对外提供一个统一的方法，来访问子系统中的一群接口。

桥接模式：将抽象部分和它的实现部分分离，使它们都可以独立的变化。

模板模式：定义一个算法结构，而将一些步骤延迟到子类实现。

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。

策略模式：定义一系列算法，把他们封装起来，并且使它们可以相互替换。

状态模式：允许一个对象在其对象内部状态改变时改变它的行为。

观察者模式：对象间的一对多的依赖关系。

备忘录模式：在不破坏封装的前提下，保持对象的内部状态。

中介者模式：用一个中介对象来封装一系列的对象交互。

命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。

访问者模式：在不改变数据结构的前提下，增加作用于一组对象元素的新功能。

责任链模式：将请求的发送者和接收者解耦，使的多个对象都有处理这个请求的机会。

迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。

单例模式

  1. 懒汉式单例类.在第一次调用的时候实例化自己 （线程不安全）
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    public static Singleton getInstance() {
         if (single == null) {  
             single = new Singleton();
         }  
        return single;
    }
}

可以给方法之间加上synchronized保证线程安全，但是会导致很大的性能开销，因为加锁其实只需要在第一次初始化的时候用到，之后的调用都没必要再进行加锁。

双重检测锁+volatile保证线程安全

public class Singleton {
    private volatile static Singleton single;
    private Singleton() {
    }
    public Singleton getInstance() {
        if (null == single) {
            synchronized (Singleton.class) {
                if (null == single) {
                    single = new Singleton(); //flag
                }
            }
        }
        return single;
    }
}

为什么要加volatile，为了禁止指令重排序

标记为flag的那行，实际上可以分解成以下三个步骤：

  1. 分配内存空间
  2. 初始化对象
  3. 将对象指向刚分配的内存空间

但是有些编译器为了性能的原因，可能会将第二步和第三步进行重排序，这样某些线程会得到一个初始化未完成的对象

  1. 饿汉式单例类.在类初始化时，已经自行实例化 （线程安全）
public class Singleton {
    private Singleton() {}
    private static final Singleton single = new Singleton1();
    //静态工厂方法 
    public static Singleton1 getInstance() {
        return single;
    }
}

简单工厂模式

interface Fruit{
    public void buy();
}
class Apple implements Fruit{
    public void buy(){
        System.out.println("buy apple");
    }
}
class Banana implements Fruit{
    public void buy(){
        System.out.println("buy banana");
    }
}
class Orange implements Fruit{
    public void buy(){
        System.out.println("buy orange");
    }
}


class Factory{
    public static Fruit produce(String kind){
        if(kind.equals("apple"))return new Apple();
        else if(kind.equals("banana"))return new Banana();
        else return new Orange();
    }
}

public class Main{

    public static void main(String[] args) {
        Fruit fruit= Factory.produce("apple");
        fruit.buy();
    }
}

工厂方法模式

interface Fruit{
    public void buy();
}
class Apple implements Fruit{
    public void buy(){
        System.out.println("buy apple");
    }
}
class Banana implements Fruit{
    public void buy(){
        System.out.println("buy banana");
    }
}
class Orange implements Fruit{
    public void buy(){
        System.out.println("buy orange");
    }
}

interface Factory{
    public Fruit produce();
}

class AppleFactory implements Factory{
    public Apple produce(){
        return new Apple();
    }
}
class BananaFactory implements Factory{
    public Banana produce(){
        return new Banana();
    }
}
class OrangeFactory implements Factory{
    public Orange produce(){
        return new Orange();
    }
}


public class Main{

    public static void main(String[] args) {
        Factory appleFactory=new AppleFactory();
        Fruit apple=appleFactory.produce();
        apple.buy();
        
    }
}

抽象工厂模式

interface BigFruit{
    public void buy();
}
interface SmallFruit{
    public void buy();
}
class BigApple implements BigFruit{
    public void buy(){
        System.out.println("buy Big apple");
    }
}
class BigBanana implements BigFruit{
    public void buy(){
        System.out.println("buy Big banana");
    }
}
class BigOrange implements BigFruit{
    public void buy(){
        System.out.println("buy Big orange");
    }
}
class SmallApple implements SmallFruit{
    public void buy(){
        System.out.println("buy Small apple");
    }
}
class SmallBanana implements SmallFruit{
    public void buy(){
        System.out.println("buy Small banana");
    }
}
class SmallOrange implements SmallFruit{
    public void buy(){
        System.out.println("buy Small orange");
    }
}

interface Factory{
    public BigFruit produceBig();
    public SmallFruit produceSmall();
}

class AppleFactory implements Factory{
    public BigApple produceBig(){
        return new BigApple();
    }
    public SmallApple produceSmall(){
        return new SmallApple();
    }
}
class BananaFactory implements Factory{
    public BigBanana produceBig(){
        return new BigBanana();
    }
    public SmallBanana produceSmall(){
        return new SmallBanana();
    }
}
class OrangeFactory implements Factory{
    public BigOrange produceBig(){
        return new BigOrange();
    }
    public SmallOrange produceSmall(){
        return new SmallOrange();
    }
}


public class Main{

    public static void main(String[] args) {
        Factory appleFactory=new AppleFactory();
        BigFruit bigapple=appleFactory.produceBig();
        bigapple.buy();

    }
}

建造者模式

public class BuliderTest {
    public static void main(String[] args) {
        ProductBuilder defaultConcreteProductBulider=new DefaultConcreteProductBulider();
        Director director=new Director(defaultConcreteProductBulider);
        Product product=director.makeProduct("product1","company1","p1","p2","p3","p4");
        System.out.println(product);
    }

}



interface ProductBuilder{
    void builderProductName(String productName);
    void buildercompanyName(String companyName);
    void builderPart1(String part1);
    void builderPart2(String part2);
    void builderPart3(String part3);
    void builderPart4(String part4);
    Product build();
}

class DefaultConcreteProductBulider implements ProductBuilder{
    private String productName;
    private String companyName;
    private String part1;
    private String part2;
    private String part3;
    private String part4;
    @Override
    public void builderProductName(String productName) {
        this.productName=productName;
    }

    @Override
    public void buildercompanyName(String companyName) {
        this.companyName=companyName;
    }

    @Override
    public void builderPart1(String part1) {
        this.part1=part1;
    }

    @Override
    public void builderPart2(String part2) {
        this.part2=part2;

    }

    @Override
    public void builderPart3(String part3) {
        this.part3=part3;

    }

    @Override
    public void builderPart4(String part4) {
        this.part4=part4;

    }

    @Override
    public Product build() {
        return new Product(this.productName,this.companyName,this.part1,this.part2,this.part3,this.part4);
    }
}

class Director{
    private ProductBuilder builder;

    public Director(ProductBuilder builder) {
        this.builder = builder;
    }

    public Product makeProduct(String productName, String companyName, String part1, String part2, String part3, String part4){
        builder.builderProductName(productName);
        builder.buildercompanyName(companyName);
        builder.builderPart1(part1);
        builder.builderPart2(part2);
        builder.builderPart3(part3);
        builder.builderPart4(part4);
        return builder.build();
    }
}

class Product{
    private String productName;
    private String companyName;
    private String part1;
    private String part2;
    private String part3;
    private String part4;

    public Product(String productName, String companyName, String part1, String part2, String part3, String part4) {
        this.productName = productName;
        this.companyName = companyName;
        this.part1 = part1;
        this.part2 = part2;
        this.part3 = part3;
        this.part4 = part4;
    }

    public Product() {

    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public String getCompanyName() {
        return companyName;
    }

    public void setCompanyName(String companyName) {
        this.companyName = companyName;
    }

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    public String getPart3() {
        return part3;
    }

    public void setPart3(String part3) {
        this.part3 = part3;
    }

    public String getPart4() {
        return part4;
    }

    public void setPart4(String part4) {
        this.part4 = part4;
    }
}

装饰器模式

public class DecoratorTest {
    public static void main(String[] args) {
        Component component=new ConcreteDecorator1(new ConcreteComponent());
        component.operation();
    }
}
interface Component{
    void operation();
}
class ConcreteComponent implements Component{
    @Override
    public void operation() {
        System.out.println("拍照");
    }
}

abstract class Decorator implements Component{
    Component component;

    public Decorator(Component component) {
        this.component = component;
    }
}

class ConcreteDecorator1 extends Decorator{
    public ConcreteDecorator1(Component component){
        super(component);
    }

    @Override
    public void operation() {
        System.out.println("添加美颜");
        component.operation();
    }
}

适配器模式

public class AdapterTest {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target=new Adapter(adaptee);
        target.output5v();

    }
}
class Adaptee{
    public int output220v(){
        return 220;
    }
}

interface Target{
    int output5v();
}

class Adapter implements Target{
    private Adaptee adaptee;

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

    @Override
    public int output5v() {
        int i=adaptee.output220v();
        System.out.println(String.format("原始电压：%d v-->输出电压：%d v",i,5));
        return 5;
    }
}

观察者模式

import java.util.ArrayList;
import java.util.List;

public class ObserverTest {
    public static void main(String[] args) {
        Subject subject=new Subject();
        subject.addObserver(new Task1());
        Task2 task2=new Task2();
        subject.addObserver(task2);
        subject.notiyObserver("xxxx");
        subject.removeObserver(task2);
        subject.notiyObserver("xxxx");
    }
}

class Subject{
    private List<Observer> container=new ArrayList<>();

    public void addObserver(Observer observer){
        container.add(observer);
    }
    public void removeObserver(Observer observer){
        container.remove(observer);
    }
    public void notiyObserver(Object object){
        for(Observer observer:container){
            observer.update(object);
        }
    }
}
interface Observer{
    void update(Object object);
}
class Task1 implements Observer{
    @Override
    public void update(Object object) {
        System.out.println("task1 received:"+object);
    }
}

class Task2 implements Observer{
    @Override
    public void update(Object object) {
        System.out.println("task2 received:"+object);
    }
}

外观模式/门面模式

import javax.crypto.Cipher;

public class FacadeTest {
    public static void main(String[] args) {
        Client1 client1=new Client1();
        client1.doSomething();
        Client2 client2=new Client2();
        client2.doSomething();
    }
}

class Client1{
    Facade facade=new Facade();

    public void doSomething(){
        facade.doSomething();
    }
}
class Client2{
    Facade facade=new Facade();

    public void doSomething(){
        facade.doSomething();
    }
}

class Facade{
    SubSystem1 subSystem1=new SubSystem1();
    SubSystem2 subSystem2=new SubSystem2();
    SubSystem3 subSystem3=new SubSystem3();

    public void doSomething(){
        subSystem1.method();
        subSystem2.method();
        subSystem3.method();
    }
}

class SubSystem1{
    public void method(){
        System.out.println("subsystem1.method executed");
    }
}

class SubSystem2{
    public void method(){
        System.out.println("subsystem2.method executed");
    }
}

class SubSystem3{
    public void method(){
        System.out.println("subsystem3.method executed");
    }
}
qianye_97
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
对开发接口服务的一些总结
xiaolizh的博客
10-11 2万+
  博主之前做过恒丰银行代收付系统（相当于支付接口），包括现在的oltpapi交易接口和虚拟业务的对外提供数据接口。总之，当你做了很多项目写了很多代码的时候，就需要回过头来，多总结总结，这样你会看到更多之前写代码的时候看不到的东西，也能更明白为什么要这样做。 做接口需要考虑的问题      什么是接口 接口无非就是客户端请求你的接口地址，并传入一堆该接口定义好的参数，通过接口自身的逻辑处理...
设计模式之工厂模式
热门推荐
aaa31203的博客
09-13 16万+
工厂模式 1、简单工厂模式 1.1、定义 简单工厂模式（Simple Factory Pattern）是指有一个工厂对象决定创建出哪一种产品类的实例，不属于23种设计模式。 简单工厂是产品的工厂 1.2、应用场景 简单工厂模式适用于工厂类创建的对象较少的场景，且客户端只需要传入工厂参数，对如何创建对象的逻辑不需要关心。 1.3、缺点 工厂类的职责相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背了开闭原则。 不易于扩展过于复杂的产品结构。 1.4、实例 支付接口规范： public interface
软件设计师-设计模式
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
04-18 1211
定义：定义一个创建对象的接口，让子类决定实例化哪一个类。
23种设计模式（软考）
qq_52211542的博客
07-06 5730
23种设计模式——软考
软考常考设计模式
qq_61273171的博客
10-23 147
用于创建对象的模式，为创建类和实例化提供指南。：处理类和对象的组合问题。对类或对象怎样交互和怎样分配职责进行描述。创建型设计模式记忆口诀： 创公园，但见愁工厂，原型，单例，建造者，抽象工厂结构型设计模式记忆口诀：姐想外租，世代装桥享元，外观，组合，适配器，代理，装饰器，桥接。
java设计模式课程设计
10-13
使用5种设计模式完成的一个点单系统，显示不同系列下的所有商品，点击选择冰度甜度之后添加到订单中，计算总金额，下单之后发送订单到门店的后厨制作商品。使用了抽象工厂模式、装饰模式、单例模式、代理模式、原型...
JAVA设计模式
10-19
JAVA深入浅出设计模式。挺好的一本书欢迎大家下载。
Java设计模式精讲1
08-08
Java设计模式精讲定义与类型适用场景优点缺点Coding源码解析第1节UML类图及时序图入门1.1本章导航定义特点分类类图时序图记忆技巧1.2UML定义统一建
Java扩大Java设计模式
最新发布
02-16
本文工程主要计划以下几大块，希望大家也可以一起加入进来，扩大Java设计模式这块的运用场景的提炼。 1. 设计模式简介：主要介绍各种设计模式的概念和运用场景等 2. 设计模式综合运用：主要是笔者在实际工作中运用...
java设计模式
04-10
常见的java设计模式：23种，每个模式有代码例子和图片
Java 设计模式 第二版
03-17
Java 设计模式，第二版，电子工业出版社出版 本书通过一个完整的Java项目对经典著作Design Patterns一书介绍的23种设计模式进行了深入分析与讲解，实践性强，却又不失对模式本质的探讨。本书创造性地将这些模式分为...
java设计模式学习文档.pdf
03-19
培养学生掌握简单工厂模式、工厂方法模式、单例模式、原型模式、桥接模式、适配器模式、装饰模式、代理模式、命令模式、观察者模式等常用设计模式的设计思想，并掌握在实际软件工程领域中的运用，能够把所学的原理...
java设计模式（刘伟）
12-14
java设计模式，刘伟版。高清目录带书签。24种设计模式。
Java设计模式刘伟书本中模拟考试答案
11-28
该资源是书本后面的模拟试题的答案，本书的课后习题答案可以参考我上传的另外一个资源
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
《java设计模式》课后习题及模拟试题答案
Java设计模式：23种设计模式全面解析，墙都不扶就服你
m0_60747327的博客
08-10 1万+
命令模式：将命令请求封装为一个对象，使得可以用不同的请求来进行参数化。 迭代器模式：一种遍历访问聚合对象中各个元素的方法，不暴露该对象的内部结构。 观察者模式：对象间的一对多的依赖关系。 仲裁者模式：用一个中介对象来封装一系列的对象交互。 备忘录模式：在不破坏封装的前提下，保持对象的内部状态。 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器。 状态模式：允许一个对象在其对象内部状态改变时改变它的行为。 责任链模式：将请求的发送者..
23种设计模式概述
qq_25091281的专栏
03-31 2万+
23种设计模式 概念 结构图
软考-软件设计师 23种设计模式
weixin_51169222的博客
10-09 1万+
软件设计师 23种设计模式
七种常用的设计模式
a154555的博客
07-05 7万+
常用的七种设计模式：单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式和责任链模式。设计模式分类设计模式根据工作的目的，分为创建型模式、结构型模式和行为型模式三类。创建型模式：单例模式、工厂方法模式、抽象工厂模式、创建者模式、原型模式。结构型模式：适配器模式、代理模式、装饰器模式、外观模式、桥接模式、组合模式、享元模式。行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。软件设计七大原则(OOP原则)
java 设计模式
08-22
Java设计模式是一套对代码设计经验的总结，被人们反复利用，并且很多人都熟知的代码设计方式。其中，单例模式是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这种模式有几个好处，比如可以节约系统资源，提高程序效率，以及提供一个全局访问点等。在实现单例模式时，可以采用饿汉式单例模式，即在类加载时创建一个对象，并通过私有构造器和静态方法来保证对象的唯一性。另外，工厂方法模式也是Java中常用的设计模式之一。在工厂方法模式中，可以定义一个工厂类，该类负责创建对象的实例，并将其封装在一个工厂方法中。通过这种方式，可以实现对象的创建与使用的分离，提高代码的灵活性和可维护性。总的来说，Java设计模式是一种用于解决特定问题的通用解决方案，可以提高代码的重用性、可读性和可扩展性。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [Java常用设计模式](https://blog.csdn.net/qq_33327680/article/details/123815614)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [JAVA中23种设计模式](https://blog.csdn.net/qw_0214/article/details/78878531)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值