//Zamiast tego
        if(account instanceof PremiumAccount) {
            var premiumAccount = (PremiumAccount) account;
            System.out.println(premiumAccount.getInfo());
        }
        // można tak
        if(account instanceof PremiumAccount premiumAccount) {
            System.out.println(premiumAccount.getInfo());
        }

        switch (account) {
            case PremiumAccount premiumAccount: //switch z rzutowaniem
                System.out.println(premiumAccount.getInfo());
                break;
            default:
                System.out.println(account.toString());
        }

public sealed class Account permits PremiumAccount {
    protected BigDecimal balance = BigDecimal.ZERO;
    @Override
    public String toString() {
        return "Account{" +
                "balance=" + balance +
                '}';
    }
}
--
public final class PremiumAccount extends Account {
    public String getInfo() {
        return "PremiumAccount{" +
                "balance=" + balance +
                '}';
    }
}
--

    public static void main(String[] args) {
        var url = "https://raw.githubusercontent.com/manum/mr-cassandra/master/mr_cassandra/all-shakespeare.txt";
        callWordCountService(url, (@NotNull var map) -> {
            System.out.println("The result is = " + map);
        });
    }
    private static void callWordCountService(String url, Consumer<Map<String, Integer>> callback) {
        callback.accept(
                Map.of("death", 1305, "great", 782, "queen", 726)
        );
    }

        return switch (part.charAt(0)) {
            case 'N'->"Knight";
            case 'B'->"Bishop";
            case 'R'->"Rook";
            case 'Q'->"Queen";
            case 'K'->"King";
            case 'P'->"Pawn";
            default ->"Pawn";
        } ;
/////// można tez tak:

case 1:
                    break "White " 

/////// i wynik do zmiennej
int x = switch (c) {
            case 'N', 'B', 'R', 'Q', 'K', 'P' -> 1;
            case 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h' -> 0;
            default -> 0;
        };

    public static void main(String[] args) throws IOException, URISyntaxException, InterruptedException {
        Path destinationPath;
        destinationPath = new File("out", "shakespeare.txt").toPath();
        URI sourceLocation = new URI("https://raw.githubusercontent.com/manum/mr-cassandra/master/mr_cassandra/all-shakespeare.txt");

        new P05HttpClient().downloadFile(sourceLocation, destinationPath);
    }

    private void downloadFile(URI sourceLocation, Path destinationPath) throws IOException, InterruptedException {
        HttpClient client = HttpClient.newBuilder().build();
        HttpRequest request = HttpRequest.newBuilder().uri(sourceLocation).build();

        client.send(request, responseInfo -> {
            HttpResponse.BodyHandler<Path> handler = HttpResponse.BodyHandlers.ofFile(destinationPath);
            return handler.apply(responseInfo);
        });
    }

 List<Kid> list = Arrays.asList(
                new Kid("Little Richard", 8),
                new Kid("Elvis King", 8),
                new Kid("Billy Bob", 7),
        );

        IntSummaryStatistics statistics = list.stream()
                .mapToInt(Kid::getAge)
                .summaryStatistics();

        //min and max
        int minSummary = statistics.getMin();
        int maxSummary = statistics.getMax();

        //other statistics
        double avgSummary = statistics.getAverage();
        long countSummary = statistics.getCount();
        long sumSummary = statistics.getSum();

package pl.training.processor.adv.examples;

import lombok.RequiredArgsConstructor;
import lombok.extern.java.Log;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.UUID;

public class DynamicProxy {
    public static void main(String[] args) {
        var uuidGenerator = new UuidGenerator();
        var generator = (IdGenerator) Proxy.newProxyInstance(IdGenerator.class.getClassLoader(),
                new Class[] {IdGenerator.class},
                new Stopper(uuidGenerator));
        System.out.println(generator.getNext());
    }
}


interface IdGenerator {
    String getNext();
}

class UuidGenerator implements IdGenerator {
    @Override
    public String getNext() {
        return UUID.randomUUID().toString();
    }
}

@RequiredArgsConstructor
@Log
class Stopper implements InvocationHandler {
    private final Object target;

    @Override
    public Object invoke(Object o, Method method, Object[] args) throws Throwable {
        var startTime = System.nanoTime();
        Object result = method.invoke(target, args);
        var totalTime = System.nanoTime() - startTime;
        log.info("Execution time for method %s equals %d ns".formatted(method.getName(), totalTime));
        return result;

    }
}