Java&Kotlin語法對比篇（一）|如何做一個隨機抽牌并比較大小的小Demo？

  • 溫馨提示：本篇重在邏輯和思維方式，只涉及少量語法！！

前言

大家好呀！在學習了一些Java和kotlin的基礎(chǔ)語法之后，小編將在這里對新學習的一些語法知識進行對比和總結(jié)。我們將通過寫一個隨機抽牌并比較大小的小Demo的方式來對Java和kotlin進行對比學習，讓我們一起來看看吧！

包含語法：
1.定義變量
2.方法重載
3.if判斷語句
4.for循環(huán)
5.構(gòu)造方法，初始化
6.輸出語句
7.基本格式

  • 注：實現(xiàn)本Demo采用了面向?qū)ο蟮乃伎挤绞?，與c是完全不同的思考方式

正文

一、pokerDemo的功能

在Demo中，我們需要在一副撲克牌中抽取兩張牌（除去大小王），然后對兩張牌進行比較。首先比較牌面點數(shù)的大小，然后比較花色的大小，最后輸出兩張牌的比較結(jié)果。

注意：點數(shù)大小順序（依次增大）："3","4","5","6","7","8","9","10","J","Q","K","A","2"
花色大小順序（依次減?。??","?","?","?"

二、分析如何實現(xiàn)pokerDemo

（一）、文字分析

  1. 有兩張牌，比較點數(shù)和花色。但由于點數(shù)非純數(shù)字而花色也難以比較，因此我們選擇將點數(shù)和花色分別放到字符數(shù)組中，將點數(shù)和花色都從小到大放置，這樣對應(yīng)元素的下標也依次增大，我們比較元素的下標時即可比較對應(yīng)的點數(shù)和花色。

  2. 創(chuàng)建一個可以管理所有撲克牌的類。這個管理器既可以產(chǎn)生所有的牌，又可以讓我們隨機從中抽取兩張牌。

（二）、UML類圖

PokerDemo-UML類圖

三、代碼對比

（一）、PokerNumber類和PokerSuit類

1. Java

public class PokerNumber {
    String number;
    int tag;

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

public class PokerSuit {
    String suit;
    int tag;

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

Java中：
1.定義變量：“類型 類型名”
2.對默認構(gòu)造方法進行重載
注：在{ }中進行重載

2. kotlin

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

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

kotlin中：
1.定義變量：“類型（var/val）類型名[：類型的類 eg.Int String...]”
2.直接賦予兩個參數(shù)進行重載
注：在（ ）中傳遞參數(shù)

（二）、Poker類

1. Java

public class Poker {
    //構(gòu)成一張牌的兩個屬性
    PokerNumber numberObj;
    PokerSuit suitObj;

    //當屬性為私有時，用get方法得到兩個屬性
    public PokerNumber getNumberObj() {
        return numberObj;
    }
    public PokerSuit getSuitObj() {
        return suitObj;
    }

    //重載默認構(gòu)造函數(shù)，可以直接使用帶參數(shù)的方法對牌進行初始化
    public Poker(PokerNumber numberObj, PokerSuit suitObj) {
        this.numberObj = numberObj;
        this.suitObj = suitObj;
    }

    //定義一個compare構(gòu)造方法，傳遞一個Poker類型的參數(shù)
    //對兩張牌進行比較，返回類型為Boolean型
    public boolean compare(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;
            }
        }
    }
}

在Java中：
1.定義一個Poker類需要的屬性和compare方法
2.if語句只能在其中進行操作，不能直接作為結(jié)果返回

2. kotlin

class Poker(
    val numberObj:PokerNumber,
    val suitObj:PokerSuit
) {
    //返回值為boolean類型
    fun compareTo(other:Poker):Boolean{
//        var result:Boolean = true
//        //比較點數(shù)
//        if (this.numberObj.tag == other.numberObj.tag){
//            //點數(shù)相同 比較花色
//            result = this.suitObj.tag > other.suitObj.tag
//        }else{
//            result = this.numberObj.tag > other.numberObj.tag
//        }
//        return result

        return if (this.numberObj.tag == other.numberObj.tag){
            //點數(shù)相同 比較花色
            this.suitObj.tag > other.suitObj.tag
        }else{
            this.numberObj.tag > other.numberObj.tag
        }
    }
}

kotlin中：
1.直接在（ ）中傳遞兩個變量（指定變量的類型），在{ }中寫構(gòu)造方法
2.if語句里{ }中的最后一句能夠直接作為結(jié)果返回也可進行操作，如以上代碼的注釋部分與Java語法相似，而return部分直接作為結(jié)果返回

（三）、PokerManager類

1. Java

public class PokerManager {
    ArrayList<Poker> pokers = new ArrayList<>();

    //建立兩個字符數(shù)組分別放置點數(shù)和花色
    String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
    String[] suits = {"?", "?", "?", "?"};

    //重載默認構(gòu)造函數(shù)，產(chǎn)生一副牌
    public PokerManager() {
        for (int i = 0; i < numbers.length; i++) {
            for (int j = 0; j < suits.length; j++) {
                //創(chuàng)造一張牌的點數(shù)和花色
                PokerNumber pokerNumber = new PokerNumber(numbers[i],i);
                PokerSuit pokerSuit = new PokerSuit(suits[j],j);
                //創(chuàng)造一張牌
                Poker poker = new Poker(pokerNumber,pokerSuit);
                //將牌添加到一副牌所在的數(shù)組中
                pokers.add(poker);
            }
        }
        //隨機置換指定列表元素，此處可以不寫，因為下方可以隨機得到牌面
        Collections.shuffle(pokers);
    }

    //隨機得到一張牌，構(gòu)造getPokers方法，返回類型為Poker
    public Poker getPokers() {
        Random random = new Random();
        int index = random.nextInt(pokers.size());
        Poker poker = pokers.get(index);
        //將得到的牌移出牌組
        pokers.remove(poker);
        return poker;
    }
}

Java中：
1.fori循環(huán)
2.產(chǎn)生隨機數(shù)的方式Random ra = new Random( );
獲得隨機數(shù)調(diào)用的方法：ra.nextInt(數(shù)組名.size() );
3.添加和移除數(shù)組中的元素：array.add/remove(移除元素的類型名)；

2.kotlin

class PokerManager {
    //提供一個容器存儲所有的撲克 可以增刪數(shù)組里的內(nèi)容
    val pokers: ArrayList<Poker> = arrayListOf()
    //點數(shù)的數(shù)組 一旦創(chuàng)建不可改變
    val numbers = arrayOf("2","3","4","5","6","7","8","9","10","J","Q","K","A")
    //花色的數(shù)組
    val suits = arrayOf("?","?","?","?")

    //和構(gòu)造函數(shù)同時處理
    init {
        for ((i,number) in numbers.withIndex()){
            for ((j,suit) in suits.withIndex()){
                //創(chuàng)建點數(shù)和花色的對象
//                val numberObj = PokerNumber(number,i)
//                val suitObj = PokerSuit(suit,j)
//                //創(chuàng)建撲克對象
//                val poker = Poker(numberObj,suitObj)
//                //添加到數(shù)組pokers中
//                pokers.add(poker)

                //直接寫 減少輪詢
                pokers.add(
                    Poker(PokerNumber(number,i),PokerSuit(suit,j))
                )
            }
        }
    }

    fun getPoker():Poker{
        //獲取一個隨機數(shù)
//        val index = Random.nextInt(pokers.size)
        val index = (0..pokers.size).random()
        val poker = pokers[index]
        pokers.removeAt(index)
        return poker
    }
}

kotlin中：
1.init初試化塊，不用重載默認構(gòu)造函數(shù)
2.fori循環(huán)中可以用for ((i,number) in numbers.withIndex())的方式找出元素的下標和內(nèi)容
3.移除和添加數(shù)組中的元素：array.add(元素類型)；array.removeAt(index)//index即元素的下標

（四）、Test類

1.Java

public class Test {
    public static void main(String[] args) {
        PokerManager pokerManager = new PokerManager();

        //產(chǎn)生兩張牌
        Poker poker1 = pokerManager.getPokers();
        Poker poker2 = pokerManager.getPokers();

        //比較兩張牌
        boolean result = poker1.compare(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中：
1.方法：“返回類型 方法名”
2.輸出：System.out.println/print //換行/不換行
3.每個語句間要加分號，輸出用“+”連接

2.kotlin

fun main() {
    val manager = PokerManager()

    val poker1 = manager.getPoker()
    val poker2 = manager.getPoker()

    val result = poker1.compareTo(poker2)
    if (result){
        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}")

    }
}

kotlin中：
1.方法：“fun 方法名”
2.輸出：println/print //換行/不換行 類似于c
3.代碼間無需分號，“ ”中若想輸出代碼里的內(nèi)容用“${xx}”

四、總結(jié)

  • Kotlin比Java更加簡潔，語法也有很多相似之處。在學習的過程中，我們可以用寫小Demo的方式進行對比學習。在本篇文章中，實現(xiàn)Demo的方式全部采用了面向?qū)ο蟮乃伎挤绞?，將這個小項目進行分析后分類，實現(xiàn)類的繼承、封裝，安全性得到了提高。
  • Kotlin和Java語法有一定程度的相似，我們在學習中應(yīng)該多寫代碼，盡量不要將兩者弄混。
  • 其實Kotlin和Java的語法區(qū)別并不大，在編程語言的學習過程中更重要的是注重項目背后的邏輯思維，在生活中我們也應(yīng)該時刻關(guān)注并使用面向?qū)ο蟮乃伎挤绞健?/li>

免責說明：
1.萌新選手剛來，不喜勿噴，如有錯誤，歡迎指正（求生欲滿滿QAQ）
2. 未經(jīng)允許，禁止轉(zhuǎn)載

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容