kotlin 与 java 对比

一、

kotlin:

1 data class Artist(
2         var id: Long,
3         var name: String,
4         var blog: String)

上面类的定义在声明属性时，Kotlin采用默认访问修饰符public，而Java是private，如果kotlin也是private，那同样得定义一系列的set()/get()，不然在类外面无法通过对象获取属性。

先看参数列表，这里其实对应的是Java中的有参构造函数。如果Kotlin定义类时有参数列表，那么新建对象时必须传入形参值，不像Java有两种方式（1 先建一个无参对象，再通过set()来给属性赋值；2 直接通过参数列表创建对象）。

而类名前的data关键字，是显示声明该类是作为数据类使用，通过toString()打印的结果可以看出区别，打印语句：

1 println("artist.toString(): " + artist.toString())

不加data结果：

artist.toString(): Artist@61bbe9ba

加上data结果：

artist.toString(): Artist(id=1, name=Dylan, blog=http://www.cnblogs.com/tgyf/)

可以看到toString()是Kotlin自动生成的，如果类声明不加data，只会打印出一串数字（应该是类的内存地址），而不是当前对象的属性信息。

二、变量空安全

Kotlin：

1 var str1: String = null  //Null can not be a value of a non-null type String
2 var str2: String? = null  //str2 can be null
3 var str3 = "testNull"  //non-null--String type
4 var str4 = null  //null
5 var str5: String  //non-null--String type
6 str5 = "testNull"  //assigned String value
7 var str6  //no type or initialization
8 var str7: String? = "testNull"

结合代码中的注释，我们来看这四行代码想表达的意思。

第1行，编译错误，kotlin规定如果显式指明了str1的类型，这里是String，声明时必须同时指定是否允许为空值（null），不加问号"?"表示不允许为null；

第2行，编译通过，作第一行代码的另一种情况，加了问号，并赋值为null；

第3行，编译通过，隐式赋值为"testNull"，Kotlin会自动推断出str3类型为String，之后便不可再更改了，即不可再赋值为1这种整形数据；

第4行，编译通过，隐式赋值为null，那么str4就一直为null了；

第5-6行，编译通过，前者只是指定类型，没有赋值；后者赋予str5 String类型值"testNull"同样不能赋值为其他类型值；

第7行，编译错误，既没有指定类型，也没有隐式地进行初始化，错误的原因应该是编译器不知道str6类型是什么，不能对其分配空间；

第8行，不需多解释，str7可为null，同时赋值为"testNull"；

2.1、对于声明为String?的变量，访问属性时会涉及到问号和双感叹号两个操作符（"?"和"!!"），前者表示执行后面代码前先检查变量赋值情况，后者表示不检查而直接访问属性（危险）。

要理解清楚，最好的方法就是让代码说话。

 1 var str2: String? = null
 2 println("str2.length: " + str2.length)  //compile error
 3 println("str2?.length: " + str2?.length)  //print null
 4 println("str2!!.length: " + str2!!.length)  //run exception
 5 if (str2 != null) {
 6     println("str2!!.length: " + str2!!.length)  //don't run
 7 }
 8 str2 = "testNull"  //assign
 9 println("str2.length: " + str2.length)  //print 8
10 println("str2?.length: " + str2?.length)  //print 8
11 println("str2!!.length: " + str2!!.length)  //print 8
12 if (str2 != null) {
13     println("str2!!.length: " + str2.length)  //print 8
14 }

第2行，编译错误，因为之前只是将str2声明为可以是null同时赋值为null，所以紧接着访问其length属性是不允许的；

第3行，输出"null"，加了问号就会先检查str2的赋值情况，如果是null，就不继续执行后半部分（.length），直接返回null；

第4行，运行异常，不检查的后果就是通过null引用去访问length属性；

第5-7行，不会执行到if代码块中，这里用了类似Java中的做法；

第9行，输出"8"，到这里，相比能体会到Kotlin的智能之处了，在第八行对str2赋值之后，就不会再像第二行那样报编译错误了；

第10-14行，不需多解释，不为null的str2，通过三种方式均可访问length属性；

那么这里有一个疑问，用"!!"来访问属性是不明智的选择，好像"?"更稳妥一些？毕竟后者在变量是否null的情况下都能做出相应的处理。我所能想到的需要用"!!"的场景之一是：当一个变量在声明时不能马上初始化，而在真正用到时又必须是非null的。这种情况应该并不少见吧，那次此时"!!"就派上用场了。

先举一个简单粗暴的列子：

1 var str: String? = null
2 //do something to assign str
3 val str2: String = str!!

当声明str的时候还需后面的处理结果给它赋值，而声明str2为非null，就必须以str!!的形式才能通过编译。

下面再给出Android中Application类单例化代码，就不做解释了。

 1 class App : Application() {
 2     companion object {
 3         private var instance: Application? = null
 4         fun instance() = instance!!
 5     }
 6     override fun onCreate() {
 7         super.onCreate()
 8         instance = this
 9     }
10 }

三、替换、替代

1.extends  用 （冐号）：代替。MainActivity extends Activity,  

　　现在是  MaiActivity ：Activity()

2.interface 用（逗号），代替。 A interface B{}　　　　　　　　

　　现在是  ,B{}

3.override 不现进 注解，而是用到了方法中 　　　　　　　　　　　

　　这样写 override fun onCreate(saveInstanceState:Bundle?)

4. 没有switch case default了，　　　　　　　　　　　　　　　　　　　　

　　现在用when、-> else组合

5.kotlin没有object类　　　　　　　　　　　　　　　　　　　　　　

　　现在是Any()没有Object()

7.不在有分号，　　　　　　　　　　　　　　　　　　　　　　　　　　

　　不在有分号，不在有分号，不过可以写的

8. java中没能返回值是void,返回值写在小括号左面　　　　　　　　　　

　　现在改成空方法是Unit,方法用fun1, fun2,代替， 并且返回值要写在小括号后面

　　　　　　fun Unit(x: Any, y: Any) {

　　　　　　fun Unit(x: Any, y: Any): Int{
　　　　　　返回值可以用一个表达式写fun add(x: Int,y: Int) : Int = x + y
9.jave中每珍上对象都要new 　　　　　　　　　　　　　　　　　　
　　kotlin不需要new这个关键字
10.在java中给控件不能直接赋值，　　　　　　　　　　　　　　　　
　　在kotlin里 通过import kotlinx.android.synthetic.main.demo.*
　　text1.text = "hello world kotlin" 这样就完成了"hello world kotlin"
11.for循环也不一样了 在java中是这样写的for(int i = ; i < 10; i++)　　　　
　　Kotlin是这样写的for (i in 0..99) {
12.java中方法在括号，　　　
　　　　new Handler().postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        main_srl.setRefreshing(false);
                    }
                }, 5000);
　　kotlin是这样写的
　　Handler().postDelayed({ main_srl!!.isRefreshing = false }, 5000) }

13 .->的用法
　　java中是这样写的
        recyclerViewAdapter.setOnItemClickedListener(new HeaderRecyclerViewAdapter.onItemClickedListener() {
            @Override
            public void onItemClick(View view, int position) {
                Toast.makeText(MainActivity.this, "position " + position, Toast.LENGTH_SHORT).show();
            }
        });
　　kotlin这样写的
　　recyclerViewAdapter.setOnItemClickedListener { view, position -> Toast.makeText(this@MainActivity, "position " + position, Toast.LENGTH_SHORT).show() }

14 . 强制转换
　　java中  mHeader(View)
　　kotlin 中是mHeader as View


Add-non-null aserted 就是改变为不是空的 mHeader!!
Case expressino      就是强制转换 mHeader as View

15.变量

　　1.java中分为二类（基本，引用）八种（byte short int long flout double char boolean）

　　2.kotlin 中分有以下不同之睡

　　　　1.基本类型中 java中有的kotlin也有，就是不能给一个int赋值为double

　　　　　　var i Int = 1;

　　　　　　var d Double = i .toDouble();  //其它也类似这样没有java中的自动提升，强转的说法了！！！

　　　　2. ｜ & 或 和 和 改为了  or 和 and

　　　　　　var testOr = Flag or Flags

　　　　　　var testAnd = Flag and Flags

　　　　3.变量 var  val  (这个类似java中的final)

　　　　4.属性  kotlin没有get,set方法，直接赋值，直接使用

16.java中asycTask 
　　kotlin 中 async{
　　　　run(){
　　　　　　uiThread{...}
　　　　　　}}

17.with函数
　　with是一个非常有用的函数，它包含在Kotlin的标准库中。它接收一个对象和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。这表示所有我们在括号中编写的代码都是作为对象（第一个参数）的一个扩展函数，
　　我们可以就像作为this一样使用所有它的public方法和属性。当我们针对同一个对象做很多操作的时候这个非常有利于简化代码。

18.增强For循环
java中： for(集合 变量：集合名)
kotlin中：for（变量名 in 变量集合）

19.在java中是没有""",这样的符号
　　kotlin中：
　　　fun main(args:Array<String>){
    val text = """
    Tell me and I forget.
    Teach me and I remember.
    Involve me and I learn.
    (Benjamin Franklin).
    """.trimMargin()
    print(text)
}

20.contait 
　　java String中contains
　　kotlin
　　 if ("ddd" in array) // collection.contains(obj) is called
        println("Yes: array contains ddd")

21.Java 定义 final 变量的写法：
Java中这么写 final String string = "hello"
Kotlin 当中应该这么写 const val string:String = "hello"

22.如何定义函数
Java 当中如何定义函数，也就是方法，需要定义到一个类当中
public boolean testString(String name){...
等价的 Kotlin 写法：
fun testString(name:String) :Boolean{...

23.如何定义数组
Java 的数组非常简单，当然也有些抽象，毕竟是编译期生成的类：
String[] names = new String[]{"a","b",}
Kotlin 的数组其实更真实一些，看上去更让人容易理解：
val name:Array<String> = arrayOf{"a","b"}//避免byte short 拆箱，装箱  写法为 XArray，例如 Int 的定制版数组为 val ints = intArrayOf(1,2,3)
val emptyStrings :Array<String?> = arrayOfNulls(10)//Array T 即数组元素的类型。另外，String? 表示可以为 null 的 String 类型

24.如何写变长参数
Java 的变长参数写法如下：
void holle(String...names){...
Kotlin 的变长参数写法如下：
fun hello(vararg names:String){...

25.如何写三元运算符
Java 可以写三元运算符：
int code = isSuccessfully?200:400;
Kotlin 该怎么写呢?
int code = if(isSuccessfully) 200 else 400

26.如何写 main 函数
Java 的写法只有一种：
class MainJava{
　　public static void main(String []args){
　　　　...
Kotlin，main 函数的写法如下：
class MainKotlin{
　　companion object{
　　　　@jvmStatic
　　　　fun main(args:Array<String>){
　　　　...

27.如何延迟初始化成员变量
Java 定义的类成员变量如果不初始化，那么基本类型被初始化为其默认值  int 0;boolean false; String null;
public class Hello{
　　private String name; 
Kotlin 当中直译为：
class Hello{
　　private var name:String? = null;//如果不使用可控类型，需要加 lateinit 关键字
class Hello{
　　private lateinit var name:String //lateinit 是用来告诉编译器，name 这个变量后续会妥善处置的。

28.如何获得 class 的实例
java中可以 类名.class ,对象.getClass();Class.forName("");
刚刚接触 Kotlin 的时候，获取 Java Class 的方法却是容易让人困惑:
class Hello
val clazz = Hello::class.java  // 拿到的是 Kotlin 的 KClass
如果想要拿到 Java 的 Class 实例，那么就需要前面的办法了。

 29.在Kotlin中写上下文不再是类名点this了而是

　　hsMain!!.OnSelectList { text -> Toast.makeText(this@MainActivity, text, Toast.LENGTH_SHORT).show()

30.伸展 spread符是什么鬼  （在数组前面加上 *），Java中可是没有

val a = arrayOf(1, 2, 3) val list = asList(-1, 0, *a, 4) 

31. ？.和 ！！. 的区别？
　　首先声名在java中是没有这个语法的，
　　在kotlin中说下它们之间的不同
　　if( is != null) is.change(); 在kotlin中是这样的 is?.change()    
　　!!.就是非空判断了