- 温馨提示：本篇重在逻辑和思维方式，只涉及少量语法！！
前言
大家好呀！在学习了一些Java和kotlin的基础语法之后，小编将在这里对新学习的一些语法知识进行对比和总结。我们将通过写一个随机抽牌并比较大小的小Demo的方式来对Java和kotlin进行对比学习，让我们一起来看看吧！
包含语法：
1.定义变量
2.方法重载
3.if判断语句
4.for循环
5.构造方法，初始化
6.输出语句
7.基本格式
- 注：实现本Demo采用了面向对象的思考方式，与c是完全不同的思考方式
正文
一、pokerDemo的功能
在Demo中，我们需要在一副扑克牌中抽取两张牌（除去大小王），然后对两张牌进行比较。首先比较牌面点数的大小，然后比较花色的大小，最后输出两张牌的比较结果。
注意：点数大小顺序（依次增大）："3","4","5","6","7","8","9","10","J","Q","K","A","2"
花色大小顺序（依次减小）："♠","♥","♣","♦"
二、分析如何实现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.对默认构造方法进行重载
注：在{ }中进行重载
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.直接赋予两个参数进行重载
注：在（ ）中传递参数
（二）、Poker类
1. Java
public class Poker {
//构成一张牌的两个属性
PokerNumber numberObj;
PokerSuit suitObj;
//当属性为私有时，用get方法得到两个属性
public PokerNumber getNumberObj() {
return numberObj;
}
public PokerSuit getSuitObj() {
return suitObj;
}
//重载默认构造函数，可以直接使用带参数的方法对牌进行初始化
public Poker(PokerNumber numberObj, PokerSuit suitObj) {
this.numberObj = numberObj;
this.suitObj = suitObj;
}
//定义一个compare构造方法，传递一个Poker类型的参数
//对两张牌进行比较，返回类型为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语句只能在其中进行操作，不能直接作为结果返回
2. kotlin
class Poker(
val numberObj:PokerNumber,
val suitObj:PokerSuit
) {
//返回值为boolean类型
fun compareTo(other:Poker):Boolean{
// var result:Boolean = true
// //比较点数
// if (this.numberObj.tag == other.numberObj.tag){
// //点数相同 比较花色
// 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){
//点数相同 比较花色
this.suitObj.tag > other.suitObj.tag
}else{
this.numberObj.tag > other.numberObj.tag
}
}
}
kotlin中：
1.直接在（ ）中传递两个变量（指定变量的类型），在{ }中写构造方法
2.if语句里{ }中的最后一句能够直接作为结果返回也可进行操作，如以上代码的注释部分与Java语法相似，而return部分直接作为结果返回
（三）、PokerManager类
1. Java
public class PokerManager {
ArrayList<Poker> pokers = new ArrayList<>();
//建立两个字符数组分别放置点数和花色
String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
String[] suits = {"♦", "♣", "♥", "♠"};
//重载默认构造函数，产生一副牌
public PokerManager() {
for (int i = 0; i < numbers.length; i++) {
for (int j = 0; j < suits.length; j++) {
//创造一张牌的点数和花色
PokerNumber pokerNumber = new PokerNumber(numbers[i],i);
PokerSuit pokerSuit = new PokerSuit(suits[j],j);
//创造一张牌
Poker poker = new Poker(pokerNumber,pokerSuit);
//将牌添加到一副牌所在的数组中
pokers.add(poker);
}
}
//随机置换指定列表元素，此处可以不写，因为下方可以随机得到牌面
Collections.shuffle(pokers);
}
//随机得到一张牌，构造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循环
2.产生随机数的方式Random ra = new Random( );
获得随机数调用的方法：ra.nextInt(数组名.size() );
3.添加和移除数组中的元素：array.add/remove(移除元素的类型名)；
2.kotlin
class PokerManager {
//提供一个容器存储所有的扑克 可以增删数组里的内容
val pokers: ArrayList<Poker> = arrayListOf()
//点数的数组 一旦创建不可改变
val numbers = arrayOf("2","3","4","5","6","7","8","9","10","J","Q","K","A")
//花色的数组
val suits = arrayOf("♦","♣","♥","♠")
//和构造函数同时处理
init {
for ((i,number) in numbers.withIndex()){
for ((j,suit) in suits.withIndex()){
//创建点数和花色的对象
// val numberObj = PokerNumber(number,i)
// val suitObj = PokerSuit(suit,j)
// //创建扑克对象
// val poker = Poker(numberObj,suitObj)
// //添加到数组pokers中
// pokers.add(poker)
//直接写 减少轮询
pokers.add(
Poker(PokerNumber(number,i),PokerSuit(suit,j))
)
}
}
}
fun getPoker():Poker{
//获取一个随机数
// val index = Random.nextInt(pokers.size)
val index = (0..pokers.size).random()
val poker = pokers[index]
pokers.removeAt(index)
return poker
}
}
kotlin中：
1.init初试化块，不用重载默认构造函数
2.fori循环中可以用for ((i,number) in numbers.withIndex())的方式找出元素的下标和内容
3.移除和添加数组中的元素：array.add(元素类型)；array.removeAt(index)//index即元素的下标
（四）、Test类
1.Java
public class Test {
public static void main(String[] args) {
PokerManager pokerManager = new PokerManager();
//产生两张牌
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.代码间无需分号，“ ”中若想输出代码里的内容用“${xx}”
四、总结
- Kotlin比Java更加简洁，语法也有很多相似之处。在学习的过程中，我们可以用写小Demo的方式进行对比学习。在本篇文章中，实现Demo的方式全部采用了面向对象的思考方式，将这个小项目进行分析后分类，实现类的继承、封装，安全性得到了提高。
- Kotlin和Java语法有一定程度的相似，我们在学习中应该多写代码，尽量不要将两者弄混。
- 其实Kotlin和Java的语法区别并不大，在编程语言的学习过程中更重要的是注重项目背后的逻辑思维，在生活中我们也应该时刻关注并使用面向对象的思考方式。
免责说明：
1.萌新选手刚来，不喜勿喷，如有错误，欢迎指正（求生欲满满QAQ）
2. 未经允许，禁止转载
