Kotlin一步一个脚印学习基础三

刺骨的言语ヽ痛彻心扉 2022-06-08 10:07 194阅读 0赞

【

26、数据类

*/\*\**

*\* 数据类：专用于只"保存"数据的类，比如用户自动登录信息，聊天记录等*

*\* 这里的保存，并不是指保存到磁盘，而是指转换成文本格式，便于保存.*

*\* Kotlin数据类：data class 类名(属性列表)*

*\*/*

data class Article( var id: Int , var title: String , var content: String)

fun main(args: Array<String>) \{

val article = Article( 1001 , "基于Kotlin安卓开发" , "Kotlin内容介绍")

//数据类的序列化：其实就是将实例转化成文本形式

*println*(article.toString())

//复制 copy：生成一个对象的克隆，并更改部分属性

val articlenewTitle = article.copy( title = "快来学习Kotlin安卓开发")

*println*(articlenewTitle.toString())

//数据类对象的解构

val (id , title) = article

*println*( " $id , $title ")

//componentN列举属性

*println*( "componentN： $\{ article.component2() \} , $\{ article.component3() \} ")

27、枚举类

*/\*\**

*\* 枚举类：有限个类型的枚举.*

*\* 其中的每一个称为枚举常量(可带初始值)，每一个以逗号分隔*

*\*/*

//扑克牌花色

enum class PokerCard \{

红心 , 方片 , 梅花 , 黑桃

//衣服尺码：带构造器的枚举

enum class Size( val height: Int) \{

S( 150) , M( 160) , L( 170) , XL( 180) , XXL( 190)

fun main(args: Array<String>) \{

//列举枚举类的常量

*println*(PokerCard.values(). *joinToString*())

//枚举常量 名称和序号，name，ordinal

*println*(Size.valueOf( "XXL"). name)

*println*(Size.valueOf( "XXL"). ordinal) //位置

*println*(Size.values(). *joinToString* **\{ it**. name \+ ":" \+ **it**. height **\}**)

28、对象声明和表达式

*/\*\**

*\* 有时候只是要对某个类进行轻微改造，供临时使用，避免继承*

*\* 对象声明和表达式就很有用.*

*\* 对面向对象编程的优化，避免一些继承导致的代价过高.*

*\*/*

//对于中国人来说，这个类，可能各省人适合继承

open class Chinese28( var name: String) \{

open val skin = "yellow"

fun main(args: Array<String>) \{

//但如果外国人入籍，就不适合用"继承"

//对象表达式：val 对象名 = object : 类，接口\{//属性或方法的override定义\}

val baako = object : Chinese28( "Baako Zaid") \{

override val skin = "black"

*println*( "肤色： $\{ baako. skin \} ")

//纯对象表达式：临时使用，无须继承任何类

val tempParking = object \{

var x = 100

var y = 200

*println*( "停车的位置:( $\{ tempParking. x \} , $\{ tempParking. y \} )")

//对象声明的调用，相当于调用函数

NetWorkRequestManager.register()

//伴生对象的方法，与类关联性强。伴生对象的使用

IDCard.create()

//对象声明，不能用在函数中

//一般用于对其他类的一种使用上的包装,不需要实例化直接使用

object NetWorkRequestManager\{

fun register()\{

*println*( "连接网络注册中...")

//伴生对象，一般用于创建一个类的实例的"工厂"方法

//相当于Java中的，静态成员

class IDCard\{

companion object \{

fun create() = IDCard()

29、异常错误处理

*/\*\**

*\* 异常错误处理*

*\* 对可能发生执行异常的代码的一种保护措施*

*\* 默认异常类：Exception*

*\*/*

fun main(args: Array<String>) \{

//直接展示错误

try \{

"333ggg". *toInt*()

\} catch (e: Exception) \{

*println*(e)

//忽略错误

val a: Int? = try \{

"3gg". *toInt*()

\} catch (e: Exception) \{

null

*println*(a)

30、类型检查和转换

*/\*\**

*\* 检查：对一个变量的类型进行辨别.*

*\* 转换：把变量转换成其他类型使用.*

*\*/*

fun main(args: Array<String>) \{

val a = 5

val b = 6

val c = if (a > b) "大于" else a - b

//类型判断：is

if(c is String)\{

*println*( c. length)

if(c !is String)\{

*println*( "整数： $c ")

//Kotlin编译器大多数时候会智能转换

if(c is Int)\{

*println*( c.inc())

//手动转换：强制转换as，安全转换 as?

val d = c as Int

*println*( "d是c强制转换后的c,值是 $d ")

//安全转换失败后返回可空类型的null

val e = c as? String

*println*(e)

31、为何使用Interface-接口

*/\*\**

*\* 接口：interface：接口是方法、属性或一段功能的"蓝本"*

*\* 仅仅是规定实现的标准(抽象的)*

*\**

*\* 通常用于对类进行附加功能，可以让类本身保持简洁的定义*

*\* 通过实现1个或N个接口的组合，来实现非继承式的功能增强。*

*\**

*\* 生物界的启示1：动物通常大量生长皮毛或者完全光溜溜，但是人基本上是裸替状态。*

*\* 人类通过进化，把皮毛功能剥离，从而实现了着装的自由，与动物极大的区分开。*

*\* 着装让人类可以在任何气候下保持适宜的体温，而不需要靠遗传来维持体温。*

*\**

*\* 启示2：猛兽有尖牙厉爪，可以在捕食大型动物占据优势。但是人类基本没有。*

*\* 人类通过发明类似尖牙厉爪的工具，同时可以轻松捕获大型动物。*

*\* 人的后代不仅不需要尖牙厉爪就可以得到大象肉，牛肉，鲸鱼肉。*

*\*而且人类如此弱体力或弱攻击的物种，居然成了几乎所有动物的噩梦。*

*\**

*\* 这些启示都在明示，继承获得的功能通常是不得已而为之，且进化缓慢，代价高昂。*

*\* 而且在此基础上通过组合各种功能，可以获得强大的能力同时可以轻装上阵。*

*\*/*

32、接口中的属性

*/\*\**

*\* 接口中的属性*

*\**

*\* 接口定义：interface 接口名\{ //各种属性或方法定义 \}*

*\*/*

//很多外国人入籍

interface Livable\{

var hasSkill : Boolean

interface ChinaLivable\{

//接口中的属性只有类型定义，不可初始化。

val hasJobOffer : Boolean

//接口中的属性可以有get，通常用于单纯增加一个常量属性:组合属性

val visaCategory : String

get() = "工作签证"

//接口中的变量属性

var city : String

33、接口中的方法

*/\*\**

*\* 接口中的方法*

*\*/*

interface ChinaLivableA\{

//接口中的方法

fun speakChinese()

//接口中的方法可以有默认实现，通常指该方法是固定不变的。

fun handleGuanxi()\{

*println*( "我知道在中国要非常注重处理人际关系。")

open class Person\{

var name = ""

34、接口的实现和组合

interface LivableB\{

val hasSkill : Boolean

interface ChinaLivableB\{

//接口中的属性只有类型定义，不可初始化。

val hasJobOffer : Boolean

//接口中的属性可以有get，通常用于单纯增加一个常量属性:组合属性

val visaCategory : String

get() = "工作签证"

//接口中的变量属性

var city : String

//接口中的方法

fun speakChinese()

//接口中的方法可以有默认实现，通常指该方法是固定不变的。

fun handleGuanxi()\{

*println*( "我知道在中国要非常注重处理人际关系。")

var bankDeposite : Int

open class PersonB\{

var name = ""

//继承父类，并实现多个接口

class ForigenChinese : PersonB() ,LivableB ,ChinaLivableB \{

override val hasJobOffer: Boolean

get() = true

override var city = ""

override fun speakChinese() \{

*println*( "我叫 $\{this. name \} ,我有HSK一级证书，日常工作生活用中文无障碍。")

override val hasSkill: Boolean

get() = true

override var bankDeposite = 100000

fun main(args: Array<String>) \{

val tom = ForigenChinese()

tom. name = "汤格林"

tom. city = "上海"

tom.speakChinese()

tom.handleGuanxi()

*println*(tom. visaCategory)

*println*(tom. hasSkill)

35、泛型

*/\*\**

*\* 泛型 Generics*

*\* 让一个类型能被"广泛"使用，即通用化，称为"泛型"*

*\* 一般用于函数的参数类型定义，让函数更通用*

*\*/*

fun  main(args: Array<String>) \{

//常用的例子，print和println函数，几乎可放任何类型的参数

*println*( 2)

*println*( "泛型")

*println*( *arrayOf*( "Swift" , "Kotlin" , "ios" , "Android"))

//Array,参数也可以是任意类型

val a = *arrayOf*( 1 , 2 , 3)

//自定义一个泛型函数：<T>,Type的首字母缩写,T代表一个占位符，用尖括号包含

fun < T> showText(pare: T)\{

*println*(pare)

showText( 3)

showText( "我也是泛型函数")

36、泛型约束

*/\*\**

*\* 泛型约束*

*\*/*

fun  main(args: Array<String>) \{

//有时候系统提供的泛型函数很好

//求和

val sum = *arrayOf*( 1 ,  3 ,  99 , \- 2 ,  10245). *sum*()

*println*( "求和为： $\{ sum \} ")

// val sum2 = arrayOf(1, 3, 99, -2, 10245,99.24).sum()

//泛型约束：<泛型占位符：类型>

fun < T:Number> sum( vararg numbers : T): Double \{

return numbers. *sumByDouble*  **\{ it**.toDouble() **\}**

*println*(sum( 1 ,  3 ,  99 , \- 2 ,  10245 , 99.24))

//多重约束：where,各个约束用逗号分隔，写在函数体之前

//例子：把数组中大于某个元素(阈值)的部分取出来并升序排列。

// (99,1,2,-389,88,1024,8888)> （88,99,1024,8888）

fun < T> biggerPart(list: Array< T> , threhold: T): List< T>

where  T:Number ,  T:Comparable< T>

return list. *filter*  **\{ it** >= threhold **\}**. *sorted*()

val b = *arrayOf*( 1 , 0 , 55 , 99 , 3 ,\- 3824 , 666)

*println*(biggerPart(b , 3))

37、扩展

*/\*\**

*\* 扩展：对既有的类增加新功能而无需继承该类，即时无法获取其源代码。*

*\* 主要作用是"立即"为相关的类整体上添加"工具类(Utils)"方法或属性，高效优雅。*

*\**

*\* Kotlin支持：扩展函数，扩展属性。 扩展协议(可能将来版本会支持，Swift中已经实现)*

*\* 与接收者类中参数、名称都一样的扩展是无效的。*

*\* 尽量避免与已有的名字重名，如果一定要重名，参数名和类型也要补一样。*

*\**

*\*/*

//扩展函数：fun 接受者类型.新扩展函数名(参数类别)\{ //函数实现 \}

//1、普通函数拓展：整数的平方

fun Int. square(): Int \{

return this \* this

//泛型属性拓展

//1、普通属性扩展。 例子：整数的下一个数字

val Int. *next*: Int

get() = this \+ 1

//泛型属性扩展：数字类型的半径对应的面积：20.3.area, 面积πr2

val < T : Number> T. *area* : Double

get() = 3.141592 \* this.toDouble() \* this.toDouble()

fun  main(args: Array<String>) \{

*println*((- 12). *square*())

val a = *arrayOf*( 1 ,  2 ,  3 ,  99 , \- 8734)

*println*( "系统方法 $\{ a. *max*() \} ") //系统方法

*println*( "泛型函数拓展方法 $\{ a. *biggest*() \} ") //泛型函数拓展

*println*( "普通属性拓展测试： $\{  3. *next* \} ")

*println*( "求圆的面积: $\{  20.33. *area* \} ")

//2、泛型函数拓展：取数字型数组中最大的元素

fun < T> Array< T>. biggest(): T

where  T : Number ,

T : Comparable< T> \{

var biggest = this\[ 0\]

for (i in  1.. *lastIndex*) \{

val element = this\[i\]

if (element > biggest) \{

biggest = element

return biggest

】

Kotlin一步一个脚印学习基础三

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Kotlin学习笔记 | 函数基础

相关 Kotlin学习笔记(三)--kotlin更方便的写法

相关 Kotlin学习系列——Kotlin 基础语法

相关 Kotlin基础学习(持续更新)

相关学习kotlin第三天

相关 Kotlin一步一个脚印学习基础三

相关 Kotlin一步一个脚印学习基础二

相关 Kotlin一步一个脚印学习基础一

相关 Kotlin学习之 4基础语法

相关 Kotlin学习-基础语法