JavaTil va OOP9 boʻlim · 30 savol

Java tili va OOP: qanday ishlaydi va nega shunday

Bu sahifa Java tilining oʻzini chuqur tushuntiradi: klass va obyekt qanday ishlaydi, qiymat metodga qanday uzatiladi, `String` va sonlar nega shunday tuzilgan, exceptionʼlar, generics va zamonaviy Java imkoniyatlari. Murakkab joylar qadamma-qadam animatsiya bilan koʻrsatilgan.

Boʻlimlar asoslardan chuqurroq mavzularga qarab ketadi. Bilgan joyingizni oʻtkazib yuborishingiz yoki istalgan boʻlimdan boshlashingiz mumkin. Asos — Java 21; boshqa versiyalarda farq qiladigan joylar alohida aytilgan.

Har boʻlim oxirida tushunganingizni tekshiradigan savollar bor. Avval javobni oʻzingiz oʻylab koʻring, keyin oching.

1OOP: klass, interfeys va modifierʼlar

Javaʼdagi OOP uchta gʻoyaga tayanadi. Inkapsulyatsiya — obyekt oʻz holatini private fieldʼlarda yashiradi va unga faqat metodlar orqali kirishga ruxsat beradi. Bu metodlar invariantlarni saqlaydi: masalan, hisob balansi manfiy boʻlib qolmaydi, chunki uni faqat tekshiruvi bor withdraw oʻzgartiradi. Har bir fieldʼga getter va setter yozish esa inkapsulyatsiya emas — holat baribir tashqaridan boshqariladi.

Inheritance — subklass ota klassning fieldʼlari va metodlarini oladi va metodlarni override qila oladi. Javaʼda klass faqat bitta klassdan extends qiladi, lekin istalgancha interfeysni implements qila oladi. Konstruktorlar meros qilib olinmaydi, private aʼzolarga subklass kira olmaydi, final klassdan esa umuman meros olib boʻlmaydi. Eng katta cheklov — subklass ota klassning implementation tafsilotlariga bogʻlanib qoladi. Shuning uchun koʻp holatda composition xavfsizroq: boshqa obyektni field sifatida saqlab, ishni unga topshirish.

Polimorfizm — ota klass turidagi oʻzgaruvchi subklass obyektini koʻrsata oladi va chaqirilgan metodning qaysi versiyasi ishlashini obyektning haqiqiy klassi belgilaydi. Bu dynamic dispatch deyiladi: kompilyator metod borligini oʻzgaruvchi turi boʻyicha tekshiradi, JVM esa runtimeʼda obyekt klassidagi versiyani chaqiradi.

1/6Animal a = new Dog(): oʻzgaruvchining turi — Animal, u koʻrsatgan obyekt esa Dog. Kompilyator faqat oʻzgaruvchi turini biladi, obyektning klassini JVM runtimeʼda koʻradi.

Overload esa boshqacha ishlaydi: nomi bir xil, lekin parametrlari har xil metodlardan qaysi biri chaqirilishini kompilyator argumentlarning static turi boʻyicha tanlaydi. static metodlar va fieldʼlar ham polimorf emas: ular override qilinmaydi, balki yashiriladi va reference turi boʻyicha tanlanadi.

JihatInterfeysAbstract class
Merosklass bir nechta interfeysni implement qila oladiklass faqat bitta klassdan extends qiladi
Holatinstance field yoʻq, faqat public static final konstantalaroddiy fieldʼlar, jumladan private
Konstruktoryoʻqbor: subklass uni super(...) bilan chaqiradi
Metodlarabstract, default va static (Java 8), private (Java 9)abstract va oddiy metodlar; oddiylari istalgan access modifier bilan
Qachonqobiliyat yoki kontrakt: Comparable, Runnable, Listumumiy holat va kodga ega yaqin klasslar oilasi

Access modifierʼlar kim nimani koʻrishini belgilaydi:

ModifierShu klassShu packageBoshqa packageʼdagi subklassHamma
publichahahaha
protectedhahahayoʻq
package-private (modifier yozilmaydi)hahayoʻqyoʻq
privatehayoʻqyoʻqyoʻq

static aʼzo obyektga emas, klassning oʻziga tegishli: static fieldʼning hamma obyektlar uchun bitta nusxasi bor, static metodda esa this yoʻq. final — «bir marta»: oʻzgaruvchiga qiymat bir marta beriladi, metodni override qilib boʻlmaydi, klassdan meros olib boʻlmaydi (String, Integer). Umumiy qoida: eng tor access bilan boshlang — fieldʼlar private, klass va metodlar faqat kerak boʻlganda ochiladi.

Tushunganingizni tekshiring

Inkapsulyatsiya nima va inheritance uni qanday buzishi mumkin?Javob
Qisqa javob

Inkapsulyatsiya — obyekt holatini private fieldʼlarda yashirib, unga faqat invariantlarni saqlaydigan metodlar orqali kirish. Inheritance esa subklassni ota klassning implementation tafsilotlariga bogʻlab qoʻyadi: ota klass oʻz metodlarini qanday chaqirishi oʻzgarsa yoki subklass buni hisobga olmasa, subklass buziladi.

Mashhur misol (Effective Java kitobidan): HashSetdan meros olib, qoʻshilgan elementlarni sanaydigan klass. add ham, addAll ham override qilingan, lekin HashSetning addAlli har bir element uchun addni chaqiradi. Uch element qoʻshilsa, hisoblagich 6 boʻladi. Subklass toʻgʻri ishlashi uchun ota klassning implementation tafsilotini bilishi kerak — bu inkapsulyatsiyaning buzilishi.

Yechim — composition: klass Setni implement qiladi, haqiqiy HashSetni private fieldʼda saqlaydi va chaqiruvlarni unga forward qiladi. Endi HashSetning implementation tafsilotlari bu klassga taʼsir qilmaydi. Inheritance «is-a» munosabati haqiqatan bor va ota klass meros uchun loyihalangan boʻlganda yaxshi; aks holda klassni final qilish yoki composition tanlash maʼqul.

class CountingSet<E> extends HashSet<E> {
    int added = 0;

    @Override
    public boolean add(E e) {
        added++;
        return super.add(e);
    }

    @Override
    public boolean addAll(Collection<? extends E> c) {
        added += c.size();
        // super.addAll har biri uchun add() chaqiradi
        return super.addAll(c);
    }
}

var s = new CountingSet<String>();
s.addAll(List.of("a", "b", "c"));
// s.added — 6, 3 emas
Override va overload farqi nima? Qaysi metod chaqirilishi qachon aniqlanadi?Javob
Qisqa javob

Overload — nomi bir xil, parametrlari har xil metodlar: qaysi biri chaqirilishini kompilyator argumentlarning static turi boʻyicha tanlaydi. Override — subklass ota klass metodini xuddi shu signature bilan qayta yozadi: qaysi versiya ishlashini runtimeʼda obyektning haqiqiy klassi belgilaydi.

Override qoidalari: nomi va parametr turlari bir xil; qaytish turi bir xil yoki uning subtipi boʻlishi mumkin — bu covariant return; access torroq boʻlmaydi; kengroq checked exception tashlab boʻlmaydi. @Override annotatsiyasi buni kompilyatorga tekshirtiradi: parametr turida adashsangiz, override oʻrniga jimgina yangi overload yaratilib qolmaydi.

Polimorf boʻlmagan narsalar: static metodlar (yashiriladi, reference turi boʻyicha tanlanadi), fieldʼlar (a.name doim reference turidagi fieldʼni oʻqiydi) va private metodlar (ular meros qilib olinmaydi, demak override ham qilinmaydi).

class Animal {
    String sound() { return "..."; }
}
class Dog extends Animal {
    @Override String sound() { return "Vov"; }
}

static void print(Animal a) {
    System.out.println("Animal");
}
static void print(Dog d) {
    System.out.println("Dog");
}

Animal a = new Dog();
a.sound(); // "Vov": override, runtimeʼda
print(a);  // "Animal": overload, kompilyatsiyada
Interfeys va abstract class farqi nima? Qachon qaysi birini tanlaysiz?Javob
Qisqa javob

Interfeys — kontrakt: klass bir nechta interfeysni implement qila oladi, lekin interfeysda instance holat va konstruktor yoʻq. Abstract class — umumiy holat va kodga ega, qisman tayyor klass: undan faqat bitta klass extends qila oladi. Odatda interfeysdan boshlanadi, abstract class esa subklasslar umumiy holat va logikani ulashishi kerak boʻlganda qoʻshiladi.

Java 8 dan beri interfeysda default va static metodlar bor, Java 9 dan private metodlar ham. Shunga qaramay farq qoldi: interfeys holat saqlay olmaydi va subklass qanday yaratilishini boshqarmaydi. Abstract classʼda protected fieldʼlar, konstruktor va final metodlar boʻladi — masalan, template method: algoritm skeleti final metodda, oʻzgaradigan qadamlar esa abstract metodlarda.

JDKʼda koʻp uchraydigan naqsh — ikkalasi birga: List interfeysi va qolgan metodlarni tayyor beradigan AbstractList. Oʻz implementationʼini yozayotgan odam bir nechta metodni yozadi xolos, foydalanuvchi kod esa faqat List interfeysiga bogʻlanadi.

protected va package-private farqi nima?Javob
Qisqa javob

Package-private (modifier yozilmasa) — aʼzoni faqat shu packageʼdagi klasslar koʻradi. protected — shu package va qoʻshimcha ravishda boshqa packageʼdagi subklasslar. Demak, protected package-privateʼdan kengroq, torroq emas.

Nozik joy: boshqa packageʼdagi subklass protected aʼzoga faqat oʻz turi (yoki oʻz subklasslari) orqali kira oladi. U oʻzining yoki boshqa Sub obyektining xini oʻqiy oladi, lekin oddiy Base turidagi obyektning xiga kira olmaydi.

Top-level klass faqat public yoki package-private boʻladi. Java 9 dagi modullar yana bir qatlam qoʻshdi: modul oʻz packageʼini exports qilmasa, undagi public klasslar ham boshqa modullarga koʻrinmaydi.

Tanlash qoidasi — eng tor access: fieldʼlar private, yordamchi klasslar package-private, public — faqat tashqi foydalanuvchilar uchun moʻljallangan API. protected ham API: uni subklasslar ishlatadi, demak keyin oʻzgartirish qiyin.

// a/Base.java
package a;
public class Base {
    protected int x;
}

// b/Sub.java
package b;
public class Sub extends a.Base {
    void f(Sub s, a.Base b) {
        x = 1;    // mumkin
        s.x = 2;  // mumkin: Sub orqali
        b.x = 3;  // compile error
    }
}
static va final nimani anglatadi va qayerda ishlatiladi?Javob
Qisqa javob

static aʼzo obyektga emas, klassga tegishli: static fieldʼning bitta nusxasi bor, static metodni obyektsiz chaqirish mumkin. final — «bir marta»: oʻzgaruvchiga qiymat bir marta beriladi, final metodni override qilib boʻlmaydi, final klassdan meros olib boʻlmaydi.

final reference obyektni immutable qilmaydi: final List<String> names boshqa listga ulanmaydi, lekin listning oʻziga element qoʻshish mumkin. Immutability uchun obyektning oʻzi oʻzgarmas boʻlishi kerak.

Mutable static field — global holat: uni hamma joy oʻzgartira oladi, testlar bir-biriga taʼsir qiladi, bir nechta thread bilan esa sinxronizatsiya kerak. static metodlar holatsiz yordamchi funksiyalar va factory metodlar uchun yaxshi: List.of, Integer.valueOf, Math.max.

Nozik joy: static final primitiv yoki String konstantasi (static final int LIMIT = 10) uni ishlatgan klasslarga kompilyatsiya paytida qiymat sifatida koʻchiriladi. Qiymatni oʻzgartirib faqat shu klassni qayta kompilyatsiya qilsangiz, uni ishlatgan klasslar eski qiymatni koʻraveradi.

final List<String> names = new ArrayList<>();
names.add("Ali");      // mumkin: list oʻzgaradi
// names = List.of(); // compile error

2Qiymat qanday uzatiladi: primitiv, reference va boxing

Javaʼda ikki xil tur bor. Sakkizta primitiv — byte, short, int, long, float, double, char, boolean: oʻzgaruvchida qiymatning oʻzi turadi. Qolgan hammasi — klasslar, interfeyslar, massivlar, enum va record — reference turlar: oʻzgaruvchida obyektning oʻzi emas, unga reference turadi, obyekt esa heapʼda.

Metodga argument berilganda Java doim uning nusxasini beradi — bu pass-by-value. Primitiv uchun qiymat nusxalanadi. Obyekt uchun reference nusxalanadi: endi ikki reference bitta obyektni koʻrsatadi. Metod obyektni oʻzgartirsa, chaqirgan joy ham buni koʻradi; lekin metod parametrga yangi obyekt bersa, chaqirgan joydagi oʻzgaruvchi oʻzgarmaydi.

1/6Metod chaqirilishidan oldin: nda qiymatning oʻzi — 5 turadi. uda esa obyekt emas, heapʼdagi User obyektiga reference turadi.

Har bir primitivning wrapper klassi bor: Integer, Long, Double, Boolean, Character va boshqalar. Kolleksiyalar va generics faqat obyektlar bilan ishlaydi, shuning uchun kompilyator kerakli joyda primitivni oʻzi oʻraydi — autoboxing (Integer.valueOf(x)) va qaytarib ochadi — unboxing (x.intValue()). Bu bepul emas: wrapper — heapʼdagi obyekt, u null boʻlishi mumkin, == esa qiymatni emas, referenceʼni solishtiradi.

Integer.valueOf -128…127 oraligʻidagi qiymatlar uchun oldindan yaratilgan, keshlangan obyektni qaytaradi — buni JLS talab qiladi. Short, Byte va Long ham shu oraliqni, Character esa 0…127 ni keshlaydi, Booleanda faqat ikkita obyekt bor. Float va Double keshlanmaydi. Wrapper konstruktorlari (new Integer(5)) Java 9 dan deprecated, Java 16 dan esa olib tashlanishi rejalashtirilgan deb belgilangan.

Tushunganingizni tekshiring

Java pass-by-valueʼmi yoki pass-by-referenceʼmi?Javob
Qisqa javob

Har doim pass-by-value. Primitiv uzatilsa, qiymat nusxalanadi. Obyekt uzatilsa, obyektning oʻzi emas, unga reference nusxalanadi: metod obyektni oʻzgartira oladi, lekin chaqirgan joydagi oʻzgaruvchini boshqa obyektga ulay olmaydi.

«Obyektlar reference orqali uzatiladi» degan gap chalkashtiradi. Haqiqiy pass-by-reference boʻlganda (C++ dagi & yoki C# dagi ref) metod chaqiruvchining oʻzgaruvchisini almashtira olardi. Javaʼda bunday mexanizm yoʻq: metod faqat reference nusxasini oladi.

Shuning uchun ikki oʻzgaruvchini almashtiradigan swap metodini Javaʼda yozib boʻlmaydi: metod ichida faqat nusxalar almashadi. Metoddan ikki qiymat qaytarish kerak boʻlsa, ularni bitta record qilib qaytarish eng toza yoʻl.

static void swap(User a, User b) {
    User t = a;
    a = b;
    b = t; // faqat lokal nusxalar almashdi
}

static void rename(User u) {
    u.name = "Vali"; // obyektning oʻzi oʻzgaradi
}
Integer a = 127, b = 127 uchun a == b — true, 1000 uchun esa false. Nega?Javob
Qisqa javob

Autoboxing Integer.valueOfni chaqiradi, u esa -128…127 oraligʻidagi qiymatlar uchun keshlangan obyektni qaytaradi. 127 da ikkala oʻzgaruvchi bitta obyektni koʻrsatadi, 1000 da esa ikkita alohida obyekt yaratiladi. == referenceʼlarni solishtiradi, shuning uchun wrapperʼlar equals bilan solishtiriladi.

Kesh oraligʻining yuqori chegarasini -XX:AutoBoxCacheMax bilan oshirish mumkin — unda 1000 == 1000 ham true boʻlib qoladi. Demak, wrapperʼlarni == bilan solishtiradigan kod nafaqat xato, balki JVM sozlamasiga qarab har xil ishlaydi.

Aralash solishtirishda, Integer == int boʻlsa, wrapper unboxing qilinadi va qiymatlar solishtiriladi (wrapper null boʻlsa — NullPointerException). Yana bir tuzoq: equals turni ham tekshiradi. Long.valueOf(1).equals(1) — false, chunki 1 Integerga boxing qilinadi. Xuddi shu sababdan Map<Long, String>da get(1) null qaytaradi.

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c == d);      // false
System.out.println(c.equals(d)); // true

Map<Long, String> names = Map.of(1L, "Ali");
System.out.println(names.get(1));  // null
System.out.println(names.get(1L)); // Ali
Hech qanday metod chaqirilmagan qatorda NullPointerException qayerdan chiqadi?Javob
Qisqa javob

Koʻpincha unboxingʼdan. Kompilyator int n = map.get(k) ni map.get(k).intValue() qilib yozadi: wrapper null boʻlsa — NullPointerException. Bu arifmetikada, < va > bilan solishtirishda, Boolean bilan if (flag) da va ternary operatorda ham yuz beradi.

Eng yashirin holat — ternary operator. ok ? map.get(k) : 0 ifodasida bir tomoni Integer, ikkinchisi int boʻlgani uchun natija turi int boʻladi. Natijani Integerga yozsangiz ham, map.get(k) avval unboxing qilinadi va u null boʻlsa, exception chiqadi.

Bunday xatoni topish osonlashgan: Java 14 da helpful NullPointerExceptions qoʻshildi (Java 15 dan default yoqilgan) va xabarda aynan nima null ekani yoziladi: Cannot invoke "java.lang.Integer.intValue()" because the return value of "java.util.Map.get(Object)" is null.

Map<String, Integer> stock = new HashMap<>();

int n = stock.get("olma"); // NPE: unboxing null

boolean ok = true;
// natija turi int, shuning uchun bu ham NPE
Integer m = ok ? stock.get("olma") : 0;

int safe = stock.getOrDefault("olma", 0); // 0

3Sonlar: overflow, double va BigDecimal

Primitiv sonli turlarning oʻlchami JLS da qatʼiy belgilangan va platformaga bogʻliq emas:

TurOʻlchamDiapazon yoki aniqlik
byte8 bit-128 … 127
short16 bit-32 768 … 32 767
char16 bit0 … 65 535 (UTF-16 code unit)
int32 bit≈ ±2,1 mlrd (-2³¹ … 2³¹ − 1)
long64 bit≈ ±9,2 · 10¹⁸
float32 bit≈ 6–7 ta aniq raqam
double64 bit≈ 15–16 ta aniq raqam
booleanbelgilanmagantrue yoki false

Butun sonlar toʻlib ketganda exception chiqmaydi: natija jimgina aylanib ketadi, Integer.MAX_VALUE + 1 — Integer.MIN_VALUE. Overflow koʻpincha koʻpaytirishda yashirinadi: ifoda avval intda hisoblanadi va faqat keyin longga yoziladi.

float va double — IEEE 754 ikkilik kasrlar. 0,1 ni ikkilik sanoq tizimida aniq yozib boʻlmaydi (xuddi 1/3 ni oʻnli kasrda yozib boʻlmagani kabi), shuning uchun unga eng yaqin qiymat saqlanadi va bunday xatolar hisob davomida yigʻiladi. Fizika, grafika yoki statistika uchun bu normal, pul va boshqa aniq hisoblar uchun esa yoʻq.

System.out.println(Integer.MAX_VALUE + 1);
// -2147483648
System.out.println(0.1 + 0.2);
// 0.30000000000000004
System.out.println(1.0 / 0); // Infinity
System.out.println(0.0 / 0); // NaN
System.out.println(1 / 0);   // ArithmeticException

Tushunganingizni tekshiring

int toʻlib ketsa nima boʻladi va buni qanday sezasiz?Javob
Qisqa javob

Exception chiqmaydi: natija aylanib ketadi va Integer.MAX_VALUE + 1 Integer.MIN_VALUEga teng boʻladi. Buni sezish kerak boʻlsa, Math.addExact, Math.multiplyExact kabi metodlar ArithmeticException tashlaydi. Kattaroq diapazon kerak boʻlsa — long yoki BigInteger.

Klassik yashirin holat: long ms = days * 24 * 60 * 60 * 1000. Oʻng tomon toʻliq intda hisoblanadi va faqat natija longga kengaytiriladi — 30 kunda overflow allaqachon boʻlib boʻlgan. Birinchi koʻpaytirishning bitta operandini long qilish kifoya (days * 24L yoki (long) days * 24): ifoda chapdan oʻngga hisoblanadi va shu nuqtadan boshlab hammasi longda boʻladi.

Yana ikki mashhur misol. Binary searchʼda oʻrtani (low + high) / 2 bilan hisoblash katta massivda overflow beradi — bu xato JDKʼning oʻzida ham yillar davomida turgan; toʻgʻrisi (low + high) >>> 1 yoki low + (high - low) / 2. Math.abs(Integer.MIN_VALUE) esa manfiy son qaytaradi, chunki 2³¹ intga sigʻmaydi.

int days = 30;
long bad = days * 24 * 60 * 60 * 1000;
// -1702967296: hammasi int boʻlib hisoblandi
long ok = days * 24L * 60 * 60 * 1000;
// 2592000000

Math.multiplyExact(days, 86_400_000);
// ArithmeticException: integer overflow
Nega 0.1 + 0.2 0.3 ga teng emas va pulni qanday hisoblash kerak?Javob
Qisqa javob

double sonni ikkilik kasr sifatida saqlaydi, 0,1 esa ikkilikda cheksiz kasr: unga eng yaqin qiymat saqlanadi va xatolar yigʻiladi. Pul uchun BigDecimal (String orqali yaratilgan) yoki eng kichik birlikdagi long — masalan, soʻm emas, tiyin — ishlatiladi.

new BigDecimal(0.1) — tuzoq: u doubledagi aniq ikkilik qiymatni oladi, 0.1000000000000000055511…. Toʻgʻrisi — new BigDecimal("0.1") yoki BigDecimal.valueOf(0.1) (u Double.toString orqali ishlaydi).

Boʻlishda scale va rounding berilishi kerak: 1/3 oʻnli kasrda cheksiz, shuning uchun ularsiz divide ArithmeticException tashlaydi. Pul uchun odatda RoundingMode.HALF_UP yoki «bank yaxlitlashi» HALF_EVEN tanlanadi.

doubleni == bilan solishtirish ham xavfli: kichik farq bilan solishtiriladi (Math.abs(a - b) < 1e-9). long tiyinlarda hisoblash esa eng tez va oddiy yoʻl, faqat foiz va boʻlishda yaxlitlashni oʻzingiz boshqarasiz.

new BigDecimal(0.1);
// 0.1000000000000000055511151231257827...
new BigDecimal("0.1");   // 0.1
BigDecimal.valueOf(0.1); // 0.1

BigDecimal total = new BigDecimal("10.00");
BigDecimal share = total.divide(
        BigDecimal.valueOf(3),
        2, RoundingMode.HALF_UP);
// 3.33; scale va rounding boʻlmasa —
// ArithmeticException

4String: immutability, pool va StringBuilder

String immutable: yaratilgandan keyin uning matni oʻzgarmaydi. toUpperCase, replace, trim kabi metodlar matn oʻzgarsa yangi String qaytaradi, oʻzgartiradigan narsa boʻlmasa — oʻsha obyektning oʻzini ("abc".trim() == "abc" — true). Eski satr har doim oʻz holicha qoladi. Klassning oʻzi final, shuning uchun bu kafolatni subklass orqali buzib boʻlmaydi.

Matn qanday saqlanadi? Java 9 dan beri String belgilarni char[]da emas, byte[]da saqlaydi va har bir satrning kodlashini eslab qoladi: satrning hamma belgilari Latin-1 boʻlsa, har belgi 1 bayt oladi; bitta boshqa belgi boʻlsa ham (masalan, oʻzbekcha ʻ), butun satr UTF-16 da — har belgiga 2 baytdan — saqlanadi. Bu compact strings deyiladi: Latin-1 matnlarda belgilar massivi ikki baravar kichik.

Immutability tufayli JVM bir xil matnli literallarni bitta obyekt qilib ishlata oladi — bu String pool. Kodda yozilgan har bir literal ("java") poolʼdan olinadi, new String(...) esa har safar heapʼda yangi obyekt yaratadi. Java 7 dan beri pool PermGenʼda emas, oddiy heapʼda turadi va GC undagi keraksiz satrlarni ham tozalaydi.

1/5String a = "java": literal String poolʼga tushadi va a shu obyektni koʻrsatadi. Java 7 dan beri pool oddiy heapʼning bir qismi.

Shuning uchun satrlar uchun ==ning natijasi matnga emas, satr qanday hosil boʻlganiga bogʻliq: ikki literal uchun true, runtimeʼda yigʻilgan satr uchun false. Matn doim equals bilan solishtiriladi; null boʻlishi mumkin boʻlsa — "java".equals(s) yoki Objects.equals(a, b).

Concatenation narxi. Bitta ifodadagi a + b + c muammo emas: Java 9 dan beri kompilyator uni invokedynamic orqali StringConcatFactoryga topshiradi va natija uzunligi oldindan hisoblanadi. Siklda esa har bir s += x yangi String yaratadi va oldingi hamma belgilarni unga nusxalaydi: n qadamda bu O(n²) ish. Siklda StringBuilder ishlatiladi.

Tushunganingizni tekshiring

"java" == "java" — true, new String("java") == "java" esa false. Nega?Javob
Qisqa javob

Literallar String poolʼdan olinadi: bir xil literal hamma joyda bitta obyekt. new String(...) esa har safar yangi obyekt yaratadi. == matnni emas, referenceʼni solishtiradi, shuning uchun satrlar doim equals bilan solishtiriladi.

Kompilyator konstanta ifodalarni oʻzi hisoblaydi: "ja" + "va" kompilyatsiyada "java" literaliga aylanadi va pooldagi obyekt bilan == boʻyicha teng chiqadi. final String fja = "ja" ham konstanta, shuning uchun fja + "va" ham. finalsiz oʻzgaruvchi bilan esa birlashtirish runtimeʼda boʻladi va yangi obyekt yaratiladi.

intern() pooldagi teng satrni qaytaradi, yoʻq boʻlsa uni poolʼga qoʻshadi. U kamdan-kam kerak: masalan, fayldan oʻqilgan millionlab takrorlanuvchi satrlarni bitta obyektga keltirish uchun. Kundalik kodda == ishlashi uchun intern() chaqirish — notoʻgʻri yechim.

String a = "java";
String c = new String("java");
String ja = "ja";
final String fja = "ja";

System.out.println(a == "java");     // true
System.out.println(a == c);          // false
System.out.println(a.equals(c));     // true
System.out.println(a == c.intern()); // true
System.out.println(a == ja + "va");  // false
System.out.println(a == fja + "va"); // true
Siklda Stringga += qilish nega sekin? StringBuilder qachon kerak?Javob
Qisqa javob

Har bir += yangi String yaratadi va oldingi hamma belgilarni unga nusxalaydi: n marta qoʻshish O(n²) ish. StringBuilder bitta oʻsadigan buferga yozadi: oxiriga qoʻshish oʻrtacha O(1). Bitta ifodadagi a + b + c uchun esa StringBuilder shart emas — kompilyator buni oʻzi yaxshi qiladi.

StringBuilder default 16 belgilik bufer bilan boshlanadi va toʻlganda taxminan ikki baravar kattalashadi: yangi hajm — eski hajm × 2 + 2. ArrayList esa 1,5 baravar oʻsadi. Natija uzunligi taxminan maʼlum boʻlsa, new StringBuilder(n) keraksiz koʻchirishlarning oldini oladi.

Koʻp holatda tayyor metodlar yanada qulay: String.join(", ", names), stream uchun Collectors.joining(", "), takrorlash uchun Java 11 dagi "-".repeat(20).

String s = "";
for (String w : words) s += w;       // O(n²)

StringBuilder sb = new StringBuilder();
for (String w : words) sb.append(w); // O(n)
String r = sb.toString();

String csv = String.join(",", words);

5Object metodlari va tenglik

Har bir klass Objectdan meros oladi va koʻpincha uning uchta metodi override qilinadi: equals, hashCode va toString. Default equals — bu ==, yaʼni identity: obyekt faqat oʻziga teng. Servis, thread yoki ulanish kabi obyektlar uchun bu toʻgʻri. Pul, sana oraligʻi, email kabi value objectʼlarda esa mantiqiy tenglik kerak: maʼnosi bir xil boʻlsa, obyektlar teng.

equals kontrakti Object hujjatida yozilgan:

TalabMaʼnosi
reflexivex.equals(x) — doim true
symmetricx.equals(y) boʻlsa, y.equals(x) ham
transitivex.equals(y) va y.equals(z) boʻlsa, x.equals(z) ham
consistentobyektlar oʻzgarmasa, natija ham oʻzgarmaydi
null bilanx.equals(null) — doim false, exception emas
hashCode bilanteng obyektlarning hashCodei ham teng

Kontrakt buzilsa, xato equals yozilgan joyda emas, uzoqda chiqadi: HashMap kalitni topmaydi, List.contains notoʻgʻri javob beradi, Setda takrorlar paydo boʻladi.

Inheritance bu kontraktni oson buzadi. Subklass yangi field qoʻshib equalsni kengaytirsa, ota va subklass obyektlari bir-biriga har xil javob beradi — simmetriya yoʻqoladi. Tenglikni faqat bir xil klass obyektlari orasida tekshirish (getClass()) simmetriyani saqlaydi, lekin Liskov tamoyilini buzadi: subklass obyekti ota klass obyekti oʻrnida ishlay olmay qoladi.

Tartib ham tenglik bilan mos boʻlishi kerak. Hash kolleksiyalar equalsga, sorted kolleksiyalar esa compareToga qaraydi, va ular kelishmasa, bir xil maʼlumot ikki joyda har xil natija beradi:

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
a.equals(b);    // false: scale har xil
a.compareTo(b); // 0

new HashSet<>(List.of(a, b)).size(); // 2
new TreeSet<>(List.of(a, b)).size(); // 1

Tushunganingizni tekshiring

equals, hashCode va toStringni qachon va qanday override qilasiz?Javob
Qisqa javob

Klass value object boʻlsa, yaʼni tengligi fieldʼlari bilan aniqlansa. equals kontraktga rioya qilib fieldʼlarni solishtiradi, hashCode oʻsha fieldʼlardan hisoblanadi, toString esa log va debug uchun obyektni oʻqiladigan koʻrinishda beradi. Identity muhim boʻlgan klasslarda equalsga tegilmaydi.

hashCode faqat equals solishtiradigan fieldʼlardan hisoblanishi shart: ularning bir qismi ham yetadi, lekin equalsda yoʻq field hashCodega kirsa, teng obyektlar har xil hash beradi. Odatda ikkalasi aynan bir xil fieldʼlarni oladi. hashCode umuman override qilinmasa, HashMap teng kalitni topmaydi. Bu fieldʼlar oʻzgarmas boʻlgani maʼqul — aks holda obyekt hash kolleksiyada «yoʻqolib» qoladi.

Default toString — klass nomi, @ va hash: Money@1b6d3586. Logda bu hech narsa aytmaydi. Yaxshi toString asosiy fieldʼlarni koʻrsatadi, lekin parol, token va shaxsiy maʼlumotni emas: toString kutilmagan joylarga — exception xabariga, logga — chiqib qoladi. JPA entityʼda lazy relationʼlarni toStringga qoʻshmaslik kerak: ular bazaga soʻrov yuboradi, ikki tomonlama bogʻlanishda esa cheksiz rekursiyaga olib keladi.

Eng oson yoʻl — record: kompilyator uchala metodni ham komponentlar boʻyicha oʻzi yozadi.

final class Money {
    private final long amount;
    private final String currency;

    Money(long amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }

    @Override
    public boolean equals(Object o) {
        return o instanceof Money m
                && amount == m.amount
                && currency.equals(m.currency);
    }

    @Override
    public int hashCode() {
        return Objects.hash(amount, currency);
    }

    @Override
    public String toString() {
        return amount + " " + currency;
    }
}

// record bitta qatorda xuddi shunday equals va
// hashCode beradi, toString esa boshqacha:
// "100 UZS" emas, Price[amount=100, currency=UZS]
record Price(long amount, String currency) {}
Subklass yangi field qoʻshib equalsni override qilsa, nima buziladi?Javob
Qisqa javob

Kontrakt buziladi. Point(1, 2) ColorPoint(1, 2, "RED")ga teng chiqadi, teskarisi esa yoʻq — simmetriya yoʻqoladi. Oddiy Point bilan solishtirganda rangni eʼtiborsiz qoldiradigan qilib «tuzatilsa», transitivlik buziladi: qizil va koʻk ColorPoint(1, 2) ikkalasi ham Point(1, 2)ga teng, lekin bir-biriga teng emas. Obyekti yaratiladigan klassdan meros olib, yangi field qoʻshgan holda equals kontraktini saqlashning umumiy yoʻli yoʻq.

instanceof oʻrniga getClass() != o.getClass() yozish simmetriyani saqlaydi, lekin boshqa narsani buzadi: endi yangi field qoʻshmagan subklass obyekti ham hech qachon ota klass obyektiga teng boʻlmaydi. Masalan, Set<Point>da shunday nuqta bor-yoʻqligini tekshirib boʻlmaydi — bu Liskov tamoyilining buzilishi. Hibernate proxyʼlari entityʼning subklassi boʻlgani uchun getClass() asosidagi equals ular bilan ham notoʻgʻri ishlaydi.

Amaliy yechimlar: value klassni final qilish (record doim final), yoki composition: ColorPoint Pointdan meros olmaydi, uni field sifatida saqlaydi va kerak boʻlsa asPoint() bilan qaytaradi.

class Point {
    final int x, y;
    Point(int x, int y) { this.x = x; this.y = y; }

    @Override
    public boolean equals(Object o) {
        return o instanceof Point p
                && p.x == x && p.y == y;
    }
    @Override
    public int hashCode() { return 31 * x + y; }
}

class ColorPoint extends Point {
    final String color;
    ColorPoint(int x, int y, String color) {
        super(x, y);
        this.color = color;
    }

    @Override
    public boolean equals(Object o) {
        return o instanceof ColorPoint cp
                && super.equals(cp)
                && color.equals(cp.color);
    }
}

var p = new Point(1, 2);
var cp = new ColorPoint(1, 2, "RED");
p.equals(cp); // true
cp.equals(p); // false: simmetriya buzildi

6Exceptionʼlar: ierarxiya, finally va try-with-resources

Hamma xatolar Throwabledan meros oladi. Undan ikki tarmoq chiqadi: Error — JVM yoki muhit darajasidagi jiddiy muammolar, Exception — dastur oʻzi hal qila oladigan holatlar. Exceptionning subklassi RuntimeException alohida oʻrinda: u va uning subklasslari unchecked.

TurMisollarKompilyator talabiOdatda nimani bildiradi
ErrorOutOfMemoryError, StackOverflowErroryoʻqJVM yoki muhit muammosi, odatda tiklab boʻlmaydi
checked: Exception va subklasslari (RuntimeExceptiondan tashqari)IOException, SQLExceptionushlash yoki throwsda eʼlon qilish sharttashqi, kutiladigan xato: fayl yoʻq, tarmoq uzildi
unchecked: RuntimeException va subklasslariNullPointerException, IllegalArgumentExceptionyoʻqkoʻpincha kod xatosi yoki notoʻgʻri argument

Checked tekshiruvi faqat kompilyatorda: JVM uchun checked va unchecked farqi yoʻq. Kotlinʼda checked exceptionʼlar umuman yoʻqligi va Lombokʼning @SneakyThrowsi shunga tayanadi.

finally bloki try qanday tugashidan qatʼi nazar bajariladi: oddiy tugasa ham, return boʻlsa ham, exception chiqsa ham. Lekin return bilan tartib intuitiv emas:

1/5int x = 1: oddiy lokal oʻzgaruvchi.

Resurslarni (fayl, socket, ulanish) yopish uchun Java 7 da try-with-resources qoʻshildi: try (...) ichida ochilgan AutoCloseable resurslar blok tugashi bilan, ochilgan tartibiga teskari tartibda yopiladi. Blokdan exception chiqib, close() ham exception tashlasa, asosiy exception yoʻqolmaydi: close()niki unga suppressed sifatida qoʻshiladi.

Exceptionʼni toʻgʻri ishlashning asosiy qoidalari: uni faqat biror narsa qila oladigan joyda ushlash, oʻrashda asl exceptionʼni cause sifatida berish va hech qachon boʻsh catch bilan yutib yubormaslik.

Tushunganingizni tekshiring

Checked va unchecked exception farqi nima? Qachon qaysi birini tanlaysiz?Javob
Qisqa javob

Checked exceptionʼni (IOException) kompilyator majburlaydi: uni ushlash yoki throwsda eʼlon qilish kerak. Unchecked (RuntimeException va subklasslari) uchun bunday talab yoʻq. Chaqiruvchi xatodan real tiklana olsa — checked; xato kod xatosini bildirsa yoki chaqiruvchi baribir hech narsa qila olmasa — unchecked.

Error Exception emas va odatda ushlanmaydi: OutOfMemoryError istalgan qatorda chiqishi mumkin va undan keyin dastur holati yaxlit ekaniga ishonib boʻlmaydi. catch (Throwable t) faqat eng yuqori darajada — loglash va toʻxtash uchun — oʻrinli.

Checked exceptionʼlarning amaldagi muammosi: ular qatlamlar orqali «oqib» chiqadi (servis metodida throws SQLException — maʼlumotlar bazasi tafsiloti APIʼga chiqib qoldi) va lambda bilan yaxshi ishlamaydi. Shuning uchun Spring kabi frameworkʼlar past darajadagi checked exceptionʼlarni unchecked exceptionʼlarga oʻraydi (DataAccessException).

// checked: ushlash yoki throws shart
String read(Path p) throws IOException {
    return Files.readString(p);
}

// unchecked: notoʻgʻri argument — chaqiruvchi xatosi
void setAge(int age) {
    if (age < 0)
        throw new IllegalArgumentException("age < 0");
    this.age = age;
}
try ichida return boʻlsa, finally bajariladimi? finally ichida return yozilsa-chi?Javob
Qisqa javob

Bajariladi: return ifodasi hisoblanadi, qiymat chetga saqlanadi, keyin finally ishlaydi va shundan soʻng metod saqlangan qiymatni qaytaradi. finally ichidagi return esa bu qiymatni ham, trydan chiqqan exceptionʼni ham bekor qiladi — exception izsiz yoʻqoladi.

Saqlangan qiymat primitiv boʻlsa, finallyda oʻzgaruvchini oʻzgartirish natijaga taʼsir qilmaydi. Reference boʻlsa, reference saqlanadi: finally listga element qoʻshsa, chaqiruvchi oʻsha oʻzgargan listni oladi.

finallydan exception tashlash ham xuddi shunday asl exceptionʼni yoʻqotadi. Kompilyator finallydagi return haqida ogohlantira oladi (-Xlint:finally: «finally clause cannot complete normally»), lekin bu ogohlantirish default yoqilmagan.

static int f() {
    int x = 1;
    try {
        return x; // 1 saqlanadi
    } finally {
        x = 2;    // natijaga taʼsir qilmaydi
    }
}   // f() → 1

static int g() {
    try {
        throw new IllegalStateException();
    } finally {
        return 2; // exception yoʻqoladi
    }
}   // g() → 2
try-with-resources qanday ishlaydi? Suppressed exception nima?Javob
Qisqa javob

try (...)da ochilgan AutoCloseable resurslar blok qanday tugashidan qatʼi nazar avtomatik yopiladi — ochilgan tartibiga teskari tartibda. Blokdan exception chiqib, close() ham exception tashlasa, asosiysi yoʻqolmaydi: close()niki unga suppressed boʻlib qoʻshiladi va getSuppressed() bilan olinadi.

Java 7 gacha resurs finallyda qoʻlda yopilardi. Blok ham, close() ham exception tashlasa, finallydagisi asl exceptionʼni almashtirib yuborardi — xatoning haqiqiy sababi yoʻqolardi. Suppressed exceptionʼlar aynan shu muammo uchun qoʻshilgan.

Tafsilotlar: ikkinchi resursni yaratish muvaffaqiyatsiz boʻlsa, birinchisi baribir yopiladi; null resurs uchun close() chaqirilmaydi; catch va finally bloklari resurslar yopilgandan keyin ishlaydi. Java 9 dan beri tashqarida yaratilgan effectively final oʻzgaruvchini ham berish mumkin: try (conn) { ... }.

try (var in = Files.newBufferedReader(src);
     var out = Files.newBufferedWriter(dst)) {
    in.transferTo(out);
} catch (IOException e) {
    // bu yerda in va out allaqachon yopilgan
    for (Throwable s : e.getSuppressed())
        System.err.println("close: " + s);
}
Exceptionʼni qayerda ushlash va qanday oʻrash kerak? Uni yutib yuborish nega xavfli?Javob
Qisqa javob

Exception faqat u bilan biror narsa qila oladigan joyda ushlanadi: tiklash, kontekst qoʻshib oʻrash yoki eng yuqori darajada loglash. Oʻrashda asl exception cause sifatida beriladi, aks holda asl stack trace yoʻqoladi. Boʻsh catch xatoni izsiz yashiradi: tizim notoʻgʻri holatda ishlashda davom etadi va sababni hech kim topa olmaydi.

Oʻz exception klassingiz chaqiruvchi shu holatni alohida ajratishi kerak boʻlganda yoki xato bilan birga maʼlumot (buyurtma ID, qolgan balans) uzatish kerak boʻlganda kerak. Odatda u RuntimeExceptiondan meros oladi va (message, cause) konstruktoriga ega boʻladi.

Koʻp uchraydigan xatolar: catch (Exception e) {}; logger oʻrniga e.printStackTrace(); loglab, keyin yana tashlash — bitta xato logda bir necha marta chiqadi; InterruptedExceptionni yutib yuborish — toʻgʻrisi Thread.currentThread().interrupt() bilan interrupt holatini qayta tiklash.

Prodʼda eʼtibor beriladigan nuqta: HotSpot bir joyda tez-tez takrorlanadigan NullPointerException, ArithmeticException kabi exceptionʼlarni bir muddatdan keyin stack traceʼsiz, oldindan yaratilgan obyekt bilan tashlashi mumkin (OmitStackTraceInFastThrow). Logda stack traceʼsiz NPE koʻrsangiz, shu xatoning birinchi uchrashuvini qidiring yoki JVMʼni -XX:-OmitStackTraceInFastThrow bilan ishga tushiring.

class OrderLoadException extends RuntimeException {
    OrderLoadException(long id, Throwable cause) {
        super("Order yuklanmadi: " + id, cause);
    }
}

Order load(long id) {
    try {
        return repo.find(id);
    } catch (SQLException e) {
        // cause beriladi: asl stack trace saqlanadi
        throw new OrderLoadException(id, e);
    }
}

7Enum, nested klasslar va generics

Javaʼdagi enum — java.lang.Enumdan meros oladigan oddiy klass, faqat uning obyektlari oldindan sanab qoʻyilgan va boshqasini yaratib boʻlmaydi. Unda fieldʼlar, konstruktor (doim private) va metodlar boʻladi, u interfeys implement qila oladi, har bir konstanta esa metodni oʻzicha override qila oladi. Har bir konstanta yagona obyekt boʻlgani uchun ularni == bilan solishtirish xavfsiz.

enum Priority {
    LOW(1), MEDIUM(5), HIGH(10);

    private final int weight;

    Priority(int weight) { this.weight = weight; }

    int weight() { return weight; }
}

Priority p = Priority.valueOf("HIGH");
p.weight(); // 10

Enum uchun maxsus kolleksiyalar bor: EnumSet elementlarni bit vektorda saqlaydi (64 tagacha konstanta — bitta long), EnumMap esa ordinal() boʻyicha indekslangan massivda. Ikkalasi ham HashSet va HashMapdan tezroq va ixchamroq. ordinal()ni bazaga yozish esa xavfli: konstantalar tartibi oʻzgarsa, eski yozuvlar boshqa qiymatga aylanadi — name() yoki alohida kod saqlanadi.

Klass boshqa klass ichida ham eʼlon qilinishi mumkin, va bu toʻrt xil boʻladi:

TurTashqi obyektga referenceQachon ishlatiladi
static nestedyoʻqtashqi klassga mantiqan tegishli yordamchi klass: AbstractMap.SimpleEntry, builder
innerbor: Outer.thistashqi obyekt holati bilan ishlaydigan obyekt, masalan kolleksiya iteratori
localinstance metodda eʼlon qilinsa — borfaqat bitta metodda kerak boʻlgan klass
anonymousinstance kontekstda yaratilsa — borbir martalik implementation; Java 8 dan beri koʻpincha lambda

Generics turlarni kompilyatsiya paytida tekshiradi: List<String>ga son qoʻshib boʻlmaydi va oʻqilgan elementni cast qilish shart emas. Runtimeʼda esa type parametrlar oʻchiriladi — bu type erasure: List<String> ham, List<Integer> ham bitta List klassi. Bu yoʻl Java 5 dan oldingi, generics boʻlmagan kod bilan moslik uchun tanlangan.

Generics invariant: Dog Animalning subtipi boʻlsa ham, List<Dog> List<Animal>ning subtipi emas — aks holda itlar listiga mushuk qoʻshib yuborish mumkin boʻlardi. Moslashuvchanlik wildcardʼlar bilan beriladi: ? extends T — elementlarni T sifatida oʻqish uchun, ? super T — T yozish uchun.

Tushunganingizni tekshiring

Javaʼdagi enum int konstantalardan nimasi bilan kuchliroq?Javob
Qisqa javob

Enum — toʻliq klass: har bir konstanta shu klassning yagona obyekti, unda field, konstruktor va metod boʻladi, har bir konstanta metodni oʻzicha override qila oladi. Kompilyator turni tekshiradi — Priority kutilgan joyga ixtiyoriy int berib boʻlmaydi, switch expression esa hamma konstanta koʻrib chiqilganini tekshiradi.

Konstantaga xos metodlar switchsiz polimorfizm beradi: har bir amal oʻz logikasini oʻzi bilan olib yuradi. Yangi konstanta qoʻshilganda abstract metodni yozish esdan chiqmaydi — kompilyator talab qiladi.

values() har chaqirilganda massivning yangi nusxasini qaytaradi; tez-tez chaqiriladigan joyda natijani static final fieldʼda saqlash maʼqul. valueOf("X") nom topilmasa IllegalArgumentException tashlaydi — tashqi kirish (JSON, URL parametri) uchun buni hisobga olish kerak.

enum Op {
    PLUS {
        int apply(int a, int b) { return a + b; }
    },
    TIMES {
        int apply(int a, int b) { return a * b; }
    };

    abstract int apply(int a, int b);
}

Op.TIMES.apply(3, 4); // 12

Map<Op, Long> calls = new EnumMap<>(Op.class);
Set<Op> enabled = EnumSet.of(Op.PLUS);
Static nested va inner klass farqi nima? Inner klass qanday qilib memory leakʼga olib keladi?Javob
Qisqa javob

Inner klass obyekti oʻzini yaratgan tashqi obyektga yashirin reference saqlaydi (Outer.this), static nested klass esa saqlamaydi. Inner obyekt uzoq yashaydigan joyga — static field, cache, listenerʼlar roʻyxati yoki boshqa threadʼga — tushsa, tashqi obyekt ham u bilan birga GC qilinmay qoladi.

Odatiy holatlar: executorʼga berilgan anonymous Runnable katta servis obyektini ushlab turadi; roʻyxatdan oʻchirilmagan anonymous listener oʻzini yaratgan ekran yoki kontrollerni ushlab turadi; «double brace initialization» — new HashMap<>() {{ put(...); }} — anonymous subklass yaratadi va u ham tashqi thisni saqlaydi.

Qoida: nested klass tashqi obyektning holatiga murojaat qilmasa, uni static qiling. Java 18 dan beri javac tashqi obyektni ishlatmaydigan inner va anonymous klasslarda bu referenceʼni saqlamaydi (serializable klasslardan tashqari), lekin tashqi fieldʼga bitta murojaatning oʻzi uni qaytaradi.

class Report {
    private final byte[] data = new byte[50_000_000];

    // inner: Task tashqi Report obyektini ushlaydi
    class Task implements Runnable {
        public void run() {
            System.out.println(data.length);
        }
    }

    // static nested: tashqi obyektga reference yoʻq
    static class Cleanup implements Runnable {
        public void run() { /* ... */ }
    }
}
Type erasure nima va u qanday cheklovlarga olib keladi?Javob
Qisqa javob

Generic turlar faqat kompilyatsiyada tekshiriladi, bytecodeʼda esa oʻchiriladi: List<String> va List<Integer> runtimeʼda bitta List klassi. Shuning uchun new T() va new T[n] yozib boʻlmaydi, List<int> mumkin emas, faqat type parametri bilan farq qiladigan ikki overload eʼlon qilib boʻlmaydi, Object x uchun esa x instanceof List<String> compile error beradi.

Kompilyator Tni uning chegarasi bilan almashtiradi (Object, yoki T extends Number boʻlsa — Number) va oʻqilgan joylarga cast qoʻyadi. Raw type yoki unchecked cast bilan bu himoyani chetlab oʻtish mumkin — bu heap pollution: List<String> ichida Integer paydo boʻladi va ClassCastException xato qilingan joyda emas, ancha keyin, elementni oʻqiganda chiqadi.

instanceof bilan generic tur faqat tekshiruvni runtimeʼda toʻliq bajarish mumkin boʻlganda ruxsat etiladi (Java 16 dan): Collection<String> c uchun c instanceof List<String> kompilyatsiya boʻladi — element turi allaqachon maʼlum, faqat List ekanini tekshirish qoladi. Runtimeʼda tur kerak boʻlsa, uni aniq berish kerak: type token — Class<T> parametri — orqali type.cast(x), type.isInstance(x). Erasure obyektlardagi turni oʻchiradi, lekin klass, field va metod eʼlonlaridagi generic maʼlumot klass faylida qoladi va reflection bilan oʻqiladi.

List<String> names = new ArrayList<>();
List raw = names;        // raw type: faqat warning
raw.add(42);             // kompilyatsiya boʻladi
String s = names.get(0); // ClassCastException

// type token: turni runtimeʼga aniq beramiz
static <T> T first(List<?> xs, Class<T> type) {
    return type.cast(xs.get(0));
}
? extends va ? super qachon ishlatiladi? PECS nima?Javob
Qisqa javob

? extends T — producer, yaʼni maʼlumot beradigan parametr uchun: elementlarni T sifatida oʻqiysiz, lekin qoʻsha olmaysiz. ? super T — consumer, yaʼni maʼlumot oladigan parametr uchun: T qoʻsha olasiz, oʻqiganda esa faqat Object olasiz. PECS — «Producer Extends, Consumer Super».

Nega cheklov bor? List<? extends Number> ortida List<Integer> ham, List<Double> ham turishi mumkin — kompilyator unga nima qoʻshish xavfsiz ekanini bilmaydi. List<? super Integer> ortida esa List<Integer>, List<Number> yoki List<Object> turadi: Integer ularning hammasiga sigʻadi, lekin oʻqilgan element turi nomaʼlum.

JDKʼdagi misollar: Collections.copy(List<? super T> dest, List<? extends T> src) va list.sort(Comparator<? super E> c) — Comparator<Object> bilan istalgan listni sort qilsa boʻladi. Wildcardʼlar parametrlarda ishlatiladi; qaytish turida ular faqat chaqiruvchining ishini qiyinlashtiradi.

Massivlar esa covariant: String[] Object[]ning subtipi. Buning narxi — runtime tekshiruvi: notoʻgʻri turdagi element yozilsa, ArrayStoreException.

static double sum(List<? extends Number> nums) {
    double s = 0;
    for (Number n : nums) s += n.doubleValue();
    return s;
}

static void fillOnes(List<? super Integer> out) {
    for (int i = 0; i < 3; i++) out.add(1);
}

sum(List.of(1, 2, 3)); // List<Integer> ham boʻladi
fillOnes(new ArrayList<Number>());

Object[] arr = new String[1];
arr[0] = 1; // ArrayStoreException

8Immutability, record va sealed: maʼlumotni modellashtirish

Immutable obyekt yaratilgandan keyin holatini oʻzgartirmaydi. Bu koʻp muammoni oʻz-oʻzidan yoʻq qiladi: obyektni threadʼlar sinxronizatsiyasiz ulashadi, HashMap kaliti sifatida xavfsiz, invariantlar faqat konstruktorda bir marta tekshiriladi, uni metodlarga nusxa olmasdan berish mumkin.

Immutable klassning retsepti: klass final; hamma fieldʼlar private final; setter yoʻq; mutable kirishlar (list, massiv, Date) konstruktorda nusxalanadi va tashqariga ham nusxa yoki oʻzgarmas view qaytariladi; konstruktor tugaguncha this tashqariga chiqmaydi. «Oʻzgartirish» kerak boʻlsa, yangi obyekt qaytariladi: withAmount(...).

Record (Java 16) maʼlumot tashuvchi klassni bitta qatorga qisqartiradi: record Money(long amount, String currency) {} — private final fieldʼlar, canonical konstruktor, amount() va currency() accessorʼlari, equals, hashCode va toString. Compact konstruktorda tekshiruv va normallashtirish yoziladi.

Sealed klass yoki interfeys (Java 17) oʻz subtiplarini permits bilan sanab qoʻyadi — boshqa hech kim undan meros ololmaydi. Pattern matching bilan birga bu yangi uslub beradi: maʼlumot — recordʼlarda, mumkin boʻlgan variantlar — sealed ierarxiyada, xatti-harakat esa switchda. Kompilyator switch hamma variantni koʻrib chiqqanini tekshiradi.

ImkoniyatPreviewStandart
var—Java 10
switch expression (->, yield)Java 12–13Java 14
text block (""")Java 13–14Java 15
recordJava 14–15Java 16
instanceof bilan pattern matchingJava 14–15Java 16
sealed klasslarJava 15–16Java 17
switchda pattern matchingJava 17–20Java 21
record patternsJava 19–20Java 21
unnamed _ variables va patternsJava 21Java 22
konstruktorda super(...)dan oldin kodJava 22–24Java 25

var (Java 10) — lokal oʻzgaruvchi turini kompilyator oʻng tomondan aniqlaydi; oʻzgaruvchi baribir statik turga ega boʻladi. Text block (Java 15) koʻp qatorli matnni escapeʼsiz yozish imkonini beradi, umumiy chap chekinish esa avtomatik olib tashlanadi:

var users = new ArrayList<User>(); // ArrayList<User>

String query = """
        SELECT id, name
        FROM users
        WHERE active = true
        """;

Tushunganingizni tekshiring

Immutable klass qanday yoziladi va record bunda qanchalik yordam beradi?Javob
Qisqa javob

Klass final, hamma fieldʼlar private final, setter yoʻq; mutable kirishlar konstruktorda nusxalanadi, tashqariga ham nusxa yoki oʻzgarmas view qaytariladi. Record birinchi qismni tayyor beradi, lekin defensive copyʼni baribir oʻzingiz yozasiz: recordʼning immutabilityʼsi sayoz.

Defensive copy nega kerak? Konstruktorga berilgan listga chaqiruvchida reference qoladi: u keyin listni oʻzgartirsa, «immutable» obyekt ham oʻzgaradi. Getter ichki listni qaytarsa ham xuddi shunday. List.copyOf ikkala muammoni hal qiladi: u oʻzgarmas nusxa qaytaradi, berilgan list allaqachon List.of bilan yaratilgan boʻlsa esa nusxa olmasdan oʻshaning oʻzini.

Thread-safety kafolati Java Memory Modelʼdan keladi: konstruktor tugagach, final fieldʼlar boshqa threadʼlarga sinxronizatsiyasiz ham toʻgʻri koʻrinadi — agar konstruktor paytida this tashqariga chiqmagan boʻlsa. Oddiy, final boʻlmagan fieldʼlar uchun bunday kafolat yoʻq.

record Order(String id, List<String> items) {
    Order {
        Objects.requireNonNull(id);
        items = List.copyOf(items); // defensive copy
    }
}

var src = new ArrayList<>(List.of("olma"));
var order = new Order("A1", src);
src.add("nok");
order.items(); // [olma]: nusxa oʻzgarmadi
// UnsupportedOperationException:
order.items().add("x");
Sealed klasslar nima beradi va ular pattern matching bilan qanday ishlaydi?Javob
Qisqa javob

Sealed klass yoki interfeys oʻz subtiplarini permits bilan aniq sanab qoʻyadi: boshqa hech kim undan meros ololmaydi. Shuning uchun kompilyator switch hamma variantni koʻrib chiqqanini tekshira oladi — default kerak emas, yangi subtip qoʻshilsa esa uni koʻrmagan har bir switch compile error beradi.

Har bir ruxsat etilgan subtip final, sealed yoki non-sealed boʻlishi shart — ierarxiya qayerda yopilishini muallif aniq aytadi. Record doim final, shuning uchun sealed interfeysga juda mos keladi. Subtiplar bitta modulda (modul boʻlmasa — bitta packageʼda) turishi kerak; ular shu faylning oʻzida boʻlsa, permits yozilmasa ham boʻladi.

Pattern matching bosqichma-bosqich qoʻshildi: Java 16 da instanceof bilan (if (o instanceof String s) — cast kerak emas), Java 21 da switchda type pattern, record pattern (case Rect(double w, double h) — komponentlarni darhol ajratib olish), when sharti va case null. case null yozilmasa, switch null uchun avvalgidek NullPointerException tashlaydi.

sealed interface Shape permits Circle, Rect {}
record Circle(double r) implements Shape {}
record Rect(double w, double h) implements Shape {}

static double area(Shape s) {
    return switch (s) {
        case Circle c -> Math.PI * c.r() * c.r();
        case Rect(double w, double h) -> w * h;
        // default kerak emas: hamma variant koʻrilgan
    };
}
Data-oriented programming nima va u klassik polimorfizmdan qachon yaxshiroq?Javob
Qisqa javob

Maʼlumot recordʼlar bilan, mumkin boʻlgan variantlar sealed ierarxiya bilan modellashtiriladi, xatti-harakat esa maʼlumotdan alohida — switch va pattern matching bilan yoziladi. Variantlar toʻplami yopiq, ular ustidagi amallar esa koʻp va tez-tez qoʻshiladigan boʻlsa — data-oriented qulay. Yangi turlar tez-tez qoʻshiladigan, amallar esa barqaror boʻlsa — klassik polimorfizm.

Bu «expression problem»ning ikki tomoni. Klassik OOPʼda yangi tur qoʻshish oson (yangi klass), yangi amal qoʻshish qiyin — har bir klassga metod yozish kerak. Data-oriented uslubda aksincha: yangi amal — bitta yangi switch, yangi tur esa hamma switchlarni oʻzgartirishni talab qiladi, lekin kompilyator ularning har birini koʻrsatib beradi.

Yaxshi misol — natijalar. Toʻlov «oʻtdi», «rad etildi» yoki «kutilmoqda» boʻlishi mumkin: buni null, flagʼlar va exceptionʼlar aralashmasi bilan emas, sealed interfeys va uchta record bilan ifodalasangiz, notoʻgʻri holatni umuman yaratib boʻlmaydi. Klassik polimorfizm esa uchinchi tomon yangi tur qoʻsha oladigan joyda (plaginlar, framework kengaytmalari) va xatti-harakat obyektning yashirin holatiga chambarchas bogʻliq boʻlganda yaxshiroq.

sealed interface PayResult
        permits Paid, Declined, Pending {}
record Paid(String txId) implements PayResult {}
record Declined(String reason) implements PayResult {}
record Pending(Instant retryAt) implements PayResult {}

static String message(PayResult r) {
    return switch (r) {
        case Paid p -> "Toʻlandi: " + p.txId();
        case Declined d -> "Rad etildi: " + d.reason();
        case Pending p -> "Kutilmoqda";
    };
}
Metod natija topmasa, nima qaytarishi kerak: null, Optional yoki exception?Javob
Qisqa javob

Natija yoʻqligi oddiy holat boʻlsa — Optional<T>: chaqiruvchi bu holatni koʻrmay oʻtib keta olmaydi. Natija yoʻqligi shartnoma buzilishi boʻlsa (ID mavjud deb kafolatlangan, argument notoʻgʻri) — exception. Kolleksiya qaytaradigan metod esa null emas, boʻsh kolleksiya qaytaradi.

Optional qaytish turi uchun moʻljallangan. Uni field qilib saqlash (Serializable emas, qoʻshimcha obyekt), metod parametri qilish (chaqiruvchini oʻrashga majburlaydi) va kolleksiyani oʻrash (Optional<List<T>> — boʻsh list yetarli) tavsiya qilinmaydi. Optional qaytaradigan metod hech qachon null qaytarmasligi kerak.

get()ni tekshiruvsiz chaqirish — oʻsha null tekshiruvini unutishning oʻzi, faqat boshqa exception bilan. Uning oʻrniga map, orElse, orElseThrow() (Java 10), ifPresentOrElse (Java 9) ishlatiladi.

API dizaynining umumiy qoidasi: parametr sifatida interfeys (List, Collection) qabul qilinadi, chaqiruvchining mutable listi saqlanmaydi (nusxa olinadi), natija esa oʻzgarmas qilib qaytariladi. Kutiladigan biznes natijalari (toʻlov rad etildi) qaytariladigan qiymat bilan — masalan, sealed natija turi bilan — ifodalanadi, kutilmagan va infratuzilma xatolari esa exception bilan.

interface Users {
    // topilmasligi — oddiy holat
    Optional<User> findByEmail(String email);

    // id albatta bor: yoʻq boʻlsa — exception
    User getById(long id);

    // natija boʻlmasa — boʻsh list, null emas
    List<Order> ordersOf(long userId);
}

String name = users.findByEmail(email)
        .map(User::name)
        .orElse("mehmon");

9java.time, serializatsiya, reflection va Lombok

Java 8 dagi java.time (JSR 310) eski Date va Calendarni almashtirdi. Uning asosiy turlari vaqtning har xil maʼnosini ifodalaydi:

TurNimani bildiradiQachon ishlatiladi
Instantvaqt chizigʻidagi aniq nuqta (UTC)log, eventʼlar, bazada saqlash, ikki lahza orasidagi vaqt
LocalDate, LocalTime, LocalDateTimezonasiz sana, soat yoki ikkalasitugʻilgan kun, «har kuni 09:00» kabi kalendar qiymatlari
ZonedDateTimesana-soat va zona qoidalari (Asia/Tashkent)foydalanuvchiga koʻrsatish, zonadagi kalendar hisoblari
OffsetDateTimesana-soat va qatʼiy offset (+05:00)API va bazaga uzatish (PostgreSQL timestamptz)
Duration, Periodvaqt oraligʻi: soniyalarda yoki kun, oy, yildatimeout, obuna muddati

Eski java.util.Date nega ishlatilmaydi: u mutable (setTime bilan oʻzgaradi — uni field qilib saqlagan klass immutable boʻlmaydi), yil 1900 dan, oy 0 dan sanaladi, SimpleDateFormat esa thread-safe emas. java.time turlari immutable va thread-safe. Eski kod bilan ulanish uchun date.toInstant() va Date.from(instant) bor.

Serializatsiya — obyektni baytlarga aylantirib, keyin qayta tiklash. Javaʼning oʻz mexanizmi (Serializable, ObjectOutputStream) bugun asosan eski kod va baʼzi kutubxonalarda qolgan; tizimlar oʻrtasida maʼlumot JSON yoki Protobuf bilan uzatiladi.

Annotatsiya — kodga biriktirilgan metamaʼlumot, oʻzi hech narsa qilmaydi: uni kimdir oʻqishi kerak. Retention kim oʻqishini belgilaydi: SOURCE annotatsiyani faqat kompilyator va annotation processorʼlar koʻradi (@Override, Lombok), CLASS klass faylida qoladi, lekin reflection uni koʻrmaydi (retention yozilmasa, shu tanlanadi), RUNTIME esa dastur ishlayotganda reflection orqali oʻqiladi (@Component, @Transactional, @Entity).

Annotation processing — kompilyator ishlayotganda chaqiriladigan plaginlar. Standart API ularga faqat yangi fayllar yaratishga ruxsat beradi: MapStruct mapper klasslarini shunday yaratadi — natija oddiy, oʻqisa boʻladigan Java kod. Lombok esa javacʼning ichki APIʼsi orqali mavjud klassning oʻzini oʻzgartiradi — shuning uchun yangi JDK chiqqanda Lombokni ham yangilash kerak boʻladi.

Tushunganingizni tekshiring

Instant, LocalDateTime va ZonedDateTime farqi nima? Qaysi birini qachon ishlatasiz?Javob
Qisqa javob

Instant — vaqt chizigʻidagi aniq nuqta: eventʼlar, log va bazada saqlash uchun. LocalDateTime — zonasiz «sana va soat», u bitta lahzani bildirmaydi: «2026-03-08 09:00» Toshkentda va Londonda har xil lahza. ZonedDateTime — sana-soat va zona qoidalari: foydalanuvchiga koʻrsatish va zonadagi kalendar hisoblari uchun.

Klassik xato — LocalDateTime.now(): u server zonasidagi soatni oladi. Konteynerlarda zona koʻpincha UTC, shuning uchun Toshkent vaqti 5 soatga farq qilib chiqadi. Lahza kerak boʻlsa — Instant.now(), mahalliy vaqt kerak boʻlsa — zonani aniq bering: ZonedDateTime.now(ZoneId.of("Asia/Tashkent")).

Yozgi vaqtga oʻtiladigan zonalarda baʼzi mahalliy vaqtlar umuman boʻlmaydi yoki ikki marta boʻladi. Toshkentda bunday oʻtish yoʻq, lekin foydalanuvchi yoki hamkor tizim boshqa zonada boʻlishi mumkin. ZoneOffset (+05:00) — qatʼiy siljish, ZoneId (Europe/Berlin) esa qoidalar toʻplami: kelajakdagi uchrashuvlar uchun offset emas, zona saqlanadi.

Instant now = Instant.now();
ZoneId tashkent = ZoneId.of("Asia/Tashkent");
ZonedDateTime local = now.atZone(tashkent);

// 2026-yil 29-mart: Berlinda soat 02:00 dan
// toʻgʻri 03:00 ga oʻtiladi, 02:30 boʻlmaydi
LocalDateTime t = LocalDateTime.of(2026, 3, 29, 2, 30);
ZonedDateTime berlin =
        t.atZone(ZoneId.of("Europe/Berlin"));
// 2026-03-29T03:30+02:00[Europe/Berlin]
Serializable, transient va serialVersionUID nima uchun kerak? Nega bugun Java serializatsiyasi oʻrniga JSON ishlatiladi?Javob
Qisqa javob

Serializable — metodsiz marker interfeys: ObjectOutputStream obyektni u bogʻlangan obyektlar bilan birga baytlarga yozadi, transient fieldʼlar esa yozilmaydi. serialVersionUID — klass versiyasi: oʻqishda mos kelmasa, InvalidClassException. JSON afzal, chunki Java serializatsiyasi faqat Java bilan ishlaydi, klassning private fieldʼlariga bogʻlanadi va ishonchsiz maʼlumotni deserializatsiya qilish xavfsizlik teshigi.

serialVersionUID eʼlon qilinmasa, u klass tuzilishidan — nomi, interfeyslari, fieldʼlari, metodlari — avtomatik hisoblanadi. Klassga yangi field yoki private boʻlmagan bitta metod qoʻshilsa ham u oʻzgaradi va oldin yozilgan maʼlumot oʻqilmay qoladi; hisob natijasi kompilyatorga ham bogʻliq boʻlishi mumkin. Shuning uchun u aniq yoziladi: private static final long serialVersionUID = 1L.

transient — parol, token, cache yoki serializatsiya qilib boʻlmaydigan narsalar (Thread, ulanish) uchun. Deserializatsiyadan keyin bunday field default qiymatda boʻladi: null, 0, false.

Asosiy muammo — xavfsizlik. Deserializatsiya classpathʼdagi istalgan Serializable klass obyektini konstruktorlarni chetlab yaratadi va ularning readObject kabi metodlarini chaqiradi. 2015 yildan beri gadget chain — kutubxonalardagi shunday klasslar zanjiri — orqali masofadan kod bajarish hujumlari koʻp topilgan. Himoya: ishonchsiz manbadan kelgan maʼlumotni umuman deserializatsiya qilmaslik; zarur boʻlsa — ObjectInputFilter (Java 9, Java 17 dan kontekstga xos filtrlar bilan).

class Session implements Serializable {
    private static final long serialVersionUID = 1L;

    private String userId;
    // yozilmaydi: oʻqilgandan keyin null
    private transient String accessToken;
}
Spring kabi frameworkʼlar annotatsiyalarni qanday ishlatadi? Reflectionʼning narxi qanday?Javob
Qisqa javob

Framework ishga tushganda klasslarni topadi va ulardagi RUNTIME retentionʼli annotatsiyalarni oʻqiydi: @Component boʻlsa — obyekt yaratadi va dependencyʼlarini beradi, @Transactional boʻlsa — obyektni proxy bilan oʻraydi. Reflection qulay, lekin oddiy chaqiruvdan sekinroq, kompilyator tekshiruvidan tashqarida ishlaydi va modul cheklovlariga duch keladi.

Reflection API: getDeclaredMethods(), getAnnotation(...), Method.invoke(...), Field.setAccessible(true). Eng qimmat qismi — qidiruv (getDeclaredMethod), shuning uchun frameworkʼlar topilgan Method va Field obyektlarini keshlaydi. Java 18 da reflectionʼning oʻzi method handleʼlar ustiga qayta yozildi (JEP 416).

Cheklovlar: Java 17 dan beri JDK klasslarining private aʼzolariga va ichki packageʼlariga setAccessible(true) bilan kirib boʻlmaydi (InaccessibleObjectException), faqat --add-opens orqali. Reflection bilan chaqirilgan kodni IDE va kompilyator kuzatmaydi: metod nomi oʻzgarsa, xato faqat runtimeʼda chiqadi. GraalVM native image uchun esa reflection oldindan konfiguratsiya qilinishi kerak.

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface Timed {}

class Service {
    @Timed void load() {}
}

for (Method m : Service.class.getDeclaredMethods()) {
    if (m.isAnnotationPresent(Timed.class))
        System.out.println("timed: " + m.getName());
}
Lombok qanday ishlaydi va @Data, @Builderning qanday tuzoqlari bor?Javob
Qisqa javob

Lombok — annotation processor: kompilyatsiya paytida klassga getter, setter, equals, konstruktor kabi kodni qoʻshadi, runtimeʼda Lombok umuman yoʻq. @Data hamma fieldʼlar boʻyicha equals, hashCode va setterʼlar yozadi — JPA entity va mutable kalitlar uchun xavfli. @Builder majburiy fieldʼlarni tekshirmaydi va field initializerʼlarini @Builder.Defaultsiz eʼtiborsiz qoldiradi.

@Data va JPA: equals va hashCode hamma fieldʼlarni, jumladan lazy relationʼlarni oladi — bu bazaga kutilmagan soʻrovlar, ikki tomonlama bogʻlanishda esa StackOverflowError degani. Entity HashSetga qoʻshilgandan keyin ID berilsa, uning hashCodei oʻzgaradi. Entityʼlarda @Getter va @Setter hamda qoʻlda yozilgan yoki @EqualsAndHashCode(onlyExplicitlyIncluded = true) bilan cheklangan equals ishlatiladi.

MapStruct boshqacha yondashuv: u mapper interfeysi uchun kompilyatsiyada oddiy Java klass yaratadi, reflection yoʻq. Maqsad obyektning biror fieldʼi map qilinmay qolsa, default holatda ogohlantirish beradi; unmappedTargetPolicy = ReportingPolicy.ERROR bilan bu compile errorʼga aylanadi.

@Getter
@Builder
class Invoice {
    private String id;
    private List<String> lines = new ArrayList<>();
}

var inv = Invoice.builder().id("A1").build();
inv.getLines(); // null: initializer eʼtiborsiz qoldi

// toʻgʻrisi:
// @Builder.Default
// private List<String> lines = new ArrayList<>();

Tushunganingizni suhbatda sinab koʻring

Mavzuli mock intervyuda «Til va OOP»ni tanlang. AI shu kabi savollarni beradi, javobingizga qarab chuqurroq savol soʻraydi va har javobingizga fikr bildiradi.

Mock intervyuni boshlash