[#Kotlin] 第一章基础编码（适用于有Java代码经验）

本文链接：https://blog.csdn.net/PKSO_LAS/article/details/123867755

代码逻辑和规范内容参考自 IntelliJ IDEA 的 AtomicKotlin课节。如果需要使用官方提供的插件进行课程学习时（有编写性的练手内容，英文说明需要自行复制粘贴进行翻译）请翻到最后部分进行插件安装。该介绍主要从Java角度说起，最好时拥有Java代码经验来查阅。本文章主要以总结式写法编成。
大部分内容为示例提供，没有详细讲解逻辑

基础编码示例和说明部分

1. Hello,World 简单的输出

main 方法默认是当前项目的起始点，用于启动和运行项目程序，在Kotlin中使用 fun main (主要方法)的方式来定义main方法。

print(#exp) exp->内容
println(#exp) exp->内容

// HelloWorld/HelloWorld.kt

/**
 * fun main指main方法
 */
fun main() {
  /* 
  可直接使用的方法 println 输出方法
  在右边括号中放入一些内容，这些内容将会在运行 main方式时
  打印到 Terminal / Console / 命令指示符 / Win + R 这种的黑窗口中
  */
  println("Hello, world!")
}
/* 运行时将会输出:
Hello, world!
*/

方法内部使用 println 来进行换行输出，或使用 print 来进行非换行输出

2. Var 和 Val 来定义量

在Kotlin中 Var 用于定义变量， val 用于定义常量
即 var 声明的内容可以改变，val 声明的内容不可以改变

var #name = #value
val #name = #value
name -> 量的名称
value -> 量的值

// VarAndVal/Vals.kt
/**
 * Main方法之后不再赘述
 */
fun main() {
  /*
   声明了变量 sum，并进行加值操作
   */
  var sum = 1
  sum = sum + 2
  sum += 3
  println(sum)
  
  /* 
   声明了变量 whole 是11，该代码将在下下行已注释的代码处报错，因为该量不可以被改变
   取消下下行注释可以查看到效果
   */
  val whole = 11
  // whole = 15 // Error   // [1]
  val fractional = 1.4
  val words = "Twas Brillig"
  println(whole)
  println(fractional)
  println(words)
}
/* 运行时将会输出:
6
11
1.4
Twas Brillig
*/

3. 其他更多的基础性质数据类型

在Kotlin中并未区分如Java的包装类或者基础类，Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言，Kotlin中的类型可以理解上认为都是Java的另一套包装类，Kotlin中由自定义的包装类（类所以类型都是大写开头）组成
Java的包装类是右边部分：

...
char    ->  Char
int     ->  Integer
boolean ->  Boolean
double  ->  Double
...

Kotlin中通过使用 :* 来指定类型，例如使用:Int 来指定当前为Int类型，除此外Kotlin中可以使用 """ 三联双引号开头和 """三联双引号结尾来组成文本域（Java15中和Kotlin当前用法类似）：

[val / var ] #name : #type = #value
name ->量名称
type -> 类型
value -> 值

// DataTypes/Types.kt

fun main() {
  /*
   默认方式时 将会自动检测值的类型
   val whole = 11
   其值会默认检测为Int类型 显示的写法如下
  */
  val whole: Int = 11              // [1]
  val fractional: Double = 1.4     // [2]
  val trueOrFalse: Boolean = true  // [3]
  val character: Char = 'z'        // [4]
  val words: String = "A value"    // [5]
  val lines: String = """Triple quotes let
you have many lines
in your string"""                  // [6]
  // 将变量依次输出az
  println(whole)
  println(fractional)
  println(trueOrFalse)
  println(character)
  println(words)
  println(lines)
}
/* 输出结构如下，之后会使用Output来代替这行解释:
11
1.4
true
z
A value
Triple quotes let
you have many lines
in your string
*/

4. 方法

在Kotlin中 fun 关键词是用来指定方法的。例如刚开始见到的 fun main() ,在方法名称后括号中设定参数信息在括号结束处限定当前方法的值类型即返回值类型，操作于上述量值定义时限定方式相同。

fun #funName ( #params ) : #returnType {
TODO
}
funName ->方法名称
params ->参数
returnType ->返回值类型
todo -> 做某些事儿

// Functions/MultiplyByTwo.kt
/**
 * 将传入数乘以2返回
 * 通过 :Int 来限定返回结果为Int
 */
fun multiplyByTwo(x: Int): Int {  // [1]
  println("Inside multiplyByTwo") // [2]
  return x * 2
}

fun main() {
  val r = multiplyByTwo(5)        // [3]
  println(r)
}
/* Output:
Inside multiplyByTwo
10
*/

再例如无参方法

/**
 * 无参，且没有限定返回值类型
 */
fun sayHello() {
  println("Hallo!")
}
/**
 * 限定返回值类型,Unit类型类似于Java的Void，相关还有Any和Nothing
 */
fun sayGoodbye(): Unit {
  println("Auf Wiedersehen!")
}

在方法实现时仅需单行逻辑便能处理时可以使用缩写方式（类似于Lambda表达式，实现仅单行时，可以忽略大括号）

/**
 * 限定返回值类型的模式
 */ 
fun multiplyByThree(x: Int): Int = x * 3
/**
 * 不限定返回值类型的模式
 */ 
fun multiplyByFour(x: Int) = x * 4

5. IF判断逻辑

基础判断逻辑和Java相同支持if else if else 格式。除此之外Kotlin还支持使用 and和 or关键词来代替 & 和 | 在非短路处理时可用（短路处理：即&& 和 ||在判断时当前半段结果可以影响整个表达式时跳过后续判断，具体可搜索 && 和 & 区别）

if (#exp){
todo
} else if ( #exp ){
todo
}

exp条件

fun main() {
  val n: Int = -11
  if ((n > 0) and (n*-1 > 0))
    println("It's positive")
  else if (n == 0)
    println("It's zero")
  else
    println("It's negative")
}

6. 字符模板

用于省略 “” + “” 等操作，使用 $ 操作符访问当前操作范围内的所有量值，并可使用 ${}

"$variable"
"${variable}"

val nowYear = "2022"
println("Hello "+ nowYear + ", Happy New Year")
// 例如上述等拼接逻辑时Kotlin采用的更简单的拼接逻辑通过
println("Hello $nowYear, Happy New Year")
println("Hello ${nowYear + 1}, Happy New Year")

7.数值的上下限和其他格式

在Kotlin中可以使用下划线 _ 来连接数值

1_00000_000_00

fun main() {
  val million = 1_000_000  // Infers Int
  println(million)
}
/* Output:
1000000
*/

整值运算 / 和 % 于Java相同， / 运算时会去除余数，% 来进行求余计算

fun main() {
  val numerator: Int = 19
  val denominator: Int = 10
  println(numerator / denominator)
  println(numerator % denominator)
}
/* Output:
1
9
*/

数值上限与Java相同
Int 类型最大值为 2147483647 最小值为 -2147483648
Long类型最大值为 9223372036854775807 最小值为 - 9223372036854775808
在二进制中首位被当作符号标识符（±），最大值比最小值去除符号后还少1，因为0 也被当做正数，最后算起来两边相同。具体情况可以参考 Int溢出问题

8. Boolean值

除去额外的操作关键词外一致，用于进行与或非操作
Boolean值用于表达当前的结果是否，包含两个结果值 true , false ，如字面意思对应着正确的 / 真的，不正确的 / 假的。
在二进制计算机中单个节点只有是否通电两种结果对应着 0 和 1。与Boolean值涵盖范围一致，所以在数据库存储时有时会使用 Byte(1) / 1位 / 0或1 来代替存储Boolean值，相对应的Java中大部分时候 Boolean也是仅占用 1 位 (注意：位 / Bit 区别于字节/Byte)
位，字节，Int数值：

中文名	字符	大小	说明
位	Bit	1bit	计算机中每个电路节点的表现,单个电子元件表现出的开关与否
字节	Byte	8bit	计算机中8位分为一组，字节也是大部分计算机处理的最小单位，也就是说1个字节的数据在数据存储时会使用8个固定的电路元件来组成一组来表示一个值
整数	Int	4 byte / 32 bit	四个字节的值

Boolean占用确实是仅仅需要 1 位即可，但是在计算机中也只能用最小单位进行存储即 1byte，1byte相比于 1bit 多的部分就用空白填充。

Boolean所需要
0
1
在计算机中，实际最小8位所以Boolean存储时即 _ 代表上面是空的
_ _ _ _ _ _ _ 0
_ _ _ _ _ _ _ 1
计算机中仅能存储 0 和 1 两种值所以上方的 _ 会按计算机中默认的空值方式展现即
0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1

扩展：Java中Boolean长度并没有明确的定义，即并非固定是1字节来存储，建议日后再来了解，也可以参考这个帖子帖子在这里

true / false

// Booleans/EvaluationOrder.kt

fun main() {
  val sunny = true
  val hoursSleep = 6
  val exercise = false
  val temp = 55

  // [1]:
  val happy1 = sunny && temp > 50 ||
    exercise && hoursSleep > 7
  println(happy1)

  // [2]:
  val sameHappy1 = (sunny && temp > 50) ||
    (exercise && hoursSleep > 7)
  println(sameHappy1)

  // [3]:
  val notSame =
    (sunny && temp > 50 || exercise) &&
      hoursSleep > 7
  println(notSame)
}
/* Output:
true
true
false
*/

9. 重复执行和循环

用于重复执行部分逻辑，在程序用于替代需要反复进行相同操作的内容，使用一个时机来控制是否仅需重复操作，时机也是对应的条件，例如没下课的情况下需要一直学习，没下班的情况需要进行工作。
Kotlin中可以使用 while ,do-while来进行循环操作。while字面意思在某个区间时做什么什么。do-while 值先做一下之后在去决断在某个区间时做什么什么。

while( #exp ){ todo }
do while( #exp ){ todo }
exp -> 条件
todo -> 做某些事儿

// RepetitionWithWhile/WhileLoop.kt
/**
 * 一个提供条件的方法，用于判断给这个方法传入的数据是否小于100
 */ 
fun condition(i: Int) = i < 100  // [1]

fun main() {
  var i = 0
  // while循环在 i < 100 时
  while (condition(i)) {         // [2]
    // 输出 一个 .
    print(".")
    i += 10                      // [3]
  }
}
/* Output:
..........
*/

do-while

fun main() {
  var i = 0
  do {
    print(".")
    i += 10
  } while (condition(i))
}
/* Output:
..........
*/

do-while和while不理解的朋友可以将condition修改为输出即
fun condition(i: Int){ print(1); return i < 100}

10. For循环和区间操作方式

除去 do-while 以及 while 来进行外还有 repeat 和 for循环方式对应Java中的 forin ,for 循环可以对任何提供迭代器（iterator）的对象进行遍历。在仅支持 forin 的Kotlin中使用 .. 区间、until 到某处为止等等额外关键词来解决复杂循环操作。

for(#item in #items)
repeat( #exp ){ todo }

1 .. n -> 1 , 2 , 3 , 4 , … , n
1 until n -> 1 , 2 , 3 , 4 , … , n-1
n downTo 1 -> n , n-1 , n-2 , … , 2 , 1
step n ↓
0 until 10 step 3) -> 0 , 3 , 6 , 9

n ≤ .. ≤ n1
n ≤ until ＜ n1
n ≥ downTo ≥ n1

// LoopingAndRanges/ForWithRanges.kt

fun showRange(r: IntProgression) {
  for (i in r) {
    print("$i ")
  }
  print("    // $r")
  println()
}

fun main() {
  showRange(1..5)
  showRange(0 until 5)
  showRange(5 downTo 1)          // [1]
  showRange(0..9 step 2)         // [2]
  showRange(0 until 10 step 3)   // [3]
  showRange(9 downTo 2 step 3)  
  repeat(2) {
    println("hi!")
  }
}
/* Output:
1 2 3 4 5     // 1..5
0 1 2 3 4     // 0..4
5 4 3 2 1     // 5 downTo 1 step 1
0 2 4 6 8     // 0..8 step 2
0 3 6 9     // 0..9 step 3
9 6 3     // 9 downTo 3 step 3
hi!
hi!
*/

以及可转化为Int的Char类型

fun main() {
  for (c in 'a'..'z') {
    print(c)
  }
}
/* Output:
abcdefghijklmnopqrstuvwxyz
*/

11. 单独使用 in 关键词

字面意思在什么之间。在用于for中时，与for组和成在某某之间的每一个；单独使用时用作逻辑判断，判断是否是在某一些之中。

#onein#others
#one!in#others

/**
 * 判断是否是0-9其中一个
 */ 
fun isDigit(ch: Char) = ch in '0'..'9'

/**
 * 判断是否不在0-9之中
 */
fun notDigit(ch: Char) =
  ch !in '0'..'9'               // [1]

/**
 * 判断Double值是否在 1.0 - 10.0之间
 * 其中 1.0 .. 10.0会转换成
 * 1.0 , 2.0 , 3.0 , 4.0 , ... , 10.0
 */   
fun inFloatRange(n: Double) {
  val r = 1.0..10.0
  println("$n in $r? ${n in r}")
}

fun main() {
  println(isDigit('a'))
  println(isDigit('5'))
  println(notDigit('z'))
  println("---------------")
  println('t' in "kotlin")
  println('a' in "kotlin")
  println("---------------") 
  inFloatRange(0.999999)
  inFloatRange(5.0)
  inFloatRange(10.0)
  inFloatRange(10.0000001)
}
/* Output:
false
true
true
---------------
true
false
---------------
0.999999 in 1.0..10.0? false
5.0 in 1.0..10.0? true
10.0 in 1.0..10.0? true
10.0000001 in 1.0..10.0? false
*/

12. 表达式语句，行内语法

在Kotlin中方法是永远都有返回值的，类似于Java中Void的结果时，返回值类型为Unit

fun unitFun() = Unit

fun main() {
  println(unitFun())
  val u1: Unit = println(42)
  println(u1)
  val u2 = println(0) // Type inference
  println(u2)
}
/* Output:
kotlin.Unit
42
kotlin.Unit
0
kotlin.Unit
*/

当代码块最后一行结果仅为值的时候会自然抛出当作返回值，若最后一行为print等仅操作性函数会返回 Unit ,即 print 返回值为 Unit

fun main() {
  val result1 = if (11 > 42) 9 else 5

  val result2 = if (1 < 2) {
    val a = 11
    a + 42
  } else 42

  val result3 =
    if ('x' < 'y')
      println("x < y")
    else
      println("x > y")

  println("-------------------")
  println(result1)
  println(result2)
  println(result3)
}
/* Output:
x < y
-------------------
5
53
kotlin.Unit
*/

13. 再次示例一下 i++ 和 ++i

// ExpressionsStatements/PostfixVsPrefix.kt

fun main() {
  var i = 10
  // 打印的时候 i 还是老值，打印之后在加1
  println(i++)
  // 上一行打印过后， i值已经变大
  println(i)
  var j = 20
  // ++j 时，先给结果加1然后，在打印
  println(++j)
  // 此时两处结果一样
  println(j)
}
/* Output:
10
11
21
21
*/

代码可以直接使用但是不要进行复制发布操作，作为一名开发人员已经见识过了百度一下一整页全是一样的内容。本末倒置。为了方便开发而来，但是影响了开发难度会很难以接受

课程插件和Kotlin课节安装

所需工具:

IntelliJ IDEA
安装当前工具的可联网电脑
一个翻译网站

插件安装步骤

1.1. 点开设置界面后查找Plugins组件打开项目后的设置界面
1.2. 安装插件
首先进入左方 Plugins 组件选项 -> 在上方选择 Marketplace 来安装新组件，已安装的组件处于 Installed 中。下一步，在搜索框区域输入EduTools，等待出现可选择的组件后点击选中，选中后在最右边会出现对应的组件信息，点击 Install 按钮即可安装，安装后会变成 Installed
在这里插入图片描述
1.3. 重启后打开课程
等待完全安装后会提示重启，之后点击 File 时界面会多出一个新的选项 Learn And Teach，在 Browse Course 中浏览和下载可用课程（当然也可以选择Create来创建自己的课程说明给别人，好为人师）
浏览课程确认
1.4. 下载新课程和打开已下载的课程
在左侧 All Courses 中可以进行全部课程的浏览，My Courses 中仅查看已下载的课程。点击Open即可开始您的课程学习
选择课程

2.1. 另一种界面的安装
在没有打开项目时的界面首先进入左方 Plugins 组件选项 -> 在上方选择 Marketplace 来安装新组件，已安装的组件处于 Installed 中。下一步，在搜索框区域输入EduTools，等待出现可选择的组件后点击选中，选中后在最右边会出现对应的组件信息，点击 Install 按钮即可安装，安装后会变成 Installed
没有打开项目时安装插件的方式
2.2. 安装完毕打开课程
等待完全安装后会提示重启，之后界面会多出一个新的选项 My Courses，在 Start New Course 中下载新课程，下方红框区域继续学习课程，示例图中展现了继续学习AtomicKotlin的情况
选择课程

学习课程

继续上面所说，选择课程后，点击Open按钮即可开始对应课程。这里以AtomicKotlin为例，这个课程也是Idea官方推荐的一种学习方式（Kotlin就是IDEA家的）

展开课程之后的图标说明

图标	说明
	大章节
	小章节
	演示
	练手环节
	额外的一些操作指南

总览介绍

在工作区域左边是您的课程列表，右边是您的当前说明，中间是您的编码区域。
通常每个大章节会分出很多小章节（之后也会继续更新后面几个大章节的内容到CSDN中，可能会需要一段时间，近期项目下来了），每个小章节通常会由 演示、练习、扩展说明 组成。

在每个 Examples / 例子区域中都会包含一或一个以上的示例代码以供餐看（请不要忘记都点开看下，以防忽略掉部分内容），
之后会有一些 Exercise / 训练来供学习人员操作来实操逻辑代码，
每个章节最后会有一到两个，可能更多的额外说明区域来做简单化或一些有用的代码提示。例如可用快捷键，或者一些缩写等等。注意：说明区域基本都会在右边的Description窗口进行提示

课程展示

虽说右边的说明通常都会很久加载出来，这种情况不太影响学习问题不大，但是以普遍理性而论这个加载时间确实有些长。

演示
训练
扩展说明

关于练习的结果答案提示

在当前Kotlin课程中，课程会使用大数量的测试数据来验证您的逻辑是否达标，编码不一定非要于官方一样，只要能够做的逻辑统一，能够处理相同的数据即可。

验证答案
在 Description 中点击 Check 按钮
查看官方示例
点击 Peek Solution，下方示例图为 IntelliJ IDEA 2021.3.3版本查看情况，之前的版本会在弹窗中展示出来。

最后为课节的官方网站和目录，包含详细说明和介绍，跟组件内的课程配套使用。仅免费部分，建议优先跟插件版配套学习，学到付费区域时仅使用插件版本，插件版可以免费学习全部。就是说只让你上课了免费，但是教材要付费，大概34美刀 ≈ ￥210。不推荐购买死贵死贵的
官方教材