Kotlin基础 （四）
·
Kotlin基础 （四）
31_kotlin面向对象概念入门
理解协同开发
32_kotlin面向对象实战
社会分工
对洗衣机生产商(程序员A)
电机工作原理
排水工作原理
马达工作原理
电压转换方式
保险
…
对使用者(程序员B)
买个洗衣机
设置模式，开始洗
…
实战代码：
创建一个 Class文件： WashMachine
示例代码：
/*
* 程序员 A 创建的洗衣机
* 属性：var module:String ——>什么牌子的
* var size:Int ——>可以洗多少升
*/
class WashMachine (var module:String,var size:Int){
// 打开洗衣机的门
fun openDoor(){
println("洗衣机的门已经打开了...")
}
// 关闭洗衣机的门
fun closeDoor(){
println("洗衣机的门已经关闭了...")
}
// 开始洗衣服的方法
fun start(){
println("放水...")
println("水放满了...")
println("电机开始转...")
println("洗好了...")
}
}
创建一个 File 文件
示例代码：
/*
* 程序员 B 写的代码
* 程序员 B 的需求：洗衣服
*/
fun main(args: Array<String>) {
// 怎么弄出一个洗衣机(买一个洗衣机)
var washMachine = WashMachine("小天鹅",12)
// 洗衣服前应该打开洗衣机的门
washMachine.openDoor()
washMachine.closeDoor()
washMachine.start()
}
33_kotlin面向对象实战-洗衣机升级
创建一个 Class文件
示例代码：
/*
* 程序员 A 创建的洗衣机
* 属性：var module:String ——>什么牌子的
* var size:Int ——>可以洗多少升
*/
class WashMachine(var module: String, var size: Int) {
var isDoorOPen = true
var currentmode = 0
// 打开洗衣机的门
fun openDoor() {
println("洗衣机的门已经打开了...")
isDoorOPen = true
}
// 关闭洗衣机的门
fun closeDoor() {
println("洗衣机的门已经关闭了...")
isDoorOPen = false
}
fun selectMode(mode: Int) {
currentmode = mode
when (mode) {
0 -> println("初始模式，请您选择模式")
1 -> println("轻柔")
2 -> println("狂柔")
else -> println("不要乱拧，拧环了不保险啊！")
}
}
// 开始洗衣服的方法
fun start() {
if (isDoorOPen) {
println("哔哔...门还没关呢，不能运行")
} else {
when (currentmode) {
0 -> {
println("选择模式错误，不能开始洗衣服")
}
1 -> {
println("放水")
println("轻柔开始，发动机转速 慢")
println("洗完啦！")
}
2 -> {
println("放水")
println("狂柔开始，发动机转速 快")
println("洗完啦！")
}
else -> {
println("选择模式错误，不能开始洗衣服")
}
}
}
}
}
创建一个 File 文件
示例代码：
/*
* 程序员 B 写的代码
* 程序员 B 的需求：洗衣服
*/
fun main(args: Array<String>) {
// 怎么弄出一个洗衣机(买一个洗衣机)
var washMachine = WashMachine("小天鹅",12)
// 洗衣服前应该打开洗衣机的门
washMachine.openDoor()
println("把衣服放进去了！")
washMachine.closeDoor()
washMachine.selectMode(1)
washMachine.start()
}
34_kotlin面向对象实战-封装
封装
隐藏内部实现的细节
隐藏内部实现的细节就是封装
封装就是隐藏内部实现的细节
创建一个 Class文件
示例代码：
/*
* 程序员 A 创建的洗衣机
* 属性：var module:String ——>什么牌子的
* var size:Int ——>可以洗多少升
*/
class WashMachine(var module: String, var size: Int) {
var isDoorOPen = true
var currentmode = 0
// 打开洗衣机的门
fun openDoor() {
println("洗衣机的门已经打开了...")
isDoorOPen = true
}
// 关闭洗衣机的门
fun closeDoor() {
println("洗衣机的门已经关闭了...")
isDoorOPen = false
}
fun selectMode(mode: Int) {
currentmode = mode
when (mode) {
0 -> println("初始模式，请您选择模式")
1 -> println("轻柔")
2 -> println("狂柔")
else -> println("不要乱拧，拧环了不保险啊！")
}
}
// 开始洗衣服的方法
fun start() {
if (isDoorOPen) {
println("哔哔...门还没关呢，不能运行")
} else {
when (currentmode) {
0 -> {
println("选择模式错误，不能开始洗衣服")
}
1 -> {
println("放水")
println("轻柔开始，发动机转速 慢")
setMotorSpeed(100)
println("洗完啦！")
}
2 -> {
println("放水")
println("狂柔开始，发动机转速 快")
setMotorSpeed(1000)
println("洗完啦！")
}
else -> {
println("选择模式错误，不能开始洗衣服")
}
}
}
}
// 封装两个逻辑 发动机转速 慢 和 发动机转速 快
// 设置发动机转速的方法
private fun setMotorSpeed(speed: Int) {
println("当前发动机转速为 ${speed} 圈/秒")
}
}
创建一个 File 文件
示例代码：
/*
* 程序员 B 写的代码
* 程序员 B 的需求：洗衣服
*/
fun main(args: Array<String>) {
// 怎么弄出一个洗衣机(买一个洗衣机)
var washMachine = WashMachine("小天鹅",12)
// 洗衣服前应该打开洗衣机的门
washMachine.openDoor()
println("把衣服放进去了！")
washMachine.closeDoor()
washMachine.selectMode(2)
washMachine.start()
// 当 WashMachine 这个类的 setMotorSpeed() 方法没有给设置 private 时 程序员 B 可以操作 转速(这样是不恰当的，所以 setMotorSpeed()要设置为私有的方法)
// setMotorSpeed()方法是洗衣机内部的一个东西，不应该被别人看到，这一点就叫封装
// （生活中的封装例如：禁止撕毁，撕毁不进行保险）
//washMachine.setMotorSpeed(10000)
}
35_kotlin面向对象-继承(open和override)
继承
继承是指一个对象直接使用另一个对象的属性和方法。
创建一个 Class 类 ：Father
示例代码：
/*
* 父亲
*
*/
// 写完 open 后才可以 进行 子类的继承
open class Father {
var chactor:String = "性格内向"
open fun action(){
println("很有绅士风度！")
}
}
创建一个 Class 类 ：Son
示例代码：
/*
* 孩子
*
*/
// 继承 父亲的属性和方法 (: Father)
// 在 kotlin 里不是随便就可以继承的，需要父类打开了允许继承才可以进行继承
// 需要到父类去写一个关键字 ：open
class Son : Father(){
// override：重写父类的方法
//在 kotlin 里不可以直接重写父类的方法，需要父类打开了允许才可以进行重写方法
override fun action(){
println("儿子很乖，在公共场合很有礼貌")
}
}
创建一个 File ：Test1
示例代码：
fun main(args: Array<String>) {
// 初始化 Son 类
var son1 = Son();
println("儿子的性格${son1.chactor}")
son1.action()
}
36_kotlin抽象类和继承
抽象类
抽象类：如果子类的某个共有行为拥有不同的实现方式，父类中用于描述该行为的方法可以不定义方法体，但此时需要在方法首部中加上 abstract 修饰符，将该方法定义为抽象方法。
创建一个 Class 类 ：Human
示例代码：
/*
* 抽象类
* 抽象的人类
*/
abstract class Human(var name:String) {
// 既然方法是抽象的那么类也应该是抽象的
// 因为 eat 方法在子类中会进行不同的操作所以进行了抽象化
abstract fun eat()
}
创建一个 Class 类 ：Man
示例代码：
class Man(name:String):Human(name) {
override fun eat(){
println("${name}可爱的！")
}
}
创建一个 Class 类 ：Woman
示例代码：
class Woman(name:String):Human(name) {
override fun eat(){
println("${name}漂亮的！")
}
}
创建一个 File ：Test2
示例代码：
fun main(args: Array<String>) {
var person1 = Man("华晨宇")
person1.eat()
var person2 = Woman("邓紫棋")
person2.eat()
}
37_kotlin面向对象-多态
多态
同种功能，不同表现形态.
创建一个 Class 类 ：Human
示例代码：
/*
* 抽象类
* 抽象的人类
*/
abstract class Human(var name:String) {
// 既然方法是抽象的那么类也应该是抽象的
// 因为 eat 方法在子类中会进行不同的操作所以进行了抽象化
abstract fun eat()
// 说话
abstract fun speak()
}
创建一个 Class 类 ：Man
示例代码：
class Man(name:String):Human(name) {
override fun eat(){
println("${name}可爱的！")
}
override fun speak() {
println("${name}高音很高！")
}
}
创建一个 Class 类 ：Woman
示例代码：
class Woman(name:String):Human(name) {
override fun eat(){
println("${name}漂亮的！")
}
override fun speak() {
println("${name}唱歌很好听！")
}
}
创建一个 File ：Test3
示例代码：
fun main(args: Array<String>) {
var person1 = Man("华晨宇")
var person2 = Woman("邓紫棋")
var person3 = Man("贝克汉姆")
var person4 = Woman("蒙娜丽莎")
// 请这些人到一个集合里面(房间)
var houseList = listOf<Human>(person1,person2,person3,person4)
// 进行遍历
for (h in houseList){
h.speak()
}
}
38_kotlin面向对象-抽象类和接口
什么是接口？
接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。
接口的声明和实现
使用 Interface 关键字
抽象类与接口十分的类似
抽象类和接口的区别是什么呢？
抽象类是事物的本质
接口是事物的能力
创建一个 Interface 接口 ：IMan
示例代码：
/*
* 抽象类 和 接口
* 定义 一个 接口
* 用途：人的接口
*/
interface IMan{
fun hair()
}
创建一个 抽象类 ：Human
示例代码：
abstract class Human {
abstract fun eat()
}
创建一个 Class类：Man
示例代码：
/*
* 如果是抽象类的话 : (:号)后面要代一个 ()
* 如果接口的话直接写名字就可以了
*
* 抽象类是事物的本质
* 接口是事物的能力
*/
class Man : Human(),IMan{
// 重写 IMan 接口的方法
override fun hair(){
println("头发是黑色的")
}
override fun eat() {
println("细嚼慢咽的吃饭!")
}
}
创建一个 Class类：NuanNan
示例代码：
// NuanNan 类不具备 IMan这样的一个接口所以不进行实现
class NuanNan : Human() {
override fun eat() {
println("慢吞吞的吃！")
}
}
创建一个 File类：Test
示例代码：
fun main(args: Array<String>) {
var man1 = Man()
man1.hair()
var man2 = NuanNan()
man2.eat()
// 因为 man2 也就是 NuanNan 类没有实现 IMan 接口所以会报错
//var house = listOf<IMan>(man1,man2)
var house = listOf<Human>(man1,man2)
for (p in house){
if (p is Man){
p.eat()
}
}
}
39_kotlin面向对象-委托和代理
委托和代理
委托是把事情托付给别人或别的机构办理.
代理是指以他人的名义，在授权范围内进行对被代理人直接发生法律效力的法律行为。代理的产生，可以是受他人委托.
Kotlin接口代理
采用 by 关键字
创建一个 Interface接口：IWashBowl
示例代码：
/*
* 洗碗的接口
*/
interface IWashBowl {
fun washing()
}
创建一个 Class类：BigHeadSon
示例代码：
/*
* 大头儿子
*/
class BigHeadSon : IWashBowl{
override fun washing(){
println("我是大头儿子，我在洗碗，一次赚1块钱.")
}
}
创建一个 Class类：SmallHeadFather
示例代码：
/*
* 小头爸爸
*/
// 在这里实现代理的接口，小头爸爸让大头儿子去洗碗，从中赚取9块钱
// 通过实现代理接口后，washing()这个方法不用再 SmallHeadFather 里去实现了，而是让 BigHeadSon 中去实现了
class SmallHeadFather : IWashBowl by BigHeadSon(){
}
创建一个 File：Test
示例代码：
fun main(args: Array<String>) {
// 因为在 SmallHeadFather 这个类中 实现了代理的接口所以是大头儿子去洗碗
var father = SmallHeadFather()
father.washing()
}
执行结果：
我是大头儿子，我在洗碗，一次赚1块钱.
修改 SmallHeadFather 类里的代码
示例代码：
/*
* 小头爸爸
*/
// 在这里实现代理的接口，小头爸爸让大头儿子去洗碗，从中赚取9块钱
// 通过实现代理接口后，washing()这个方法不用再 SmallHeadFather 里去实现了，而是让 BigHeadSon 中去实现了
class SmallHeadFather : IWashBowl by BigHeadSon(){
override fun washing() {
// 实现代理接口后可以再代理前实现一些东西
println("我是小头爸爸，我赚了10块钱")
BigHeadSon().washing()
// 实现代理接口后可以再代理后实现一些东西
println("我看着儿子把碗洗完了！")
}
}
执行结果：
我是小头爸爸，我赚了10块钱
我是大头儿子，我在洗碗，一次赚1块钱.
我看着儿子把碗洗完了！
40_kotlin面向对象-单例模式
fun main(args: Array<String>) {
// 如果定义同一个类的两个对象出来，那么它们是不相等的（这时会报错）
var a = BigHeadSon()
var b = BigHeadSon()
println(a == b)
}
上面的代码会报错因为，是两个不同的对象
如果在BigHeadSon 类 中(把 class 修改为 object)
那么by BigHeadSon ：代表的是不需要重新创建 BigHeadSon 这个类的对象了，并且大头儿子在内存当中有且仅有一个
上一节的代码中有一些些错误(如下代码中)
错误为：by BigHeadSon())中有 BigHeadSon()
// 代码(by BigHeadSon())中有 BigHeadSon()：只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
class SmallHeadFather : IWashBowl by BigHeadSon(){
override fun washing() {
// 实现代理接口后可以再代理前实现一些东西
println("我是小头爸爸，我赚了10块钱")
// 只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
// 所以这里又再一次创建了一个对象出来了(大头儿子被创建了两次)
BigHeadSon().washing()
// 实现代理接口后可以再代理后实现一些东西
println("我看着儿子把碗洗完了！")
}
}
修改了 BigHeadSon 类：(把 class 修改为 object)
示例代码：
/*
* 大头儿子
*/
// object：保证大头儿子有且只有一个
object BigHeadSon : IWashBowl{
override fun washing(){
println("我是大头儿子，我在洗碗，一次赚1块钱.")
}
}
修改了 SmallHeadFather类：(把 BigHeadSon() 修改为 BigHeadSon)
示例代码：
/*
* 小头爸爸
*/
// 在这里实现代理的接口，小头爸爸让大头儿子去洗碗，从中赚取9块钱
// 通过实现代理接口后，washing()这个方法不用再 SmallHeadFather 里去实现了，而是让 BigHeadSon 中去实现了
// by BigHeadSon ：代表的是不需要重新创建 BigHeadSon 这个类的对象了，并且大头儿子在内存当中有且仅有一个
class SmallHeadFather : IWashBowl by BigHeadSon{
// 上面的代码(by BigHeadSon())中有 BigHeadSon()：只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
override fun washing() {
// 实现代理接口后可以再代理前实现一些东西
println("我是小头爸爸，我赚了10块钱")
// BigHeadSon().washing()：
// 如果用上面的代码：只要调用了构造方法 BigHeadSon() 那么在计算机内存里就是创建了一个对象(大头儿子)了
// 如果用上面的代码：只所以这里又再一次创建了一个对象出来了(大头儿子被创建了两次)
// 如果用下面的代码：大头儿子在内存当中有且仅有一个
BigHeadSon.washing()
// 实现代理接口后可以再代理后实现一些东西
println("我看着儿子把碗洗完了！")
}
}
File：Test 的代码基本没变(只是添加了测试代码)
示例代码：
fun main(args: Array<String>) {
// 因为在 SmallHeadFather 这个类中 实现了代理的接口所以是大头儿子去洗碗
var father = SmallHeadFather()
father.washing()
// 如果定义同一个类的两个对象出来，那么它们是不相等的（这时会报错）
// var a = BigHeadSon()
// var b = BigHeadSon()
// println(a == b)
}
开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。
更多推荐
0
0- 0
已为社区贡献4条内容
所有评论(0)