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)
}