首页 > 编程语言 >Kotlin与Java语法对比学习

Kotlin与Java语法对比学习

时间:2023-08-02 15:23:54浏览次数:38  
标签:... Java 定义 val Kotlin 语法 class

定义变量

// Kotlin
val i: Int = 10  // 定义一个整数变量
val d: Double = 10.0  // 定义一个双精度浮点数变量
val b: Boolean = true  // 定义一个布尔变量
val c: Char = 'a'  // 定义一个字符变量
val s: String = "Hello, World!"  // 定义一个字符串变量
val arr: Array<Int> = arrayOf(1, 2, 3)  // 定义一个整数数组
val ui: UInt = 10u  // 定义一个无符号整数变量
// Java
int i = 10;  // 定义一个整数变量
double d = 10.0;  // 定义一个双精度浮点数变量
boolean b = true;  // 定义一个布尔变量
char c = 'a';  // 定义一个字符变量
String s = "Hello, World!";  // 定义一个字符串变量
int[] arr = {1, 2, 3};  // 定义一个整数数组
// java不支持无符号整数变量

类型检测

// Kotlin
if (obj is String) { val str = obj as String }  // 类型检测与类型转换
// Java
if (obj instanceof String) { String str = (String) obj; }  // 类型检测与类型转换

控制流

// Kotlin
val max = if (a > b) a else b  // 条件表达式
when (x) { 1 -> print("x == 1") else -> print("x != 1") }  // when表达式,类似于Java的switch
for (item in collection) println(item)  // for循环
while (x > 0) x--  // while循环
// Java
int max = (a > b) ? a : b;  // 条件表达式
switch (x) { case 1: System.out.println("x == 1"); break; default: System.out.println("x != 1"); }  // switch语句
for (Object item : collection) System.out.println(item);  // for-each循环
while (x > 0) x--;  // while循环

..

// Kotlin 
for (i in 1..10) { if (i == 5) break }  // 使用break跳出循环
for (i in 1..10) { if (i % 2 == 0) continue; println(i) }  // 使用continue跳过当前迭代
// Java
for (int i = 1; i <= 10; i++) { if (i == 5) break; }  // 使用break跳出循环
for (int i = 1; i <= 10; i++) { if (i % 2 == 0) continue; System.out.println(i); }  // 使用continue跳过当前迭代

异常

// Kotlin
try { /*...*/ } catch (e: SomeException) { /*...*/ } finally { /*...*/ }  // 异常处理
throw SomeException()  // 抛出异常
// Java
try { /*...*/ } catch (SomeException e) { /*...*/ } finally { /*...*/ }  // 异常处理
throw new SomeException();  // 抛出异常

导包

// Kotlin
package com.example.myapp  // 定义包
import kotlin.text.*  // 导入包
// Java
package com.example.myapp;  // 定义包
import java.util.*;  // 导入包

类相关

// Kotlin
class MyClass { var x = 5 }  // 定义一个类
open class Base { /*...*/ }  // 定义一个可以被继承的类
class Derived : Base() { /*...*/ }  // 定义一个继承自Base的类
interface MyInterface { /*...*/ }  // 定义一个接口
fun interface Runnable { fun run() }  // 定义一个函数式接口
val runnable = Runnable { println("Running") }  // 创建一个函数式接口的实例
public var x = 5  // 定义一个公有变量
private fun foo() { /*...*/ }  // 定义一个私有函数
// Java
class MyClass { int x = 5; }  // 定义一个类
class Base { /*...*/ }  // 定义一个可以被继承的类
class Derived extends Base { /*...*/ }  // 定义一个继承自Base的类
interface MyInterface { /*...*/ }  // 定义一个接口
@FunctionalInterface interface Runnable { void run(); }  // 定义一个函数式接口
Runnable runnable = () -> System.out.println("Running");  // 创建一个函数式接口的实例
public int x = 5;  // 定义一个公有变量
private void foo() { /*...*/ }  // 定义一个私有函数

扩展函数和扩展属性

// Kotlin
fun String.lastChar(): Char = this[this.length - 1]  // 定义一个扩展函数
val <T> List<T>.lastIndex: Int get() = size - 1  // 定义一个扩展属性
// Java
// 没有

数据类

// Kotlin
data class User(val name: String, val age: Int)  // 定义一个数据类
// Java
// 没有,用Lombok可以实现

密封类

// Kotlin
sealed class Expr  // 定义一个密封类
data class Const(val number: Double) : Expr()  // 定义一个继承自Expr的数据类
data class Sum(val e1: Expr, val e2: Expr) : Expr()  // 定义一个继承自Expr的数据类
// Java
// 没有

接口、泛型

// Kotlin
interface List<out E> : Collection<E>  // 定义一个带有协变类型参数的接口
fun <T> MutableList<T>.swap(index1: Int, index2: Int)  // 定义一个泛型函数
fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T>  // 定义一个接受lambda表达式参数的泛型函数
fun <T> List<T>.binarySearch(element: T, fromIndex: Int = 0, toIndex: Int = size, comparator: Comparator<in T>? = null): Int where T : Comparable<T>  // 定义一个带有约束的泛型函数
// Java
interface List<E> extends Collection<E> { /*...*/ }  // 定义一个带有类型参数的接口
<T> void swap(List<T> list, int i, int j)  // 定义一个泛型函数
<T> List<T> customFilter(List<T> list, Predicate<T> predicate)  // 定义一个接受函数式接口参数的泛型函数
<T extends Comparable<T>> int binarySearch(List<? extends T> list, T key)  // 定义一个带有约束的泛型函数

嵌套类、内部类

// Kotlin
class Outer { class Nested { /*...*/ } }  // 定义一个嵌套类
class Outer { inner class Inner { /*...*/ } }  // 定义一个内部类
// Java
class Outer { static class Nested { /*...*/ } }  // 定义一个静态嵌套类
class Outer { class Inner { /*...*/ } }  // 定义一个内部类

枚举类

// Kotlin
enum class Direction { NORTH, SOUTH, EAST, WEST }  // 定义一个枚举类
// Java
enum Direction { NORTH, SOUTH, EAST, WEST; }  // 定义一个枚举类

内联类

// Kotlin
inline class Password(val value: String)  // 定义一个内联类
// Java
// 没有

匿名内部类、单例

// Kotlin
val listener = object : MouseAdapter() { /*...*/ }  // 创建一个匿名内部类的实例
object Singleton { /*...*/ }  // 定义一个单例
// Java
// 没有用匿名内部类和单例模式实现

委托

// Kotlin
class Derived(b: Base) : Base by b  // 类委托
class Example { var p: String by Delegate() }  // 属性委托
// Java
// 没有

别名

// Kotlin
typealias NodeSet = Set<Network.Node>  // 类型别名
typealias FileTable<K> = MutableMap<K, MutableList<File>>  // 类型别名
// Java
// 没有

函数和lambda

// Kotlin
fun add(a: Int, b: Int): Int { return a + b }  // 定义一个函数
fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T>  // 定义一个接受lambda表达式参数的泛型函数
// Java
int add(int a, int b) { return a + b; }  // 定义一个函数
<T> List<T> customFilter(List<T> list, Predicate<T> predicate)  // 定义一个接受函数式接口参数的泛型函数
// Kotlin
val sum = { x: Int, y: Int -> x + y }  // 定义一个lambda表达式
// Java
BinaryOperator<Integer> sum = (x, y) -> x + y;  // 定义一个lambda表达式
// Kotlin
inline fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T>  // 定义一个内联函数
// Java
// 没有

重载操作符

// Kotlin
operator fun BigInteger.plus(other: BigInteger): BigInteger  // 定义一个重载操作符的函数
// Java
// 没有

类型安全的构建器

// Kotlin
html { body { p { +"Hello, World!" } } }  // 使用类型安全的构建器创建一个HTML文档
// Java
// 没有,用建造者模式实现

null

// Kotlin
var a: String? = null  // 定义一个可空类型的变量
a?.length  // 安全调用操作符
// Java
String a = null;  // 定义一个可以为null的变量
int length = (a != null) ? a.length() : null;  // 使用条件表达式进行空安全的调用

相等判断

// Kotlin
a == b  // 结构相等性
a === b  // 引用相等性
// Java
a.equals(b)  // 结构相等性
a == b  // 引用相等性

this表达式

// Kotlin
class A { fun foo() { println(this) } }  // this表达式
class A { inner class B { fun foo() { println(this@A) } } }  // 使用限定的this表达式
// Java
class A { void foo() { System.out.println(this); } }  // this表达式
class A { class B { void foo() { System.out.println(A.this); } } }  // 使用外部类的this表达式

协程

// Kotlin
fun main() = runBlocking { /*...*/ }  // 使用协程进行异步编程
// Java
// 没有协程用其他异步方式可以实现

注解

// Kotlin
@Target(AnnotationTarget.CLASS) annotation class Fancy  // 定义一个注解
// Java
@Target(ElementType.TYPE) @interface Fancy { }  // 定义一个注解

解构

// Kotlin
val (name, age) = person  // 解构声明
// Java
// 没有

反射

// Kotlin
val c = MyClass::class  // 反射
// Java
Class c = MyClass.class;  // 反射

这只是Kotlin和Java的一部分代码示例,更多的语法元素和细节,你可以在Kotlin官方文档Java官方文档中找到。

标签:...,Java,定义,val,Kotlin,语法,class
From: https://www.cnblogs.com/coderzhouyu/p/17600769.html

相关文章

  • Kotlin/Swift语法对比
    原文地址juejin.cn变量和常量SwiftvarmyVariable=42letmyConstant=42KotlinvarmyVariable=42valmyConstant=42对比:变量都是variable,常量kotlin是val,swift是let,let在js中主要是做局部变量,js中常量有const类型声明SwiftletexplicitD......
  • Java编程-目录整理、新建接口、集成mybatis plus以及数据库初始化
    数据库初始化新建对应调试库```#dockerps#dockerexec-it6d542566d077/bin/bashpostgres=#createdatabasenovel;```执行全量脚本......
  • Java是如何处理异常的?
    Java异常处理是通过五个关键字来完成的:try、catch、finally、throw和throws。try:这个块用来包裹可能会引发异常的代码。catch:这个块用来捕获异常。可以有多个catch块来捕获不同类型的异常。finally:这个块无论是否捕获到异常都会执行。通常用于关闭资源等。throw:用于手动抛......
  • windows系统下配置java项目运行环境
    一、操作系统背景二、所需安装包注意事项:安装目录需放在英文路径下。1.安装winrar2.Redis/everything/Notepad一直默认下一步,tomcat/maven/nginx解压即可(maven注意修改中央仓库地址为阿里巴巴)。3.jdk如果双击没有反应,那么右键“以管理员身份运行”,选好安装地址一直下一步......
  • Ubuntu java配置环境变量后,开启新终端窗口环境变量失效
    先给出解决方案第一种每打开一次终端都输入一次source/etc/profile,这样就可以加载配置文件,环境变量自然就有了第二种输入vim./bashrc,在底部添加配置在/etc/profile里的配置,这样就可以无需使用source命令加载了也可以在./bashrc底部添加source/etc/profile,也能达到相......
  • MySQL8_SQL语法
    MySQL8_SQL语法SQL全称StructuredQueryLanguage,结构化查询语言。操作关系型数据库的编程语言,定义了一套操作关系型数据库统一标准。 一、SQL通用语法在学习具体的SQL语句之前,先来了解一下SQL语言的同于语法。1).SQL语句可以单行或多行书写,以分号结尾。2).SQL语句可......
  • 在校生如何面向面试地学习Java
    在校生如何面向面试地学习Java最近我在博客园里,看到不少在校的同学在学java,而且,在我最近举办的一次直播活动中,也有不少在校生同学来提问,java该怎么学。对于那些已经工作的同学,哪怕才工作不久,毕竟也能从项目实践里总结和探索java的学习途径和相关方法。但在校生同学由于没机会接......
  • Java单例模式
    单例模式线程安全的四种创建方式静态代码块,静态内部类,双重检锁,枚举模式代码展示静态代码块privatestaticfinalSingletonDemoSINGLETON_DEMO;static{SINGLETON_DEMO=newSingletonDemo();}privateSingletonDemo(){}publicstaticSingletonDemoget......
  • JavaScript学习 -- SM4算法应用实例
    SM4算法,也被称为国密算法,是中国公布的一种高效且安全的对称加密算法。在JavaScript中,我们可以通过使用CryptoJS库来实现SM4算法的加密和解密。本篇博客将为您介绍如何在JavaScript中使用SM4算法,并提供一个实际的案例。首先,确保您已经引入了CryptoJS库。以下是一个使用SM4算法进行加......
  • Java设计模式--装饰器模式
    Java设计模式--装饰器模式一、问题背景在项目场景中,有这样一个需求,需要对录入的加班进行规则校验,包括但不限于,对加班的录入时间进行检查,对录入的加班类型进行检查,对加班日期的班次进行对比检查,对潜入系统的时长进行对比检查等等。具体来说,就是对一条加班记录,进行多种规则的检查......