What is the difference between 'open' and 'public' in Kotlin?

I am new to Kotlin and I am confused between open and public keywords. Could anyone please tell me the difference between those keywords?

The open keyword means “open for extension“:

> The open annotation on a class is the opposite of Java's final: it allows others to inherit from this class. By default, all classes in Kotlin are final, which corresponds to Effective Java, Item 17: Design and document for inheritance or else prohibit it.

You also need to be explicit about methods you want to make overridable, also marked with open:

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

The public keyword acts as a visibility modifier that can be applied on classes, functions etc. Note that public is the default if nothing else is specified explicitly:

> If you do not specify any visibility modifier, public is used by default, which means that your declarations will be visible everywhere

class A { ... } in Java is equal to open class A { ... } in Kotlin.
final class B { ... } in Java is equal to class B { ...} in Kotlin.

It is not related with public.

In Kotlin, everything without access modifiers is public by default. You can explicitly say public in the definition, but it is not necessary in Kotlin.

So,

public class A { ... }

and

class A { ... }

are the same in Kotlin.

I put here just for my memo, maybe useful for someone else :

open class in kotlin means that a class can be inherited because by default they are not:

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

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

public class in Java is about the visibility of class (nothing to do with inheritance : unless a class in java is final, it can be inherited by default). In kotlin all the class are public by default.

open method in kotlin means that the method can be overridden, because by default they are not. Instead in Java all the methods can be overridden by default

The method of an open class cannot be overridden by default as usual (doesn't matter if the class is open), they must be declared that they can be overridden :

 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
 }

for more details : https://kotlinlang.org/docs/reference/classes.html

public: public keyword in Kotlin is similar to java it is use to make the visibility of classes, methods, variables to access from anywhere.

open: In Kotlin all classes, functions, and variables are by defaults final, and by inheritance property, we cannot inherit the property of final classes, final functions, and data members. So we use the open keyword before the class or function or variable to make inheritable that.

open is opposite to Final in java. If the class is not 'open', it can't be inherited.

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

Don't get confused with open and public. public is a visibility modifier

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
}

OPEN VS FINAL VS PUBLIC

OPEN :

1. child class can access this because they are inherited by its parent.
2. In Kotlin you need to add 'open' keyword unlike java whose all classes are 'open' by default Example :

> 1. Kotlin : open class A () {} > 2. Java : class A () {}

FINAL :

1. child class can't access or inherit.
2. In JAVA you need to add 'final' keyword unlike kotlin whose all classes are 'final' by default Example :

> 1. Kotlin : class A () {} > 2. Java : final class A () {}

PUBLIC : Any class whether its inherited or not can access its data or methods.

Example in Kotlin :

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

Example in 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
}

All classes, methods, and members are public by default BUT not open

Keyword open in kotlin means "Open for Extension"

means if you want any class to be inherited by any subclass or method to be overriden in subclasses you have to mark as open otherwise you will get compile time error

NOTE: abstract classes or methods are open by default you do not need to add explicitly.