Dog dog = new Dog("Шарик");
Animal animal = dog;  // Upcasting: Dog → Animal (автоматически)
animal.makeSound();   // Вызывает версию Dog (полиморфизм)

Здесь animal — тип Animal, но объект Dog.

Animal animal = new Dog("Шарик");  // Upcasting
Dog dog = (Dog) animal;            // Downcasting: Animal → Dog
dog.bark();                        // Доступен метод Dog

Работает, потому что объект действительно Dog.

Animal animal = new Cat("Мурка");
Dog dog = (Dog) animal;  // ClassCastException: Cat cannot be cast to Dog

object instanceof Type

Возвращает true, если объект является экземпляром Type (класс, интерфейс) или его подтипа.

Animal animal = new Dog("Шарик");

if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();  // Безопасно
} else {
    System.out.println("Не собака!");
}

Проверка предотвращает ClassCastException.

SoundMaker sound = new Dog("Шарик");
if (sound instanceof SoundMaker) {  // true
    // ...
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = {new Dog("Шарик"), new Cat("Мурка"), new Animal("Зверь")};

        for (Animal a : animals) {
            a.makeSound();  // Полиморфизм: каждый свой звук

            if (a instanceof Dog) {
                Dog d = (Dog) a;
                d.bark();  // Только для Dog
            } else if (a instanceof Cat) {
                Cat c = (Cat) a;
                // Специфический метод Cat, если есть
            }
        }
    }
}

Цикл работает с массивом Animal, но проверяет и приводит для специфического поведения.

public class Task030925 {
    public static void main(String[] args) {
        Object obj = "Hello";
        
        if (obj instanceof Integer) {
            Integer num = (Integer) obj;
            System.out.println(num + 10);
        } else if (obj instanceof String str) {
            System.out.println(str.length());
        } else {
            System.out.println("Unknown");
        }
    }
}

public abstract class AbstractClass {
    // Абстрактные методы, concrete методы, поля
}

public abstract class Shape {
    protected String color;  // Общее поле

    public Shape(String color) {
        this.color = color;
    }

    // Абстрактный метод: Подклассы должны реализовать
    public abstract double getArea();

    // Concrete метод: Общий для всех
    public void displayColor() {
        System.out.println("Цвет: " + color);
    }
}

getArea(): Абстрактный — без тела, заканчивается ;.
displayColor(): С реализацией — наследуется как есть.

public abstract returnType methodName(params);

public class Circle extends Shape {
    private double radius;

    public Circle(String color, double radius) {
        super(color);  // Вызов конструктора абстрактного класса
        this.radius = radius;
    }

    // Реализация абстрактного метода
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

Circle не abstract, так что обязан реализовать getArea().
Теперь можно new Circle(...), но не new Shape().

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle("Красный", 5.0);  // Полиморфизм: Shape на Circle
        shape.displayColor();  // Цвет: Красный (concrete метод)
        System.out.println("Площадь: " + shape.getArea());  // Площадь: ~78.54 (реализация Circle)
    }
}

Нюанс: Конструктор абстрактного класса вызывается через super(), даже если класс abstract.

public class Task040925 {
    public static void main(String[] args) {
        String s1 = "Java";
        String s2 = new String("Java");
        String s3 = s2.intern();
        String s4 = new StringBuilder("Ja").append("va").toString();
        String s5 = s4.intern();
        
        System.out.println((s1 == s3) + " " + (s1 == s5) + " " + (s4 == s5));
    }
}

docker run -d --name web nginx

docker run --network host -d nginx

docker network create -d overlay my_overlay

volumes:
  db_data:
services:
  db:
    volumes:
      - db_data:/var/lib/postgresql/data

services:
  app:
    volumes:
      - ./logs:/app/logs

environment:
  DB_URL: jdbc:postgresql://db:5432/mydb

  cat /proc/1/environ | tr '\0' '\n'  # PID 1 — процесс Java
  

echo "my_password" | docker secret create db_password -

logging:
  driver: gelf
  options:
    gelf-address: "udp://graylog:12201"

  {"version": "1.1", "host": "app", "short_message": "Error", "level": 3}
  

  environment:
    JAVA_TOOL_OPTIONS: "-XX:MaxRAMPercentage=75.0"
  
  - -XX:MaxRAMPercentage указывает JVM использовать 75% от лимита cgroups, а не от общей памяти хоста.  

version: '3.8'
services:
  app:
    build: ./app
    environment:
      DB_URL: jdbc:postgresql://db:5432/mydb
      DB_PASSWORD: ${DB_PASSWORD}
    volumes:
      - app_logs:/app/logs
    logging:
      driver: json-file
      options:
        max-size: "50m"
    networks:
      - app_net

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pg_data:/var/lib/postgresql/data
    networks:
      - app_net

volumes:
  app_logs:
    driver: local
  pg_data:

networks:
  app_net:
    driver: bridge

public class Main {
  public static void main(String[] args) {
    String dbUrl = System.getenv("DB_URL"); // Чтение из process namespace
    try (Connection conn = DriverManager.getConnection(
        dbUrl, "user", System.getenv("DB_PASSWORD"))) {
      // Запись в файловый лог
      try (FileWriter fw = new FileWriter("/app/logs/application.log", true)) {
        fw.write("DB connection established\n");
      }
    }
  }
}