【
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: Intget() = this + 1
//泛型属性扩展：数字类型的半径对应的面积：20.3.area, 面积πr2val <T : Number> T.area : Doubleget() = 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(): Twhere 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}
}
】