【Kotlin】Kotlin 面向对象 ( 类 | 成员变量 | 成员方法 | 封装 | 继承 | 多态 )

I . 创建简单类 ( 整型字段 )

定义类 :

① 定义类 : 定义类的关键字是 class ;

② 定义字段 : 在类后的括号内 , 使用 var 字段名称:字段类型 可以定义一个字段 ;

/**
 * 定义 Rect 类 : 定义类的关键字是 class
 *
 * 类字段 : 该类对象有两个属性 , 宽 ( width ) 和 高 ( height ) , 类型都是 int
 *
 */
class Rect (var width:Int , var height : Int)

/**
 * 函数入口
 */
fun main(args:Array<String>){
    //创建矩形
    var rect = Rect(10, 8);

    //使用字符串模板打印 Rect 对象字段
    println("Rect width : ${rect.width} , height : ${rect.height}")
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
 

执行结果 :

Rect width : 10 , height : 8

  

 

  
1
 

II . 创建简单类 ( 整型字段 + 字符串字段 )

定义类 :

① 定义类 : 定义类的关键字是 class ;

② 定义字段 : 在类后的括号内 , 使用 var 字段名称:字段类型 可以定义一个字段 ;

/**
 * 定义学生类
 *
 * 定义字段 : 其含有一个字符串字段 ,
 */
class Student ( var name:String , var age:Int )

fun main(args:Array<String>) {

    //创建 Student 对象
    var student = Student("Tom", 18)

    //使用字符串模板打印 Student 对象字段
    println("student name : ${student.name} , age : ${student.age}")

}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
 

执行结果 :

student name : Tom , age : 18

  

 

  
1
 

III . 类方法定义

类方法定义 : 使用 fun 关键字 , 在类中定义方法 , 在该方法中可以访问对象的成员变量 ;

/**
 * 定义学生类
 *
 * 定义字段 : 其含有一个字符串字段 ,
 */
class Student ( var name:String , var age:Int ){

    fun talk(){
        println("Student ${name} is talking")
    }

}

fun main(args:Array<String>) {

    //创建 Student 对象
    var student = Student("Tom", 18)

    //使用字符串模板打印 Student 对象字段
    println("student name : ${student.name} , age : ${student.age}")

    //调用类中的方法
    student.talk()

}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
 

执行结果 :

student name : Tom , age : 18
Student Tom is talking

  

 

  
1
  
2
 

IV . 封装

封装作用 : 隐藏对象内部的属性和方法实现的细节 , 仅对外公开公共接口 ;

如 : Student 类 , 封装了 name 和 age 字段 , 和 talk 方法 ;

V . 继承

1 . 父类 : open 关键字使用 :

① 打开继承 : 只有在类前使用 open 关键字 , 只有打开了该类 , 才能有类继承该类 ;

② 允许方法重写 : 允许方法重写 , 只有 open 的函数 , 才能被子类重写 ;

/**
 * 定义父类
 *
 * open 关键字作用 : 打开继承 , 只有打开了该类 , 才能有类继承该类
 *                 允许方法重写 , 只有 open 的函数 , 才能被子类重写
 */
open class Father {

    var familyName:String = "Trump"

    fun name(){
        println("My family name is ${familyName}")
    }

    //允许方法被重写
    open fun say(){
        println("I'm father. family : ${familyName}")
    }

}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
 

2 . 子类 : 继承类 并 重写方法 ;

/**
 * 子类代码
 *
 * 继承 : 使用 冒号 ":" , 表示继承
 */
class Son : Father() {

    //重写父类方法
    override fun say(){
        println("I'm son. family : ${familyName}")
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
 

3 . 测试继承 :

/**
 * 测试继承
 */
fun main() {

    //创建子类对象
    var son = Son();

    //调用子类对象继承的父类的方法
    son.name();

    //调用子类对象重写的父类方法
    son.say();
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
 

4 . 执行结果 :

My family name is Trump
I'm son. family : Trump

  

 

  
1
  
2
 

VI . 多态 与 抽象类

1 . 定义抽象类 : 只有抽象类中才能定义抽象方法 ( 与 Java 不同 ) ;

/**
 * 抽象类 : 只有抽象类中才能定义抽象方法 ( 与 Java 不同 )
 */
abstract class Human ( var name:String , var age:Int ) {

    /**
     * 定义抽象方法 , 类必须是抽象类
     */
    abstract fun say();

}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
 

2 . 实现类 1 :

/**
 * 定义 Man 类 , 继承抽象类 Human
 */
class Man(name : String, age : Int) : Human(name, age) {

    /**
     * 实现的 Human 抽象类 的 say 抽象方法
     */
    override fun say() {
       println("Man : name : ${name} , age : ${age}")
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
 

3 . 实现类 2 :

/**
 * 定义 Women 类 , 继承抽象类 Human
 */
class Woman(name : String, age : Int) : Human(name, age) {

    /**
     * 实现的 Human 抽象类 的 say 抽象方法
     */
    override fun say() {
        println("Women : name : ${name} , age : ${age}")
    }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
 

4 . 多态引入 : Man 和 Women 调用 say 方法 , 执行的不同的操作 , 就是多态的体现 ;

/**
 * 测试抽象类与多态
 */
fun main() {

    // Man 和 Women 调用 say 方法 , 执行的不同的操作
    //  这就是多态

    var tom = Man("Tom", 18);

    //Man : name : Tom , age : 18
    tom.say();

    var jerry = Woman("Jerry", 19);

    //Women : name : Jerry , age : 19
    jerry.say();

}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
 

文章来源: hanshuliang.blog.csdn.net，作者：韩曙亮，版权归原作者所有，如需转载，请联系作者。

原文链接：hanshuliang.blog.csdn.net/article/details/104527342