用java怎么创建一副扑克牌

一张扑克牌有两个属性，一个是花色（suit），一个是点数（rank），下面写一个简单的类

Card

package com.syz.card;

import java.io.Serializable;

public class Card implements Serializable{

    private static final long serialVersionUID = -4279016186402068401L;

    private int suit;

    private int rank;

    public static final int SPADE = 0;

    public static final int HEART = 1;

    public static final int CLUB = 2;

    public static final int DIAMOND = 3;

    public static final int BLACK = 4;

    public static final int RED = 5;

    private static final String[] suits = new String[] { "黑桃", "红桃", "梅花", "方块",
            "小", "大" };

    public static final int ACE = 1000;

    public static final int TWO = 1001;

    public static final int THREE = 1002;

    public static final int FOUR = 1003;

    public static final int FIVE = 1004;

    public static final int SIX = 1005;

    public static final int SEVEN = 1006;

    public static final int EIGHT = 1007;

    public static final int NINE = 1008;

    public static final int TEN = 1009;

    public static final int JACK = 1010;

    public static final int QUEEN = 1011;

    public static final int KING = 1012;

    public static final int JOKER = 1013;

    private static final String[] ranks = new String[] { "A", "2", "3", "4",
            "5", "6", "7", "8", "9", "10", "J", "Q", "K", "王" };

    public Card(int suit, int rank) {
        if (suit > -1 && suit < 6) {
            if (suit < 4) {
                if (rank < 1000 || rank > 1012) {
                    throw new IllegalArgumentException("花色或点数参数错误！");
                }
            }
            else {
                if (rank != 1013) {
                    throw new IllegalArgumentException("花色或点数参数错误！");
                }
            }
        }
        else {
            throw new IllegalArgumentException("花色参数错误！");
        }
        this.suit = suit;
        this.rank = rank;
    }

    public int getSuit() {
        return suit;
    }

    public int getRank() {
        return rank;
    }

    @Override
    public String toString() {
        return suits[suit] + ranks[rank - 1000];
    }

}

写完之后，要new一张扑克牌，需要两个参数，suit和rank，而且suit和rank是有关系的黑红梅方可以对应A2345678910JQK，然后黑色小王，红色大王。这个在构造器里做了校验，如果不符合，则抛出参数错误异常。

下面是测试类

CardClient

package com.syz.card;

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

public class CardClient {
    public static void main(String[] args) {
        test2();

    }

    private static void test1() {
        Card c = new Card(Card.BLACK, Card.JOKER);
        System.out.println(c);
    }

    private static void test2() {
        int[] suits = new int[] { Card.SPADE, Card.HEART, Card.CLUB,
                Card.DIAMOND };
        int[] ranks = new int[] { Card.ACE, Card.TWO, Card.THREE, Card.FOUR,
                Card.FIVE, Card.SIX, Card.SEVEN, Card.EIGHT, Card.NINE,
                Card.TEN, Card.JACK, Card.QUEEN, Card.KING };
        List<Card> cards = new ArrayList<Card>();
        for (int i = 0; i < suits.length; i++) {
            for (int j = 0; j < ranks.length; j++) {
                cards.add(new Card(suits[i], ranks[j]));
            }
        }
        cards.add(new Card(Card.BLACK, Card.JOKER));
        cards.add(new Card(Card.RED, Card.JOKER));
        System.out.println(cards);
    }
}

测试结果：

[黑桃A, 黑桃2, 黑桃3, 黑桃4, 黑桃5, 黑桃6, 黑桃7, 黑桃8, 黑桃9, 黑桃10, 黑桃J, 黑桃Q, 黑桃K, 红桃A, 红桃2, 红桃3, 红桃4, 红桃5, 红桃6, 红桃7, 红桃8, 红桃9, 红桃10, 红桃J, 红桃Q, 红桃K, 梅花A, 梅花2, 梅花3, 梅花4, 梅花5, 梅花6, 梅花7, 梅花8, 梅花9, 梅花10, 梅花J, 梅花Q, 梅花K, 方块A, 方块2, 方块3, 方块4, 方块5, 方块6, 方块7, 方块8, 方块9, 方块10, 方块J,
方块Q, 方块K, 小王, 大王]

这样一副扑克就创建成功了。

扑克原来有52张，没有大小王，后来才加上了大小王。现在有些扑克会带一张白板牌里面是一些广告什么的，如果把这张牌加入的话，就得改改这个Card类了。

下面我们来看看第二种方式创建一副扑克牌，不过这儿的类有些多，好处就是可以扩展。看代码：

1.Suit

package com.syz.pattern.bridge;

public abstract class Suit {

private Face face;

public Suit(Face face) {

this.face = face;

}

public void show() {

face.show(this);

}

protected abstract String getName();

}

2.Face

package com.syz.pattern.bridge;

public abstract class Face {

protected abstract String getName();

public void show(Suit suit) {

System.out.println(suit.getName() + this.getName());

}

}

以上两个抽象类，相互引用。是花色和点数的父类。

Suit的几个子类：

package com.syz.pattern.bridge;

public class Spade extends Suit {

    public Spade(Face face) {
        super(face);
    }

    @Override
    public String getName() {
        return "黑桃";
    }
}

package com.syz.pattern.bridge;

public class Heart extends Suit {

    public Heart(Face face) {
        super(face);
    }

    @Override
    protected String getName() {
        return "红桃";
    }

}

package com.syz.pattern.bridge;

public class Club extends Suit {

    public Club(Face face) {
        super(face);
    }

    @Override
    protected String getName() {
        return "梅花";
    }

}

package com.syz.pattern.bridge;

public class Diamond extends Suit {

    public Diamond(Face face) {
        super(face);
    }

    @Override
    protected String getName() {
        return "方块";
    }

}

package com.syz.pattern.bridge;

public class Black extends Suit {

    public Black(Face face) {
        super(face);
    }

    @Override
    protected String getName() {
        return "小";
    }

}

package com.syz.pattern.bridge;

public class Red extends Suit {

    public Red(Face face) {
        super(face);
    }

    @Override
    protected String getName() {
        return "大";
    }

}

Face的几个子类

package com.syz.pattern.bridge;

public class Ace extends Face {

    @Override
    protected String getName() {
        return "A";
    }

}

package com.syz.pattern.bridge;

public class Two extends Face {

    @Override
    protected String getName() {
        return "2";
    }

}
package com.syz.pattern.bridge;

public class Three extends Face {

    @Override
    protected String getName() {
        return "3";
    }

}

package com.syz.pattern.bridge;

public class Four extends Face {

    @Override
    protected String getName() {
        return "4";
    }

}

package com.syz.pattern.bridge;

public class Five extends Face {

    @Override
    protected String getName() {
        return "5";
    }

}

package com.syz.pattern.bridge;

public class Six extends Face {

    @Override
    protected String getName() {
        return "6";
    }

}

package com.syz.pattern.bridge;

public class Seven extends Face {

    @Override
    protected String getName() {
        return "7";
    }

}
package com.syz.pattern.bridge;

public class Eight extends Face {

    @Override
    protected String getName() {
        return "8";
    }

}

package com.syz.pattern.bridge;

public class Nine extends Face {

    @Override
    protected String getName() {
        return "9";
    }

}
package com.syz.pattern.bridge;

public class Ten extends Face {

    @Override
    protected String getName() {
        return "10";
    }

}

package com.syz.pattern.bridge;

public class Jack extends Face {

    @Override
    protected String getName() {
        return "J";
    }

}

package com.syz.pattern.bridge;

public class Queen extends Face {

    @Override
    protected String getName() {
        return "Q";
    }

}

package com.syz.pattern.bridge;

public class King extends Face {

    @Override
    protected String getName() {
        return "K";
    }

}

package com.syz.pattern.bridge;

public class Joker extends Face {

    @Override
    protected String getName() {
        return "王";
    }

}

接下来看一些测试:

Suit c1 = new Spade(new Ace());

c1.show();

c1 = new Heart(new Jack());

c1.show();

c1 = new Club(new Queen());

c1.show();

c1 = new Diamond(new King());

c1.show();

c1 = new Spade(new Joker());

c1.show();

测试结果：

黑桃A

红桃J

梅花Q

方块K

黑桃王

花色和点数组合，可以看出，这里没有规则，“黑桃王”这样的都可以拼出来，我就呵呵了。

那么怎么组合成一副54张的扑克呢，这里可以用反射来做，看代码：

package com.syz.pattern.bridge;

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

public class CardClient {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static void main(String[] args) throws Exception {
        // reflect
        String[] suitNames = { "com.syz.pattern.bridge.Spade",
                "com.syz.pattern.bridge.Heart", "com.syz.pattern.bridge.Club",
                "com.syz.pattern.bridge.Diamond" };
        String[] rankNames = { "com.syz.pattern.bridge.Ace",
                "com.syz.pattern.bridge.Two", "com.syz.pattern.bridge.Three",
                "com.syz.pattern.bridge.Four", "com.syz.pattern.bridge.Five",
                "com.syz.pattern.bridge.Six", "com.syz.pattern.bridge.Seven",
                "com.syz.pattern.bridge.Eight", "com.syz.pattern.bridge.Nine",
                "com.syz.pattern.bridge.Ten", "com.syz.pattern.bridge.Jack",
                "com.syz.pattern.bridge.Queen", "com.syz.pattern.bridge.King" };
        List<Suit> cards = new ArrayList<>();
        for (int i = 0; i < suitNames.length; i++) {
            Class suitClazz = Class.forName(suitNames[i]);
            for (int j = 0; j < rankNames.length; j++) {
                Class rankClazz = Class.forName(rankNames[j]);
                cards.add((Suit) suitClazz
                        .getConstructor(new Class[] { Face.class })
                        .newInstance(new Object[] { rankClazz.newInstance() }));
            }
        }
        cards.add(new Black(new Joker()));
        cards.add(new Red(new Joker()));
        for (int i = 0; i < cards.size(); i++) {
            Suit card = cards.get(i);
            card.show();
        }
    }
}

结果：

黑桃A

黑桃2

黑桃3

黑桃4

黑桃5

黑桃6

黑桃7

黑桃8

黑桃9

黑桃10

黑桃J

黑桃Q

黑桃K

红桃A

红桃2

红桃3

红桃4

红桃5

红桃6

红桃7

红桃8

红桃9

红桃10

红桃J

红桃Q

红桃K

梅花A

梅花2

梅花3

梅花4

梅花5

梅花6

梅花7

梅花8

梅花9

梅花10

梅花J

梅花Q

梅花K

方块A

方块2

方块3

方块4

方块5

方块6

方块7

方块8

方块9

方块10

方块J

方块Q

方块K

小王

大王

时间： 2024-12-28 17:36:26

用java怎么创建一副扑克牌的相关文章

使用LinkedList存储一副扑克牌，然后实现洗牌功能。

/* 需求: 使用LinkedList存储一副扑克牌,然后实现洗牌功能. */ //扑克类 class Poker{ String color; //花色 String num; //点数 public Poker(String color, String num) { super(); this.color = color; this.num = num; } @Override public String toString() { return "{"+color+num+&quo

【JAVA 动态创建风水罗盘 超精华Swing项目方案 - 文章01】

如何利用java swing 创建动态效果项目,在这里完整的给大家展示swing创建动态的风水罗盘项目方案和策略. 动态风水罗盘效果图: 下篇继续-

Java进阶 创建和销毁对象

最近准备写点Javase的东西,希望可以帮助大家写出更好的代码. 1.给不可实例化的类提供私有构造器 比如:每个项目中都有很多工具类,提供了很多static类型的方法供大家使用,谁也不希望看到下面的代码: TextUtils textUtils = new TextUtils(); if(textUtils.isDigitsOnly("123")) { //doSometing }else { //doSomething } 自己写个工具类,总有人喜欢先初始化个实例在调用方法,然后还附

ART运行时Java堆创建过程分析

与Dalvik虚拟机一样,ART运行时内部也有一个Java堆,用来分配Java对象.当这些Java对象不再被使用时,ART运行时需要回收它们占用的内存.在前面一文中,我们简要介绍了ART运行时的垃圾收集机制,从中了解到ART运行时内部使用的Java堆是由四种Space以及各种辅助数据结构共同描述的.为了后面可以更好地分析ART运行时的垃圾收集机制,本文就对它内部使用的Java堆的创建过程进行分析. 本博参加博客之星评选,求投票:点击投票 老罗的新浪微博:http://weibo.com/shen

深入理解java虚拟机（二）HotSpot Java对象创建，内存布局以及访问方式

内存中对象的创建.对象的结构以及访问方式. 一.对象的创建 在语言层面上,对象的创建只不过是一个new关键字而已,那么在虚拟机中又是一个怎样的过程呢? (一)判断类是否加载.虚拟机遇到一条new指令的时候,首先会检查这个指令的参数是否能在常量池中定位到一个类的符号引用,并且检查这个符号代表的类是否被加载.解析并初始化.如果没有完成这个过程,则必须执行相应类的加载. (二)在堆上为对象分配空间.对象需要的空间大小在类加载完成后便能确定.之后便是在堆上为该对象分配固定大小的空间.分配的方式也有两种:

Spring Boot 使用Java代码创建Bean并注册到Spring中

从 Spring3.0 开始,增加了一种新的途经来配置Bean Definition,这就是通过 Java Code 配置 Bean Definition. 与Xml和Annotation两种配置方式不同点在于: 前两种Xml和Annotation的配置方式为预定义方式,即开发人员通过 XML 文件或者 Annotation 预定义配置 bean 的各种属性后,启动 Spring 容器,Spring 容器会首先解析这些配置属性,生成对应都?Bean Definition,装入到 DefaultL

JAVA中创建字符串的两种方式的区别

我们知道,通常在Java中创建一个字符串会有两种方式,通过双引号直接赋值和通过构造器来创建. String x = "abcd"; String y = new String("abcd"); 然而,这两种方式之间的区别是什么?分别应用于哪些情况,之前还不是很懂. 1.双引号的方式 String x = "abcd"; String y = "abcd"; System.out.println(x==y);//true Sys

java多线程创建方法

1.继承Thread类 2.实现Runnable接口 3.两种实现方法之间的关系 4.实例 sleep是属于Thread类的静态函数. /** * aThread.java * @author cjc */ public class aThread extends Thread { public void run() { for(int i=0;i<10;i++) { System.out.println("The son thread1 is running..."); try

Dalvik虚拟机Java堆创建过程分析

使用C/C++开发应用程序最令头痛的问题就是内存管理.慎不留神,要么内存泄漏,要么内存破坏.虚拟机要解决的问题之一就是帮助应用程序自动分配和释放内存.为了达到这个目的,虚拟机在启动的时候向操作系统申请一大块内存当作对象堆.之后当应用程序创建对象时,虚拟机就会在堆上分配合适的内存块.而当对象不再使用时,虚拟机就会将它占用的内存块归还给堆.Dalvik虚拟机也不例外,本文就分析它的Java堆创建过程. 老罗的新浪微博:http://weibo.com/shengyangluo,欢迎关注! 从前面Da