ContainingClass::staticMethodName

import java.util.function.Function;

public class MethodReferenceExample {
    public static void main(String[] args) {
        Function<String, Integer> converter = Integer::parseInt;
        Integer number = converter.apply("123");
        System.out.println(number); // 123
    }
}

containingObject::instanceMethodName

import java.util.Arrays;
import java.util.List;

public class MethodReferenceExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.forEach(System.out::println);
    }
}

ContainingType::methodName

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        Function<String, Integer> stringLength = String::length;
        Integer length = stringLength.apply("Hello, World!");
        System.out.println(length); // 13
    }
}

ClassName::new

import java.util.function.Supplier;

public class MethodReferenceExample {
    public static void main(String[] args) {
        Supplier<MethodReferenceExample> exampleSupplier = MethodReferenceExample::new;
        MethodReferenceExample example = exampleSupplier.get();
        System.out.println(example); // MethodReferenceExample@<hashcode>
    }
}

🟢При разработке игр на Java требуется работать со звуком и музыкой.

🟢Нужно подключить звуковые звуки (эффекты и музыку) к игровому проекту.

🟢Реализовать звуковой сигнал в нужные моменты (например, выстрел, прыжок, победа).

🟢Обеспечить громкость и возможность паузы/продолжения музыки.

🟢Оптимизировать загрузку и меры для минимизации задержек и нагрузки на систему.

🟢javax.sound.sampled позволяет работать с аудиофайлами формата WAV, AIFF и др.

🟢Например, LWJGL OpenAL , TinySound , JOAL — более мощные и гибкие решения для работы со звуком в играх, 3D-звуке, резервных источниках и других возможностях.

🟢Если используются игровые движки (например, LibGDX), он обычно предоставляет собственный удобный API для работы со звуком.

import javax.sound.sampled.*;
import java.io.File;
import java.io.IOException;

public class SoundPlayer {

    private Clip clip;

    // Загрузка и подготовка звукового файла
    public void loadSound(String filepath) {
        try {
            AudioInputStream audioInputStream = AudioSystem.getAudioInputStream(new File(filepath));
            clip = AudioSystem.getClip();
            clip.open(audioInputStream);
        } catch (UnsupportedAudioFileException | IOException | LineUnavailableException e) {
            System.err.println("Ошибка загрузки звука: " + e.getMessage());
        }
    }

    // Воспроизведение звука
    public void play() {
        if (clip == null) return;
        if (clip.isRunning()) clip.stop();
        clip.setFramePosition(0);
        clip.start();
    }

    // Остановка звука
    public void stop() {
        if (clip != null && clip.isRunning()) {
            clip.stop();
        }
    }

    // Регулировка громкости (от 0.0 до 1.0)
    public void setVolume(float volume) {
        if (clip == null) return;
        FloatControl gainControl = (FloatControl) clip.getControl(FloatControl.Type.MASTER_GAIN);
        float dB = (float)(Math.log10(volume) * 20);
        gainControl.setValue(dB);
    }

    public static void main(String[] args) {
        SoundPlayer sound = new SoundPlayer();
        sound.loadSound("jump.wav"); // Замените на путь к вашему звуковому файлу
        sound.setVolume(0.5f);
        sound.play();

        // Для демонстрации задержка перед завершением программы
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        sound.stop();
    }
}

🟢Сохранить состояние игрового объекта (например, класс Player) в файл.

🟢Загрузить данные из файла при старте игры.

🟢Обеспечить корректную работу даже при изменениях в структуре класса.

🟢Обработать возможные ошибки ввода-вывода.

🟢Класс реализует интерфейс Serializable, и с помощью ObjectOutputStream и ObjectInputStream объекты записываются и читаются из файла.

🟢Сериализация в человекочитаемый формат с помощью библиотек, например, Gson, Jackson (для JSON) или JAXB (для XML). Это удобно для отладки и совместимости.

🟢Реализация собственных методов записи и чтения данных, например, через DataOutputStream/DataInputStream, что даёт больше контроля над форматом и размером файла.

import java.io.*;

class Player implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int level;
    int score;

    public Player(String name, int level, int score) {
        this.name = name;
        this.level = level;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Player{name='" + name + "', level=" + level + ", score=" + score + '}';
    }
}

public class SaveLoadGame {
    public static void savePlayer(Player player, String filename) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename))) {
            oos.writeObject(player);
            System.out.println("Прогресс сохранён.");
        } catch (IOException e) {
            System.err.println("Ошибка при сохранении: " + e.getMessage());
        }
    }

    public static Player loadPlayer(String filename) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename))) {
            return (Player) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            System.err.println("Ошибка при загрузке: " + e.getMessage());
            return null;
        }
    }

    public static void main(String[] args) {
        Player player = new Player("Игрок1", 5, 1500);
        String saveFile = "player.dat";

        savePlayer(player, saveFile);

        Player loadedPlayer = loadPlayer(saveFile);
        if (loadedPlayer != null) {
            System.out.println("Загруженный игрок: " + loadedPlayer);
        }
    }
}

for (initialization; condition; update) {
    // тело цикла
}

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    System.out.println(i + ": " + numbers[i]);
}

for (type element : collection) {
    // тело цикла
}

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println(number);
}

while (condition) {
    // тело цикла
}

String code = UUID.randomUUID().toString();
boolean isCodeExists = repo.isCodeExists(code);
while (isCodeExists) {
    code = UUID.randomUUID().toString();
    isCodeExists = repo.isCodeExists(code);
}
repo.saveCode(code);

do {
    // тело цикла
} while (condition);

String command;
do {
    command = readCommand();
    doCommand(command);
} while (!"EXIT".equals(command));

default <V> Function<V,R> compose(Function<? super V,? extends T> before)
default <V> Function<T,V>   andThen(Function<? super R,? extends V> after)

import java.util.function.Function;

public class ComposeAndThenDemo {
    public static void main(String[] args) {
        Function<String, Integer> parse  = Integer::parseInt;
        Function<Integer, Double> half   = i -> i / 2.0;
        Function<Double, String> toStr   = d -> "Result: " + d;

        // Составляем: сначала parse, затем half, затем toStr
        Function<String, String> pipeline =
            toStr
             .compose(half)      // toStr(half(x))
             .compose(parse);    // toStr(half(parse(x)))

        // То же самое через andThen:
        Function<String, String> pipeline2 =
            parse
             .andThen(half)      // half(parse(x))
             .andThen(toStr);    // toStr(half(parse(x)))

        System.out.println(pipeline.apply("42"));   // Result: 21.0
        System.out.println(pipeline2.apply("42"));  // Result: 21.0
    }
}

interface Example {
    int process(int a);
    default void show() {
        System.out.println("default show()");
    }
}

interface Paper {
    default void show() {
        System.out.println("default show()");
    }
}

class Licence implements Paper {
    public void show() {
        Paper.super.show();
    }
}

interface Paper {
    static void show() {
        System.out.println("static show()");
    }
}

class Licence {
    public void showPaper() {
        Paper.show();
    }
}

String day = "MONDAY";
int numLetters;
switch (day) {
    case "MONDAY":
    case "FRIDAY":
    case "SUNDAY":
        numLetters = 6;
        break;
    case "TUESDAY":
        numLetters = 7;
        break;
    default:
        numLetters = 8;
}
System.out.println(numLetters); // Вывод: 6

String day = "MONDAY";
int numLetters = switch (day) {
    case "MONDAY", "FRIDAY", "SUNDAY" -> 6;
    case "TUESDAY" -> 7;
    default -> 8;
};
System.out.println(numLetters); // Вывод: 6

import java.util.List;
import java.util.stream.Collectors;

public class StreamCollectorsExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        
        // Примеры использования Collectors
        // Преобразование элементов коллекции в строку
        String numbersAsString = numbers.stream()
                                        .map(Object::toString)
                                        .collect(Collectors.joining(", "));
        System.out.println("Числа в виде строки: " + numbersAsString);
        
        // Получение среднего значения всех элементов коллекции
        double average = numbers.stream()
                                 .collect(Collectors.averagingInt(Integer::intValue));
        System.out.println("Среднее значение: " + average);
        
        // Фильтрация элементов и сборка их в новую коллекцию
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(num -> num % 2 == 0)
                                           .collect(Collectors.toList());
        System.out.println("Четные числа: " + evenNumbers);
        
        // Группировка элементов по условию
        System.out.println("Числа по остатку от деления на 3: " + numbers.stream()
                                                                      .collect(Collectors.groupingBy(num -> num % 3)));
    }
}

var list = new ArrayList<String>();

   var map = new HashMap<String, List<Integer>>();
   

   for (var entry : map.entrySet()) { ... }
   

   var result = someMethod();  // Что за тип?
   

@FunctionalInterface
public interface IntUnaryOperator {
    int applyAsInt(int operand);
}

import java.util.function.IntUnaryOperator;

public class Main {
    public static int applyOperation(int number, IntUnaryOperator operator) {
        return operator.applyAsInt(number);
    }

    public static void main(String[] args) {
        int number = 5;

        // Лямбда-выражение для удвоения значения
        IntUnaryOperator doubleOperation = x -> x * 2;
        System.out.println("Double: " + applyOperation(number, doubleOperation)); // Double: 10

        // Лямбда-выражение для увеличения значения на 10
        IntUnaryOperator addTenOperation = x -> x + 10;
        System.out.println("Add Ten: " + applyOperation(number, addTenOperation)); // Add Ten: 15
    }
}

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> wordLengths = new HashMap<>();
        String word = "apple";

        // Использование computeIfAbsent для вычисления и вставки значения в Map
        wordLengths.computeIfAbsent(word, String::length);

        // Вывод длины слова "apple", которая была вычислена и вставлена в Map
        System.out.println("Длина слова apple: " + wordLengths.get(word));
    }
}

// Ошибка компиляции!
List<String>[] array = new List<String>[10];

List<String> list = List.of("a", "b");
if (list instanceof List<String>) { … } // компилятор не пропустит

// Ошибка name clash: стираются оба в process(Collection)
void process(Collection<String> c) { … }
void process(Collection<Integer> c) { … }

@Test
void shouldReturnTrueWhenInputIsValid() {
    assertTrue(MyService.validate("test"));
}

@BeforeEach
void init() {
    db.connect();
}

@AfterEach
void cleanup() {
    db.disconnect();
}

@BeforeAll
static void globalSetup() {
    System.out.println("Запускаем все тесты");
}

@DisplayName("Должен вернуть true при корректном email")
@Test
void validEmailTest() {
    assertTrue(EmailValidator.isValid("test@example.com"));
}

@Nested
class WhenUserIsAdmin {
    @Test
    void shouldHaveFullAccess() { ... }
}

@ParameterizedTest
@ValueSource(strings = {"admin", "user", "guest"})
void roleShouldNotBeNull(String role) {
    assertNotNull(role);
}

@Disabled("Фича ещё не реализована")
@Test
void futureFeatureTest() {
    fail("не должно запускаться");
}

List<String> names = List.of("Alice", "bob", "CHARLIE", "dave");

List<String> result = new ArrayList<>();
for (String name : names) {
    String upper = name.toUpperCase();
    if (upper.length() > 3) {
        result.add(upper);
    }
}

List<String> result = names.stream()
    .map(String::toUpperCase)
    .filter(s -> s.length() > 3)
    .collect(Collectors.toList());

   .map(String::trim)
   .map(String::toLowerCase)
   

   .filter(s -> s.startsWith("a"))
   

   .collect(Collectors.toSet())
   .collect(Collectors.joining(", "))
   

List<User> users = getUsers();

List<String> activeAdults = users.stream()
    .filter(User::isActive)
    .filter(u -> u.getAge() >= 18)
    .map(User::getName)
    .collect(Collectors.toList());

final int port = 8080;
port = 9090; // ❌ ошибка компиляции

final List<String> list = new ArrayList<>();
list.add("Hello");         // ✅ можно
list = new ArrayList<>();  // ❌ нельзя

class Animal {
    final void sleep() {
        System.out.println("Zzz...");
    }
}

class Dog extends Animal {
    // ❌ Нельзя переопределить sleep()
}

final class Utility {
    static void log(String msg) { ... }
}

class MyUtil extends Utility {} // ❌ ошибка