public sealed class Shape permits Circle, Square, Rectangle { ... }

public final class Circle extends Shape { ... }  // Нельзя наследовать
public non-sealed class Square extends Shape { ... }  // Можно наследовать
public sealed class Rectangle extends Shape permits FilledRectangle { ... }
public final class FilledRectangle extends Rectangle { ... }

public sealed interface Animal permits Dog, Cat { ... }
public final class Dog implements Animal { ... }
public record Cat() implements Animal { ... }  // record тоже может реализовывать sealed-интерфейс

public String getShapeType(Shape shape) {
    return switch (shape) {
        case Circle c -> "Circle";
        case Square s -> "Square";
        case Rectangle r -> "Rectangle";
        // Компилятор знает все варианты, поэтому default не обязателен!
    };
}

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

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

@Override
public int compareTo(Person other) {
    return Integer.compare(this.age, other.age);
}

@Override
public String toString() {
    return name + " (" + age + ")";
}

}

List people = new ArrayList<>(); 
people.add(new Person("Alice", 30)); 
people.add(new Person("Bob", 25)); 
Collections.sort(people); 
System.out.println(people); // Вывод: [Bob (25), Alice (30)]

import java.util.Comparator;

public class NameComparator implements Comparator { 
      @Override 
       public int compare(Person p1, Person p2) { 
              return p1.getName().compareTo(p2.getName()); 
       }
 }

List people = new ArrayList<>(); 
people.add(new Person("Alice", 30)); 
people.add(new Person("Bob", 25)); 
Collections.sort(people, 
new NameComparator()); 
System.out.println(people); // Вывод: [Alice (30), Bob (25)]

import java.util.HashSet;

public class Task230425 {
    public static void main(String[] args) {
        HashSet<Double> set = new HashSet<>();
        set.add(0.0);
        set.add(-0.0);
        set.add(Double.NaN);
        set.add(Double.NaN);

        System.out.println(set.size());
    }
}

public class Book implements Comparable {

private String title; private double price;

public Book(String title, double price) {
    this.title = title;
    this.price = price;
}

@Override
public int compareTo(Book other) {
    return this.title.compareTo(other.title);
}

}

public class BookPriceComparator implements Comparator { 

@Override public int compare(Book b1, Book b2) {

     return Double.compare(b1.getPrice(), b2.getPrice()); 

   } 
}

public class BookAuthorComparator implements Comparator { 

    @Override public int compare(Book b1, Book b2) {

            return b1.getAuthor().compareTo(b2.getAuthor()); 
     }
}

List books = new ArrayList<>(); 
books.add(new Book("Java", 50.0));
books.add(new Book("Python", 40.0)); 
Collections.sort(books, new BookPriceComparator()); // Сортировка по цене

List books = new ArrayList<>(); 
books.add(new Book("Java", 50.0)); 
books.add(new Book("Python", 40.0));
Collections.sort(books, Comparator.comparing(Book::getPrice)); // Сортировка по цене

List books = new ArrayList<>(); 
books.add(new Book("Java", 50.0)); 
books.add(new Book("Java", 40.0)); 
Collections.sort(books, Comparator.comparing(Book::getTitle) .thenComparing(Book::getPrice)); // Сначала по названию, затем по цене

public class Person implements Comparable { 

private String name; private int age;

   @Override
   public int compareTo(Person other) {
       return this.name.compareTo(other.name); // Сравнение только по имени
   }

   @Override
   public boolean equals(Object obj) {
       if (!(obj instanceof Person)) return false;
       Person other = (Person) obj;
       return this.name.equals(other.name) && this.age == other.age;
   }

}

@Override public int compareTo(Person other) {
    if (other == null) return 1; // null считается "меньше" return this.age - other.age; 
}

List people = new ArrayList<>(); 

Collections.sort(people, (p1, p2) -> p2.getAge() - p1.getAge()); // Сортировка по убыванию возраста

Comparator nullSafeComparator = Comparator .nullsFirst(Comparator.comparing(Person::getName)); // null-объекты будут первыми

import java.util.HashSet;

public class Task240425 {
    public static void main(String[] args) {
        HashSet<Magic> set = new HashSet<>();
        
        Magic m1 = new Magic(1);
        Magic m2 = new Magic(1);
        Magic m3 = new Magic(2);
        
        set.add(m1);
        set.add(m2);
        set.add(m3);
        
        m3.value = 1;
        
        set.remove(m1);
        set.remove(new Magic(2));
        set.remove(new Magic(1));
        
        System.out.println(set.size());
    }
    
    static class Magic {
        int value;
        
        Magic(int value) {
            this.value = value;
        }
        
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Magic magic = (Magic) o;
            return value == magic.value;
        }
        
        @Override
        public int hashCode() {
            return value;
        }
    }
}

public class Employee { 

private String department; 
private double salary;

public Employee(String department, double salary) {
    this.department = department;
    this.salary = salary;
}

public String getDepartment() { return department; }
public double getSalary() { return salary; }

@Override
public String toString() {
    return department + ": " + salary;
  }

}

List employees = new ArrayList<>(); 

employees.add(new Employee("HR", 50000)); 
employees.add(new Employee("IT", 60000)); 
employees.add(new Employee("HR", 45000));

Comparator comparator = Comparator.comparing(Employee::getDepartment).thenComparingDouble(Employee::getSalary);

Collections.sort(employees, comparator); 

System.out.println(employees); // Вывод: [HR: 45000.0, HR: 50000.0, IT: 60000.0]

Comparator reverseComparator = Comparator.comparingDouble(Employee::getSalary).reversed();

Collections.sort(employees, reverseComparator); 

System.out.println(employees); // Вывод: [IT: 60000.0, HR: 50000.0, HR: 45000.0]

TreeSet employeeSet = new TreeSet<>(Comparator.comparing(Employee::getDepartment).thenComparingDouble(Employee::getSalary)); 

employeeSet.add(new Employee("HR", 50000)); 
employeeSet.add(new Employee("IT", 60000)); 
employeeSet.add(new Employee("HR", 45000)); 

System.out.println(employeeSet); // Вывод: [HR: 45000.0, HR: 50000.0, IT: 60000.0]