前言
大家好呀！上一篇中我们只涉及了少量语法知识，而在本篇文章中会更加细致和丰富一些，增加了一些Java和Kotlin中的语言基础知识，让我们一起来看看吧！
1.定义基本类型数据：常量和变量
2.控制语句：
（1）分支结构：if 语句、switch 语句
（2）循环结构：for 循环、while 循环、do-while 循环
（3）中断结构：break 语句、continue 语句
3.输入输出语句
正文
一、定义常量和变量
1.Java
（1）常量
常量是用某些特征含义的表示符表示某些不变化的数值，它的值在运行期间不会被改变，即只能被引用，不能重新赋值
定义常量的基本格式：
final 数据类型 变量名 = 值
//例如：
final int age = 10;
final String name = "jack";
（2）变量
程序的基本存储单元，用于存储需要的数据。可以被引用和改变。
定义变量的基本格式：
数据类型 变量名 = 值；
//例如：
int age = 10;//进行初始化
String name;//可以不进行初始化
int[] nums1 = {1,2,3,4}; //定义数组，可以不指定长度
int[] nums2 = new int[]{1,2,3,4,5}; //新建一个对象分配空间
int[] nums3 = new int[5]; //指定长度，不进行初始化
2.Kotlin
定义常量和变量的基本格式：
val / var 变量名 ：数据类型（开头字母大写）= 初始化值
val age:Int = 18 //val 声明一个常量，赋值后不可改变
var name:String = "jack"//var 声明一个变量，赋值后可以重复修改
val age = 18 //也可不指定类型，kotlin可以进行自动类型推断
val nums = arrayOf(1,2,3,4) //定义数组并对其初始化
二、控制语句
（一）、分支结构
1.if 语句
（1）Java
if条件语句的基本格式：
if （判断条件）{ } [else { }] // [ ]中的内容可以不加*
例如：
public boolean compare(Poker other){
if (this.suitObj.tag > other.suitObj.tag){
return true;
}else {
return false;
} //比较扑克牌的花色为例，if条件语句可以返回所需要的类型
if (true){ //括号内的判断类型可以直接是boolean型
System.out.println("成功");
}else {
System.out.println("失败"); //在if语句中执行命令
}
（2）kotlin
if （判断条件）{ } [else { }] // [ ]中的内容可以不加*
if-esle语句格式与Java区别不大，值得注意的是kotlin中可以直接返回if语句的最后一句的类型。例如：
fun compare(other:Poker): Boolean {
return if(this.number.tag == other.number.tag){ //直接返回if语句中最后一句的类型
this.suit.tag > other.suit.tag
}else this.number.tag > other.number.tag
}
2.swith语句（Java）与 when 语句（kotlin）
（1）Java中的 switch 选择分支语句
java中的多分支选择结构可以采用switch语句，其基本结构如下：
switch(表达式)
{
case 值1:语句1;break;
case 值2:语句2;break;
case 值3:语句3;break;
default:语句4;break; //注意此处没有分号
}
switch语句中表达式里的值会依次与值1、2、3进行比较，若满足1则执行1里的语句；若语句1执行后不写break中断语句，则会判断是否满足值2，若满足则执行语句2直至遇到break中断语句跳出分支结构或者无满足值执行default中的语句然后跳出。
注：default语句可有可无
例如：
int a = 1;
switch(a){
case 1:
System.out.println("1");break;
case 1:
System.out.println("2");break;
case 1:
System.out.println("3");break;
default :
System.out.println("other");break;
}
（2）kotlin中的 when 选择分支语句
kotlin中的多分支选择结构使用when语句，其结构如下：
when(表达式){
//只要满足一个条件直接break
条件1 -> println("1")
条件2 -> println("2")
条件3 -> println("3")
else -> println("other")
}
kotlin的多分支结构when语句与Java中的switch语句最大的区别除了格式上的区别外，就是kotlin中一旦满足一个条件，执行该条件之后的语句后直接break跳出多分支选择结构，不会再判断下一个条件是否满足。
例如：
val c = 'A'
when(c){
//只要满足一个条件直接break
'A' -> println("1")
'B' -> println("2")
'C' -> println("3")
else -> println("others")
}
when(c){
//多种情况 逗号隔开即可
'A','B' -> println("AB")
'C' -> println("C")
}
val score = 60
when(score){
!in 0..59 -> println("及格")
else -> println("不及格")
}
//Any - Object
val obj:Any ?= null
when (obj){ //判断obj属于哪个类用“is 类名”
//方法外声明类
is Person -> println("人类")
is Animal -> println("禽兽")
else -> println("不明生物")
}
//when的表达式直接赋值
val result = when(c){
'A' -> "1"
'B' -> "2"
'C' -> "3"
else -> "others"
}
// {} 表示独立的代码块
//结果为分支最后一行的值
val result2 = when(c){
'A' -> {
if (2 > 1){}
//最后一行表示结果
"1"
}
'B' -> "2"
'C' -> "3"
else -> "others"
}
（二）、循环结构
1.for 循环
（1）Java
java的for循环语句包括两种，一种是for-i循环，一种是for-each遍历循环
for-i循环：
for(下标初始化 ; 判断条件 ; 执行条件){ }
for-each循环：
for(int i:数组名){ }
直接上例子：
//for-i循环
int[] a = {1,2,3,4,5};
for (int i = 0;i < a.length ; i++){
System.out.print(a[i] + " ")
}
//for-each循环
int[] a = {1,2,3,4,5};
for (int i:a){
System.out.print( i + " ") //此处直接输出a[i]的内容，而不是输出下标，这就是遍历数组的好处
}
（2）kotlin
kotlin中只有for-each循环，不提供for-i循环
for (变量名 in 数组名/范围){
print(变量名) //即可打印相应内容
}
例如：
//“某数..某数”指<= <=
for (i in 0..3){
print(nums[i])
}
println()
for (i in 1..6 step 2){ //step指i=i+2
print(i)
}
println()
//until 指 <= <
for (i in 1 until 5){
print(i)
}
println()
//相当于for-each item是随意写的变量名
for (item in nums){
print(item)
}
println()
//i为item 所在的索引值
for ((i,item) in nums.withIndex()){
println("$i-$item")
}
2.while 循环
（1）Java
while语句的基本格式：
while(条件) { }
例如：
int i = 0 ;
while(i < 10){
System.out.print(i);
i++ ;
}
（2）kotlin
while语句的基本格式与Java基本一致：
while(条件) { }
例如：
var i = 0
while(i < 10){
print(i)
i++
}
3.do-while 循环
（1）Java
do-while语句是先执行再判断，因此至少会执行一次do内执行语句的内容
do-while语句的基本格式：
do{执行语句} while(条件语句);
例如：
int i = 0;
do {
System.out.println(i);
i++;
} while (i < 3);
（2）kotlin
与Java的do-while基本一致，其格式为：
do{执行语句} while(条件语句);
例如：
var i = 0;
do {
print(i)
i++
} while (i < 3)
（三）、中断结构
break： 结束整个循环体或者直接跳出
continue： 结束本次的循环，调过continue后的动作，直接进行下一次循环，并未结束整个循环体
1.Java
例如：
for(int i=0; i<4; i++){
if(i==2){
break;
}
System.out.print(i);
}
输出结果为：01 //不打印2，直接结束整个循环
for(int i=0; i<4; i++){
if(i==2){
continue;
}
System.out.print(i);
}
输出结果为：013 //不打印2，跳过当次循环
2.kotlin
例如：
for(i in 0..4){
if(i==2) break
print(i)
}
输出结果为：01 //不打印2，直接结束整个循环
for(i in 0..4){
if(i==2) continue
print(i)
}
输出结果为：0134 //不打印2，跳过当次循环
三、输入和输出语句
（一）、Java
1.输入语句
//接收输入的对象Scanner
Scanner scanner = new Scanner(System.in);
//转化接受数据的类型
int a = scanner.nextInt(System.in); //转化为int型
2.输出语句
//不换行打印
System.out.print("")
//换行打印
System.out.println("")
（二）、kotlin
1.输入语句
//接收输入并转换为int型
var a = readline().toInt
2.输出语句
//不换行打印
print("")
//换行打印
println("")
四、总结
1.kotlin的语法比Java更加简洁
2.kotlin的单个语法小点比Java更多
