语法实训之比牌demo——Java，Ktolin

想要学好Java，Ktolin等编程语言，必不可少的就是培养良好的程序思维，以及对代码的灵活运用。这些都离不开各种demo的铺垫，多写多练才能熟能生巧，接下来就与小编一同来完成一个比牌demo吧~

培养程序思维，程序搭建少不了~着手写一个程序，首先要明确的就是程序要实现的具体功能，即程序分析；第二步也是最重要的一步就是画类图，类图体现的不仅是一个程序该如何实现的具体方法，也体现了一个程序的内部逻辑的框架，是一个程序的灵魂所在。最后一步就是根据类图写代码啦，具体过程如下：

一 . 程序分析

1.明确程序要实现的功能：
由系统给出两张牌，再进行两张牌大小的比较

2.实现方法：
两张牌需要从“一副牌”中随机获取，即要实现对一副牌的管理。每张牌由两个部分组成：点数和花色。一副牌中的点数包含：2 3 4 5 6 7 8 9 10 J Q K A，花色包含：♠ ❤ ♣ ♦，通过先比点数再比花色来实现牌面的大小比较。

二 . 画类图

画类图，小编这里用的是Processon，其特点画面清晰，内容丰富也很好上手，很适合初学者小白（比如我hhhh）链接献上☑(https://www.processon.com/)

类图是一个程序的灵魂所在，在此步我们要着手分析并整理好各个类要实现的功能，以及类与类之间的关系。下面就是一个分析的过程（保姆级解说）：

1️⃣首先我们要获取两张牌，就需要对一副牌进行管理。先把每张牌的点数和花色组合在一起，再放到一个ArraryLiat数组里生成我们的一副牌，并从这个数组里得到我们想要的‘两张牌’。这里我们可以通过一个PokerManger类来实现以上两个功能；
2️⃣得到牌之后我们就要对两张牌进行比较。不难发现，对于一副牌的点数与花色都不是我们所能直接用的正常大小关系，因此就需要我们自己编译一个排序来比较大小，小编这里解决这个的方法是：分别将牌的点数和花色按从小到大的顺序放到两个数组里，再根据数组元素的位置即‘索引值’进行大小的比较。因此点数和花色需要重新分配到两个类中，分别为PokerNumber类和PokerSuit类，两个类都包含两个参数，一个属性本身（String类型）和一个索引值（Int类型）；3️⃣最后再设定一个Poker主类，对于我们得到的两张牌，给出对比较大小的方法！这样就实现了我们的最终目的✅
构思完就可以开始着手画类图啦~类图如下：

uml类图

图中的1v1以及1v may表示类与类之间的对应关系~

三 . 根据类图写代码

1.我们先用Java来实现程序

首先是PokerNumber类和PokerSuit类，都有两个变量，一个代表点数和花色，一个用来比较大小

public class PokerNumber {
    String number;
    int tag;

    public PokerNumber(String number, int tag) {
        this.number = number;
        this.tag = tag;
    }
}

public class PokerSuti {
    String suit;
    int tag;

    public PokerSuti(String suit, int tag) {
        this.suit = suit;
        this.tag = tag;
    }
}

Poker类：实现两张牌的比较，用compareTo方法实现，先比点数，后比花色

public class Poker {
    PokerSuti suitObj;
    PokerNumber numberObj;

    public Poker(PokerSuti suitObj, PokerNumber numberObj) {
        this.suitObj = suitObj;
        this.numberObj = numberObj;
    }

    public PokerSuti getSuitObj() {
        return suitObj;
    }

    public PokerNumber getNumberObj() {

        return numberObj;
    }
    public boolean compareTo(Poker other){
        if (this.numberObj.tag==other.numberObj.tag) {
            if (this.suitObj.tag>other.suitObj.tag){
                return true;
            }else {
                return false;
            }
        }else {
            if (this.numberObj.tag > other.numberObj.tag) {
                return true;
            } else {
                return false;
            }
        }
    }
}

PokerManger类:实现一副牌的管理，编译一个数组存放一副牌，并实现单张牌的获取

public class PokerManger {
    ArrayList<Poker> pokers=new ArrayList<>();
    String[] numbers={"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
    String[] sutis={"♦","♣","❤","♠"};
    public PokerManger() {
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < sutis.length; j++) {
                PokerNumber numberObj=new PokerNumber(numbers[i],i);
                PokerSuti sutiObj=new PokerSuti(sutis[j],j);
                Poker poker=new Poker(sutiObj, numberObj);
                pokers.add(poker);
            }
        }
        Collections.shuffle(pokers);
//        打乱
    }
    public Poker getPoker(){
        Random random=new Random();
        int index=random.nextInt(pokers.size());
        Poker poker=pokers.get(index);
        pokers.remove(index);
        return poker;
    }
}

Myclass：测试程序

public class Myclass {
    public static void main(String[] args) {
        PokerManger manger=new PokerManger();
        Poker poker1=manger.getPoker();
        Poker poker2=manger.getPoker();
        boolean result=poker1.compareTo(poker2);
        if (result){
            System.out.println(poker1.numberObj.number+poker1.suitObj.suit+">"+
                    poker2.numberObj.number+poker2.suitObj.suit);
        }else {
            System.out.println(poker1.numberObj.number+poker1.suitObj.suit+"<"+
                    poker2.numberObj.number+poker2.suitObj.suit);
        }
    }
}

程序运营截图如下：

Java程序运行截图

2.用Kotlin实现程序

与Java同理有5个类，分别如下
PokerNumber类和PokerSuit类

class PokerNumber (
    val number:String,
    val tag:Int
)

class Pokersuit(
    val suit:String,
    val tag:Int
)

Poker类

class Poker(
    val numberObj:PokerNumber,
    val suitObj:Pokersuit
) {
   fun compareTo(other: Poker):Boolean{
        return if (this.numberObj.tag == other.numberObj.tag){
            //点数相同 比较花色
            this.suitObj.tag > other.suitObj.tag
        }else{
            this.numberObj.tag > other.numberObj.tag
        }
    }
}

PokerManger类

import kotlin.random.Random

class Pokermanager {
    val pokers:ArrayList<Poker> = arrayListOf()
    val numbers= arrayOf("2","3","4","5","6","7","8","9","10","J","Q","K","A")
    val suit= arrayOf("♦","♣","❤","♠")
    init {
        for ((i,number) in numbers.withIndex()){
            for ((j,suit) in suit.withIndex()){
                pokers.add(Poker(PokerNumber(number,i), Pokersuit(suit,j)))
            }
        }

    }
    fun getPoker():Poker{
               Random.nextInt(pokers.size).also {
            pokers[it].apply {
                pokers.remove(this)
                return this
            }
        }
}

Main类

fun main() {
    Pokermanager().apply {
        val poker1 = getPoker()
        val poker2 = getPoker()
        poker1.compareTo(poker2).also {
            if (it){
                println("${poker1.numberObj.number}${poker1.suitObj.suit} > " +
                        "${poker2.numberObj.number}${poker2.suitObj.suit}")
            }else{
                println("${poker1.numberObj.number}${poker1.suitObj.suit} < " +
                        "${poker2.numberObj.number}${poker2.suitObj.suit}")
            }
        }
    }
}

同样献上Ktolin程序运营截图

Ktolin 程序运行截图

四 . 总结

1.想写好一个程序，首先就得明确目标与功能，以及属性的分析，同时要考虑到各种牵扯进来的内容；其次就是要找准实现解决问题所要用到的各种方法，方法找得好，程序简明了；而最最最重要的一步就是要理清整个程序的内部逻辑，明确各个类实现的功能，通过类图来展现其中对应的关系；最后就是写代码啦，把基础的语法语句加以组织串联，赋予代码生命来实现我们想要实现的具体功能~

2.Java与Ktolin相比起来，Ktolin的代码会更加简洁，看起来也会舒服些，写法上也比Java少了些符号，在方法的实现上也省去了一些冗杂变量的使用。同样的Ktolin也需要记忆更多的语法知识。

今天的demo就写到这里啦，路漫漫其修远兮，我们一同加油！