kotlin的基础知识

最新推荐文章于 2024-07-10 15:05:30 发布
最新推荐文章于 2024-07-10 15:05:30 发布
阅读量431 收藏
点赞数
分类专栏： Android kotlin 文章标签： android kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014674558/article/details/108690418
版权

kotlin

kotlin变量声明

val 与var

val 定义不可更改的属性 类似于Java的final修饰过的字段
var 定义可变的的属性

完整的定义：

var <propertyName>[: <PropertyType>] [= <property_initializer>]
[<getter>]
[<setter>]

var vertexCount: Int
    set(value) {
        vertexCount = value
    }
    get() {
        return vertexCount
    }

val 与var

    var name: String ="hello";
    var age: Int =19;
    var firstName:String?=null; // 赋值为null  主动设置

if --else 与when的使用

val answerString: String = if (count == 42) {
    "I have the answer."
} else if (count > 35) {
    "The answer is close."
} else {
    "The answer eludes me."
}

when的使用类似于Java的switch的使用(无三目运算)

val answerString = when {
    count == 42 -> "I have the answer."
    count > 35 -> "The answer is close."
    else -> "The answer eludes me."
}

方法的定义

方法 用fun修饰

fun xxxxxx(xxx:参数类型，xxx:参数类型):类型(返回类型）


// 不带参数的
 fun getUserName(): String {

        var tip = when {
            age == 19 -> "已成年"
            age > 19 -> "已成年"
            age < 19 -> "未成年"
            else -> "未成年"
        }
        return tip
    }
    
    
    // 带参数的
    fun getUserName(childage:Int,name:String): String {

        var tip = when {
            childage == 19 -> "已成年"
            childage > 19 -> "已成年"
            childage < 19 -> "未成年"
            else -> "未成年"
        }
        return tip
    }

匿名函数

val stringLengthFunc: (String) -> Int = { input ->
    input.length
}


val stringLength: Int = stringLengthFunc("Android")

入参是string类型，出参是int类型,注意该方法使用var修饰的不是fun修饰的

相当于定义了一个变量该变量的值是输入值的input指入参，相当于入参的引用

高阶函数

相当于方法中，再调方法和Java的类似

类的创建

####1.无参构造

class Car() {

    private var wheels = wheel
    
    }

####2.有参数的构造，构造方法如有修饰必须使用constructor修饰

class Car(var wheel: List<Wheel>) {

    private var wheels = wheel
    
    }

####3.有参构造 切方法重载，重载方法必须继承this



class Car(var wheel: List<Wheel>) {

    private var wheels = wheel

    constructor(wheel: List<Wheel>, name: String, firstName: String, age: Int) : this(wheel) {

    }

}
4.主次构建均存在且多个参数

class Car(var wheel: List<Wheel>) {

    private var wheels = wheel

    constructor(wheel: List<Wheel>, name: String, firstName: String, age: Int) : this(wheel) {

    }

    constructor(wheel: List<Wheel>, name: String, firstName: String, age: Int,names:String) : this(wheel) {

    }


}
5.init方法要比constructor要早，init类似于static，但是static是在类加载是调用，init是在类初始化的时候。

class Constructors {
    init {
        println("Init block")
    }

    constructor(i: Int) {
        println("Constructor")
    }
}

####6.类的继承

kotlin中所有类的父类是any，默认类是不能被继承的，需要被继承需要open关键字

open class Car(var wheel: List<Wheel>) {

}

class CarSon(wheel: List<Wheel>) : Car(wheel) {


}
7.子类没有主构造方法，但是有次构造方法，次构造方法必须使用super关键字
class MyView  : View {

    constructor(ctx: Context) : super(ctx)

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)

}
8.子类方法的覆盖，必须在父类中open修饰,且被override修饰的方法，被继承，都会是可以被重写的，如果不想被重写，需要使用final 修饰

open class Car(var wheel: List<Wheel>) {
    
    open   fun getName(): String {

        return ""
    }

}


class CarSon(wheel: List<Wheel>) : Car(wheel) {

     override fun getName(): String {
         return super.getName()
     }

}

例如：继承CarSon后的子类是无法调用getName


open class CarSon(wheel: List<Wheel>) : Car(wheel) {

   final  override fun getName(): String {
         return super.getName()
     }

}
9.属性的重写
class Car(var wheel: List<Wheel>) {

    open fun getName(): String {

        return ""
    }

   open var tts: String = "hello"
     open val vertexCount: Int = 0
}


// 重写后的
open class CarSon(wheel: List<Wheel>) : Car(wheel) {

   final  override fun getName(): String {
         return super.getName()
     }

     override var tts: String="ssdsdsd"
     override val vertexCount: Int=1
     
}
10.子类的初始化与父类的初始化，与Java的一致，先进行父类的，之后进行子类的，在init的方法中使用时要注意使用子类的顺序。

父类的构造方法-init–字段赋值之后是子类的和Java的基本一致。

open class Base(val name: String) {

    init { println("Initializing Base") }

    open val size: Int = 
        name.length.also { println("Initializing size in Base: $it") }
}

class Derived(
    name: String,
    val lastName: String
) : Base(name.capitalize().also { println("Argument for Base: $it") }) {

    init { println("Initializing Derived") }

    override val size: Int =
        (super.size + lastName.length).also { println("Initializing size in Derived: $it") }
}

fun main() {
    println("Constructing Derived(\"hello\", \"world\")")
    val d = Derived("hello", "world")
}

结果：

ArgConstructing Derived("hello", "world")
Argument for Base: Hello
Initializing Base
Initializing size in Base: 5
Initializing Derived
Initializing size in Derived: 10
11.内部类调用外部类的

文档使用是：super@Outer:，但是实际使用的是直接调用的，应该是文档版本和我的安装的kotlin的文档不一致的结果。

 open class Car(var wheel: List<Wheel>) {

    open fun getName(): String {

        return ""
    }

     fun getage(): Int {

         return 1;
     }
     
     open var tts: String = "hello"
     open val vertexCount: Int = 0
}




open class CarSon(wheel: List<Wheel>) : Car(wheel) {

    final override fun getName(): String {
        return super.getName()
    }

    override var tts: String = super.getName()
    override val vertexCount: Int = 1


// 内部类
    inner class CarBody {

        fun getSonAge(): Int {
            return getage()
        }
    }
}

12.继承类或者实现接口，出现相同方法时，的规则，先看看Java的：

public class Car {
    public  String  getName(){
        return "";
    }
}


public interface CarInterface {

    String getName();
}

public class Son extends Car  implements CarInterface{
    @Override
    public String getName() {
        return super.getName();
    }
}

java 中已有getName方法了实现接口就不会再让重写getName方法了


open class Car(var wheel: List<Wheel>) {

    open fun getName(): String {

        return ""
    }

     fun getage(): Int {

         return 1;
     }

     open var tts: String = "hello"
     open val vertexCount: Int = 0
}


interface CarInterface {
    fun getName(): String
}

open class CarSon(wheel: List<Wheel>) : Car(wheel),CarInterface{

    override var tts: String = super.getName()
    override val vertexCount: Int = 1


	// 只能重写父类的，接口的无法实现，这和Java的是一样的
    override fun getName(): String {
        return super.getName()
    }
}

还有一种是：不带返回参数的

open class Rectangle {
    open fun draw() { /* ... */ }
}

interface Polygon {
    fun draw() { /* ... */ } // interface members are 'open' by default
}

class Square() : Rectangle(), Polygon {
    // The compiler requires draw() to be overridden:
    override fun draw() {
    	// 明确你要回调的是哪一个父类的方法
        super<Rectangle>.draw() // call to Rectangle.draw()
        super<Polygon>.draw() // call to Polygon.draw()
    }
}
13.抽象类

抽象类和抽象方法和Java的相似，重写的方法也可以做抽象方法基本和Java的一直。


 open class Car(var wheel: List<Wheel>) {

    open fun getName(): String {

        return ""
    }

     fun getage(): Int {

         return 1;
     }

     open var tts: String = "hello"
     open val vertexCount: Int = 0
}



open abstract class CarSon(wheel: List<Wheel>) : Car(wheel),CarInterface{

    override var tts: String = super.getName()
    override val vertexCount: Int = 1

   abstract override fun getName(): String
}


class CarSonSon(wheel: List<Wheel>) : CarSon(wheel) {
    override fun getName(): String {
        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
    }

}

接口

接口的使用和Java的使用基本一样

特殊的有一点是 data修饰的类，类似于Java的javabean，只实现接口

同时实现多个接口出现同名的接口，无返回参数的接口，可直接成组重写

interface A {
    fun foo() { print("A") }
    fun bar()
}

interface B {
    fun foo() { print("B") }
    fun bar() { print("bar") }
}

class C : A {
    override fun bar() { print("bar") }
}

class D : A, B {
    override fun foo() {
        super<A>.foo()
        super<B>.foo()
    }

    override fun bar() {
        super<B>.bar()
    }
}

可见性修饰符

###修饰符

private：声明该文件的内部可见

public ：任何地方可见

peotected：被保护的

intener：内部模块可见的

默认为public

修饰属性，方法，的可见性

修饰类和接口的可见性

对于在类内声明的成员：

private 表示仅在此类内（包括其所有成员）可见；
protected-也与private+在子类中可见；
internal— 该模块内部的任何看到声明类的客户端都会看到其internal成员；
public—任何看到声明类的客户都会看到其public成员。
请注意，在Kotlin中，外部类看不到其内部类的私有成员。

如果您覆盖protected成员并且未明确指定可见性，则覆盖成员也将具有protected可见性。

open class Outer {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4  // public by default
    
    protected class Nested {
        public val e: Int = 5
    }
}

class Subclass : Outer() {
    // a is not visible
    // b, c and d are visible
    // Nested and e are visible

    override val b = 5   // 'b' is protected
}

class Unrelated(o: Outer) {
    // o.a, o.b are not visible
    // o.c and o.d are visible (same module)
    // Outer.Nested is not visible, and Nested::e is not visible either 
}

注：internal修饰的跨model，比如一个lib中的方法或者类被internal修饰，依赖后不可见该方法，或者该类。

泛型


class Box<T>(t: T) {
    var value = t;
}


val box: Box<Int> = Box(1);

kotlin的泛型感觉和Java的差不多

清浅岁月
关注
专栏目录
Kotlin与Java不兼容的情况
Kartist的博客
07-12 1056
定义一个Java的interface： public interface IJavaTest { void test(int param); void test(Integer param); void test(float param); void test(Float param); } 用Kotlin实现这个Java interface，用AS的自
kotlin 不兼容java_Kotlin兼容性
weixin_42531579的博客
02-27 5407
本页介绍 Kotlin 不同版本以及子系统的兼容性保证。兼容性词汇表兼容性意味着回答这个问题：对于给定的两个版本的 Kotlin(例如，1.2 和 1.1.5)，为一个版本编写的代码可以与另一个版本一起使用吗？下面的列表解释了不同版本对的兼容模式。请注意，如果版本号较小(即使发布时间晚于版本号较大的版本)那么版本较旧。对于“旧版本”我们使用 OV，对于“新版本”使用 NV。C——完全兼容(Full...
kotlin 不兼容java_Kotlin 与 Java 兼容的神坑，Int 说：怪我咯
weixin_29104059的博客
02-27 589
Kotlin 是一门完全面向对象的语言，连函数也都是对象，基本类型也是对象，所以类似 Java 那样不伦不类的类型系统，Kotlin 的类型表现起来有着高度的一致性。这样是好的，不仅 Kotlin 这么做，很多语言都这么做。可是，Kotlin 号称 100% 兼容 Java 啊，谁让你这么号称的，只要出了问题就是 Kotlin 的锅！话说我们社区的一位“萌新”(大佬，您也真是太萌了)提了个问题，说...
Kotlin Class
最新发布
hsw
07-10 505
转换为Java后的变化。转换为Java后的变化。转换为Java后的变化。
快速学习Kotlin（二）Kotlin与Java的兼容
u013637594的博客
10-26 1596
与Java的互相调用 由于Java与Kotlin是100%共通的，所以他们可以进行相互的调用。那么在Kotlin中声明了一个函数，在Java中该如何调用这个函数呢？ 假设我们在KotlinDemo.kt文件里写一个Kotlin的函数 fun getMessage(str:String):String{ return str; } 这个时候我们又新建一个Java文件名字叫做Ja...
java类无法调用值,Kotlin无法调用到Java中定义的interface类的问题记录
weixin_31025595的博客
03-22 778
问题产生原因概述一个kotlin类，调用一个Java类中的一个方法。引发了下面这个错误。因为我在kotlin中调用了了java代码中定义的一个接口，然后就报错一个IllegalAccessError错误。如下：E/AndroidRuntime: FATAL EXCEPTION: mainProcess: test.juyoufuli.com.myapplication, PID: 19866jav...
Kotlin基础知识
02-12
Kotlin基础知识 参加课程和Google 训练营后，初步了解Kotlin的发展。 目录 主要景点 内置空安全性。 一流的协程支持。 不鼓励继承以支持合成。 允许您为Web +移动应用程序和微服务使用相同的语言。 JetBrains...
Kotlin基础知识及案例.zip
02-26
本压缩包"Kotlin基础知识及案例.zip"包含了一些关于Kotlin语言的基本概念、语法特性以及实战案例，旨在帮助初学者快速掌握这门语言。 1. **基础语法**： - **变量声明**：Kotlin支持var（可变变量）和val（不可变...
Kotlin基础知识点
劝学
05-13 1350
本文来自刘兆贤的博客_CSDN博客-Java高级,Android旅行,Android基础领域博主，引用必须注明出处！ Kotlin越来越流行，新的知识点和应用技巧，也十分吸引人，尤其是协程，其他还有规避回调的代码写法（类似RxJava）。 下面是经典写法，比较符合kotlin语法 class Test { public static long plus(int i1, int i2) { return i1 + i2; } publi...........
Kotlin基础知识和代码1
08-04
【Kotlin基础知识与代码解析】 Kotlin是一种现代的、面向对象的编程语言，它被设计为简洁、安全和富有表现力。在这个基础教程中，我们将深入理解Kotlin的关键概念，包括变量声明、类型系统、关键字以及二进制和十六...
kotlin 不兼容java_Kotlin无法识别Java保留关键字
weixin_39714835的博客
02-27 460
我在Kotlin中使用Java的保留关键字时遇到问题.由于Kotlin中并非所有保留关键字都可用,因此Kotlin编译器无法(不是？)检测到仅Java中的保留关键字.例如,以默认为例.它是Java保留的关键字.这意味着您不能执行以下操作.public class UserJava {public String default;}但是,它不是Kotlin中的保留关键字,因此您可以按以下方式使用它cl...
2018 Kotlin中的model
人生只是一种体验，不必用来演绎完美。
08-09 1173
数据类 我们经常创建主要用于保存数据的类。在这样的类中，一些标准功能和效用函数通常可以从数据中机械地导出。在Kotlin中，这称为数据类，标记为data： data class User(val name: String, val age: Int) 编译器自动从主构造函数中声明的所有属性派生以下成员： equals()/ hashCode()pair; toString()形式”Use...
Android开发——在Java项目中引用Kotlin的库出现的问题
aue3202128的博客
09-17 595
在Android开发当中，我遇到Kotlin底层的库比Java的库好用。看到那个第三方库支持Java实现，于是我就想在Java底层项目中调用Kotlin底层库。但是我编译的时候，遇到了下面的错误 错误: 无法访问Unit 找不到kotlin.Unit的类文件 解决方案 apply plugin: 'kotlin-android' apply plugin: 'kot...
kotlin小结
王温暖的博客
01-16 355
一、协程相关 1-1、协程使用 官网例子（组合挂起函数）：https://www.kotlincn.net/docs/reference/coroutines/composing-suspending-functions.html 1、顺序调用： suspend fun doSomethingUsefulOne(): Int { delay(1000L)// 假设我们在这里做了一些有用的事 return13 } suspend ...
使用 kotlin 来进行 Android 开发（一）
热门推荐
NekoCode 的记事本
11-20 1万+
文章选自本人知乎专栏并做更改：http://zhuanlan.zhihu.com/kotandroid 未经允许请勿转载。 本系列文章将通过解剖 kotlin_android_base_framework 项目，对其中的一些代码进行展开讲解，来挖掘 kotlin 在现实应用中的一些敏捷优雅之处。 一些资料 本系列文章内容的侧重点是 「 kotlin 在 Android Stu
python基础教程
x13262608581的博客
11-25 1211
－　变量 先赋值［不用显式指定类型］，后使用． －　模板 先导入，后使用 如： import xxx xxx.fun(xxx) 导入模块xxx 使用模块定义的函数fun 另一种导入形式 如： from xxx import fun fun(xxx) 此方式可能引入命名冲突 －　长字符串 """xxxxxx xxxxxxxxxx""" '''xxxxxxxxx xxxxxxxxxx''' 'xxxx' \ 'xxxxxxxx' \ 'xxx' ...
三种call解释（一）： cdcall stdcall naked call等在hook时，保持堆栈平衡
onlyfunboy的专栏
12-06 1505
exe调用某个函数时： int TestFun(int a, int b); EBP+C: second parameter EBP+8: first parameter EBP+4: return address EBP: previous EBP ===》 旧的ebp值（调用者的ebp） EBP-4: local variable EBP-8: local variable ...
oracle package中 table类型参数 调试/debug
baidu_37289241的博客
01-05 512
create or replace type “t_params” is table of varchar2(32000); test代码： declare – Non-scalar parameters require additional processing tparams t_params := t_params(); begin –扩展空间 tparams.extend(4); tparams(1) := ‘aaa’; tparams(2) := ‘bbb’; tparams(3) := ‘ccc
Python学习2
cozy_baby的博客
09-03 158
“”” Brief:1.嵌套函数&amp;return的写法      2.函数调用&amp;括号的写法 “”” def funa(x): def funb(y): z = x + y #return z return funb #funa(1)(2) print(funa(1)(2))#None def funaa(x): def funbb(y): z = x + ...
Kotlin基础知识开场白
05-12
Kotlin 是一种现代化的静态类型编程语言，它最初由 JetBrains 开发，目前已经成为 Android 开发中的主要语言之一。Kotlin 具有许多优秀的...本次对话中，我可以为你提供 Kotlin 基础知识的相关问题解答和学习资源推荐。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值