public class VariableTypesExample {
    static int classVariable = 10; // Class variable
    
    public static void main(String[] args) {
        int localVariable = 5; // Local variable
        VariableTypesExample example = new VariableTypesExample();
        example.instanceMethod();
        staticMethod();
        
        System.out.println("Class Variable: " + classVariable);
        System.out.println("Local Variable: " + localVariable);
        System.out.println("Instance Variable: " + example.instanceVariable);
    }
    
    int instanceVariable = 20; // Instance variable
    
    void instanceMethod() {
        classVariable = 15;
        instanceVariable = 25;
    }
    
    static void staticMethod() {
        classVariable = 30;
    }
}

import java.io.Serializable;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializationExample {
    public static void main(String[] args) {
        Person person = new Person("John Doe", 30);

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"))) {
            oos.writeObject(person);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeserializationExample {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {
            Person person = (Person) ois.readObject();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    // остальные поля и методы
}

class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private transient String password;

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{username='" + username + "', password='" + password + "'}";
    }
}

public class WrapperExample {
    public static void main(String[] args) {
        Integer integerObject = Integer.valueOf(10);
        int intValue = integerObject.intValue();
        System.out.println("Integer value: " + intValue);

        String str = "20";
        int parsedInt = Integer.parseInt(str);
        System.out.println("Parsed integer: " + parsedInt);
    }
}

public class WrapperExample {
    public static void main(String[] args) {
        Double doubleObject = Double.valueOf(10.5);
        double doubleValue = doubleObject.doubleValue();
        System.out.println("Double value: " + doubleValue);

        String str = "20.5";
        double parsedDouble = Double.parseDouble(str);
        System.out.println("Parsed double: " + parsedDouble);
    }
}

public class WrapperExample {
    public static void main(String[] args) {
        Character charObject = Character.valueOf('a');
        char charValue = charObject.charValue();
        System.out.println("Character value: " + charValue);

        char upperChar = Character.toUpperCase(charValue);
        System.out.println("Upper case: " + upperChar);

        boolean isLetter = Character.isLetter(charValue);
        System.out.println("Is letter: " + isLetter);
    }
}

public class BoxingExample {
    public static void main(String[] args) {
        Integer a = 1000;
        Integer b = 1000;
        Integer c = 10;
        Integer d = 10;

        System.out.println(a == b);
        System.out.println(c == d);
    }
}

public class AutoboxingExample {
    public static void main(String[] args) {
        int intValue = 5;
        Integer integerObject = intValue; // Автоупаковка
        System.out.println("Integer object: " + integerObject);

        char charValue = 'a';
        Character characterObject = charValue; // Автоупаковка
        System.out.println("Character object: " + characterObject);
    }
}

public class UnboxingExample {
    public static void main(String[] args) {
        Integer integerObject = Integer.valueOf(10);
        int intValue = integerObject; // Распаковка
        System.out.println("Primitive int: " + intValue);

        Character characterObject = Character.valueOf('a');
        char charValue = characterObject; // Распаковка
        System.out.println("Primitive char: " + charValue);
    }
}

public class UnboxingPitfall {
    public static void main(String[] args) {
        Integer integerObject = null;
        try {
            int intValue = integerObject; // Может вызвать NullPointerException
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException!");
        }
    }
}

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }
}

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class ObjectMethodsExample {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass(1);
        MyClass obj2 = new MyClass(1);
        MyClass obj3 = obj1;

        System.out.println(obj1.equals(obj2));
        System.out.println(obj1 == obj2);
        System.out.println(obj1.hashCode() == obj2.hashCode());
        System.out.println(obj1 == obj3);
    }
}

class MyClass {
    int value;

    MyClass(int value) {
        this.value = value;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        MyClass myClass = (MyClass) obj;
        return value == myClass.value;
    }

    @Override
    public int hashCode() {
        return value;
    }
}

public class Person implements Cloneable {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }

    public static void main(String[] args) {
        try {
            Person person1 = new Person("John", 25);
            Person person2 = (Person) person1.clone();
            System.out.println(person1);
            System.out.println(person2);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

public class WaitNotifyExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1: Waiting for lock...");
                    lock.wait();
                    System.out.println("Thread 1: Got the lock!");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Got the lock!");
                lock.notify();
                System.out.println("Thread 2: Notified!");
            }
        });

        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        t2.start();
    }
}

public class FinalizeExample {
    @Override
    protected void finalize() throws Throwable {
        try {
            System.out.println("Finalize method called");
        } finally {
            super.finalize();
        }
    }

    public static void main(String[] args) {
        FinalizeExample obj = new FinalizeExample();
        obj = null;
        System.gc(); // Запрос сборщика мусора (не гарантия вызова finalize)
    }
}

Queue<String> queue = new LinkedList<>();

Queue<String> priorityQueue = new PriorityQueue<>();

Queue<String> arrayDeque = new ArrayDeque<>();

queue.add("Element");

queue.offer("Element");

String element = queue.remove();

String element = queue.poll();

String element = queue.element();

String element = queue.peek();

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // Добавление элементов
        queue.add("Element 1");
        queue.offer("Element 2");

        // Просмотр элемента
        System.out.println("Peek: " + queue.peek());

        // Удаление элементов
        System.out.println("Removed: " + queue.remove());
        System.out.println("Polled: " + queue.poll());

        // Попытка просмотра/удаления из пустой очереди
        System.out.println("Peek from empty queue: " + queue.peek());
        System.out.println("Poll from empty queue: " + queue.poll());
    }
}

import java.util.*;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        queue.add(1);
        queue.add(2);
        queue.add(3);
        queue.offer(4);
        queue.poll();
        queue.remove();

        System.out.println(queue);
    }
}