კონსტრუქტორების და სტატიკური ბლოკების გამოყენებისას ინიციალიზაციის თანმიმდევრობა

მოდით გავიგოთ, რა თანმიმდევრობით ხორციელდება კოდი ინიციალიზაციის ბლოკებში (სტატიკური და არა სტატიკური), კონსტრუქტორებში, ასევე სტატიკური და არა სტატიკური ველების ინიციალიზაციისას. გავიგოთ ეს პრაქტიკულად, კოდის შესრულებით.

ასაწყობად გვაქვს კლასი, რომელიც შეიცავს ყველა შესაძლო ელემენტს:

public class MyClass {
    static {
        System.out.println("სტატიკური ბლოკი №1.");
    }

    public static String staticField = setStaticField();

    public MyClass() {
        System.out.println("კონსტრუქტორი.");
    }

    static {
        System.out.println("სტატიკური ბლოკი №2.");
    }

    {
        System.out.println("ინიციალიზაციის ბლოკი №1.");
    }

    public String nonStaticField = setNonStaticField();

    {
        System.out.println("ინიციალიზაციის ბლოკი №2.");
    }

    private String setNonStaticField() {
        System.out.println("არა სტატიკური ველი.");
        return "nonStaticField";
    }

    private static String setStaticField() {
        System.out.println("სტატიკური ველი.");
        return "staticField";
    }

    public static void print() {
        System.out.println("მეთოდი print.");
    }
}

ახლა აქვე ავაწყოთ მეორე კლასი, სადაც იქნება main მეთოდი და გავუშვათ:

public class Solution {
    public static void main(String args[]) {
        System.out.println("hello");
    }
}

public class Solution {
    public static void main(String args[]) {
        MyClass.print();
        MyClass.print();
    }
}

გამოყვანა:

მხოლოდ სტატიკური ბლოკები და ველები შესრულდა და სტატიკური ველი მხოლოდ ერთხელ ინიციალიზდა. მიზეზი ისაა, რომ მეორე გამოძახებისას print() კლასი უკვე ჩატვირთულია. ვიმახსოვრებთ: სტატიკური ველები და ბლოკები ერთხელ შესრულდება, როდესაც პირველად იხილება კლასი.

მომდევნო, სტატიკური ბლოკების და ველების შესრულების თანმიმდევრობა მათი გამოცხადების რიგითაა.

შემდეგი ნაბიჯი, ჩვენ ვცდით ჩვენი კლასის ობიექტების შექმნას ორჯერ:

public class Solution {
    public static void main(String args[]) {
        new MyClass();
        System.out.println();
        new MyClass();
    }
}

გამოყვანა:

ჯერ ერთი შესრულდება სტატიკური ბლოკები და ველები და შემდეგ, როდესაც ობიექტები შეიქმნება, შესრულდება არა სტატიკური ბლოკები, ველები და კონსტრუქტორი. ხოლო თუ ველები და ბლოკები ინიციალიზაციის მიხედვით შესრულდება, კონსტრუქტორი ყოველთვის ბოლოს შესრულდება, განურჩევლად მისი ადგილმდებარეობისა.

გართულებას ვცდილობთ, მოვიყვანოთ ორი კლასი, რომელთაგან ერთი იმეორებს მეორეს:

public class ParentClass {
    static {
        System.out.println("სტატიკური ბლოკი №1 მშობელი კლასის.");
    }

    public static String parentStatic = setParentStatic();

    static {
        System.out.println("სტატიკური ბლოკი №2 მშობელი კლასის.");
    }

    {
        System.out.println("ინიციალიზაციის ბლოკი №1 მშობელი კლასის.");
    }

    public String parentNonStatic = setParentNonStatic();

    {
        System.out.println("ინიციალიზაციის ბლოკი №2 მშობელი კლასის.");
    }

    public ParentClass() {
        System.out.println("კონსტრუქტორი მშობელი კლასის.");
    }

    private String setParentNonStatic() {
        System.out.println("არა სტატიკური ველი მშობელი კლასის.");
        return "parentNonStatic";
    }

    private static String setParentStatic() {
        System.out.println("სტატიკური ველი მშობელი კლასის.");
        return "parentStatic";
    }

    public String setChildNonStatic1() {
        System.out.println("არა სტატიკური ველი შვილი კლასის №1.");
        return "childNonStatic2" + parentNonStatic;
    }
}
 
public class ChildClass extends ParentClass {
    static {
        System.out.println("სტატიკური ბლოკი №1 შვილი კლასის.");
    }

    public static String childStatic = setChildStatic();

    static {
        System.out.println("სტატიკური ბლოკი №2 შვილი კლასის.");
    }

    public String childNonStatic1 = setChildNonStatic1();

    {
        System.out.println("ინიციალიზაციის ბლოკი №1 შვილი კლასის.");
    }

    public String childNonStatic2 = setChildNonStatic2();

    {
        System.out.println("ინიციალიზაციის ბლოკი №2 შვილი კლასის.");
    }

    public ChildClass() {
        System.out.println("კონსტრუქტორი შვილი კლასის.");
    }

    private String setChildNonStatic2() {
        System.out.println("არა სტატიკური ველი შვილი კლასის №2.");
        return "childNonStatic";
    }

    private static String setChildStatic() {
        System.out.println("სტატიკური ველი შვილი კლასის.");
        return "childStatic";
    }
}

შევქმნათ ორი ობიექტი შვილი კლასის:

public class Solution {
    public static void main(String[] args) {
        new ChildClass();
        System.out.println();
        new ChildClass();
    }
}

გამოყვანა:

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

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