Java asoslari 6-qism. OYD davomi

1. Interface

Interface - class nima qila olishini belgilaydigan shartnoma.

public interface PaymentService {
    void pay(double amount);
}

Bu interface "to‘lov qilish kerak" deydi, lekin qanday qilishni aytmaydi.

public class ClickPaymentService implements PaymentService {
    @Override
    public void pay(double amount) {
        System.out.println("Click orqali to'landi: " + amount);
    }
}

Bu yerda ClickPaymentService interface ichidagi pay() methodini real ishlatmoqda.

Qachon interface ishlatiladi?

Masalan, sizda bir nechta to‘lov turi bor:

• Click

• Payme

• Uzum

• Naqd

Har birida pay() bor, lekin ishlash usuli har xil.

public class PaymePaymentService implements PaymentService {
    @Override
    public void pay(double amount) {
        System.out.println("Payme orqali to'landi: " + amount);
    }
}

Shunda kodimiz bitta interface orqali bir nechta implementation bilan ishlay oladi.

1.2 Abstract class

Abstract class - to‘liq tayyor bo‘lmagan class.

public abstract class Animal {
    public void breathe() {
        System.out.println("Nafas olyapti");
    }

    public abstract void makeSound();
}

Bu yerda:

• breathe() tayyor method;

• makeSound() esa majburiy yozilishi kerak bo‘lgan method.

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Vov-vov");
    }
}

Interface vs Abstract class

Oddiy qoida:

Interface - nima qila oladi. Abstract class - qanday umumiy asosga ega.

2. Polymorphism

Polymorphism - bitta tur orqali turli obyektlar bilan ishlash.

PaymentService service = new ClickPaymentService();
service.pay(100_000);

Keyin boshqa implementation qo‘ysak ham kod ishlaydi:

PaymentService service = new PaymePaymentService();
service.pay(100_000);

Bu juda muhim. Chunki real loyihalarda kodni moslashuvchan qiladi.

Hayotiy misol

public class OrderService {
    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void createOrder(double amount) {
        paymentService.pay(amount);
        System.out.println("Order yaratildi");
    }
}

Bu class Click’ga ham, Payme’ga ham, boshqa to‘lov tizimiga ham bog‘lanib qolmaydi.

Bu prinsip Spring Boot’da juda ko‘p ishlatiladi.

3. Composition over inheritance

Junior uchun juda muhim mavzu.

Ko‘p Boshlang'ichlar extendsni ko‘p ishlatadi. Lekin real loyihalarda ko‘pincha composition afzal.

Inheritance

public class Car extends Engine {
}

Bu yaxshi emas, chunki Car - engine emas. Car ichida engine bor.

Composition

public class Car {
    private Engine engine;
}

Bu to‘g‘riroq.

Agar "A is B" bo‘lsa - inheritance.
Agar "A has B" bo‘lsa - composition.

Misol:

• Dog is Animal - inheritance bo‘lishi mumkin.

• Car has Engine - composition.

• Order has Customer - composition.

• User has Role - composition.

4. Encapsulation

Encapsulation - class ichidagi ma’lumotni tashqaridan noto‘g‘ri o‘zgartirishdan himoya qilish.

Yomon kod:

public class User {
    public String name;
    public int age;
}

Bu yerda istalgan joydan noto‘g‘ri qiymat berish mumkin:

user.age = -10;

Yaxshi kod:

public class User {
    private String name;
    private int age;

    public void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age manfiy bo'lishi mumkin emas");
        }
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

Bu yerda class o‘z holatini o‘zi nazorat qiladi.

5. Inner class, anonymous class

Inner class

Class ichida class yozish mumkin.

public class Order {
    private String orderNumber;

    class OrderItem {
        private String productName;
        private int quantity;
    }
}

Lekin real backend loyihalarda inner class ko‘p ishlatilmaydi. Ko‘proq DTO yoki kichik helper classlarda uchraydi.

Anonymous class

Nom berilmagan class.

Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("Task ishladi");
    }
};

Java 8'dan keyin bunday joylarda ko‘pincha lambda ishlatiladi:

Runnable task = () -> System.out.println("Task ishladi");

6. Enum

Enum - oldindan aniq bo‘lgan qiymatlar ro‘yxati.

Masalan, order status:

public enum OrderStatus {
    NEW,
    PAID,
    CANCELLED,
    DELIVERED
}

Yomon usul:

String status = "PAID";

Nega yomon?

Chunki xato yozish mumkin:

String status = "PADI";

Enum bilan esa bunday xato kamayadi.

public class Order {
    private OrderStatus status;
}

Enum ichida field va method ham bo‘lishi mumkin

public enum UserRole {
    ADMIN("Administrator"),
    USER("Oddiy foydalanuvchi");

    private final String title;

    UserRole(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}

7. Amaliy mashq

Quyidagi kichik loyiha orqali OOP deep dive’ni mustahkamlash mumkin.

Loyiha: Payment System

Talablar:

• PaymentService interface yarating.

• ClickPaymentService, PaymePaymentService, CashPaymentService classlarini yozing.

• OrderService ichida PaymentService ishlating.

• OrderStatus enum yarating.

• Order yaratilganda status NEW bo‘lsin.

• To‘lov qilinganda status PAID bo‘lsin.

Minimal struktura:

src
 └── main
     └── java
         └── uz.demo
             ├── payment
             │   ├── PaymentService.java
             │   ├── ClickPaymentService.java
             │   ├── PaymePaymentService.java
             │   └── CashPaymentService.java
             ├── order
             │   ├── Order.java
             │   ├── OrderStatus.java
             │   └── OrderService.java
             └── Main.java