学习地址：
https://classroom.udacity.com/courses/ud9011
https://www.kotlincn.net/docs/reference/
Kotlin的好处：
1.Statically typed, object-oriented, modern programming language
2.Properties and extensions for classes
3.Created from developers for developers
4.Concise,much less boilerplate code than some other languages
5.Increased null safety with nullable and non-nullable data types
6.Open sourced
7.Supports lambdas and higher-order functions
8.Fully compatible with the Java language,so that you can migrate over time and continue
9.Officially supported for Android development,and included with IntelliJ and Android Studio
准备环境
安装JDK，Intellij（也可以直接用andorid studio）
用于 Android 开发的工具
Kotlin 团队为 Android 开发提供了一套超越标准语言功能的工具：
1.在 Kotlin 中则需要添加 kotlin-kapt 插件激活 kapt，并使用 kapt 替换 annotationProcessor
apply plugin: 'kotlin-kapt'
2.相信每一位安卓开发人员对 findViewById() 这个方法再熟悉不过了，毫无疑问，潜在的 bug 和脏乱的代码令后续开发无从下手的。尽管存在一系列的开源库能够为这个问题带来解决方案，those libraries require annotating fields for each exposed View.
现在 Kotlin 安卓扩展插件能够提供与这些开源库功能相同的体验，不需要添加任何额外代码。
apply plugin: 'kotlin-android-extensions'
3.Anko 是一个提供围绕 Android API 的 Kotlin 友好的包装器的库 ，以及一个可以用 Kotlin 代码替换布局 .xml 文件的 DSL。
4.对于初学Kotlin的开发者而言，编译器提供了贴心的小工具，甚至可以直接把Java代码转换成Kotlin代码。直接把Java代码拷贝到.kt文件中，编译器会弹出如下提示：
我们可以通过 Android Studio工具看到编译的bytecode，kotlin最终会编译成Java字节码
我们还可以把编译出来的Java字节码反编译成Java代码
可见性
Kotlin 中一切都是默认 public 的。并且 Kotlin 还有一套丰富的可见性修饰符，例如：private, protected, internal。它们每个都以不同的方式降低了可见性。
kotlin中的null安全
var a: String = "abc"
a = null // compilation error
var b: String? = "abc"
b = null // ok
Lazy()委托属性
lazy()委托属性可以用于只读属性的惰性加载，但是在使用lazy()时经常被忽视的地方就是有一个可选的model参数：
- LazyThreadSafetyMode.SYNCHRONIZED：初始化属性时会有双重锁检查，保证该值只在一个线程中计算，并且所有线程会得到相同的值。
- LazyThreadSafetyMode.PUBLICATION：多个线程会同时执行，初始化属性的函数会被多次调用，但是只有第一个返回的值被当做委托属性的值。
- LazyThreadSafetyMode.NONE：没有双重锁检查，不应该用在多线程下。
lazy()默认情况下会指定LazyThreadSafetyMode.SYNCHRONIZED，这可能会造成不必要线程安全的开销，应该根据实际情况，指定合适的model来避免不需要的同步锁。
在Kotlin中有3种数组类型：
- IntArray，FloatArray，其他：基本类型数组，被编译成int[]，float[]，其他
- Array<T>：非空对象数组
-
Array<T?>：可空对象数组
kotlin代码：
image.png
对应的java代码：image.png
后面两种方法都对基本类型做了装箱处理，产生了额外的开销。
所以当需要声明非空的基本类型数组时，应该使用xxxArray，避免自动装箱。
基础语法
打印日志
//java
System.out.print("demo print");
System.out.println("demo print");
//kotlin
print("demo print")
println("demo print")
编译期常量
已知值的属性可以使 const 修饰符标记为 编译期常量。 这些属性需要满⾜以下要求：
a.位于顶层或者是 object 的一个成员
b.用String 或原类型 值初始化
c.没有定义 getter
这些属性可以用在在注解中：
const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"
@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { …… }
不可变量和变量
//java
String name = "Variable variable";
final String name = "Immutable variable";
//kotlin
var name = "Variable variable"
val name = "Immutable variable"
null声明
//Java
String otherName;
otherName = null;
//Kotlin
var otherName : String?
otherName = null
空判断
//Java
if (text != null) {
int length = text.length();
}
//Kotlin
text?.let {
val length = text.length
}
// or simply
val length = text?.length
?和!!的区别：kotlin:a?.foo()相当于java:if(a!=null){a.foo();}，kotlin:a!!.foo()相当于java: if(a!=null){a.foo();}else{throw new KotlinNullPointException();}
字符串拼接
//Java
String firstName = "ren";
String lastName = "kuo";
String message = "My name is: " + firstName + " " + lastName;
//Kotlin
val firstName = "ren"
val lastName = "kuo"
val message = "My name is: $firstName $lastName"
当你要输出某个对象的某个属性的时候一定要用{}括起来，正确方法${data.nickname}，错误方式$data.nickname
换行
//java
String text = "First Line\n" +
"Second Line\n" +
"Third Line";
//Kotlin
val text = """
|First Line
|Second Line
|Third Line
""".trimMargin()
三元表达式
//Java
String text = x > 5 ? "x > 5" : "x <= 5";
//Kotlin
val text = if (x > 5)
"x > 5"
else "x <= 5"
操作符
//java
final int andResult = a & b;
final int orResult = a | b;
final int xorResult = a ^ b;
final int rightShift = a >> 2;
final int leftShift = a << 2;
final int unsignedRightShift = a >>> 2;
//Kotlin
val andResult = a and b
val orResult = a or b
val xorResult = a xor b
val rightShift = a shr 2
val leftShift = a shl 2
val unsignedRightShift = a ushr 2
类型判断和转换（声明式）
//Java
if (object instanceof Car) {
}
Car car = (Car) object;
//Kotlin
if (object is Car) {
}
var car = object as Car
var car = object as? Car(表示object非null的时候强转为Car)
类型判断和转换 (隐式)
//Java
if (object instanceof Car) {
Car car = (Car) object;
}
//Kotlin
if (object is Car) {
var car = object // 聪明的转换
}
多重条件
//Java
if (score >= 0 && score <= 300) { }
//Kotlin
if (score in 0..300) { }
in包含上界和下界
更灵活的case语句
//Java
int score = // some score;
String grade;
switch (score) {
case 10:
case 9:
grade = "Excellent";
break;
case 8:
case 7:
case 6:
grade = "Good";
break;
case 5:
case 4:
grade = "OK";
break;
case 3:
case 2:
case 1:
grade = "Fail";
break;
default:
grade = "Fail";
}
//Kotlin
var score = // some score
var grade = when (score) {
9, 10 -> "Excellent"
in 6..8 -> "Good"
4, 5 -> "OK"
in 1..3 -> "Fail"
else -> "Fail"
}
for循环
//Java
for (int i = 1; i <= 10 ; i++) { }
for (int i = 1; i < 10 ; i++) { }
for (int i = 10; i >= 0 ; i--) { }
for (int i = 1; i <= 10 ; i+=2) { }
for (int i = 10; i >= 0 ; i-=2) { }
for (String item : collection) { }
for (Map.Entry<String, String> entry: map.entrySet()) { }
//Kotlin
for (i in 1..10) { }
for (i in 1 until 10) { }
for (i in 10 downTo 0) { }
for (i in 1..10 step 2) { }
for (i in 10 downTo 1 step 2) { }
for (item in collection) { }
for ((key, value) in map) { }
关键字in,until,downTo,step
更方便的集合操作
//Java
final List<Integer> listOfNumber = Arrays.asList(1, 2, 3, 4);
final Map<Integer, String> keyValue = new HashMap<Integer, String>();
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
// Java 9
final List<Integer> listOfNumber = List.of(1, 2, 3, 4);
final Map<Integer, String> keyValue = Map.of(1, "one",
2, "two",
3, "three");
//Kotlin
val listOfNumber = listOf(1, 2, 3, 4)
val keyValue = mapOf(1 to "one",
2 to "two",
3 to "three")
遍历
//Java
// Java 7 and below
for (Car car : cars) {
System.out.println(car.speed);
}
// Java 8+
cars.forEach(car -> System.out.println(car.speed));
// Java 7 and below
for (Car car : cars) {
if (car.speed > 100) {
System.out.println(car.speed);
}
}
// Java 8+
cars.stream().filter(car -> car.speed > 100).forEach(car -> System.out.println(car.speed));
//Kotlin
cars.forEach {
println(it.speed)
}
cars.filter { it.speed > 100 }
.forEach { println(it.speed)}
关键词filter，forEach
方法定义
//Java
void doSomething() {
// logic here
}
void doSomething(int... numbers) {
// logic here
}
//Kotlin
fun doSomething() {
// logic here
}
fun doSomething(vararg numbers: Int) {
// logic here
}
vararg 表示可变参数
带返回值的方法
//Java
int getScore() {
// logic here
return score;
}
//Kotlin
fun getScore(): Int {
// logic here
return score
}
// as a single-expression function
fun getScore(): Int = score
无结束符号
//Java
int getScore(int value) {
// logic here
return 2 * value;
}
//Kotlin
fun getScore(value: Int): Int {
// logic here
return 2 * value
}
// as a single-expression function
fun getScore(value: Int): Int = 2 * value
constructor 构造器
//Java
public class Utils {
private Utils() {
// This utility class is not publicly instantiable
}
public static int getScore(int value) {
return 2 * value;
}
}
//Kotlin
class Utils private constructor() {
companion object {
fun getScore(value: Int): Int {
return 2 * value
}
}
}
// another way
object Utils {
fun getScore(value: Int): Int {
return 2 * value
}
}
Get Set 构造器
//Java
public class Developer {
private String name;
private int age;
public Developer(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Developer developer = (Developer) o;
if (age != developer.age) return false;
return name != null ? name.equals(developer.name) : developer.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
@Override
public String toString() {
return "Developer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
//Kotlin
data class Developer(val name: String, val age: Int)
数据类： data class 编译器⾃动从主构造函数中声明的所有属性导出以下成员： 1.equals() / hashCode() ； 2.toString() 格式是 "User(name=John, age=42)" ； 3.componentN() 函数 按声明顺序对应于所有属性； 4.copy() 函数。 为了确保生成的代码的一致性和有意义的行为，数据类必须满足以下要求： 1.主构造函数需要至少有一个参数； 2.主构造函数的所有参数需要标记为 val 或 var ； 3.数据类不能是抽象、开放、密封或者内部的； （在1.1之前）数据类只能实现接口。 此外，成员生成遵循关于成员继承的这些规则： 1.如果在数据类体中有显式实现 equals() 、 hashCode() 或者 toString() ，或者这些函数在父类中有 final 实现，那么不会生成这些函数，而会使用现有函数； 2.如果超类型具有 open 的 componentN() 函数并且返回兼容的类型， 那么会为数据类生成相应的函数，并覆盖超类的实现。如果超类型的这些函数由于签名不兼容或者是 final 而导致无法覆盖，那么会报错； 从一个已具 copy(……) 函数且签名匹配的类型派生一个数据类在 Kotlin 1.2 中已弃用，并且会在 Kotlin 1.3 中禁用。 不允许为 componentN() 以及 copy() 函数提供显式实现。
原型扩展
//Java
public class Utils {
private Utils() {
// This utility class is not publicly instantiable
}
public static int triple(int value) {
return 3 * value;
}
}
int result = Utils.triple(3);
//Kotlin
fun Int.triple(): Int {
return this * 3
}
var result = 3.triple()
//Java
public enum Direction {
NORTH(1),
SOUTH(2),
WEST(3),
EAST(4);
int direction;
Direction(int direction) {
this.direction = direction;
}
public int getDirection() {
return direction;
}
}
//Kotlin
enum class Direction constructor(direction: Int) {
NORTH(1),
SOUTH(2),
WEST(3),
EAST(4);
var direction: Int = 0
private set
init {
this.direction = direction
}
}
本文参考：https://github.com/MindorksOpenSource/from-java-to-kotlin
上一篇kotlin相关文章：https://www.jianshu.com/p/b9f5ed423613
错误不足之处或相关建议欢迎大家评论指出，谢谢！如果觉得内容可以的话麻烦喜欢（♥）一下
