Differencebetween Final Class and Class

What is the difference between final Class and Class?

Final is class modifier which prevents it from being inherited or being overridden. From apple documentation

You can prevent a method, property, or subscript from being overridden
by marking it as final. Do this by writing the final modifier
before the method, property, or subscript’s introducer keyword (such
as final var, final func, final class func, and final subscript).

Any attempt to override a final method, property, or subscript in a
subclass is reported as a compile-time error. Methods, properties, or
subscripts that you add to a class in an extension can also be marked
as final within the extension’s definition.

You can mark an entire class as final by writing the final modifier
before the class keyword in its class definition (final class). Any
attempt to subclass a final class is reported as a compile-time error.

What is the point of final class in Java?

First of all, I recommend this article: Java: When to create a final class

If they do, when do they use it so I can understand it better and know when to use it.

A final class is simply a class that can't be extended.

(It does not mean that all references to objects of the class would act as if they were declared as final.)

When it's useful to declare a class as final is covered in the answers of this question:

Good reasons to prohibit inheritance in Java?

If Java is object oriented, and you declare a class final, doesn't it stop the idea of class having the characteristics of objects?

In some sense yes.

By marking a class as final you disable a powerful and flexible feature of the language for that part of the code. Some classes however, should not (and in certain cases can not) be designed to take subclassing into account in a good way. In these cases it makes sense to mark the class as final, even though it limits OOP. (Remember however that a final class can still extend another non-final class.)

What is the difference between a final Class and a Record?

Record is an immutable class, i.e. all its fields are final. Records are implicitly final, hence as well as regular final class record can't be extended.

There are a number of restrictions imposed on records (for more details, take a look at JEP 395).

Contrary to normal classes:

it's forbidden to declare instance fields explicitly inside records (and reminder: all fields are final, which is a very impotent distinction);
extends clause is not allowed with records, because every record implicitly extends abstract class Record;
record can't be declared with any of these modifiers: abstract, sealed, or non-sealed (as a consequence of being implicitly final);
records can't declare instance initializers and native methods.

Records are meant to be "transparent carriers for immutable data" as JEP 395 says.

They are designed to be concise, default constructor, getters, hashCode/equals and toString() will be generated by the compiler for you. So that inside a record you need to declare only your custom logic (if any) and record declaration can be literally a one-liner.

Records differ a lot from regular final classes.

Also, apart from the peculiarities mentioned above, the mechanism of serialization / deserialization was reimplemented for records, so that deserialization doesn't bypass the constructor.

In which case should I use a record?

In short, if your objects must be stateful, or you need to extend a particular class, then you can't utilize record in such a case.

On the other hand, if your objects are meant just carry the data, they are not intended to be modified or inherit from other classes, then it might be a good candidate to be implemented as a record.

What is the difference between having a class as final and having a class constructor as private

A final class cannot be extended. It prevents this

final class FinalClass {

}

// and later

class ExtendedClass extends FinalClass { // ERROR

}

This is useful for things like String - you wouldn't want someone to be able to overwrite the logic of String, one of the most commonly used Objects, and be able to, oh I don't know, add networking and send all the strings back you use. It's possible to do if you can extend String.

A private constructor cannot be called outside the class.

class PrivateCons {

    private PrivateCons() {

    }
}

// later
PrivateCons pc = new PrivateCons(); // ERROR

Often this ends up working like this: (java.lang.Math is a good example)

class FuncLib {
    private FuncLib() { } // prevent instantiation
    public static void someFunc(...) { }
    public static int anotherFunc(...) { }
}

Or it ends up working like this // Integer does this actually

class VerySpecial {

    private static Map<String,VerySpecial> cache;

    public static VerySpecial generate(String data) {
        VerySpecial result = cache.get(data);
        if(result == null) {
            result = new VerySpecial(data);
            cache.put(data,result);
        }
        return result;
    }

    private String data;

    private VerySpecial() { }

    private VerySpecial(String data) { this.data = data}

}

When you extend a class, your constructor by default attempts to call the default (no argument) constructor. If that is private, then you must explicitly call a non-private constructor when you extend it. If you have no non-private constructors to call you won't be able to extend it. Thanks for comments for pointing this out. :-)

Difference between sealed and final class in Java

final class A {...} means that no class is allowed extend A.

sealed class A permits B {...} means that only B can extend A but no other class is allowed to do that.

java singleton class vs final class

A final class is one which cannot be extended. You can have any number of instances in a final class. The best example of a final class is String. Singleton is a single instance of a class. So both are not exactly same, however you can make your singleton class final to restrict someone from extending it.

What is the difference between a final and a non-sealed class in Java 15's sealed-classes feature?

As you've marked Cat as final, no other class can extend Cat.
As you've marked Duck as non-sealed, any class can extend Duck.

When marking a class as sealed, all directly extending classes (the ones after the permits clause) have to be marked either as final, sealed or non-sealed:

Marking a class that extends a sealed class as sealed, applies the same effect on it: Only classes specified after the permits clause are allowed to extend it.
non-sealed just "breaks the seal", so the effect doesn't have to be carried on down the hierarchy. The extending class is open (again) for being extended by unknown subclasses itself.
final is effectively the same as sealed without any class specified after the permits clause. Notice that specifying nothing after permits is not possible, so sealed cannot replace final.

Difference Between final class and static class

Final class : In simple words is a class that cannot be extended .
- It is generally useful for writing classes to be immutable e.g. String class that is generally done for security

Static class : Static classes can only be used in case of nested classes.
- Nested static class doesn't need reference of Outer class but non static nested class needs it

What is the difference between static func and final class func in swift

Just because a final class function can't be overridden doesn't mean it's statically dispatched. A final class function be override a superclass non-final class function. Such a method call must be dynamically dispatched.

static is merely an alias for final class. They behave the same:

class C1 { class func foo() {} }
class C2: C1 { override final class func foo() {} }
class C3: C1 { override static func foo() {} }