Java作业-模拟扎金花

news2025/5/28 3:35:00

要求

实现扑克牌的创建、洗牌、发牌、大小对比，输出赢家牌。

前提条件

首先需要创建三个集合，用于存储牌面值、牌号与比较规则，再创建一个类作为牌。

其次还需要了解到一个工具类，就是Collections类，该类的所有方法都是由 static 静态关键字修饰的，所以该类的所有方法都可直接使用 类名+. 的方式调用。
Collections类是针对集合的一个工具类，里面的所有方法就是针对集合来写的。

下面两个方法就是给类中给定的方法。

在这里插入图片描述
在这里插入图片描述


private static HashMap<Integer,poker> pokerBox; // 牌盒
     /*
     存储牌盒中的key键值，与牌盒中的牌一一对应，用于取出牌盒中的牌，对牌号的操作等同于对牌盒操作
     但是对Integer类型操作比对String类型操作更简单。
     同时牌号也能表示不同花色间的大小关系
     */
private static List<Integer> listPoker; // 牌号
private static HashMap<String,Integer> map; // 存储牌面值的大小规则

// poker类
// 代表扑克牌便于操作
class poker{
    // 花色与牌面值分离了
    // 汇总就是总值
    String flowerColor; // 花色
    String faceValue;   // 牌面值
    String value;       // 总值

    public poker(){}

    // 有参构造
    public poker(String flowerColor, String faceValue,String value) {
        this.flowerColor = flowerColor;
        this.faceValue = faceValue;
        this.value=value;
    }
}

扑克牌的创建

使用一个静态代码块来构建牌，初始化牌盒、牌号与大小规则等。
静态代码块是一种特殊的语法结构，它允许你在类加载到JVM时执行某些操作。这种结构常用于一次性的设置或初始化静态变量。
静态代码块在类被加载时执行一次，并且只执行一次。

 // 准备牌
    static {
        map=new HashMap<>();
        pokerBox=new HashMap<>();
        listPoker=new ArrayList<>();

        // 将牌号存入map集合，用于比较时的牌大小对比
        map.put("2",2);
        map.put("3",3);
        map.put("4",4);
        map.put("5",5);
        map.put("6",6);
        map.put("7",7);
        map.put("8",8);
        map.put("9",9);
        map.put("10",10);
        map.put("J",11);
        map.put("Q",12);
        map.put("K",13);
        map.put("A",14);

        map.put("234",15);
        map.put("345",16);
        map.put("456",17);
        map.put("678",18);
        map.put("789",19);
        map.put("8910",20);
        map.put("910J",21);
        map.put("JQK",22);
        map.put("QKA",23);

        map.put("222",24);
        map.put("333",25);
        map.put("444",26);
        map.put("555",27);
        map.put("666",28);
        map.put("777",29);
        map.put("999",30);
        map.put("101010",31);
        map.put("JJJ",32);
        map.put("QQQ",33);
        map.put("KKK",34);
        map.put("AAA",35);

        // 235通吃(保留）
        map.put("235",999999999);

        // 花色
        String[] FlowerColor=new String[]{"♦","♣","♥","♠"};
        // 字母牌
        String[] letter=new String[]{"J","Q","K","A"};

        // 数字牌部分
        int keyIndex=0;
        for (int i = 2; i < 11; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);    // 存放序号
                pokerBox.put(keyIndex++,new 2poker(FlowerColor[j],i+"",FlowerColor[j]+i));  // 将序号与牌产生对应关系
            }
        }

        // 字母牌部分
        for (int i = 0; i < letter.length; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);
                // 将牌号与牌存入牌盒中
                pokerBox.put(keyIndex++,new poker(FlowerColor[j],letter[i],FlowerColor[j]+letter[i]));
            }
        }
    }

洗牌

由于牌号内的序号是与牌盒中的牌一一对应的，那么将存储牌号的list集合打乱就可以达到洗牌的效果。

// 洗牌
public void pokerShuffle(){
	// shuffle方法作用是将指定List集合使用默认随机源进行置换，也就是打乱List集合内元素的位置，当然该方法只对List集合有效。
  	Collections.shuffle(listPoker); // 打乱牌的序号
}

发牌

List集合与List集合之间是可以嵌套的，使用List<List>作为该方法的返回值，外层的List集合中代码每一个玩家，内层的List中代表玩家的扑克牌数。

public List<List<Integer>> dealCards(int playerNumber){
        // 对人数进行限制
        if((playerNumber*3) > pokerBox.size() || playerNumber <= 0){
            System.out.println("玩家超出限制，最多允许17位玩家、最少1一位玩家参加此游戏,请重新选择人数");
            return null;
        }

        // 玩家列表
        List<List<Integer>> playerList=new ArrayList<>();

        int k=3;    // 每位玩家牌的张数

        for (int i = 0,curIntdex=0; i < playerNumber; i++) {
            List<Integer> curPlayer=new ArrayList<>();
            // 每位玩家发三张牌
            for (int j = 0; j < k; j++) {
                curPlayer.add(listPoker.get(curIntdex++));
            }
            playerList.add(curPlayer); // 将当前玩家添加到玩家列表中
        }

        return playerList;
    }

看牌

// 看牌
    public void lookPoker(List<List<Integer>> list){

        // 所有玩家
        for(int i=0,end=list.size(); i<end; ++i){
            System.out.print("玩家"+(i+1)+"：");
            // 代表当前玩家
            List<Integer> curPople=list.get(i);
            // 玩家手中的牌
            for(int j=0,n=curPople.size(); j<n; ++j){
                // 从当前玩家curPople手中获取牌得序号，根据序号从牌盒PokerBox中取出牌来
                System.out.print(pokerBox.get(curPople.get(j)).value + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

内排序

对每个玩家的手牌内部进行排序。

// 玩家手牌进行排序
    public void playerPokerSort(List<List<Integer>> lists){
        // 最大手牌在第一位，第二次之....
        for (int i = 0; i < lists.size(); i++) {
            // 排序，逆序
            Collections.sort(lists.get(i),((o1, o2) -> (o2-o1)));
        }
    }

牌与牌之间的比较方法


返回值：

  • 大于0：玩家a的手牌 大于 玩家b的手牌
  • 小于0：玩家a的手牌 小于 玩家b的手牌
  • 等于0：玩家a的手牌 等于 玩家b的手牌
// 比较函数
    public int cmp(List<Integer> a,List<Integer> b){
        // O(a.size)
        StringBuilder sbA=new StringBuilder();
        StringBuilder sbB=new StringBuilder();
        // 逆序取
        for(int i=a.size()-1; i>=0; --i){
            sbA.append(pokerBox.get(a.get(i)).faceValue);
            sbB.append(pokerBox.get(b.get(i)).faceValue);
        }
		// 判断是否存在顺子牌等的情况
        Integer numA=map.get(sbA.toString());
        Integer numB=map.get(sbB.toString());
        if((numA != null && null == numB) || (null == numA && numB != null)){
            return (null == numA) ? -1 : 1;
        }else if(numA != null && numB != null){
            return numA-numB;
        }

        // O(a.size)
        for(int i=0,end=a.size(); i < end; ++i) {
            // 从两个玩家手中获取牌根号，获取到牌号后再从牌盒中取出牌面值来
            // 再从map中获取牌面值的大小，进行比较
            numA=map.get(pokerBox.get(a.get(i)).faceValue);
            numB=map.get(pokerBox.get(b.get(i)).faceValue);
			
            if (numA == numB) { continue; }
            if (numA > numB) { return 1; }
            else { return -1; }
        }
        // 相等的情况
        return 0;
    }

找出牌最大的玩家

// 输出最大玩家的手牌
public void printWinPlayer(List<List<Integer>> list){
    int maxIndex=0;
    List<Integer> maxPlayer=list.get(0);

    // 循环比较出最大玩家
    for(int i=1,end=list.size(); i<end; ++i){
        List<Integer> cur=list.get(i);
        // 根据比较方法来找出牌最大的玩家
        if(cmp(maxPlayer,cur) < 0){
            maxIndex=i;
            maxPlayer=cur;
        }
    }

    System.out.print("最大的手牌是玩家"+(maxIndex+1)+"：");

    List<Integer> ans=list.get(maxIndex);
    for(Integer i : ans){
        System.out.print(pokerBox.get(i).value + " ");
    }
    System.out.println();
}

完整代码


运行结果

在这里插入图片描述


启动代码

package newGame;

public class app {
    public static void main(String[] args) {
        new pokerGame();
    }
}

游戏代码

package newGame;

import java.util.*;

public class pokerGame {

    // 由于牌盒不需要排序，那么使用hashMap即可
    private static HashMap<Integer,poker> pokerBox; // 牌盒
     /*
     存储牌盒中的key键值，与牌盒中的牌一一对应，用于取出牌盒中的牌，对牌号的操作等同于对牌盒操作
     但是对Integer类型操作比对String类型操作更简单。
     同时牌号也能表示不同花色间的大小关系
     */
    private static List<Integer> listPoker; // 牌号

    private static HashMap<String,Integer> map; // 存储牌面值的大小规则

    // 准备牌
    static {
        map=new HashMap<>();
        pokerBox=new HashMap<>();
        listPoker=new ArrayList<>();

        // 将牌号存入map集合，用于比较时的牌大小对比
        map.put("2",2);
        map.put("3",3);
        map.put("4",4);
        map.put("5",5);
        map.put("6",6);
        map.put("7",7);
        map.put("8",8);
        map.put("9",9);
        map.put("10",10);
        map.put("J",11);
        map.put("Q",12);
        map.put("K",13);
        map.put("A",14);

        map.put("234",15);
        map.put("345",16);
        map.put("456",17);
        map.put("678",18);
        map.put("789",19);
        map.put("8910",20);
        map.put("910J",21);
        map.put("JQK",22);
        map.put("QKA",23);

        map.put("222",24);
        map.put("333",25);
        map.put("444",26);
        map.put("555",27);
        map.put("666",28);
        map.put("777",29);
        map.put("999",30);
        map.put("101010",31);
        map.put("JJJ",32);
        map.put("QQQ",33);
        map.put("KKK",34);
        map.put("AAA",35);

        // 最大值(保留）
        map.put("235",1000);

        // 花色
        String[] FlowerColor=new String[]{"♦","♣","♥","♠"};
        // 字母牌
        String[] letter=new String[]{"J","Q","K","A"};

        // 数字牌部分
        int keyIndex=0;
        for (int i = 2; i < 11; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);    // 存放序号
                pokerBox.put(keyIndex++,new poker(FlowerColor[j],i+"",FlowerColor[j]+i));  // 将序号与牌产生对应关系
            }
        }

        // 字母牌部分
        for (int i = 0; i < letter.length; i++) {
            for (int j = 0; j < FlowerColor.length; j++) {
                listPoker.add(keyIndex);
                pokerBox.put(keyIndex++,new poker(FlowerColor[j],letter[i],FlowerColor[j]+letter[i]));
            }
        }
    }
    // 洗牌
    public void pokerShuffle(){
        Collections.shuffle(listPoker); // 打乱牌的序号
    }
    // 发牌
    public List<List<Integer>> dealCards(int playerNumber){
        // 对人数进行限制
        if((playerNumber*3) > pokerBox.size() || playerNumber <= 0){
            System.out.println("玩家超出限制，最多允许17位玩家、最少1一位玩家参加此游戏,请重新选择人数");
            return null;
        }

        // 玩家列表
        List<List<Integer>> playerList=new ArrayList<>();

        int k=3;    // 每位玩家牌的张数

        for (int i = 0,curIntdex=0; i < playerNumber; i++) {
            List<Integer> curPlayer=new ArrayList<>();
            // 每位玩家发三张牌
            for (int j = 0; j < k; j++) {
                curPlayer.add(listPoker.get(curIntdex++));
            }
            playerList.add(curPlayer); // 将当前玩家添加到玩家列表中
        }

        return playerList;
    }

    // 看牌
    public void lookPoker(List<List<Integer>> list){

        // 所有玩家
        for(int i=0,end=list.size(); i<end; ++i){
            System.out.print("玩家"+(i+1)+"：");
            // 代表当前玩家
            List<Integer> curPople=list.get(i);
            // 玩家手中的牌
            for(int j=0,n=curPople.size(); j<n; ++j){
                // 从当前玩家curPople手中获取牌得序号，根据序号从牌盒PokerBox中取出牌来
                System.out.print(pokerBox.get(curPople.get(j)).value + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    // 玩家手牌进行排序
    public void playerPokerSort(List<List<Integer>> lists){
        // 最大手牌在第一位，第二次之....
        for (int i = 0; i < lists.size(); i++) {
            // 排序，逆序
            Collections.sort(lists.get(i),((o1, o2) -> (o2-o1)));
        }
    }

    // 比较函数
    public int cmp(List<Integer> a,List<Integer> b){
        // O(a.size)
        StringBuilder sbA=new StringBuilder();
        StringBuilder sbB=new StringBuilder();

        // 逆序取
        for(int i=a.size()-1; i>=0; --i){
            sbA.append(pokerBox.get(a.get(i)).faceValue);
            sbB.append(pokerBox.get(b.get(i)).faceValue);
        }

        Integer numA=map.get(sbA.toString());
        Integer numB=map.get(sbB.toString());
        if((numA != null && null == numB) || (null == numA && numB != null)){
            return (null == numA) ? -1 : 1;
        }else if(numA != null && numB != null){
            return numA-numB;
        }

        // O(a.size)
        for(int i=0,end=a.size(); i < end; ++i) {
            // 从两个玩家手中获取牌根号，获取到牌号后再从牌盒中取出牌面值来
            // 再从map中获取牌面值的大小，进行比较
            numA=map.get(pokerBox.get(a.get(i)).faceValue);
            numB=map.get(pokerBox.get(b.get(i)).faceValue);

            if (numA == numB) { continue; }
            // a玩家大于b玩家的情况
            if (numA > numB) { return 1; }
            // 小于的情况
            else { return -1; }

        }
        // 相等的情况
        return 0;
    }

    // 输出最大玩家的手牌
    public void printWinPlayer(List<List<Integer>> list){
        int maxIndex=0;
        List<Integer> maxPlayer=list.get(0);

        // 循环比较出最大玩家
        for(int i=1,end=list.size(); i<end; ++i){
            List<Integer> cur=list.get(i);
            if(cmp(maxPlayer,cur) < 0){
                maxIndex=i;
                maxPlayer=cur;
            }
        }

        System.out.print("最大的手牌是玩家"+(maxIndex+1)+"：");

        List<Integer> ans=list.get(maxIndex);
        for(Integer i : ans){
            System.out.print(pokerBox.get(i).value + " ");
        }
        System.out.println();
    }

    public pokerGame(){

        // 同花顺的逻辑没有编写

        pokerShuffle(); // 洗牌
        int playyern=3; // 玩家人数
        List<List<Integer>> lists = dealCards(playyern);   // 发牌

        if(null == lists){
            System.out.println("玩家数不规范，程序退出");
            System.exit(-1);
        }

        lookPoker(lists);   // 看牌

        playerPokerSort(lists); // 每个玩家的手牌内进行排序

//        lookPoker(lists);

        printWinPlayer(lists);  // 输出手牌值最大的玩家

    }

}

class poker{
    // 花色与牌面值分离了
    // 汇总就是总值
    String flowerColor; // 花色
    String faceValue;   // 牌面值
    String value;       // 总值

    public poker(){}

    // 有参构造
    public poker(String flowerColor, String faceValue,String value) {
        this.flowerColor = flowerColor;
        this.faceValue = faceValue;
        this.value=value;
    }
}

End


基本功能是实现了，如果有别的需求可自行魔改。如遇bug，请评论告知。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1010353.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

python，迪卡尔象限中画点

python，迪卡尔象限中画点

import numpy as np import matplotlib.pyplot as plt circleNum 30 # 同时圆刻度值 pointNum 20 # 点的数量 theta np.linspace(0.0, 2*np.pi, pointNum, endpointFalse) s circleNum * np.random.rand(pointNum) # plt.polar(theta, s, linestyleNone, marker*) # 无连接…
阅读更多...
不知道有用没用的Api

不知道有用没用的Api

encodeURIComponent(https://www.baidu.com/?name啊啊啊) decodeURIComponent(https%3A%2F%2Fwww.baidu.com%2F%3Fname%3D%E5%95%8A%E5%95%8A%E5%95%8A) encodeURI(https://www.baidu.com/?name啊啊啊) decodeURI(https://www.baidu.com/?name%E5%95%8A%E5%95%8A%E5%95%8A) …
阅读更多...
​LeetCode解法汇总1222. 可以攻击国王的皇后

​LeetCode解法汇总1222. 可以攻击国王的皇后

目录链接&#xff1a; 力扣编程题-解法汇总_分享记录-CSDN博客 GitHub同步刷题项目&#xff1a; https://github.com/September26/java-algorithms 原题链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 描述&#xff1a; 在一个 8x…
阅读更多...
解决虚拟机重启后ifconfig看不到IP的问题

解决虚拟机重启后ifconfig看不到IP的问题

目录 背景 解决方案 背景 虚拟机&#xff0c;桥接模式&#xff0c;启动后一切正常&#xff0c;但重启后发现终端连不上虚机了&#xff0c;也ping不到&#xff0c;最后检查发现&#xff0c;IP消失了&#xff0c;虚机没有IP了。 解决方案 不论是否重启&#xff0c;只要是看不…
阅读更多...
2023-09-14 LeetCode每日一题（可以攻击国王的皇后）

2023-09-14 LeetCode每日一题（可以攻击国王的皇后）

2023-09-14每日一题 一、题目编号 1222. 可以攻击国王的皇后二、题目链接 点击跳转到题目位置 三、题目描述 在一个 8x8 的棋盘上&#xff0c;放置着若干「黑皇后」和一个「白国王」。 给定一个由整数坐标组成的数组 queens &#xff0c;表示黑皇后的位置&#xff1b;以及…
阅读更多...
关于浅克隆和深克隆入门理解

关于浅克隆和深克隆入门理解

浅克隆:需要类实现Cloneable,并重写clone()方法 一般在重写clone()方法时,将返回值类型强转为自己类,避免每次克隆之后需要强转 public class Test {public static void main(String[] args) throws CloneNotSupportedException {A a1new A();A a2 a1.clone();//克隆之后 a1…
阅读更多...
【搭建私人图床】本地PHP搭建简单Imagewheel云图床，在外远程访问

【搭建私人图床】本地PHP搭建简单Imagewheel云图床，在外远程访问

文章目录 1.前言2. Imagewheel网站搭建2.1. Imagewheel下载和安装2.2. Imagewheel网页测试2.3.cpolar的安装和注册 3.本地网页发布3.1.Cpolar临时数据隧道3.2.Cpolar稳定隧道&#xff08;云端设置&#xff09;3.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 4.公网访问测…
阅读更多...
Linux——（第十章）进程管理

Linux——（第十章）进程管理

目录 一、概述 二、常用指令 1.ps查看当前系统进程状态 2.kill 终止进程 3.pstree 查看进程树 4.top 实时监控系统进程状态 5.netstat 监控网络状态 一、概述 &#xff08;1&#xff09;进程是正在执行的一个程序或命令&#xff0c;每一个进程都是一个运行的实体&#…
阅读更多...
Redis 常用命令

Redis 常用命令

目录 全局命令 1&#xff09;keys 2&#xff09;exists 3) del(delete) 4&#xff09;expire 5&#xff09;type SET命令 GET命令 MSET 和 MGET命令 其他SET命令 计数命令 redis-cli&#xff0c;进入redis 最核心的命令&#xff1a;我们这里只是先介绍 set 和 get 最简单的操作…
阅读更多...
IP地址，子网掩码，默认网关，DNS讲解

IP地址，子网掩码，默认网关，DNS讲解

IP地址&#xff1a;用来标识网络中一个个主机&#xff0c;IP有唯一性&#xff0c;即每台机器的IP在全世界是唯一的。 子网掩码&#xff1a;用来判断任意两台计算机的ip地址是否属于同一子网络的根据。最为简单的理解就是两台计算机各自的ip地址与子网掩码进行and运算后&#x…
阅读更多...
常用排序算法

常用排序算法

一、插入排序1、直接插入排序2、折半插入排序3、希尔排序 二、交换排序1、冒泡排序2、快速排序 三、选择排序1、简单选择排序2、堆排序&#xff08;1&#xff09;调整堆&#xff08;2&#xff09;创建堆 四、归并排序五、基数排序六、各种排序方法的比较 将一组杂乱无章的数据按…
阅读更多...
Zookeeper应用场景和底层设计

Zookeeper应用场景和底层设计

一、什么是zookeeper Zookeeper是一个开源的分布式协调服务框架&#xff0c;它是服务于其它集群式框架的框架。 【简言之】 有一个服务A&#xff0c;以集群的方式提供服务。只需要A专注于它提供的服务就可以&#xff0c;至于它如何以多台服务器协同完成任务的事情&#xff0c…
阅读更多...
9.14号作业

9.14号作业

仿照vector手动实现自己的myVector&#xff0c;最主要实现二倍扩容功能 有些功能&#xff0c;不会 #include <iostream>using namespace std; //创建vector类 class Vector { private:int *data;int size;int capacity; public://无参构造Vector(){}//拷贝构造Vector(c…
阅读更多...
2023年最新 Nonobot2 制作QQ聊天机器人详细教程（每周更新中）

2023年最新 Nonobot2 制作QQ聊天机器人详细教程（每周更新中）

协议端 go-cqhttp 安装 使用 mirai 以及 MiraiGo 开发的 cqhttp golang 原生实现&#xff0c;并在 cqhttp 原版 的基础上做了部分修改和拓展。 测试版下载地址&#xff1a;https://github.com/Mrs4s/go-cqhttp/releases 正式版下载地址&#xff1a;https://github.com/Mrs4s…
阅读更多...
广义表基础知识

广义表基础知识

广义表 (又称列表 Lists)是 n > 0个元素 . a0,a1....an-1的有限序列&#xff0c;其中每一个 ai 或者是原子&#xff0c;或者是一个广义表 广义表通常记作: LS (a1&#xff0c;a2&#xff0c;.....&#xff0c;an&#xff09;&#xff0c; LS为表名&#xff0c;n为表的长度&…
阅读更多...
使用 LoRA 和 QLoRA 对大型语言模型进行参数高效的微调

使用 LoRA 和 QLoRA 对大型语言模型进行参数高效的微调

概述 随着我们深入研究参数高效微调 (PEFT) 的世界，了解这种变革性方法背后的驱动力和方法变得至关重要。在本文中，我们将探讨 PEFT 方法如何优化大型语言模型 (LLM) 对特定任务的适应。我们将揭开 PEFT 的优点和缺点，深入研究 PEFT 技术的复杂类别，并破译两种卓越技术的内…
阅读更多...
SpingMyc项目如何搭建

SpingMyc项目如何搭建

目录 一、创建项目 二、环境搭建 &#xff08;1&#xff09;引入相关依赖 &#xff08;2&#xff09;在web.xml中配置前端控制器DispatcherServlet &#xff08;3&#xff09;编写SpringMVC核心配置文件springmvc.xml 三、测试是否成功 &#xff08;1&#xff09;编写控…
阅读更多...
Java反射机制简单入门

Java反射机制简单入门

标题 反射能干嘛获取Class对象的三种方式下面开始重点&#xff0c;需要掌握获取类的构造器并进行操作获取成员变量获取成员方法 这块建议先听第一个视频入门&#xff0c;第二个视频深入了解 视频学习地址1 视频学习地址1 正射:知道某个类&#xff0c;类的地址&#xff0c;通过…
阅读更多...
在Linux和Windows上安装分布式事务seata

在Linux和Windows上安装分布式事务seata

1 前言 官网地址&#xff1a;https://seata.io/ 源码地址&#xff1a;https://github.com/seata/seata 官网手册&#xff1a;https://seata.io/zh-cn/docs/ops/deploy-guide-beginner.html Seata&#xff0c;一款开源的分布式事务解决方案&#xff0c;致力于提供高性能和简…
阅读更多...
软件设计模式系列之五——建造者模式

软件设计模式系列之五——建造者模式

1 模式的定义 建造者模式是一种对象创建型设计模式&#xff0c;它将一个复杂对象的构建过程与其表示分离。这意味着你可以使用相同的构建过程来创建不同类型的对象&#xff0c;而不必关心每个对象的内部细节。这种模式适用于构建具有复杂配置的对象&#xff0c;例如具有多个可…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023