სად შეიძლება გამოიყენოს final მორფი Java-ში?

Java-ში final მოდიფიკატორს გამოიყენება შემდეგი მიზნებისთვის:

1. მოძრაობის გარეშე ცვლილებადი (ცვლადი):
   • ლოკალური ცვლადები: მათი მნიშვნელობა ერთჯერაა განსაზღვრული და ინიციალიზაციის შემდეგ არ შეიძლება შეიცვალოს.
   • კლასის ველები: ველის მნიშვნელობა ან გამოქვეყნების დროს, ან კონსტრუქტორში განსაზღვრულია და შემდეგ არ შეიძლება შეიცვალოს.
   • მეთოდის პარამეტრები: მეთოდის შიგნით პარამეტრი ხდება კონსტანტა; მას არ შეუძლია გადაწერილი იყოს მეთოდის სხეულში.

final გამოყენება ცვლადებზე უზრუნველყოფს:

• მიუხედავად ცვლილებების: გარანტია, რომ მნიშვნელობა არ შეიცვლება.
• მუშაობის უსაფრთხოება: final კლასის ველი ავტომატურად ჩანს ყველა ნაკადისთვის კონსტრუქტორის დასრულების შემდეგ, დამატებითი სინქრონიზაციის გარეშე.
• კომპილატორის ოპტიმიზაციები: კომპილატორი შეუძლია გარკვეული ოპტიმიზაციები განახორციელოს, იცის, რომ მნიშვნელობა არ შეიცვლება.

2. მეთოდები:

   • final მითითებული მეთოდი არ შეიძლება გადაწერილი იყოს ქვესაკლასებში:
   • ეს სასარგებლოა:
     • არასაჭირო ცვლილებების თავიდან აცილება: გარანტია, რომ მეთოდის ლოგიკა დარჩება უცვლელი.
     • კომპოზიციის ხელშეწყობა: ხელს უწყობს კომპოზიციის გამოყენებას მემკვიდრეობასთან ნაცვლად.
     • კომპილატორის ოპტიმიზაციები: final მეთოდების ინლაინინგი შესაძლებელია.

3. კლასები:

   • final კლასს არ შეუძლია მემკვიდრეობა:
   • გამოყენება:
     • მიუხედავად ცვლილებადი (immutable) კლასების შექმნა: მაგალითად, ობერკატული კლასი პრიმიტივებისთვის (Integer, String).
     • დიზაინის დაცვა: აცილებს გაფართოებას, რაც შეიძლება დაარღვიოს კლასის ინვარიანტები.
     • უსაფრთხოების გაზრდა: გარანტია, რომ კლასის ქცევა ვერ შეიცვლება მემკვიდრეობით.

გამოყენება	აღწერა	უპირატესობები
final ველი	მნიშვნელობა ერთჯერაა განსაზღვრული (გამოქვეყნების ან კონსტრუქტორის დროს).	მყარი, უსაფრთხო, ოპტიმიზაციები
final პარამეტრი	მნიშვნელობა არ შეიძლება შეიცვალოს მეთოდის შიგნით.	ნათელი სიგნატურა, ცვლილების გარანტია
final მეთოდი	არ შეიძლება გადაწერილი იყოს ქვესაკლასებში.	ცვლილების თავიდან აცილება, კომპოზიციის მხარდაჭერა, ოპტიმიზაციები
final კლასი	არ შეიძლება მემკვიდრეობა.	მყარი, დიზაინის დაცვა, უსაფრთხოების გაზრდა

მაგალითები:

public class Example {
    // final ველი
    private final String name;

    // final პრიმიტიული ველი
    private final int id;

    // final, მაგრამ შეიძლება იყოს სხვადასხვა ობიექტის მითითება List-ზე, სანამ არ შექმნილია
    // ობიექტის შექმნის შემდეგ, მითითებას შეცვლა შეიძლება, მაგრამ სხვა List-ზე მითითების შეცვლა — არა
    private final List<String> items;

    // კომპილაციის დროის მუდმივობა
    public static final double PI = 3.14159;

    public Example(String name, int id) {
        this.name = name; // `final` ველზე მნიშვნელობის განსაზღვრა
        this.id = id; // `final` ველზე მნიშვნელობის განსაზღვრა
        this.items = new ArrayList<>(); // `final` ველის სია ინიციალიზაცია
    }

    // `final` მეთოდი
    public final void printDetails() {
        System.out.println("Name: " + name + ", ID: " + id);
    }

    // მეთოდი `final` პარამეტრით
    public void addItem(final String item) {
        // item = "ახალი ელემენტი"; // შეცდომა — ვერ დააწესებს `final` პარამეტრს
        items.add(item);
    }
}

// final კლასი
// public final class ImmutableClass {
//     private final int value;
//
//     public ImmutableClass(int value) {
//         this.value = value;
//     }
//
//     public int getValue() {
//         return value;
//     }
// }

// public class SubclassOfImmutable extends ImmutableClass { // შეცდომა — ვერ მემკვიდრეობს final კლასიდან
// }