public class Point {
    private final int x;
    private final int y;

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

    public boolean equals(Point other) {
        if (this == other) return true;

        return this.x == other.x && this.y == other.y;
    }

    public int hashCode() {
        return Objects.hash(x, y);
    }
}

Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);
Point p3 = new Point(2022, 2023);

System.out.println(p1.equals(p2));
System.out.println(p1.equals(p3));

Set<Point> set = new HashSet<>();
set.add(p1);

System.out.println(set.contains(p2));
System.out.println(set.contains(p3));

public class Point {
    private final int x;
    private final int y;

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

    // getters

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Point)) return false;

        Point other = (Point) o;

        return x == other.x && y == other.y;
    }
}

public class ColourPoint extends Point {
    private final String colour;

    public ColourPoint(int x, int y, String colour) {
        super(x, y);
        this.colour = colour;
    }

    // getters

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ColourPoint)) return false;

        ColourPoint other = (ColourPoint) o;

        return this.getX() == other.getX() &&
               this.getY() == other.getY() &&
               this.colour.equals(other.colour);
    }

}

class A {}
class B extends A {}
class C extends B {}
class D extends C {}

public class Loader {
    public static void main(String[] args) {
        B b = new C();
        A a = b;
        if (a instanceof A) System.out.println("A");
        if (a instanceof B) System.out.println("B");
        if (a instanceof C) System.out.println("C");
        if (a instanceof D) System.out.println("D");
    }
}

class SuperBase {
    public int i = 3;

    public void foo (Object o) {
        System.out.println("Object " + i);
    }
    public void foo (String s) {
        System.out.println("String " + i);
    }
}

class Base extends SuperBase {
    public Base() {
        i = 5;
    }

    public static void main(String[] args) {
        SuperBase sb = new Base();
        Object o = "";
        sb.foo(o);
        sb.foo("");
    }
}

class Parent {}
class DeriveOne extends Parent {}
class DeriveTwo extends Parent {}
Parent p = new Parent();
DeriveOne d1 = new DeriveOne();
DeriveTwo d2 = new DeriveTwo();
d1 = (DeriveOne) d2;

public class Sample<T> {
    T data;
    public Sample(T data) {
        this.data = data;
    }
}

public class App {
        public Sample method(Integer value1, String value2) { //1
        var sample1 = new Sample<Integer>(value1);
        if (value2 != null) {
            var sample2 = (Sample) sample1; //2
            sample2.data = value2;
            return sample2;
        }
        return sample1;
    }
}

class VolatileExample {
    private static boolean running = true; // Не использовано volatile

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            int count = 0;
            while (running) {
                count++;
            }
            System.out.println("Stopped at count: " + count);
        });

        thread.start();
        Thread.sleep(1000);

        running = false;
        thread.join();
        System.out.println("Main thread completed.");
    }
}

class ReorderingExample {
    private int x = 0;
    private boolean flag = false;  // тут нужен volatile

    public void writer() {
        x = 42;  // (1)
        flag = true;  // (2)
    }

    public void reader() {
        if (flag) {  // (3)
            System.out.println(x);  // (4)
        }
    }

    public static void main(String[] args) {
        ReorderingExample example = new ReorderingExample();

        Thread writerThread = new Thread(example::writer);
        Thread readerThread = new Thread(example::reader);

        writerThread.start();
        readerThread.start();
    }
}

class Singleton {
    private static Singleton instance; // Тут еще нужно вкрячить volatile

    private Singleton() {
        // Private constructor
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

class UnsafePublication {
    private Object resource; // нужен volatile что бы решить проблему

    public UnsafePublication() {
        new Thread(() -> {
            resource = new Object();
        }).start();
    }

    public Object getResource() {
        return resource;
    }

    public static void main(String[] args) throws InterruptedException {
        UnsafePublication unsafe = new UnsafePublication();
        Thread.sleep(100);
        if (unsafe.getResource() != null) {
            System.out.println("Resource is initialized");
        } else {
            System.out.println("Resource is null");
        }
    }
}

CREATE TABLE town
(
    id   bigserial PRIMARY KEY,
    name text
);

CREATE TABLE person
(
    id      bigserial PRIMARY KEY,
    name    text,
    town_id bigint not null REFERENCES town (id)
);

CREATE TABLE bridge
(
    id      bigserial PRIMARY KEY,
    name    text,
    town_id bigint not null REFERENCES town (id)
);

SELECT p.id
FROM person p
        LEFT JOIN bridge b on p.town_id = b.town_id
WHERE b.id IS NULL;