(1)常量与变量
package 程序结构
val FINAL_HELLO_WORLD:String="HelloWorld"//运行时常量,与Java的final还有区别
const val ADSDS:String="dsadsda"//编译期常量,与Java中final时一样的
var helloWorld:String="HelloWorld"
val FINAL_HELLO_CHINA="HelloStringl"
fun main(args: Array<String>) {
helloWorld="HelloChina"
println(FINAL_HELLO_CHINA)
}
(2)函数
kotlin中函数可以说是核心,kotlin之所以说比java方便使用,其实就是在于他的函数机制,目前的编程风格慢慢统一到了响应式编程,kotlin有大量的高阶函数,结合lambda表达式可以将很多复杂的代码使用一行搞定,带来代码简洁性的同时,也给程序员编程带来更多的挑战,我们需要记住更多的api和函数使用,如果原生的函数库还不能够满足你,kotlin还提供了自定义扩展函数,可以方便的去实现代码复用,函数这一块很大,这篇只能简单的介绍一下:
package 程序结构
fun main(args: Array<String>) {
// var args1=args[0].toInt()
// var args2=args[1].toInt()
// println("$args1 + $args2 = ${sum(args1,args2)}")
sum(1,2,3,4,1)
}
fun sum(args1:Int,args2:Int): Int {
return args1+args2
}
fun sum(x: String, y: String)=x+y
//可变参数类型
fun sum(vararg x: Int){
x.forEach (::print)
}
(3)lambda表达式
lambda表达式出来也有段时间了,但是其实一直是不温不火的,爱他的人爱不释手,不屑的人碰都懒得碰,在我看来吧,lambda表达式确实是方便,但是感觉不适应,代码有时候简洁的让你感到可怕,不过,感觉这是以后的潮流,谁让乔布斯曾经说过,减少bug的最好方式就是减少代码量呢?
package 程序结构
fun main(args: Array<String>) {
println(sum(1,3))
args.forEach foreach@{
if (it=="5") return@foreach
println(it)
}
}
val sum={arg1:Int,arg2:Int ->
println("$arg1 + $arg2 = ${arg1+arg2}")
arg1+arg2
}
val minus={arg1:Int,arg2:Int -> print("$arg1 - $arg2=${arg1 - arg2}")}
val printHello={ print("Hello")}
lambda表达式分为三个部分:以中间的 ->为基准,左边是参数,右边是函数主体,比如说在java中的这么一段代码:
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("lambda");
}
});
}
如果你使用的是idea编译期的话,他会提示你使用lambda表达式进行代码简化,简化后的代码就是这样:
public static void main(String[] args) {
new Thread(() -> System.out.println("lambda"));
}
左边参数,没有参数,所以是(),右边函数主体,也就是打印语句,这就是lambda,这是java,如果在kotlin中,那就会想我刚刚说的,简洁的让你感到可怕:
Thread{ println("dsadasda")}
是的,没错,就是这样,莫慌莫慌,一步步来,他本来应该这样写:
Thread(object :Runnable{
override fun run() {
}
})
然后变成这样:
Thread(Runnable { println("dsadasda") })
再然后:
Thread(){ -> println("dasda")}
最后就变成刚开始的那样;
(4)运算符:
kotlin运算符和java中运算符没有什么大区别,但是有一点很重要,kotlin支持运算符重载,比如说,如果要实现虚数的加减,在kotlin中,你可以这样写:
class Complex(var real:Double, var viryual:Double){
/**
* '+' 运算符重载
*/
operator fun plus(other: Complex):Complex{
return Complex(real+other.real,viryual+other.viryual)
}
/**
* '()'运算符重载
*/
operator fun invoke():Double{
return Math.hypot(real,viryual)
}
override fun toString(): String {
return "$real + ${viryual}i"
}
}
在这里实现+运算符的重载,使他具有虚数相加的功能;然后你可以这么调用
fun main(args: Array<String>) {
val c1=Complex(3.0,4.0)
val c2=Complex(2.0,7.5)
println(c1())
println(c1+c2)
}
(5)表达式,控制语句
《1》分支表达式由java的switch变为when
val a=when{
args.isNotEmpty()&&args[0]=="1"-> DEBUG
else -> USER
}
《2》中缀表达式
class Book{
//infix 中缀表达式
infix fun on(any:Any):Boolean{
return false
}
}
class Desk
fun main(args: Array<String>) {
if (!(Book() on Desk())){
println("sdafasfsadas")
}
}
《3》循环语句
package 程序结构
fun main(args: Array<String>) {
for (arg in args){
println(arg)
}
for ((index,value)in args.withIndex()){
println("$index -> $value")
}
while (args[0].isNotEmpty()){
println(args)
}
}
《4》异常捕获,try catch
package 程序结构
fun main(args: Array<String>) {
println(message = try {
args[0]+args[1]
}catch (e:Exception){
"0"
})
}
(6)小案例:计算器
package 程序结构
fun main(args: Array<String>) {
while (true) {
try {
println("请输入算式例如:3 + 4")
val input = readLine() ?: break
val splits = input.trim().split(" ")
if (splits.size<3){
throw IllegalArgumentException("参数个数错误")
}
val arg1 = splits[0].toDouble()
val op = splits[1]
val arg2 = splits[2].toDouble()
val opC = Operator(op)
println("$arg1 $op $arg2=${opC.apply(arg1, arg2)}")
}catch (e:NumberFormatException){
println("你确定输入的是数字么?")
}catch (e:IllegalArgumentException){
println("您确定输入的是三个参数么?(未使用空格分隔)")
}catch (e:Exception){
println("未知异常!"+e.message)
}
print("再来一次?【Y】")
val cmd = readLine()
if (cmd == null || cmd.toLowerCase() != "y") {
break
}
}
}
class Operator(op: String) {
val opFun: (left: Double, right: Double) -> Double
init {
opFun = when (op) {
"+" -> { l, r -> l + r }
"-" -> { l, r -> l - r }
"*" -> { l, r -> l * r }
"/" -> { l, r -> l / r }
else -> {
throw UnsupportedOperationException(op)
}
}
}
fun apply(l: Double, r: Double): Double {
return opFun(l, r)
}
}