抛弃旧恋 Java ,选择新欢 Kotlin 的六个月后,我突然后悔了

Android快速转战Kotlin教程 前言 kotlin是啥?这里就不用多说了,想必看这篇文章的童鞋肯定是有所了解的。 那么这篇文章你可以收获什么? 答:本文主要通过本人如何从java转战到kotlin并应用在实际项目中的个人经历,给大家提供一些学习思路、学习方法以及一些学习资料和个人总结。 前提:你的项目(包含个人项目)即将开始用到kotlin(没有项目作为依托你会缺少十足的动力,而且缺少应用场景乘热打铁那也是白学) 建议:建议... 阅读详情
 点击上方“开发者技术前线”,选择“星标”
13:21 在看 真爱

640?wx_fmt=jpeg

作者:Bartosz Walacik | 来自:优快云 |  编辑 :可可


毫无疑问,Kotlin 在去年很受欢迎,业界甚至有人认为其将取代 Java 的霸主地位。它提供了 Null 安全性,从这一点来说它确实比 Java 更好。那么是不是这就意味着开发者应该毫不犹豫地拥抱 Kotlin,否则就落伍了?
等等,或许事情并非如此。
在开始使用 Kotlin 编程之前,本文想要分享个故事给你。在这个故事中,作者最早使用 Kotlin 来编写一个项目,后来 Kotlin 的各种怪异模式以及一些其他障碍越来越让人厌烦,最终,他们决定重写这个项目。
640?wx_fmt=jpeg
以下为译文:
一直以来,我对基于 JVM 的语言都非常情有独钟。我通常会用 Java 来编写主程序,再用 Groovy 编写测试代码,两者配合使用得心应手。
2017年夏天,团队发起了一个新的微服务项目,和往常一样,我们需要对编程语言和技术进行选型。部分团队成员是 Kotlin 的拥护者,再加上我们都想尝试一下新的东西,于是我们决定用 Kotlin 来开发这个项目。由于 Spock 测试框架不支持 Kotlin,因此我们决定坚持使用 Groovy 来测试。
2018年春天,使用 Kotlin 开发几个月之后,我们总结了 Kotlin 的优缺点,最终结论表明 Kotlin 降低了我们的生产力。
于是我们使用 Java 来重写这个微服务项目。
那么 Kotlin 主要存在哪些弊端?下面来一一解释。
名称遮蔽
这是 Kotlin 最让我震惊的地方。看看下面这个方法:


fun inc(num : Int) {
    val num = 2
    if (num > 0) {
        val num = 3
    }
    println ("num: " + num)
}


当你调用 inc(1) 会输出什么呢?在 Kotlin 中, 方法的参数无法修改,因此在本例中你不能改变 num。这个设计很好,因为你不应该改变方法的输入参数。但是你可以用相同的名称定义另一个变量并对其进行初始化。
这样一来,这个方法作用域中就有两个名为 num 的变量。当然,你一次只能访问其中一个 num,但是 num 值会被改变。
在 if 语句中再添加另一个 num,因为作用域的原因 num 并不会被修改。
于是,在 Kotlin 中,inc(1) 会输出 2。同样效果的 Java 代码如下所示,不过无法通过编译: 


void inc(int num) {
    int num = 2; //error: variable 'num' is already defined in the scope
    if (num > 0) {
        int num = 3; //error: variable 'num' is already defined in the scope
    }
    System.out.println ("num: " + num);
}


名字遮蔽并不是 Kotlin 发明的,这在编程语言中很常见。在 Java 中我们习惯用方法参数来映射类字段:


public class Shadow {
    int val;
    public Shadow(int val) {
        this.val = val;
    }
}


在 Kotlin 中名称遮蔽有些严重,这是 Kotlin 团队的一个设计缺陷。
IDEA 团队试图通过向每个遮蔽变量显示警告信息来解决这个问题。两个团队在同一家公司工作,或许他们可以互相交流并就遮蔽问题达成共识。我从个人角度赞成 IDEA 的做法因为我想不到有哪些应用场景需要遮蔽方法参数。
类型推断
在Kotlin中,当你声明一个var或是val,你通常会让编译器从右边的表达式类型中猜测变量类型。我们称之为局部变量类型推断,这对程序员来说是一个很大的改进。它允许我们在不影响静态类型检查的情况下简化代码。
例如,这个Kotlin代码:


var a = "10"


Kotlin 编译器会将其翻译成: 


var a : String = "10"


Java 同样具备这个特性,Java 10中的类型推断示例如下:  


var a = "10";


实话实说,Kotlin 在这一点上确实更胜一筹。当然,类型推断还可应用在多个场景。关于 Java 10中的局部变量类型推断,点击以下链接了解更多:
  • https://medium.com/@afinlay/java-10-sneak-peek-local-variable-type-inference-var-3022016e1a2b

Null 安全类型
Null 安全类型是 Kotlin 的杀手级功能。
这个想法很好,在 Kotlin 中,类型默认不可为空。如果你需要添加一个可为空的类型,可以像下列代码这样: 


val a: String? = null      // ok
val b: String = null       // compilation error


假设你使用了可为空的变量但是并未进行空值检查,这在 Kotlin 将无法通过编译,比如:


println (a.length)          // compilation error
println (a?.length)         // fine, prints null
println (a?.length ?: 0)    // fine, prints 0


那么是不是如果你同时拥有不可为空和可为空的变量,就可以避免 Java 中最常见的 NullPointerException 异常吗?事实并没有想象的简单。
当 Kotlin 代码必须调用 Java 代码时,事情会变得很糟糕,比如库是用 Java 编写的,我相信这种情况很常见。于是第三种类型产生了,它被称为平台类型。Kotlin 无法表示这种奇怪的类型,它只能从 Java 类型推断出来。 它可能会误导你,因为它对空值很宽松,并且会禁用 Kotlin 的 NULL 安全机制。
看看下面这个 Java 方法:


public class Utils {
    static String format(String text) {
        return text.isEmpty() ? null : text;
    }
}


假如你想调用 format(String)。应该使用哪种类型来获得这个 Java 方法的结果呢?你有三个选择。
第一种方法:你可以使用 String,代码看起来很安全,但是会抛出 NullPointerException 异常。


fun doSth(text: String) {
    val f: String = Utils.format(text)       // compiles but assignment can throw NPE at runtime
    println ("f.len : " + f.length)
}


那你就需要用 Elvis 来解决这个问题:


fun doSth(text: String) {
    val f: String = Utils.format(text) ?: ""  // safe with Elvis
    println ("f.len : " + f.length)
}


第二种方法:你可以使用 String,能够保证 Null 安全性。


fun doSth(text: String) {
    val f: String? = Utils.format(text)   // safe
    println ("f.len : " + f.length)       // compilation error, fine
    println ("f.len : " + f?.length)      // null-safe with ? operator
}


第三种方法:让 Kotlin 做局部变量类型推断如何? 


fun doSth(text: String) {
    val f = Utils.format(text)            // f type inferred as String!
    println ("f.len : " + f.length)       // compiles but can throw NPE at runtime
}


馊主意!这个 Kotlin 代码看起来很安全、可编译,但是它容忍了空值,就像在 Java 中一样。
除此之外,还有另外一个方法,就是强制将 f 类型推断为 String:


fun doSth(text: String) {
    val f = Utils.format(text)!!          // throws NPE when format() returns null
    println ("f.len : " + f.length)
}


在我看来,Kotlin 的所有这些类似 scala 的类型系统过于复杂。Java 互操作性似乎损害了 Kotlin 类型推断这个重量级功能。
类名称字面常量
使用类似 Log4j 或者 Gson 的 Java 库时,类文字很常见。
Java 使用 .class 后缀编写类名: 


Gson gson = new GsonBuilder().registerTypeAdapter(LocalDate.class, new LocalDateAdapter()).create();


Groovy 把类进行了进一步的简化。你可以忽略 .class,它是 Groovy 或者 Java 类并不重要。


def gson = new GsonBuilder().registerTypeAdapter(LocalDate, new LocalDateAdapter()).create()


Kotlin 把 Kotlin 类和 Java 类进行了区分,并为其提供了语法规范:


val kotlinClass : KClass<LocalDate> = LocalDate::class
val javaClass : Class<LocalDate> = LocalDate::class.java


因此在 Kotlin 中,你必须写成如下形式:


val gson = GsonBuilder().registerTypeAdapter(LocalDate::class.java, LocalDateAdapter()).create()


这看起来非常丑陋。
反向类型声明
C 系列的编程语言有标准的声明类型的方法。简而言之,首先指定一个类型,然后是该符合类型的东西,比如变量、字段、方法等等。
Java 中的表示方法是:


int inc(int i) {
    return i + 1;
}


Kotlin 中则是:


fun inc(i: Int): Int {
    return i + 1
}


这种方法有几个原因令人讨厌。
首先,你需要在名称和类型之间加入这个多余的冒号。这个额外角色的目的是什么?为什么名称与其类型要分离?我不知道。可悲的是,这让你在 Kotlin 的工作变得更加困难。
第二个问题,当你读取一个方法声明时,你首先看到的是名字和返回类型,然后才是参数。
在 Kotlin 中,方法的返回类型可能远在行尾,所以需要浏览很多代码才能看到: 


private fun getMetricValue(kafkaTemplate : KafkaTemplate<String, ByteArray>, metricName : String) : Double {
    ...
}


或者,如果参数是逐行格式的,则需要搜索。那么我们需要多少时间才能找到此方法的返回类型呢?


@Bean
fun kafkaTemplate(
        @Value("\${interactions.kafka.bootstrap-servers-dc1}") bootstrapServersDc1: String,
        @Value("\${interactions.kafka.bootstrap-servers-dc2}") bootstrapServersDc2: String,
        cloudMetadata: CloudMetadata,
        @Value("\${interactions.kafka.batch-size}") batchSize: Int,
        @Value("\${interactions.kafka.linger-ms}") lingerMs: Int,
        metricRegistry : MetricRegistry
)
: KafkaTemplate<String, ByteArray> {
    val bootstrapServer = if (cloudMetadata.datacenter == "dc1") {
        bootstrapServersDc1
    }
    ...
}


第三个问题是 IDE 中的自动化支持不够好。标准做法从类型名称开始,并且很容易找到类型。一旦选择一个类型,IDE 会提供一些关于变量名的建议,这些变量名是从选定的类型派生的,因此你可以快速输入这样的变量: 


MongoExperimentsRepository repository


Kotlin 尽管有 IntelliJ 这样强大的 IDE,输入变量仍然是很难的。如果你有多个存储库,在列表中很难实现正确的自动补全,这意味着你不得不手动输入完整的变量名称。


repository : MongoExperimentsRepository


伴生对象
一位 Java 程序员来到 Kotlin 面前。
“嗨,Kotlin。我是新来的,我可以使用静态成员吗?"他问。
 “不行。我是面向对象的,静态成员不是面向对象的。” Kotlin 回答。
 “好吧,但我需要 MyClass 的 logger,我该怎么办?” 
“这个没问题,使用伴生对象即可。”
 “那是什么东西?” “这是局限到你的类的单独对象。把你的 logger 放在伴生对象中。”Kotlin解释说。
 “我懂了。这样对吗?”


class MyClass {
    companion object {
        val logger = LoggerFactory.getLogger(MyClass::class.java)
    }
}


“正确!”
 “很详细的语法,”程序员看起来很疑惑,“但是没关系,现在我可以像 MyClass.logger 这样调用我的 logger,就像 Java 中的一个静态成员?” 
“嗯......是的,但它不是静态成员!这里只有对象。把它看作是已经实例化为单例的匿名内部类。事实上,这个类并不是匿名的,它的名字是 Companion,但你可以省略这个名字。看到了吗?这很简单。"
我很欣赏对象声明的概念——单例很有用。但从语言中删除静态成员是不切实际的。在 Java 中我们使用静态 Logger 很经典,它只是一个 Logger,所以我们不关心面向对象的纯度。它能够工作,从来没有任何坏处。
因为有时候你必须使用静态。旧版本 public static void main() 仍然是启动 Java 应用程序的唯一方式。


class AppRunner {
    companion object {
        @JvmStatic fun main(args: Array<String>) {
            SpringApplication.run(AppRunner::class.java, *args)
        }
    }
}


集合字面量
在Java中,初始化列表非常繁琐:


import java.util.Arrays;
...
List<String> strings = Arrays.asList("Saab", "Volvo");


初始化地图非常冗长,很多人使用 Guava:


import com.google.common.collect.ImmutableMap;
...
Map<String, String> string = ImmutableMap.of("firstName", "John", "lastName", "Doe");


在 Java 中,我们仍然在等待新的语法来表达集合和映射。语法在许多语言中非常自然和方便。
JavaScript:


const list = ['Saab', 'Volvo']
const map = {'firstName': 'John', 'lastName' : 'Doe'}


Python:


list = ['Saab', 'Volvo']
map = {'firstName': 'John', 'lastName': 'Doe'}


Groovy:


def list = ['Saab', 'Volvo']
def map = ['firstName': 'John', 'lastName': 'Doe']


简单来说,集合字面量的整齐语法就是你对现代编程语言的期望,特别是如果它是从头开始创建的。Kotlin 提供了一系列内置函数,比如 listOf()、mutableListOf()、mapOf()、hashMapOf() 等等。
Kotlin: 


val list = listOf("Saab", "Volvo")
val map = mapOf("firstName" to "John", "lastName" to "Doe")


在地图中,键和值与 to 运算符配对,这很好。但为什么一直没有得到广泛使用呢?令人失望。
Maybe
函数式语言(比如 Haskell)没有空值。相反,他们提供 Maybe monad(如果你不熟悉monad,请阅读 Tomasz Nurkiewicz 的这篇文章:http://www.nurkiewicz.com/2016/06/functor-and-monad-examples-in-plain-java.html)。
Maybe 很久以前就被 Scala 以 Option 引入到 JVM 世界,然后在 Java 8 中被采用为 Optional。如今,Optional 是在 API 边界处理返回类型中的空值的非常流行的方式。
Kotlin 中没有 Optional 的等价物,所以你大概应该使用 Kotlin 的可空类型。让我们来调查一下这个问题。
通常情况下,当你有一个 Optional 的时候,你想要应用一系列无效的转换。
例如,在 Java 中: 


public int parseAndInc(String number) {
    return Optional.ofNullable(number)
                   .map(Integer::parseInt)
                   .map(it -> it + 1)
                   .orElse(0);
}


在 Kotlin 中,为了映射你可以使用 let 函数:


fun parseAndInc(number: String?): Int {
    return number.let { Integer.parseInt(it) }
                 .let { it -> it + 1 } ?: 0
}


上面的代码是错误的,parseInt() 会抛出 NPE 。map() 仅在有值时执行。否则,Null 就会跳过,这就是为什么 map() 如此方便。不幸的是,Kotlin 的 let 不会那样工作。它从左侧的所有内容中调用,包括空值。
为了保证这个代码 Null 安全,你必须在每个代码之前添加 let: 


fun parseAndInc(number: String?): Int {
    return number?.let { Integer.parseInt(it) }
                 ?.let { it -> it + 1 } ?: 0
}


现在,比较 Java 和 Kotlin 版本的可读性。你更倾向哪个?
数据类
数据类是 Kotlin 在实现 Value Objects 时使用的方法,以减少 Java 中不可避免的样板问题。
例如,在 Kotlin 中,你只写一个 Value Object :


data class User(val name: String, val age: Int)


Kotlin 对 equals()、hashCode()、toString() 以及 copy() 有很好的实现。在实现简单的DTO 时它非常有用。但请记住,数据类带有严重的局限性。你无法扩展数据类或者将其抽象化,所以你可能不会在核心模型中使用它们。
这个限制不是 Kotlin 的错。在 equals() 没有违反 Liskov 原则的情况下,没有办法产生正确的基于价值的数据。
这也是为什么 Kotlin 不允许数据类继承的原因。
开放类
Kotlin 类默认为 final。如果你想扩展一个类,必须添加 open 修饰符。
继承语法如下所示: 


open class Base
class Derived : Base()


Kotlin 将 extends 关键字更改为: 运算符,该运算符用于将变量名称与其类型分开。那么再回到 C ++语法?对我来说这很混乱。
这里有争议的是,默认情况下类是 final。也许 Java 程序员过度使用继承,也许应该在考虑扩展类之前考虑三次。但我们生活在框架世界,Spring 使用 cglib、jassist 库为你的 bean 生成动态代理。Hibernate 扩展你的实体以启用延迟加载。
如果你使用 Spring,你有两种选择。你可以在所有 bean 类的前面添加 open,或者使用这个编译器插件: 


buildscript {
    dependencies {
        classpath group: 'org.jetbrains.kotlin', name: 'kotlin-allopen', version: "$versions.kotlin"
    }
}


陡峭的学习曲线
如果你认为自己有 Java 基础就可以快速学习 Kotlin,那你就错了。Kotlin 会让你陷入深渊,事实上,Kotlin 的语法更接近 Scala。这是一项赌注,你将不得不忘记 Java 并切换到完全不同的语言。
相反,学习 Groovy 是一个愉快的过程。Java 代码是正确的 Groovy 代码,因此你可以通过将文件扩展名从 .java 更改为 .groovy。
最后的想法
学习新技术就像一项投资。我们投入时间,新技术让我们得到回报。但我并不是说 Kotlin 是一种糟糕的语言,只是在我们的案例中,成本远超收益。
以上内容编译自 From Java to Kotlin and Back Again,作者 Kotlin ketckup。
他是一名具有15年以上专业经验的软件工程师,专注于JVM 。在 Allegro,他是一名开发团队负责人,JaVers 项目负责人,Spock 倡导者。此外,他还是 allegro.tech/blog 的主编。
本文一出就引发了业内的广泛争议,Kotlin 语言拥护者 Márton Braun 就表示了强烈的反对。
Márton Braun 十分喜欢 Kotlin 编程,目前他在 StackOverflow 上 Kotlin 标签的最高用户列表中排名第三,并且是两个开源 Kotlin 库的创建者,最著名的是 MaterialDrawerKt。此外他还是 Autosoft 的 Android 开发人员,目前正在布达佩斯技术经济大学攻读计算机工程硕士学位。

以下就是他针对上文的反驳:
当我第一次看到这篇文章时,我就想把它转发出来看看大家会怎么想,我肯定它会是一个有争议的话题。后来我读了这篇文章,果然证明了它是一种主观的、不真实的、甚至有些居高临下的偏见。
有些人已经在原贴下进行了合理的批评,对此我也想表达一下自己的看法。
名称遮蔽
“IDEA 团队”(或者 Kotlin 插件团队)和“Kotlin 团队”肯定是同样的人,我从不认为内部冲突会是个好事。语言提供这个功能给你,你需要的话就使用,如果讨厌,调整检查设置就是了。
类型推断
Kotlin 的类型推断无处不在,作者说的 Java 10 同样可以简直是在开玩笑。
Kotlin 的方式超越了推断局部变量类型或返回表达式体的函数类型。这里介绍的这两个例子是那些刚刚看过关于 Kotlin 的第一次介绍性讲话的人会提到的,而不是那些花了半年学习该语言的人。
例如,你怎么能不提 Kotlin 推断泛型类型参数的方式?这不是 Kotlin 的一次性功能,它深深融入了整个语言。
编译时 Null 安全
这个批评是对的,当你与 Java 代码进行互操作时,Null 安全性确实被破坏了。该语言背后的团队曾多次声明,他们最初试图使 Java 可为空的每种类型,但他们发现它实际上让代码变得更糟糕。
Kotlin 不比 Java 更差,你只需要注意使用给定库的方式,就像在 Java 中使用它一样,因为它并没有不去考虑 Null 安全。如果 Java 库关心 Null 安全性,则它们会有许多支持注释可供添加。
也许可以添加一个编译器标志,使每种 Java 类型都可以为空,但这对 Kotlin 团队来说不得不花费大量额外资源。
类名称字面常量
:: class 为你提供了一个 KClass 实例,以便与 Kotlin 自己的反射 API 一起使用,而:: class.java为你提供了用于 Java 反射的常规 Java 类实例。
反向类型声明
为了清楚起见,颠倒的顺序是存在的,这样你就可以以合理的方式省略显式类型。冒号只是语法,这在现代语言中是相当普遍的一种,比如 Scala、Swift 等。
我不知道作者在使用什么 IntelliJ,但我使用的变量名称和类型都能够自动补全。对于参数,IntelliJ 甚至会给你提供相同类型的名称和类型的建议,这实际上比 Java 更好。
伴生对象
原文中说:
有时候你必须使用静态。旧版本 public static void main() 仍然是启动 Java 应用程序的唯一方式。


class AppRunner {
    companion object {
        @JvmStatic fun main(args: Array<String>) {
            SpringApplication.run(AppRunner::class.java, *args)
        }
    }
}


实际上,这不是启动 Java 应用程序的唯一方式。你可以这样做:


 fun main(args:Array <String>){ SpringApplication.run(AppRunner :: class.java,* args)} 


或者这样:


 fun main(args:Array <String>){ runApplication <AppRunner>(* args)}


集合字面量
你可以在注释中使用数组文字。但是,除此之外,这些集合工厂的功能非常简洁,而且它们是另一种“内置”到该语言的东西,而它们实际上只是库函数。
你只是抱怨使用:进行类型声明。而且,为了获得它不必是单独的语言结构的好处,它只是一个任何人都可以实现的功能。
Maybe
如果你喜欢 Optional ,你可以使用它。 Kotlin 在 JVM 上运行。
对于代码确实这有些难看。但是你不应该在 Kotlin 代码中使用 parseInt,而应该这样做(我不知道你使用该语言的 6 个月中为何错过这个)。你为什么要明确地命名一个 Lambda 参数呢?
数据类
原文中说:
这个限制不是 Kotlin 的错。在 equals() 没有违反 Liskov 原则的情况下,没有办法产生正确的基于价值的数据。
这就是为什么 Kotlin 不允许数据类继承的原因。
我不知道你为什么提出这个问题。如果你需要更复杂的类,你仍然可以创建它们并手动维护它们的 equals、hashCode 等方法。数据类仅仅是一个简单用例的便捷方式,对于很多人来说这很常见。
公开类
作者再次鄙视了,对此我实在无话可说。
陡峭的学习曲线
作者认为学习 Kotlin 很难, 但是我个人并不这么认为。
最后的想法
从作者列举的例子中,我感觉他只是了解语言的表面。
很难想象他对此有投入很多时间。
最近的语言排行,java依然排在第一,在语言排行榜上,Koltin已被甩到10名之外!
原文:https://allegro.tech/2018/05/From-Java-to-Kotlin-and-Back-Again.html
END

640?wx_fmt=png
「在看」大家一起看
Kotlin介绍,开发环境搭建,语法,高级特性,编程技巧 Kotlin中的扩展函数和属性可以为现有类添加新的函数和属性,而无需修改原始类的代码。Kotlin中的函数可以使用fun关键字声明。Kotlin中的泛型可以使用来表示,可以使用out和in关键字来表示协变和逆变。Kotlin中的数据类可以自动生成equals、hashCode和toString等方法,可以提高代码的可读性和可维护性。Kotlin中的扩展函数和属性可以为现有类添加新的函数和属性,可以提高代码的复用性和可读性。Kotlin中的Lambda表达式可以简化代码,可以提高代码的可读性和可维护性。 阅读详情

相关推荐

java,c,kotlin,Python性能对比

可以看出从时间上看出各个语言之间的性能高低了,从高到低依次是: c>Python>Java>kotlin。这应该就是为什么kotlin没有火起来的原因吧,而Python火到飞起的原因吧。如果您有意见欢迎下发留言讨论。 学习更多Python技术联系QQ(备注优快云 Python学习):3170161679大佬在线一对一辅导。 ...

weixin_44772948的博客 3037

Kotlin入门学习(非常详细),从零基础入门到精通,看完这一篇就够了

和Java中的接口定义类似。

Javachichi的博客 6万+

【AI智能体】Coze 搭建个人旅游规划助手实战详解

本文将详细介绍如何使用Coze平台搭建个人旅游规划助手。首先概述了AI智能体如何简化传统复杂任务的开发流程,然后重点介绍了Coze工作流的作用和核心节点类型(包括大模型、插件、知识库等)。通过实际操作演示,从创建智能体到配置多级工作流,逐步实现旅游规划功能:解析用户输入时间地点、查询必玩景点、获取景点详细信息等。该教程展示了如何利用Coze的可视化编排能力,即使非技术人员也能快速构建专业级AI应用。最终呈现的旅游助手可提供天气查询、行程建议等一站式服务。

Hello, New World! 2121

Kotlin第一弹:Kotlin详细介绍

Kotlin是一门用于现代多平台应用的静态编程语言,其中被广泛用于Android 平台的开发,被称之为Android世界的Swift。它由大名鼎鼎的JetBrains 公司设计开发并开源,著名的IDE工具就是他们的产品,所以无疑他们是对编程语言设计领域最为熟悉的专家。Kotlin从2016年发布1.0的release版本开始至今,使用的开发者数量快速增长。此外Kotlin已经拥有强大的生态和社区开发者的支持:•Kotlin是著名的IDE厂商JetBrains。

m0_58941767的博客 8609

mysql数据库中使用存储过程带来的好处和示例(存储过程的概念、定义、作用等详解)

MySQL的存储过程(Stored Procedure)是一组SQL语句集合。用户通过指定的存储过程名和参数来调用并执行它。存储过程可以在数据库中预编译并存储,这样它们可以被多次调用而无需重新编写或解析SQL语句。 存储过程将复杂的SQL逻辑封装在一个可重用的单元中。多次调用存储过程,而不需要重复编写相同的SQL代码。- 通过封装,可以隐藏复杂的SQL逻辑,只向用户或应用程序提供简单的接口。MySQL的存储过程和编程语言中的函数的原理和目标是一致的:封装可重用的代码逻辑并提高代码的可维护性和可重用性。

weixin_70208651的博客 1720

【GEE实战】Sen+MK趋势分析:从代码到地图,解锁植被变化时空密码

本文详细介绍了在Google Earth Engine(GEE)平台上使用Sen斜率估计和Mann-Kendall(MK)检验进行植被变化趋势分析的全流程。从遥感数据加载、Sen斜率计算到MK显著性检验,结合代码示例和实战经验,帮助读者掌握植被时空变化分析的实用技巧,为生态监测和环境保护提供数据支持。

weixin_42628688的博客 214

抛弃 Java 改用 Kotlin 的六个月后,我后悔了

点击上方“优快云”,选择“置顶公众号”关键时刻,第一时间送达!毫无疑问,Kotlin 目前很受欢迎,业界甚至有人认为其将取代 Java 的霸主地位。它提供了 Null ...

优快云资讯 20万+

【软件使用】向日葵网络连接错误

一直报这个错误,尝试了修改版本无果,各种密码都正确,最后得出结轮是时间没有同步,查看代理是否更改了时间,做一下同步即可。

andeyeluguo的博客 7989

2024年Java最全抛弃 Java 改用 Kotlin 的六个月后,我后悔了!,真是经典中的经典

这份面试题几乎包含了他在一年内遇到的所有面试题以及答案,甚至包括面试中的细节对话以及语录,可谓是细节到极致,甚至简历优化和怎么投简历更容易得到面试机会也包括在内!也包括教你怎么去获得一些大厂,比如阿里,腾讯的内推名额!某位名人说过成功是靠99%的汗水和1%的机遇得到的,而你想获得那1%的机遇你首先就得付出99%的汗水!你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功!成功只会留给那些有准备的人!本文已被。

2401_84692456的博客 1608

毕设助力!从0到1构建基于YOLO的家居安防异常活动监测系统,让你的毕设守护家庭安全

做完这个项目,你会发现自己完整走过了“数据采集→标注→模型训练→功能集成→界面开发”的毕设全流程,这不仅是技术能力的证明,更是对“技术守护生活”这一理念的实践。答辩时,你可以重点讲这几点:系统解决了家居安防的哪些痛点、对比了不同YOLO模型的性能差异、系统未来能怎么优化(比如对接智能门锁/报警器、实现语音交互)。未来,这个系统还能往“更智能”的方向发展:比如结合行为分析判断异常意图、开发移动端APP实现全屋设备联动、在智慧社区中实现多家庭联防……想象空间很大。

LXY_LOVE36的博客 125

【AI大模型应用开发】教你用AI轻松将你的知识库变为知识图谱(附完整代码,直接运行)

本文我们来介绍如何使用AI,将自己的知识库自动转换为知识图谱,并进行可视化展示。

同学小张的博客 3930

抛弃 Java 改用 Kotlin 的六个月后,我后悔了!

点击上方“朱小厮的博客”,选择“设为星标”后台回复"书",获取毫无疑问,Kotlin 目前很受欢迎,业界甚至有人认为其将取代 Java 的霸主地位。它提供了 Null 安...

朱小厮的博客 1948

如何利用gretna软件计算脑网络全局属性(聚类系数,小世界属性,最短路径),局部属性指标(度,度分布,节点效率),如何理解网络稀疏度

grena工具箱被设计用于fMRI数据的图论网络分析。它是一套MATLAB函数和基于MATLAB的接口,用于常规的fMRI预处理,用于计算和统计分析最常用的网络指标,如小世界参数、效率、度、间性、关联性、层级性、同步性和模块化。......

从事脑科学核磁共振方法学研究,在Nature communications等权威期刊发表研究论文,熟练掌握磁共振处理方法和统计学方法,欢迎大家和我交流。 9176

抛弃Java 改用 Kotlin 的六个月,你不知道的小秘密。

自 2017 年 Kotlin 被 Google 认证为 Android 开发官方编程语言后,最常提及的一个问题:是否应该学习 Kotlin 进行 Android 开发?相比传统 Java 语言有什么优势? 如今答案十分清晰了 —— 这几年,Google 大力发展基于 Kotlin 的 Androidx 库、Jetpack 库、Compose 库,很多新特性都是为 Kotlin 优化的。可以说,不懂 kotlin,今后在 Android 开发领域标准库的发展上将很受阻碍,Android 开发由 Java 转

老皮的博客 1964

【软考中级】多媒体应用设计师复习笔记第十章【free】

第10章法律法规与标准规范 行业标准 缩写的大写拼音 地方标准 DB加生代码 企业标准Q加斜线企业代号国际标准是国际标准化组织ISO和国际电工委员会IEC制定的标准 国家标准是由国务院标准化行政主管部门制定,全国范围内使用 ?强制性国家标准的代号为GB,推荐性国家标准的代号为GB/T。 ?软件开发规范GB8566-88属于强制性国家标准 在这里插入图片描述 行业标准代号由大写汉语拼音字母组成,加上斜线和T,组成推荐性行业标准,如XX/T。已经发布的行业代号有QJ(航天),SJ(电子

weixin_47120900的博客 642

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

我用kotlin写了一个项目之后就开始后悔了

前言 就2021年JVM生态系统报告来看,Java 最受欢迎,91%,Kotlin 次之,接近 18%,虽然 JVM 语言的种类在过去几年中有所增长,但 Java 处于领先地位。超过 90% 的开发人员使用 Java,我们可以看到它仍然是一种非常流行的语言。Kotlin 的受欢迎程度却比我们去年想象的要广泛得多。令人印象深刻的是,17.7% 的开发人员在生产中使用 Kotlin。 那么使用Kotlin相比Java有什么好处呢? 首先,**是将语言特性的发展与jvm虚拟机脱钩。**虽然java也在不断迭代,但

Eqiqi的博客 6316

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

上一篇: 抖音上好看的小姐姐,Python给你都下载了
下一篇: 清华学霸直博简历火了:CPU、操作系统、编译器全自己写
DevolperFront
博客等级 码龄8年 465粉丝 81原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值