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

【

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

}

}

】