kotlin 慕课网学习笔记

最新推荐文章于 2023-02-17 11:51:09 发布
最新推荐文章于 2023-02-17 11:51:09 发布
阅读量242 收藏
点赞数
文章标签： 移动开发 java c/c++
原文链接：https://juejin.im/post/5cb33a6ee51d456e4c4bfffd
版权

数据类型

Number

Char

不能隐式转换

String

== 和 ===

字符串模板

$变量

${表达式}

转义字符

rawString

类和对象

定义一个类
class Man constructor( name: String,  age: Int) {
    init {//方法体
        println("My name is $name, and My age is $age")
    }
}
复制代码

如果只有一个构造方法，constructor可以省略

class Man ( name: String, age: Int) {
    init {
        println("My name is $name, and My age is $age")
    }

复制代码

如果没有方法，可以省略括号

class Man constructor( name: String,  age: Int) 
复制代码
new 一个对象，注意不需要new关键字
val man = Man("mr wang", 100)
复制代码

更多构造方法： Kotlin学习系列之：Kotlin的构造函数

继承
//父类
open class Person(color: String) {

    init {
        println("My color is $color")
        println("${this.javaClass.simpleName}")//打印对象的类名
    }
}
//子类
class Man(name: String, age: Int, color: String) : Person(color) {//子类的color传递给父类
    init {
        println("My name is $name, and My age is $age")
    }
}

val man = Man("mr wang", 100, "yellow")
println(man is Person)//类似java instanceof

复制代码

My color is yellow Man My name is mr wang, and My age is 100

true

空安全

String？可为空类型，后面.方法，需要先判断空，或者 加？再去.方法

String 不可空类型

fun say(): String? {
    return null
}
复制代码
 //   say()是可null类型，不可以直接.length，处理方式如下：
//    println(say().length)//会报错
复制代码
//    方式一：加?
//   如果 say()为null 则打印null，不然就打印length
    println(say()?.length)
//  如果 say()为null 则打印"---"，不然就打印length，第二个?:表示当你为null是要输出的内容
    println(say()?.length ?: "---")
复制代码
//    方式二：！！
//    通知编译器我确定不会是null
    println(say()!!.length )
复制代码

智能类型转换

如果知道p是child不需要强转
// java
Parent p = new Child();
if (p instanceof Child) {
    ((Child) p).hello_in_child();
}
复制代码
//kotlin
val parent: Parent = Child()
if( parent is Child){
// hello_in_child是child的方法,因为判断了parent is Child ，所以不需要强转
   parent.hello_in_child()
}
复制代码
强转写法 as
val p = Parent()
val child: Child = p as Child
这样写会报错，因为明显p的类型是父类Parent ，p是不能转为子类的
复制代码

java.lang.ClassCastException: com.kotlin.www.kotlindemo.Parent cannot be cast to com.kotlin.www.kotlindemo.Child

at com.kotlin.www.kotlindemo.ExampleUnitTest.addition_isCorrect(ExampleUnitTest.kt:46)
复制代码

解决方法：as?

可以强转就强转，不能的话就返回null

val p = Parent()
val child: Child? = p as? Child
println(child)
复制代码

null

包

// 虽然位于不同包名下，但是这样会报错，提示冲突
import com.kotlin.www.kotlindemo.test.Parent 
import com.kotlin.www.kotlindemo.Parent
复制代码
//要加入as起个别名区分，以后用这个类也必须使用别名
import com.kotlin.www.kotlindemo.test.Parent as TestParent
import com.kotlin.www.kotlindemo.Parent as Parent


  val p1=TestParent()
  val p2=Parent1()
复制代码

区间

val range=1..3 //[1,3]
val range1=1 until 3//[1,3)

复制代码

遍历

for (r in range){
    println(r)
}

复制代码

判断在不在区间内 in 操作符 或者 contains

println(3 in range)
println(3 in range1)
println(range.contains(3))
println(range1.contains(3))

复制代码

true false true false

数组

i

    基本类型内置数组类型
   	val byteArray = byteArrayOf(1, 2, 3)
    val charArray = charArrayOf('a', 'b', 'c')
    val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
    val floatArray: FloatArray = floatArrayOf(0.1f, 0.2f, 0.3f)
    val booleanArray = booleanArrayOf(true, true, true)
    val shortArray = shortArrayOf(1, 2, 3)
    val longArray = longArrayOf(1, 2, 3)
    val doubleArray = doubleArrayOf(0.1, 0.2, 0.3)
    
    通用定义方式为:
    val array: Array<Parent1> = arrayOf(Parent1(), Parent1(), Parent1())
    val array1: Array<String> = arrayOf("hello","nihao","dajiahao")
    val arrayOf:Array<Int> = arrayOf(1, 2, 3)

复制代码
val intArray: IntArray = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)
// 切片
val slice = intArray.slice(1..3)

复制代码

[2, 3, 4]

程序结构

val

val定义的不可变，基本类似于java的final，要想完全一样，要加上const

函数

一般函数
fun say(): String? {
    return "djh"i
}

// 一般函数
fun sum(a: Int, b: Int) = print(a + b)
sum(1, 2)


复制代码

匿名函数
// 匿名函数
val sum1 = fun(a: Int, b: Int) = print(a + b)
sum1(1, 2)

复制代码

lambda表达式

写法
// lamda表达式
val sum2 = { a: Int, b: Int ->
    println("$a+$b=${a + b}")
    a + b
}

复制代码

lambda表达式作为参数传递
        val arrayInt = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9)

//           接收一个lambda表达式  （ (Int) -> Unit ）
        arrayInt.forEach({ it: Int -> println(it) })
//          只有一个参数时候，it可以省略
        arrayInt.forEach { println(it) }
//           还可以更省略
        arrayInt.forEach(::println)

复制代码
注意事项，lambda表达式return会return整个函数
private fun xunhuan() {
    val arrayInt = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    arrayInt.forEach {
        if (it == 3) {
            return//因为lambda是表达式，这里return 会让整个xunhuan函数返回，最后的一句话不会打印
        }
        println(it)
    }

    println("dajiahao")
}

复制代码

如何解决问题呢

private fun xunhuan() {
    val arrayInt = intArrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    arrayInt.forEach forEach@{
        if (it == 3) {
            return@forEach//这样写，最后的一句话会打印
        }
        println(it)
    }

    println("dajiahao")
}

复制代码

lambda表达式是有类型的

lambda表达式的简化使用方法

类

定义属性

构造方法写在类名字后面

属性访问控制 get set

java的get set 方法

想写kotlin的get set方法怎么办 ，默认有的get set

属性初始化

运算符

class Student(var age: Int) {
//    运算符"+"相当于plus函数，注意必须是plus名称的函数才对应+，参数个数必须是一个，其他没要求
    operator fun plus(s: Student): Student {
        return Student(age + s.age)
    }
}

        val s1 = Student(1)
        val s2 = Student(2)
        val s3 = s1 + s2
//        val s3 = s1.plus(s2)//等同于上面
        print(s3.age)//输出3

复制代码
中缀表达式

class Student(var age: Int) {
    infix fun on(i: Any):Boolean {
        return true
    }
}

复制代码
s1.on(1)
s1 on 1//上面的式子可以简写成 s1 on 1,中缀表达式多用于dsl，一般不用，因为表达不是太清楚

复制代码

分支表达式

if 表达式

每个分支的最后的值是返回值

when表达式 替代switch

when也可以是表达式，也就是可以把他赋值给变量，每个分支最后一个值就是返回值

循环

异常

异常写法

异常表达式

具名参数

变长参数

test(1,2,3,4,5,6,7,8,9,s="fds")
fun test(vararg ints:Int,s:String):Int{
    println(ints[0])
    return ints[0]
}

复制代码
展开操作符*

val arr = intArrayOf(1, 2, 3)
test(*arr, s = "fff")

复制代码

默认参数

 val arr = intArrayOf(1, 2, 3)
 test(ints = *arr, s = "fff")//由于使用了默认参数double(没传递)，第一个参数会有歧义，这时候需要指定具名参数
    
 fun test(double: Double = 1.0, vararg ints: Int, s: String): Int {
        println(ints[0])
        return ints[0]
    }

复制代码

面向对象

继承

![image-20190414194650600](/Users/apple/Library/Application Support/typora-user-images/image-20190414194650600.png)

一个类必须open才能被继承

abstract抽象类和interface接口默认含有open，所以可以直接被继承

父类方法属性也必须open才能被复写，复写必须写override关键字

接口代理

package com.kotlin.www.kotlindemo.daimazai



interface Writer {
    fun write()
}

interface Driver {
    fun drive()
}

class MyWriter : Writer {
    override fun write() {
        println(" I can write")
    }
}


class MyDriver : Driver {
    override fun drive() {
        println("I can drive")
    }
}


//一般接口实现的写法
class Manager : Writer, Driver {
    override fun drive() {
        println("I can Drive")
    }

    override fun write() {
        println("I can write")
    }

}

//接口代理的写法（不要事必躬亲），不需要再次重写接口里的实现方法，而是通过构造函数传递进来一个已经实现接口的实现类对象直接使用这个对象的方法就行
class SeniorManager(private val writer: MyWriter, private val driver: MyDriver) : Writer by writer, Driver by driver

fun test_() {
//    接口代理写法
    val myWriter = MyWriter()
    val myDriver = MyDriver()
    val seniorManager = SeniorManager(myWriter, myDriver)
    seniorManager.write()
    seniorManager.drive()
// 普通实现接口
    val manager = Manager()
    manager.drive()
    manager.write()


}

复制代码

接口方法冲突

package com.kotlin.www.kotlindemo.daimazai
abstract class A {
    open fun hello(): Int = 1
}

interface B {
    fun hello(): Int = 2
}

interface C {
    fun hello(): Int = 3
}

class D(var y: Int) : A(), B, C {
    override fun hello(): Int {

        if (y > 100) {
            return super<A>.hello()//注意使用泛型指明是哪一个接口（抽象类）的方法
        } else if (y > 10) {
            return super<B>.hello()
        } else {
            return super<C>.hello()

        }
    }

}

fun test___(){
    val d = D(1000)
    val hello = d.hello()
    println(hello)
}

复制代码

接口

接口可以有实现方法

可见性

object kotlin的单例写法

他的本质如下

java调用object单例

伴生对象与静态成员

定义

java调用

在定义时候加上注解

java调用更加方便

定义了一个静态成员

java使用kotlin的静态成员

方法重载

下面一个默认参数

kotlin里，不传参代表默认为0，传递了就是传入的值

java如何调用kotlin的默认参数函数呢 必须先改造kotlin写法

java就可以不传参了

扩展成员（方法和属性）

注意：扩展方法定义在了一个Extend.kotlin文件里，不是被扩展的类String里，所以java里如何使用呢

本质是

扩展成员属性

属性代理

属性代理目的

为了让使用属性时候能做更多操作

例如file getfile读文件 setfile 写文件

外界通过访问属性，完成了很多事情

经典例子就是lazy

写代理就是实现getValue和setValue方法，看着下面的class X写就ok

lazy解析

val 只要实现get

var 实现 get set

数据类

加上data，kotlin默认干了很多事情

自己写component

dataclass当做Javabean使用的坑

如何解决呢 使用两个注解

  1. 先 引入依赖

  2. 自定义注解

3.配置自定义注解

4. 使用注解

结果

但是这是在编译期时，操作字节码实现的，所以虽然有无参构造方法，你的代码是在编译期前面写的，此时还没有无参构造方法，但是反射可以拿到

内部类

kotlin默认内部类写法是静态内部类

inner 关键字 实现非静态内部类

匿名内部类

枚举

实例可数

密封类

子类可数

高阶函数

map 几何元素转换

    val list = listOf(1, 2, 3, 4)
    println(list)//[1, 2, 3, 4]

    val list1 = list.map { it * 2 + 3 }//[1, 2, 3, 4]
    val list2 = list.map { it.toDouble() }//[1.0, 2.0, 3.0, 4.0]
    val list3 = list.map(Int::toDouble)//[1.0, 2.0, 3.0, 4.0]
复制代码

flatmap 集合打平

  //集合的集合
    val list = listOf(
        1..10,
        10..13,
        30..37
    )//[1..10, 10..13, 30..37]
    //打平
    val list1 = list.flatMap { it + 100 }
    //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 100, 10, 11, 12, 13, 100, 30, 31, 32, 33, 34, 35, 36, 37, 100]

//所有数字前加No.  注意不同it代表含义不同
    val list2 = list.flatMap {
        it.map {
            "No.$it"
        }
    }
//    [No.1, No.2, No.3, No.4, No.5, No.6, No.7, No.8, No.9, No.10, No.10, No.11, No.12, No.13, No.30, No.31, No.32, No.33, No.34, No.35, No.36, No.37]

复制代码

reduce 累计操作

val list = listOf(1, 2, 3, 4)
    val reduce = list.reduce { acc, i -> acc + i }//累加  10
    val reduce1 = list.reduce { acc, i -> acc * i }//累乘法   24
    
//拼接字符串
  val list = listOf("java", "kotlin", "c++")
  val ccc= list.reduce { acc, s -> acc+","+s }
  println(ccc)//java,kotlin,c++
复制代码
/**
 * 求阶乘
 */
fun jiecheng(n: Int): Int {

    return if (n == 0) {
        1
    } else {
        (1..n).reduce { acc, i -> acc * i }
    }
}

// 集合map变为阶乘，再循环打印
(0..9).map(::jiecheng).forEach(::println)

// 集合map变为阶乘，再累加集合里的元素
(0..9).map(::jiecheng).reduce { acc, i -> acc + i }
复制代码

fold 累计运算，但是可以指定初始值

(0..9).reduce { acc, i -> acc+i }//45

(0..9).fold(100) { acc, i -> acc+i }//145  (100)为指定的初始值

val c= (0..9).fold(StringBuilder("qwe")){ acc, i ->acc.append(i).append(",") }
println(c)//qwe0,1,2,3,4,5,6,7,8,9,
复制代码

foldRight 从右往左累计运算（指定初始值 ）

val list = listOf("java", "kotlin", "c++")
val w=list.foldRight(StringBuilder()){
        s: String, acc: StringBuilder ->
        acc.append(s).append(",")
    }
//c++,kotlin,java,
复制代码

joinToString 连接字符串

    val list = listOf("java", "kotlin", "c++")
    val q=list.joinToString(",")//java,kotlin,c++


复制代码

filter 过滤元素

//    返回偶数(模2为0的数字)的元素
    val filter = (0..10).filter { it % 2 == 0 }
    println(filter)//[0, 2, 4, 6, 8, 10]
复制代码

filterIndexed 过滤索引+元素

//获取奇数位置的数字
    val a: IntArray = intArrayOf(9, 8, 7, 3, 7)
   val ccc= a.filterIndexed { index, i -> index % 2 == 0 }//[9,7,7]
复制代码

takeWhile 和 takeLastWhile


//  取出数组里的奇数元素，遇到不是奇数就停止
    val qwe: IntArray = intArrayOf(17, 9, 8, 19, 3, 7)
    val ok = qwe.takeWhile { it % 2 == 1 }// [17, 9] 从前往后取
    val last = qwe.takeLastWhile {it % 2 == 1   }//[19, 3, 7] 从后往前取值

复制代码

let


data class Cat constructor(var name: String, var age: Int)

fun main() {
    println(100)

//    因为 findCat()?已经非空判断了，所以后面可以直接使用
    findCat()?.let {
        print(it.name)
        print(it.age)
    }
    
//    使用了dataclass的解包操作 component1，2
    findCat()?.let { (name, age) ->
        {
            print(name)
            print(age)
        }
    }
}

fun findCat(): Cat? {
    return null
}

复制代码

apply

package objectori

data class Cat constructor(var name: String, var age: Int) {


    fun work() {

    }

    fun play() {

    }
}

fun main() {
    println(100)

//    因为 findCat()?已经非空判断了，所以后面可以直接使用
    findCat()?.let {
        print(it.name)
        print(it.age)
        it.play()//在let里可以直接用it调用方法
    }


    findCat()?.apply {
        // 在apply里可以直接调用方法，
        work()
        play()
        name
        age

    }
/
}

fun findCat(): Cat? {
    return null
}

复制代码

use with

略

尾递归优化

函数调用了自己后没有任何操作 关键是分辨什么是尾递归

闭包

对象携带状态


fun makeFun(): ()->Unit{

    var count =0

//    返回一个函数
    return fun(){
        count++
        println(count)
    }
}
fun main() {
    var x= makeFun()
    x()
    x()
    x()
    x()
}
//1
2
3
4
复制代码
package objectori


/**
 * start；起始步数 
 * step：每次走的步数
 * 
 */
fun makeFun(start: Int, step: Int): () -> Unit {

    var count = start

//    返回一个函数
    return fun() {
        count += step
        println(count)
    }
}

fun main() {
    var x = makeFun(100,2)
    x()
    x()
    x()
    x()
}
102
104
106
108
复制代码

函数的复合

下面是两个函数

add5：把一个值加5

multiplyBy2：把一个值乘以2

fun main() {
    val add = add5(8)
    val multi = multiplyBy2(add)

    println(add) //13
    println(multi)//26
}

//加5
val add5 = { i: Int -> i + 5 }
//乘2
val multiplyBy2 = { i: Int -> i * 2 }
复制代码


fun main() {
    val add = add5(8)
    val multi = multiplyBy2(add)

    println(add) //13
    println(multi)//26


//    val result = add5.andThen(multiplyBy2)
    val result = add5 andThen multiplyBy2
    println(result(8))


}

//加5
val add5 = { i: Int -> i + 5 }
//乘2
val multiplyBy2 = { i: Int -> i * 2 }


infix fun <P1, P2, R> Function1<P1, P2>.andThen(function: Function1<P2, R>): Function1<P1, R> {
    return fun(p1: P1): R {
        return function.invoke(this.invoke(p1))
    }
}
复制代码

科理化

偏函数

协程

参考这篇文

Kotlin1.3版本的协程

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        coroutine.setOnClickListener { click() }
    }

    private fun click() = runBlocking {
        GlobalScope.launch(Dispatchers.Main) {
            coroutine.text = GlobalScope.async(Dispatchers.IO) {
                // 比如进行了网络请求
                // 放回了请求后的结构
                return@async "main"
            }.await()
        }
    }
}
复制代码

更好的入门 www.kotlincn.net/docs/tutori…

与java交互

SAM转换 单一抽象方法 Single Abstract Method

注意：

示例一 kotlin引用java里的函数（sam转换只是默认支持java接口）

  1. 在java里定义一个addTask（参数为接口实现）
public class SamJava {
    public void addTask(Runnable runnable){

    }
}
复制代码
  1. kotlin调用这个方法

 val samJava = SamJava()

    samJava.addTask(object : Runnable {
        override fun run() {
        // do sth            
        }
    })

    samJava.addTask {
        // do sth   
    }

复制代码

示例二 kotlin引用kotlin里的函数（sam转换只是默认不支持kotlin接口）

只能这样调用

  val samKotlin = SamKotlin()
    samKotlin.addTask(object :Runnable{
        override fun run() {
        }

    })
复制代码

如果kotlin接口想使用sam的话

必须加别名

typealias Runnable = () -> Unit
复制代码

完整如下：

typealias Runnable = () -> Unit

class SamKotlin {
    fun addTask(runnable: Runnable) {

    }

}


fun test() {
    val samKotlin = SamKotlin()
    samKotlin.addTask { 
    //  do sth
    }
}
复制代码

为Runnable起了别名后， java调用加别名后的kotlin 方式如下：

        SamKotlin samKotlin=new SamKotlin();
//       为Runnable起了别名后， java调用加别名后的kotlin 
        samKotlin.addTask(new Function0<Unit>() {
            @Override
            public Unit invoke() {
                return null;
            }
        });
//        简写如下：
        samKotlin.addTask(() -> null);

    }
复制代码

正则表达式

java写法

kotlin写法

直接抄java

也可以用有kotlin自己的写法

集合框架

mapOf同理不可变

注意

java认为kotlin listOf定义的list与普通list没区别，支持调用add remove ，但是实际运行会报错

先在kotlin使用listOf定义一个list

java里使用这个list

IO 操作

Java里面

kotlin 代码

自带关闭流

简单文件读写

    File("KotlinDemo.iml").readLines().forEach(::println)

复制代码

装箱与拆箱

注解处理器

weixin_34236869
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
自定义注解并生成类文件（kotlin实现）
移动，移着动动
01-12 1643
1.新建一个Java Library 的module（文中示例为extent） 2.修改module gradle文件 apply plugin: 'java-library' apply plugin: 'kotlin' dependencies { implementation fileTree(dir: 'libs', include: ['*.jar']) im...
Kotlin笔记
Last Dance
06-06 320
在AndroidStudio里的Prefernces里的Plugins找到Kotlin进行安装并重启。 AndroidStudio3.0会支持Kotlin；Kotlin已成为Android官方指定编程语言，Java依旧能用；Kotlin相对Java，更简洁一些。 Mac下cmd(win)+Alt+Shift+K可以将之前的Java转成Kotlin。 继承(extends)关键字变成了冒号(：)； 实
Kotlin笔记（1）
GXH_APOLOGIZE的博客
05-20 348
什么是Kotlin Kotlin是一门全栈语言。 Kotlin就是一门可以运行在Java虚拟机、Android、浏览器上的静态语言，它与Java100%兼容。 Kotlin除了自己的标准库之外，大多仍然使用经典的Java集合框架。 Kotlin优点 简洁（主要相对于Java） 空值安全 100%与Java兼容 函数式编程 协程 DSL 参考资料 http://kotlin...
Kotlin学习手记，完整版开放免费下载
09-02 83
get可见性必须和属性可见性一致, 不能定义public属性的get为private set可见性不能大于属性的可见性, 不能定义private属性的set为public lateinit 这玩意好像有坑，kotlin中的新玩意，大神都嫌弃它，我们可以了解一下，既然是坑我们不用去记住它，免得被坑。。 lazy是比较推荐的延迟初始化方式，实际上它是一个属性代理 接口代理其实就是可以把一些没必要实现的接口方法隐藏起来不去实现，方便一些，而不用每一个接口都要写一下。其中by关键字右...
Android 程序 Kotlin入门
初心一点的专栏
05-19 300
Android 程序 Kotlin入门Kotlin基本语法1. 定义常量与变量2. 注释3. 字符串模板4. NULL检查机制5. 类型检测及自动类型转换6. 区间 参考链接：Kotlin 基础语法 Kotlin基本语法 1. 定义常量与变量 // 可变变量定义：var 关键字 var <标识符> : <类型> = <初始化值> // 不可变变量定义：val ...
kotlin学习笔记
03-04
Kotlin是一种静态类型编程语言，它在Java虚拟机（JVM）上运行，同时也支持编译成JavaScript，这使得Kotlin编写的...通过学习和实践Kotlin的语法和特性，开发者可以更高效地进行编程工作，提高软件开发的生产力和质量。
learn-kotlin:kotlin 学习笔记
04-30
【Kotlin 学习笔记】 Kotlin 是一种现代、面向对象的编程语言，由 JetBrains 公司开发，主要设计用于解决 Java 语言的一些痛点。它被广泛应用于 Android 应用开发，同时也适用于服务器端开发、Web 开发以及跨平台...
Kotlin-学习笔记
最新发布
07-19
Kotlin-学习笔记
KotlinImoocVideoStudyNotes:Kotlin https的学习笔记
05-09
A study notes for kotlin ：  Index 版权声明 所有原创文章(未进行特殊标识的均属于原创) 的著作权属于 JsonChao。 所有译文文章(标题注明[译]的所有文章) 的原文著作权属于原作者，译文著作权属于 JsonChao。 ...
kotlin-android：学习笔记
02-13
"Kotlin-android：学习笔记"这个主题涵盖了使用Kotlin进行Android应用开发的核心概念、工具和实践。 首先，Kotlin的设计目标是简洁、安全和富有表现力。它的语法简洁明了，减少了冗余代码，使得开发者能更高效地...
Kotlin新手教程三（类与继承）
m0_49622667的博客
02-17 1333
在构造派生类的新实例的过程中，第一步完成其基类的初始化（在之前只有对基类构造函数参数的求值），因此发生在派生类的初始化逻辑运行之前。也就是说，当你实例化一个子类时，首先会初始化父类的主构造方法，父类的初始化代码块和初始化属性，接下来才是子类的。2.主构造器不能包含除属性声明的任何代码块，初始化的代码可以放到以init关键字作为前缀的初始代码块中。注：使用override修饰的方法实际效果也相当在重写的情况下使用open修饰了，如果不想再被其子类重写，那么可以使用final修饰。
Kotlin 创建对象
小牧在一直在学习,在前进的道路上大家一起学习，进步。
05-08 1万+
在java中创建一个对象 可以使用new关键字 类名 对象名 = new 类名(); 例如 LocationService ls = new LocationService(); 注意 Kotlin 并没有new关键字。 可以如下创建 var ls = LocationService() 也就是 类型 对象名 = 类名() 类型 可以使用var 或者val ...
kotlin使用小记。
陌上丿花已开的博客
08-15 297
最近尝试在项目里使用kotlin ，记录一下使用时遇到的问题。 1.List 创建。 kotlin中没有new 关键字，创建对象如下 val listIv = mutableListOf<ImageView>() list添加元素和遍历集合如下 listIv.add(iv) for (i in listIv.indices) { ...
《Kotlin 极简教程 》第3章 Kotlin语言基础
禅与计算机程序设计艺术
09-18 9132
第3章 Kotlin语言基础 掌握基础，持续练习 学习任何东西，都是一个由表及里的过程。学习一门编程语言也一样。对于一门编程语言来说，“表” 就是基本词汇（关键字、标识符等）、句子（表达式）和语法。 每一门编程语言的学习内容都会涉及： 运行环境、基础数据类型（数字、字符串、数组、集合、映射字典等） 、表达式、 流程控制 、类、方法（函数） 等等，不同的语言会借鉴其他的语言特性，同时也会有各自的特性。这样我们就可以通过对比学习来加深理解。另外，我们还通过大量实践深入理解，达到熟练使用。 所谓“纸上得来终
jetbrain kotlin试用笔记
热门推荐
New World
11-09 1万+
试用了一下kotlin语言，挺有意思的：一个基于jvm的语言，能够在jdk6上享用jdk8的lambda、deferred method、stream语法、C#的delegate、类scala语法和类型推断、ruby的code block 等特性。 以前弄过一段时间的scala，实在无法忍受scala的编译速度和一次编写到处编译的特性（字节码不兼容）、天书般的APIdoc。不谈语法，为了
kotlin new一个匿名对象作为参数是怎么样一步一步简化现在的样子
我的专栏
12-16 826
text_home.setOnClickListener(object :View.OnClickListener{ override fun onClick(v: View?) { print("onClick") } }) text_home.setOnClickListener({view:View->{ print("onClick") }}) text_home.setOnClickListener({v..
Kotlin基本语法
xingfeng_coder的博客
07-04 2311
Kotlin语法简洁，主要的几种区别或重点如下： - 不用分号结尾 - 没有new关键字 - “：”很重要 - 参数名在前，类型在后 - …包的定义包的指定需要位于源文件的最顶部。（和Java相同）示例如下： package com.xingfeng_coder.basic.syntas/** * Created by Xingfeng on 2017-06-12. */函数的定义
Kotlin学习（二）：类和接口
lostfound的博客
10-27 595
Kotlin学习（二）：类和接口 类声明 在Kotlin中，类的声明与Java一样，也使用class关键字。 class MyClass{ ... } 类声明由类名、类头（指定其类型参数、主构造函数等）以及由花括号包围的类体构成。类头与类体都是可选的； 如果一个类没有类体，可以省略花括号。 构造函数 在Kotlin中，一个类可以有一个主构造函数（ primary constructor ）及多个次构造函数（ secondary constructor ）。 主构造函数 主构造函数是类头的一部分，紧
三、kotlin的类和对象(二)
bangiao的博客
06-27 849
theme: channing-cyan 沿用了 的单继承系统, 不允许 的多继承出现, 但允许 接口的多实现 (1) 子类需要继承父类, 子类有责任负责父类字段的初始化(2) 子类最终都需要调用到父类的构造函数以初始化父类的字段, 子类构造函数如果要调用父类构造函数需要使用上 (3) 子类构造函数如果要调用到子类的其他构造函数则需要使用到 覆盖方法(重写方法) kotlin 所有的类、函数和字段默认都添加上了 如果我们需要重写这些功能，可以使用 覆盖属性 在字段上: (字段可见性默认是
Kotlin编程语言学习指南
Kotlin学习教程 Kotlin是一种静态类型的编程语言，运行于Java虚拟机（JVM）上，由 JetBrains 开发。Kotlin的设计目标是创建一种更简洁、更加安全、更加 interoperable 的语言，能够与Java完全互操作。Kotlin的语法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值