Kotlin基础知识学习(四)

类和对象

类的构造

定义

类也是用关键字class修饰。
如果是public修饰的类，public可以省略
用：表示类的继承。
继承需要在类后面加上()。
创建类实例时不需要new。
init{}表示类初始化模块。

/*** 1、如果是public修饰的类，public可以省略* 2、用：表示类的继承* 3、继承需要在类后面加上()*/
class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {super.onCreate(savedInstanceState, persistentState)}
}

class Shape {/*** 初始化函数属于构造函数的一部分*/init {println("Shape是表示形状的类")}
}

构造函数

主构造函数

主构造函数，放在类名后面，用constructor修饰。
没有带@符号修饰的，constructor可以省略。
主构造函数不是必须的。

/*
* 主构造函数，放在类名后面
* */
class Shape1(name:String) {/*** 初始化函数属于构造函数的一部分*/init {println("Shape1是表示形状的类，名称是$name")}
}

class Shape1 constructor(name:String) {}

//只有带参的主构造函数，创建需要参数声明var shape1 = Shape1("通用形状")

次构造函数

没有名称。
用关键字constructor修饰。
如果有主构造函数需要调用主构造函数。
会先调用主构造函数的初始化函数。

/*
* 主构造函数，放在类名后面
* */
class Shape2(name:String) {/*** 初始化函数属于构造函数的一部分*/init {println("Shape2是表示形状的类，名称是$name")}/** 二级构造造函数* 1、没有名称* 2、用关键字constructor修饰* 3、需要调用主构造函数* 4、会先调用主构造函数的初始化函数* */constructor(name:String,side:Int) : this(name) {println("Shape2是表示形状的类，名称是$name，是${side}边形")}
}

    //有主构造和二级构造，可以用两种方式声明var shape2 = Shape2("通用形状")var shape3 = Shape2("通用形状",4)

/*** 没有主构造函数*/
class Shape3 {init {println("Shape3是表示形状的类")}constructor() {println("Shape3是表示形状的类,无参")}constructor(name:String) {println("Shape3是表示形状的类，名称是$name")}constructor(name:String,side:Int) {println("Shape3是表示形状的类，名称是$name，是${side}边形")}}

    //只有二级构造函数，会先调用初始化函数var shape4 = Shape3()var shape5 = Shape3("通用形状")var shape6 = Shape3("通用形状",5)

参数带默认值的造函数

构造函数的参数可以带默认值。

class Shape4 {/*** 初始化函数属于构造函数的一部分*/init {println("Shape4是表示形状的类")}/*** 带默认参数的构造函数*/constructor(name:String,side:Int = 6) {println("Shape4是表示形状的类，名称是$name，是${side}边形")}}

    //参数带带默认值，创建的时候可以不用传var shape7 = Shape4("通用形状")var shape8 = Shape4("通用形状",8)

如果要兼容Java创建实例的时候也能用默认参数，则需要加上@JvmOverloads修饰，否则编译会出错。

class Shape5 {/*** 初始化函数属于构造函数的一部分*/init {println("Shape5是表示形状的类")}/*** 带默认参数的构造函数* 如果要兼容Java创建实例的时候也能用默认参数，则需要加上@JvmOverloads修饰* 否则编译会出错*/@JvmOverloads constructor(name:String,side:Int = 6) {println("Shape5是表示形状的类，名称是$name，是${side}边形")}}

        //java形式创建Shape5 shape4 = new Shape5("通用形状");

类的成员

属性

在类里面定义属性，在init模块里面初始化属性。

/*
* 在类里面定义属性，在init模块里面初始化属性
* */
class People (name:String,age:Int){//成员属性var name:Stringvar age:Intinit {//初始化this.name = namethis.age = age}
}

    var people = People("张三",18)//属性访问people.age = 19println(people.age )//19println(people.name )//张三

直接在主构造函数里面声明属性。

/*
* 直接在主构造函数里面声明属性
* */
class People1 (var name:String, var age:Int){}

    var people1 = People1("李四",18)println(people1.age )//18println(people1.name )//李四

方法

用fun修饰表示方法。
调用也是通过.方法名。

/*
* 直接在主构造函数里面声明属性
* */
class People1 (var name:String, var age:Int){fun getName():String {return name}fun getAge():Int {return age}
}

    var people1 = People1("李四",18)println(people1.getName())//李四println(people1.getAge())//18

伴生对象

使用伴生对象来模拟静态属性和方法。
伴生对象中的属性和方法可以通过类名直接访问。
用companion object进行修饰。

    /** companion object表示半生对象，相当于Java中的静态* */companion object {//属性var speciesCount:Int = 0//方法fun judgeSex(sex:Int):Int {var sexName:String = when (sex) {0 -> "女"1 -> "男"else -> ""}return sex}}

    //用类名直接访问People2.speciesCountPeople2.judgeSex(people2.sex)

类的继承、抽象、接口

开放修饰符

修饰符	说明
public	公共开放，默认是public
internal	本模块内能访问
protected	自己和其子类
private	私有

继承

默认不能被继承。
类要能被继承需要声明open类型。
private和open不能共存。
父类中如果方法允许被重写，方法也得加上open。
用:表示继承。
方法重写需要加上override关键字。
不允许多继承即同时继承多个类。

/*
* class前面加上open表示允许被继承
* */
open class People (var name:String, var age:Int){protected var height:Double = 0.0private var sex:Int = 0/** 加上open方法才能被重写* */open fun eat() {println("${name}正在吃饭")}protected open fun introduce() {println("我是个好人")}fun setSex(sex:Int){this.sex = sex}
}

/*
* 继承用:表示
* */
class Student(name:String,age:Int) : People(name,age) {/** 方法重写在方法前面加上override* */override fun eat(){introduce()println("学生${name}正在吃饭")}override fun introduce(){println("我是个好学生")}}

抽象类

抽象类用关键字abstract修饰。
抽象类不一定有抽象方法，但有抽象方法的必须是抽象类。
可以有非抽象的方法。
抽象类和方法需要被实现，所以open关键字可以不写。

/*
* 定义形状抽象类Shape
* 1、抽象类用关键字abstract修饰
* 2、抽象类不一定有抽象方法，但有抽象方法的必须是抽象类
* 3、可以有非抽象的方法
* */
abstract class Shape {/** 抽象方法* */abstract fun draw()/** 非抽象方法* */open fun area(): Double {throw UnsupportedOperationException("This method should be overridden by subclasses")}
}


class Circle(val radius:Double) : Shape(){/** 方法重写* */override fun draw() {println("画一个圆")}override fun area(): Double {return Math.PI * radius * radius}
}

class Rectangle(val width: Double, val height: Double) : Shape(){override fun draw() {println("画一个长方形")}override fun area(): Double {return width * height}
}

    val circle = Circle(10.0)circle.draw()//画一个圆println("圆的面积是${circle.area()}")//圆的面积是314.1592653589793val rectangle = Rectangle(10.0, 10.0)rectangle.draw()//画一个长方形println("长方形的面积是${rectangle.area()}")//长方形的面积是100.0

接口

用interface表示接口
接口不能有构造函数，否则会报错。
没实现的方法默认是抽象，所以open可以省略。
允许有实现的方法。
也是用:表示实现接口。

* 用interface表示接口
* 1、接口不能有构造函数，否则会报错。
* 2、没实现的方法默认是抽象，所以open可以省略。
* 3、允许有实现的方法。
* */
interface Animal {fun eat()fun makeSound()fun common(name:String){println("${name}是一只可爱的动物")}
}

class Dog : Animal{override fun eat() {println("狗正在吃饭")}override fun makeSound() {println("狗正在汪汪叫")}}

class Cat : Animal{override fun eat() {println("猫正在吃饭")}override fun makeSound() {println("猫正在喵喵叫")}
}

特殊类

嵌套类

在外部内定义一个类，嵌套类不能访问外部类的属性、方法等。
调用嵌套类时通过调用嵌套类时通过(外部类名称.内部类)，相当是外部类的静态内部类。

class Outer(var name:String) {fun outFunction(){}//嵌套类class NestedInObject(var nestedName:String) {fun nestedFunction() {//不能访问外部类的属性和方法//println(name)//outFunction()}}
}

    //调用嵌套类时通过(外部类名称.内部类）// 相当是外部类的静态内部类Outer.NestedInObject("嵌套类")

内部类

在类内部定义一个类，且用inner进行修饰，称为内部类。
内部类可以访问外部类的属性。
调用内部类需要先创建外部类。

class OuterInner(var name:String) {fun outFunction(){println("outFunction")}//用inner表示是内部类inner class Inner(var innerName:String){fun innerFunction(){println("$innerName")//可以访问外部类的属性println("$name")outFunction()}}
}

    //访问内部类需要先创建内部类val inner = OuterInner("外部类").Inner("内部类")inner.innerFunction()

枚举类

通过enmu修饰，用于定义一组常量。

enum class Color {RED, GREEN, BLUE
}

    //直接访问val red = Color.REDprintln(red)//REDprintln(red.name)

遍历枚举

    //遍历枚举for (color in Color.values()) {println(color)}

可以添加属性

/*** 可以添加属性*/
enum class Planet(val mass: Double, val radius: Double) {MERCURY(3.303e+23, 2.4397e6),VENUS(4.869e+24, 6.0518e6),EARTH(5.976e+24, 6.37814e6);}

println(Planet.EARTH.mass)

添加方法

/*** 可以添加方法*/
enum class Operation {PLUS {override fun apply(x: Int, y: Int) = x + y},MINUS {override fun apply(x: Int, y: Int) = x - y},TIMES {override fun apply(x: Int, y: Int) = x * y},DIVIDE {override fun apply(x: Int, y: Int): Int {return if (y == 0) throw ArithmeticException("Division by zero") else x / y}};abstract fun apply(x: Int, y: Int): Int
}

Operation.PLUS.apply(10,20)

数据类

一种用于存储数据的特殊类，其主要目的是简化数据持有者的实现。
数据类会自动为你生成一些常用的方法，比如 equals()、hashCode() 和 toString()，以及 copy() 方法（用于复制对象并修改其部分属性）。
用data修饰，需要有主构造函数。

data class Person(val name:String,val age:Int)

    val person = Person("张三", 19)val copy = person.copy()person.equals(copy)person.toString()

密封类

一种用于表示受限的类继承结构的特殊类。
密封类可以有一个或多个子类，但所有这些子类必须在同一个文件中声明。这意味着你不能在密封类声明的文件之外继承它。
密封类常用于表示一组受限的、相关的类，例如状态、事件或者消息类型。
密封类的主要用途之一是提供更强的类型安全性，在 when 表达式中尤为明显。当你使用密封类时，编译器可以确保你已经覆盖了所有可能的子类，从而避免使用 else 分支或者处理未预期的类型。

sealed class OrderStatus {object Pending : OrderStatus()object Shipped : OrderStatus()object Delivered : OrderStatus()object Cancelled : OrderStatus()
}fun printOrderStatus(status: OrderStatus) {when (status) {is OrderStatus.Pending -> println("Order is pending.")is OrderStatus.Shipped -> println("Order has been shipped.")is OrderStatus.Delivered -> println("Order has been delivered.")is OrderStatus.Cancelled -> println("Order has been cancelled.")}
}fun main() {val status = OrderStatus.ShippedprintOrderStatus(status)
}