Kotlin '；打开'；和'；公共'；在科特林？

我是Kotlin的新手，我对

open

和

public

关键字感到困惑。有人能告诉我这些关键字之间的区别吗？

关键字的意思是“开放扩展”：

类上的

open

注释与Java的

final

相反：它允许其他人从该类继承。默认情况下，Kotlin中的所有类都是

final

，对应于有效的Java，第17项：继承的设计和文档，或者禁止它

您还需要明确说明要使其可重写的方法，并用

open

标记：

open class Base {
    open fun v() {}
    fun nv() {}
}

public

关键字用作可见性修饰符，可应用于类、函数等。 请注意，如果未明确指定任何其他内容，则默认为

public

：

如果未指定任何可见性修饰符，则默认情况下使用

public

，这意味着您的声明将随处可见

---

Java中的

类A{…}

等于Kotlin中的

开放类A{…}

。
Java中的

最终类B{…}

等于Kotlin中的

类B{…}

它与

public

无关

在Kotlin中，默认情况下，没有访问修饰符的所有内容都是

public

。您可以在定义中显式地说

public

，但在Kotlin中这不是必需的

所以

及

---

在Kotlin中是相同的。

open在java中与Final相反。 如果类不是“打开”的，则无法继承它

class First{}
class Second:First(){}  // Not allowed. Since 'First' is Final(as in Java) by default. Unless marked "open" it can't be inherited 

不要混淆开放和公共。公共是可见性修饰符

class Third{}  // By default this is public
private class Fourth{}
class Fifth{
    val third = Third() // No issues
    val fourth = Fourth() // Can't access because Fourth is private
}

---

我放在这里只是为了我的备忘录，也许对其他人有用：

在kotlin中打开类意味着可以继承类，因为默认情况下它们不是：

 class Car{....}
 class Supercar:Car{....} : // give an error

 open Car2{....}
 class Supercar:Car2{....} : // ok

publicJava中的类是关于类的可见性的（与继承无关：除非Java中的类是最终类，否则默认情况下可以继承它）。 在kotlin中，默认情况下所有类都是公共的

kotlin中的打开方法意味着可以重写该方法，因为默认情况下它们不是。 相反，在Java中，默认情况下可以覆盖所有方法

打开的类的方法在默认情况下不能像往常一样被重写（不管该类是否打开），必须声明它们可以被重写：

 open class Car{
    fun steering{...}
 }
 class Supercar:Car{
    override fun steering {...}  // give an error
 } 

 open class Car2{
    open fun steering{...}
 }
 class Supercar:Car2{
    override fun steering {...}  // ok
 }

---

有关更多详细信息：

默认情况下，所有

类

、

方法

和

成员都是
公共
，但不是
打开的

关键字
open
在kotlin中的意思是“为扩展而打开”

这意味着，如果您希望任何类被任何子类继承，或者希望在子类中重写方法，则必须将其标记为打开，否则将出现编译时错误

注意：
abstract
类或方法在默认情况下是
打开的
，您不需要显式添加。
public：Kotlin中的public关键字类似于java，它用于使类、方法和变量的可见性从任何地方都可以访问

open：在Kotlin中，所有类、函数和变量默认为final，而通过继承属性，我们无法继承final类、final函数和数据成员的属性。因此，我们在类、函数或变量之前使用open关键字使其可继承。
open VS final VS PUBLIC

开放式：

子类可以访问它，因为它们是由其父类继承的
在Kotlin中，您需要添加“open”关键字，而java的所有类在默认情况下都是“open”的
例如：
Kotlin:打开类A（）{}
Java:class A（）{}
最终：

子类无法访问或继承
在JAVA中，您需要添加'final'关键字，而kotlin的所有类默认为'final'
例如：
Kotlin:class A（）{}
Java:final类A（）{}
PUBLIC：任何类，无论其继承与否，都可以访问其数据或方法

科特林的例子：

//Final
class DemoA() {
    
    protected fun Method() {

    }

}

class DemoB() : DemoA {
    Method() // can't access
}

//OPEN
open class DemoA() {
    
    protected fun Method() {

    }

}

class DemoB() : DemoA {
    Method() // can access
}

//Public
class DemoA() {

    fun Method() {

    }

}

class DemoB()  {
    val a = DemoA()
    a.Method() // can access
}

Java中的示例：

//FINAL
final class DemoA() {
    protected void name() {
        
    }
}

class DemoB() extends DemoA {
    name(); // Can't access
}

//Open
class DemoA() {
    protected void name() {
        
    }
}

class DemoB() extends DemoA {
    name(); // Can access
}

//Public
class DemoA() {
    void name() {
        
    }
}

class DemoB(){
    DemoA a = new DemoA()
    a.name(); // Can access
}

如果是这样，将类
公开到底有什么用？如果使用
打开
，您可以继承该类。将类
公开
的主要目的是什么？我认为这就像Kotlin中的分号。它们对Java人来说是存在的。“您的声明将随处可见”这句话是什么意思？这是文档中的引用，任何类都可以访问并创建实例：好的。现在我明白了。“可见”指的是“可访问”。而
public
使它可以从任何地方访问。
open
允许继承类。谢谢！如果您想了解Kotlin中“open”关键字的更多说明，请阅读本文
//Final
class DemoA() {
    
    protected fun Method() {

    }

}

class DemoB() : DemoA {
    Method() // can't access
}

//OPEN
open class DemoA() {
    
    protected fun Method() {

    }

}

class DemoB() : DemoA {
    Method() // can access
}

//Public
class DemoA() {

    fun Method() {

    }

}

class DemoB()  {
    val a = DemoA()
    a.Method() // can access
}

//FINAL
final class DemoA() {
    protected void name() {
        
    }
}

class DemoB() extends DemoA {
    name(); // Can't access
}

//Open
class DemoA() {
    protected void name() {
        
    }
}

class DemoB() extends DemoA {
    name(); // Can access
}

//Public
class DemoA() {
    void name() {
        
    }
}

class DemoB(){
    DemoA a = new DemoA()
    a.name(); // Can access
}