当前位置: 首页>移动开发>正文

koltin版本 java兼容 kotlin和java性能

一.kotlin相比于java:

java:

1.语法表现力差,例如:java1.8之前不支持lambda表达式,匿名内部的写法繁琐,在函数方面,不支持高洁函数,不支持参数默认值,也不支持函数命名参数。

2.可读性差,难维护 例如:java中的Callback嵌套多层的话,代码可读性就特别差,对维护更加困难

3.并发编程:在java 中,线程的并发以及它复杂的同步机制导致学习成本高。

总结:前期开发效率低,中期线上问题多,后期代码难维护

kotlin:

1.kotlin具有更加简洁的语法跟现代化语法特性,大大提高开发效率,线上奔溃率降低,java中的空指针问题也几乎可以避免

2.兼容性强:kotlin可以跟java混编,大部分旧的项目都是java开发,kotlin强大的兼容性可以让我们渐进的从java迁移到kotlin,不用一次性重写很多代码,从而产生新的问题

3.谷歌宣布kotlin成为官方语言后,现在各大招聘android,都会写着熟悉kotlin的优先,所以koltin我觉得是有非常好的前景的,赶紧入坑。

变量

在java中,如果我们要声明变量,我们必须声明它的类型,后面跟着变量的名称和对应的值,然后以分号结尾。就像这样:

int price = 100;  

String msg = "我是msg";

而kotlin则不一样,我们要使用 val 或者是 var这样的关键字作为开头,后面跟“变量名称 -> price ”,接着是变量类型 ->Int 和赋值语句 ,

如下:

var price : Int  = 100 ;

在kotlin 中,一般会把末尾的分号省略掉

var price : Int  = 100 

还有一点我们要注意,在kotlin中,我们应该尽可能的避免使用var ,尽可能多的去使用val。

var 跟 val 的区别

var  price = 100  price = 101   //编译通过

val  price  = 0   price =101 //编译器报错

原因很简单,val声明的变量,我们叫不可变变量,它的值在初始化后就不能再次被修改,它相当于java中的 final 变量。

var声明的变量,我们叫可变变量,它对应java中的普通变量

基础类型

基础类型:包括我们常见的数字类型,布尔类型,字符类型。以及这些类型组成的数组

一切皆对象

在java中,基础类型会分为原始类型和包装类型。比如整型会有对应的int 和 Integer,前者是原始类型,后者是包装类型

int i = 0 ;//原始类型

Integer  i = 1 ;//包装类型

java之所以要这么做,是因为原始类型的开销小,性能高,但它不是对象,无法很好的融入到面向对象的系统中。而包装类型的开销大,性能相对较差,但它是对象,可以很好的发挥面向对象的特性。

然而在kotlin语言体系中,是没有原始类型这个概念的,这就意味着,在kotlin里,一切都是对象

koltin版本 java兼容 kotlin和java性能,koltin版本 java兼容 kotlin和java性能_java,第1张

实际上,从某种程度上讲,Java 的类型系统并不是完全面向对象的,因为它存在原始类型,而原始类型并不属于对象。而 Kotlin 则不一样,它从语言设计的层面上就规避了这个问题,类型系统则是完全面向对象的。

Val i :Double = 1.toDouble()

可以发现,由于在kotlin中,整型数字“1”被看作对象了,所以我们可以调用它的成员方法toDoubel(),而这样的代码在java是无法实现的。

空安全

既然kotlin 中的一切都是对象,那么对象就有可能为空。也许你会想到写出这样的代码:

 val i :Double = null //编译器报错

可事实上,以上的代码是不能通过编译。这是因为kotlin强制开发者在定义变量的时候,指定这个变量是否可能为null 。对于可能为null的变量,我们需要在声明的时候在变量类型后面加一个问号“?”:

   val i :Double = null //编译器报错 

   val j :Double? = null //编译通过

并且kotlin 对可能为空的变量类型做了强制区分,这就意味着,“可能为空的变量”无法赋值给“不可能为空的变量”,当然,反向赋值是没有问题的

 var i :Double  = 1.0

 var j :Double = null

 i = j  //编译器报错

 j = i //编译通过

不过如果你有这种需求的话,也是可以做的:

var i :Double = 1.0 

var j : Double = null 

If( j !=  null ) i = j // 编译通过

数字类型

首先,在数字类型上,kotlin 跟 java 几乎是一样的,包括它们对数字“字面量” 的定义方式。

   val int = 1 // 整型默认会被推导成“Int” 类型

   val long = 12345L   // Long类型,我们则需要使用 “L” 后缀

  val double = 13.14  // 小数默认会被推导为 “Double ” ,我们不需要使用“D”后缀

  val float = 13.14F  // Float 类型, 我们需要使用 “F” 后缀

  val hexadecimal = OxAF。//使用“Ox” 来代表十六进制字面量

  val binary = Ob01010101  //使用“Ob”,来代表二进制字面量

数字类型的转换在 java 是可以隐式转换数字类型,而kotlin更推荐显示转换

例如 int 类型赋值给long类型,编译器会自动为我们做类型转换

int j =100;

long j  = i ;

按照java的思维来看,好像是没有问题的,但是你要注意,虽然java编译器不会报错,可它可能会带来问题,因为它们本质不是同一个类型,int long float double 这些类型之间的互相转换是会存在精度问题的,尤其这样的代码掺杂在复杂的逻辑中,在碰到一些边界条件下,即使出现了bug 也很难排查出来 

所以在kotlin中 在像这样的隐式转换是被抛弃了。 正确的做法是使用显式调用Int类型的toLong()函数

val i = 100

 val j :Long = i.toLong( )

还有比如 toByte()、toShort()、toInt()、toLong()、toFloat()、toDouble()、toChar() 等等。Kotlin 这样设计的优势也是显而易见的,我们代码的可读性更强了,将来也更容易维护了

布尔类型 

kotlin 布尔类型的变量 只有两种值 true 和false 布尔类型还支持一些逻辑操作,比如:

“&”代表“与运算”;“|”代表“或运算”;“!”代表“非运算”;“&&”和“||”分别代表它们对应的“短路逻辑运算”。

val i = 1

val j = 2

val k = 3

val isTrue: Boolean = i < j && j < k

字符:Cher

Char 用于表达单个字符 比如'A'. 'B'字符应该用单引号括起来

字符串 :String

字符串用于表达一连串的字符,和java一样,kotlin的字符串也是不可变的,一般用双引号

kotlin还提供非常简洁的字符串模板:

val name = "kotlin"

print("Hello $name!")

在java中我们需要使用两个“+”进行拼接

print("Hello" + name + "!" )

这样看是不是简洁了许些,在字符串格式更复杂的情况下,更能体现出这个特性的简洁

如果我们需要在字符串当中引用更复杂的变量,则需要使用花括号将变量括起来:

val array = array("java","kotlin")

print("Hello ${ array.get( 1 ) } ! " )

Kotlin 还新增了一个原始字符串 ,用三个引号表示:"""  

它可以用来存放复杂的多行文本,并且它定义的时候是什么格式,打印也是对应的格式,不需要跟java写一堆的加号和换行符。 

                val s = """
       当我们的字符串有复杂的格式时
       原始字符串非常的方便
       因为它可以做到所见即所得。 """

        print(s)  

数组

在kotlin中,我们一般会使用 arrayOf()来创建数组

val arrayInt = arrayOf(1,2,3)

val arrayString = arrayOf("apple","pear")

同时kotlin编译器也会根据传入的参数进行类型推导,比如针对这里的arrayInt,由于我们赋值的时候传入的是整数,所以它的类型会被推导为整形数组。

在java中,获取数组的长度,java中应该使用"array.length", 如果是获取List的大小则是使用"list.size".这主要是因为数组不属于java集合。

不过在kotlin中,虽然数组仍然不属于集合,但它的一些操作是跟集合统一的。

val arrayString = arrayOf("apple","pear")
println("Size is ${array.size}")
println("First element is ${array[0]}")
//输出
Size is 2
First element is apple

如上面的代码,我们直接使用array.size就能拿到数组的长度

函数声明

我们看一下以下的代码:

/*
 关键字    函数名          参数类型   返回值类型
  ↓        ↓                ↓       ↓      */
 fun helloFunction(name: String): String {
     return "Hello $name !"
 }/*   ↑
    花括号内为:函数体
 */

在这段代码中:

  • 使用了fun关键字来定义函数
  • 函数名称。使用的是驼峰命名法
  • 函数参数是以参数名在前,参数类型在后的写法
  • 返回值类型,紧跟参数后面

在上面的代码,你会发现它的函数体只有一行代码,针对这种其实我们可以省略函数体的花括号,直接使用  ‘ = ’ 来连接,如下

fun helloFunction(name:String):String = "Hello $name !"

这种写法,我们称为单一表达式函数。

另外,由于kotlin支持类型推导,我们可以把返回值的类型也省略掉:

fun helloFunction(name:String) = "Hello $name !"

函数调用

如果我们想调用它:

heeloFunction("kotlin")

不过,kotlin还提供一些新的特性,那就是命名参数,简单来说,就是它允许我们在调用函数时传入“形参的名字”。

helloFunction(name = "kotlin")

让我们看一下更具体的使用场景:

fun createUser( name: String,
 age: Int,
 gender: Int, 
friendCount: Int, 
feedCount: Int, 
likeCount: Long, 
commentCount: Int) { 
//.....省略
}

这是一个包含很多参数的函数,在kotlin中,我们一般提倡以纵向的方式排列,这样更符合我们的阅读习惯

但是,如果我们像java那样调用createUser ,代码会非常难以阅读:

createUser("Tom ",30,1,78,2093,10937,1211)

这里的第一个参数,我们知道肯定是name ,但是到了后面的一堆数字,就容易迷惑。

createUser(
     name = "Tom",
     age = 30,
     gender = 1,
     friendCount = 78,
     feedCount = 2093,
     likeCount = 10937,
     commentCount = 3285
 )

如果我们这样写的话,可读性是不是变得更加强了呢。这里体现出kotlin命名参数的可读性跟易维护性两个优势

除了命名参数这个特性,kotlin还支持参数默认值。

fun createUser(
     name: String,
     age: Int,
     gender: Int = 1,
     friendCount: Int = 0,
     feedCount: Int = 0,
     likeCount: Long = 0L,
     commentCount: Int = 0
 ) {
     //..
 }

我们可以看到,里面的 参数大部分都被赋予了默认值,这样的好处在于,我们在调用时候就可以省很多事情,比如,下面这段代码只需要传3个参数,剩下的4个参数不传,编译器就会自动帮我们填上默认值。

createUser(
     name = "Tom",
     age = 30,
     commentCount = 3285
 )

流程控制

在kotlin中,流程控制主要有 if ,when,for ,while 

if

if主要用于逻辑判断。跟java基本一致

val i = 1
 if (i > 0) {
     print("Big")
 } else {
     print("Small")
 }输出结果:
 Big

我们也可以这样写:

val message = if (i > 0) "Big" else "Small"
print(message)

另外,由于kotlin明确规定类型分为 “可空类型” 跟“不可空类型”,因此,我们会经常遇到可空的变量,并且要判断它们是否为空:

fun getLength(text: String?): Int {
   return if (text != null) text.length else 0
 }

在这个例子中,我们把if当成表达式,如果text不为空,就返回它的长度,如果为空,则返回0

在kotlin中,类型这样的逻辑判断出现的很频繁,因此,kotlin针对这种情况提供一种简写,叫做Elvis表达式

fun getLength(text: String?): Int {
   return text?.length ?: 0
 }

when 

when语句,一般我们的逻辑只有两个分支时候,我们直接用if/else,而大于两个逻辑分支,我们使用when

val i :Int  =1 
when( i ){
1 -> print("1")
2 -> print ("2")
else -> print("i 不是1也不是2")
}

when语句有点像java里面的 switch case语句,不过kotlin的when更加强大,它也可以作为表达式,为变量赋值:

val i :Int  =1 
val  message  = when( i ){
1 -> "一"
2 -> "二"
else -> print("i 不是1也不是2")
}
println(message)

循环迭代:while 与 for

首先while循环,它在使用上跟java没有什么区别,都是用于重复执行某些代码

var i = 0
 while (i <= 2) {
     println(i)
     i++
 }var j = 0
 do {
     println(j)
     j++
 } while (j <= 2)输出结果:
 0
 1
 2
 0
 1
 2

for

但是对于for语句,kotlin跟java的用法就不一样了。

kotlin的for语句更多用于“迭代” 如下代码就代表迭代array这个数组里的所有元素,程序会依次打印出 “1,2,3”。

val array = arrayOf(1, 2, 3)
for (i in array) {
    println(i)
}

除了迭代数组跟集合外,kotlin还支持迭代一个区间。

首先,我们要定义一个区间,可以使用“..”来连接数组的区间的两端,比如“1..3”就代表从1到3的封闭间,左闭右闭

val oneToThree = 1..3 //代表[1,3]

接着,我们可以使用for语句,对这个闭区间范围进行迭代:

for (i in oneToThree) {
     println(i)
 }输出结果:
 1
 2
 3

甚至,我们可以逆序迭代一个区间,比如:

for (i in 6 downTo 0 step 2) {
     println(i)
 }输出结果:
 6
 4
 2
 0

以上代码的含义就是逆序迭代一个区间,从6到0,每次的迭代的步长是2。需要注意的是,逆序区间我们不能使用“6..0”来定义。而是使用downTo


https://www.xamrdz.com/mobile/4ew1963368.html

相关文章: