Kotlin中类是否与Java一样存在封装、继承、多态？

一、核心结论

Kotlin 完整支持面向对象三大特性：封装、继承、多态 ，设计思想和 Java 一致，但语法规则、默认行为、关键字有大量差异，很多坑点需要区分。

二、封装（访问控制、数据隐藏）

1. 访问修饰符对比

修饰符	Java	Kotlin	作用范围
public	默认	默认	全部可见
private	当前类内	当前类内	仅本类访问
protected	本类+子类	本类+子类+同一包	子类可访问
default(包私有)	同包可见	无此修饰符	Kotlin 不提供包私有
internal	无	Kotlin独有	同一模块内可见

2. Kotlin 封装特色

属性自带 getter/setter，天然封装
Java 需要手动写 get/set，Kotlin 自动生成，还能自定义访问器：

kotlin 复制代码

class User {
    var age: Int = 0
        set(value) {
            if (value > 0) field = value
        }
    val name: String = "test" // 只读，只有getter无setter
}

val / var 区分只读/可变，强化封装
val 等同于 Java final 字段，外部无法修改；
数据类 data class 封装数据，自动生成 equals、toString、拷贝；
私有化构造函数实现单例、禁止外部实例化：
kotlin 复制代码
```
class Manager private constructor()
```

3. 与 Java 封装区别

Kotlin 没有包私有，新增 internal 模块级可见；
字段不会直接暴露，访问必然走 getter，封装更彻底；
无需大量模板代码。

三、继承

1. 核心规则差异（重点）

Java 类默认可继承；Kotlin 类默认 final 不可继承
Kotlin 想要被继承必须显式加 open：
java 复制代码
```
// Java 默认能被继承
class Parent{}
```
kotlin 复制代码
```
open class Parent // 不加open无法子类继承
class Son : Parent()
```
方法同理：普通方法默认 final，重写需父类 open、子类 override
单继承：和 Java 一致，只能继承一个父类，不支持多类继承；
构造函数继承：
- Java 子类构造第一行必须 super()
- Kotlin 在子类父类声明处直接调用构造 Son : Parent(参数)
抽象类 abstract class：和 Java 作用一致，不能实例化，可包含抽象方法；
接口 interface：
- Java 8 前接口只有抽象方法，Kotlin 接口可带属性、实现方法；
- 一个类可实现多个接口，弥补单继承限制。

2. 代码示例

kotlin 复制代码

open class Animal(name: String) {
    open fun speak() {}
}

class Dog(name: String) : Animal(name) {
    override fun speak() {
        println("汪汪")
    }
}

四、多态

Kotlin 完全支持多态，分为方法重写多态、接口多态，逻辑和 Java 完全一致。

1. 多态实现条件（和Java相同）

存在继承/实现关系；
父类/接口方法 open，子类重写 override；
父类引用指向子类对象。

2. 示例

kotlin 复制代码

open class Animal {
    open fun speak() = println("动物叫声")
}
class Cat : Animal() {
    override fun speak() = println("喵喵")
}
class Bird : Animal() {
    override fun speak() = println("叽叽")
}

fun main() {
    // 父类引用接收不同子类，多态体现
    val a1: Animal = Cat()
    val a2: Animal = Bird()
    a1.speak() // 喵喵
    a2.speak() // 叽叽
}

3. 接口多态（常用）

kotlin 复制代码

interface Play {
    fun game()
}
class Boy : Play {
    override fun game() = println("打游戏")
}
class Girl : Play {
    override fun game() = println("画画")
}

fun playGame(p: Play) {
    p.game()
}
// 传入不同实现类，多态分发
playGame(Boy())
playGame(Girl())

五、补充：Kotlin 独有的面向对象补充特性（Java没有）

密封类 sealed class：限制继承范围，强化多态分支判断；
枚举类 enum class 语法更简洁；
对象表达式 object 匿名内部类，简化多态临时实现；
委托 by 语法，快速实现接口代理，简化多态代码。

六、总结

封装：完整支持，新增 internal、自动get/set、val只读，封装能力强于Java；
继承：规则大体一致，唯一关键区别：Kotlin 类/方法默认 final，需 open 才能继承重写；同样单类继承、多接口实现；
多态：底层原理、使用场景和 Java 完全相同，依靠重写 + 父类引用指向子类实现；
Kotlin 只是优化语法，没有删减面向对象三大基础特性。