# 前言
**以一个`java`老鸟的角度，如何去看 `kotlin`。 Java源代码应该如何用Kotlin重构。 如何正确学习kotlin并且应用到实际开发中。本文将会探究。**
**本文分两大块，重难点和潜规则。**
**重难点**：Kotlin中可以独立出来讲解的**大块知识点**。提供单独Demo。这部分大多数是Kotlin开创的新概念（相比于Java）。
**潜规则**：Kotlin是谷歌用来替换Java的，它和java百分百完全兼容，但是实际上java转成kotlin之后，需要我们手动修改很多东西，甚至某些部分必须打散重构来达到最优编码。其中，kotlin的某些特性和java不同，甚至完全反转。这部分知识点比较零碎，单独Demo不方便提供，就以小例子的形式来写。
- 重难点
- lambda以及操作符
- 高阶函数以及操作符
- `Kotlin`泛型
- 集合操作
- 协程
- 操作符重载
- 潜规则
- Kotlin文件和类不存在一对一关系
- 共生体
- 继承
- 修饰符
- 空指针问题
## 潜规则
从Java转到kotlin，基本上都会存在java代码与kotlin共存的问题。而且为了快速转型，可能会直接把java类转成kotlin类，而这个过程中，涉及到java和kotlin的交互，往往会磕磕碰碰，以下总结了一部分 java kotlin交互方面的问题.
### Kotlin文件和类不存在一对一关系
kotlin的文件，可以和类名一致，也可以不一致。这种特性，和c++有点像，毕竟c++的.h 和 .cpp文件是分开的。只要最终编译的时候对的上，文件名其实无所谓的。Java中，一个类文件的类名和文件名不一致，如果是public类，就会报异常。
在kotlin中，可以写成一致，如：
不一致：
这样做的意义在于：
如果有很多个行数很短的类：在java中可能要占用大量的文件个数（Java中可以用内部类的形式解决），kotlin中则可以把这些类都放到同一个kt文件中，不用内部类也能解决。
### 共生体
Java中的静态 static关键字，在kotlin中不复存在，作为替换，Kotlin提出了共生体的概念。如果是kt文件去调用kt类的“静态”方法（不依赖对象），则要求后者的类结构中增加一个 companion object 成员变量。并且可以在 成员中写上 你想要定义的"静态"成员变量和成员方法
```kotlin
class Test001(_name: String) : Person(_name) {
companion object {
const val s: String = ""
const val s2: String = ""
fun t1(){
}
}
}
fun main(){
Test001.s
Test001.t1()
}
```
注：每一个kotlin类中，只能有一个共生体对象.
但是在java调用kt的"静态"成员方法时，必须带上共生体，但是，访问"静态"成员变量，则不能带：
```Java
public static void main(String[] args) {
Test001.Companion.t1();//Java访问kt的t1()共生体方法，必须带上Companion
String s2 = Test001.s;// 而访问共生体成员变量，不能带Companion
}
```
好纠结。为什么要这么设计。算了。查了一下kt反编译之后的Java源码：
共生体变成了Java类中的静态内部类，包含t1()方法。而s，s2 则是普通的静态变量。
### 修饰符
修饰符指的是 类 和 成员变量，成员方法 前面的 权限访问关键字。原 Java拥有 private ,protected，default ,public ,访问权限分别为： 本类内部，同包名或子类，同包名，全局。
然而，kotlin新增了一个概念，internal ，表示，**相同Module内可访问**，跨Module则不行。
并且，java和kotlin的 private ,protected，default ,public 的访问权限还有区别，但是我这里就不详述了，因为我觉得意义不大。能不能访问，写代码的时候编译器会告诉你，当场警告你，你就会修改代码。如果有问题。可以把kotlin Decompile成Java代码自己去对比试试。如有需要，后期再说吧。
### 空指针问题
通常要快速的将 旧java代码转化成kotlin代码，是拷贝java代码粘贴到kotlin文件内，让as自动转化，但是这种方式，容易造成很多空指针问题，有一些是很直白的报了编译错误，而有一些则是隐藏起来，等到程序运行时才会报错。直接报错的就不提了，下面演示隐藏的空指针问题：
Kotlin类：
```kotlin
class Student(name:String) {
var name: String = name
fun showName(tag: String) {
println("$tag : $name")
}
}
```
Java调用kt：
```java
public class Main {
public static void main(String[] args) {
Student s = new Student("zhou");
s.showName(null);
}
}
```
此时，如果运行main函数，就会报出：
告诉我们参数tag不可为null。但是奇怪的是，在java代码中，居然不会报编译错误。贼特么诡异。
解决方案：
在方法参数后面加上问号，变成这样：
### 没有基本数据类型
Kotlin之中没有基本数据类型，它只有：
`Int，Short，Long，Float，Double，Byte ，Char，Boolean` 这样的包装类型。
为什么没有？没有必要去纠结，但是只提供包装类型有一个好处，那就是 方便扩展函数的定义。
我们可以很轻松地对 Int，类型去扩展函数。
比如： `Kotlin`自带了很多扩展函数：
这是系统定的，我们也可以自己来定义：
```kotlin
fun Int.plus100(): Int {//自定义扩展
return this + 100
}
fun main() {
val a: Int = 20
println("${a.plus100()}")
}
```
### 继承
在用kt重构部分模块的过程中，我发现频繁出现下面的问题:
Kotlin基类:
```kotlin
abstract class Person(name: String) {
var name: String? = name
}
```
Java子类：
由于我是从基础类开始重构，所以，在原先的Java代码中频繁出现了类似这种 访问权限不足的问题。一个一个去改成setName函数，工作量巨大。后来找到一个办法：
在kotin中加入 @JvmField 变成这样：
```kotlin
abstract class Person(name: String) {
@JvmField
var name: String? = name
}
```
@JvmField可以让 kotlin的成员属性变成公有的，kt转化成java时，会是如下这样:
```Java
public abstract class Person {
@JvmField
@Nullable
public String name;
public Person(@NotNull String name) {
Intrinsics.checkParameterIsNotNull(name, "name");
super();
this.name = name;
}
}
```
兼容原先的Java代码。不用大面积修改了。
### 默认支持可选命名参数
了解高级语言语法的同学肯定知道 **可选命名参数**和 **可选位置参数**，经测试: Kotlin的任何方法（包括构造方法和普通和方法），可以这么写：
```kotlin
fun test001(s: String, s1: String) {
println("$s - $s1")
}
fun main() {
test001(s = "1111", s1 = "2222") //卧槽，Kotlin默认支持 可选命名参数
}
```
这种特性可以很好的避免了Java中出现的一个方法包含N个参数 把人眼睛看花的情况：
```java
private void test(String s1, String s2, String s3, String s5, String s6, String s7, String s8, String s9, String s10, String s11, String s12) {
//...
}
```
比如如上面所示，一个方法，有12个String参数，看多了会骂娘，谁特么写的。然而，用kotlin：
```kotlin
fun test(s1: String, s2: String, s3: String, s4: String, s5: String, s6: String, s7: String, s8: String, s9: String, s10: String, s11: String, s12: String) {}
fun main() {
test(s1 = "",s2 = "",s3 = "",s4 = "",s5 = "",s6 = "",s7 = "",s8 = "",s9 = "",s10 = "",s11 = "",s12 = "")
}
```
直觉上这种语法，融入了 建造者设计模式。让同一个函数的多个参数不再混乱。当然如果你怀旧的话，你也可以用原始方法，12个string依次摆下去。反正我不会这么做。
### 类，成员方法 默认封闭
和Java相反，kotlin给类，成员方法 都采用了默认封闭原则。具体体现为：类，默认不可继承，成员方法默认不可重写（继承时）。如果要继承类，或者重写父类方法，必须在父类中手动加入 `open ` 关键字，子类中重写方法必须加上`override`关键字 ：
kotlin父类：
```kotlin
open class Student(name:String) {
var name: String = name
open fun showName(tag: String?) {
println("$tag : $name")
}
}
```
kotlin子类：
```kotlin
class StudentExt(name: String) : Student(name) {
override fun showName(tag: String?) {
super.showName(tag)
println("xxxxx")
}
}
```
### Kotlin中方法和函数的区别
函数，是c/c++的词汇，而方法，则是Java里面。现在kotlin中同时存在了方法和函数，那么区别在哪里？
通常我们人为：在Kotlin类内部，称为**成员**方法。而在类外部定义的，则成为**全局**函数（这里就不用去讨论kotlin变成java之后长什么样）。
应用到具体场景，一句话解释清楚:
> A.kt 中有一个A类，它有a()成员方法。 同时我们可以在 B.kt中给A类扩展一个函数。创建一个A类对象之后，我们既可以调用a()成员方法，又可以调用它的扩展函数。
A.kt
```kotlin
class A {
fun a() {}
}
```
B.kt
```kotlin
fun A.foo(){}// 扩展A的一个函数
fun main() {
val a = A()//创建对象
a.a() //调用成员方法
a.foo() //调用扩展函数
}
```
# 结语
Java转kotlin，给我的感觉就是：
1. kotlin对于一个function内部的管理更加有条理，它引入了 scope 作用域的概念，利用基于lambda表达式的高阶函数，把function内部的代码块管理起来，让代码可读性更高
2. kotlin的代码行数会大大减少，因为kotlin设计了很多顶层函数，高阶函数，使用大量的链式调用，把可以占用行数的代码都浓缩在一行。这样做的结果是，一行代码的信息量大大增加，对于新手是噩梦，但是对于kotlin熟手，会感觉很美妙。
3. 关于协程，本文只做了最简单的管中窥豹描述，未曾详细说到的东西还有很多。但是可以肯定一点，协程的出现，颠覆了 android开发的异步编程思维，原本很多不敢想的，原本很多java实现起来要绕很多路的，在kotlin上都可以很优雅地实现。
# 参考资料
Kotlin in Action 下载pdf书籍（https://www.7down.com/soft/209822.html）
菜鸟教程 https://www.runoob.com/kotlin/kotlin-tutorial.html
kotlin中文站 https://www.kotlincn.net
