Омельченко Никита ПрИ-201. Модуль 4

task01/src/com/example/task01/Point.java

@@ -7,8 +7,35 @@ public class Point {
     int x;
     int y;
 
+    Point(){}
+
+    public Point(int x, int y){
+        this.x = x;
+        this.y = y;
+    }
+
+
     void print() {
         String pointToString = String.format("(%d, %d)", x, y);
         System.out.println(pointToString);
     }
+
+    void flip(){
+        this.x *= -1;
+        this.y *= -1;
+        int buffer = this.x;
+        this.x = this.y;
+        this.y = buffer;
+    }
+
+    double distance(Point point) {
+        int dx = this.x - point.x;
+        int dy = this.y - point.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("(%d, %d)", x, y);
+    }
 }

task02/src/com/example/task02/Task02Main.java

@@ -2,6 +2,27 @@
 
 public class Task02Main {
     public static void main(String[] args) {
+        System.out.println("--- Тест конструктора и нормализации ---");
+        // Тест: 0 часов, 100 минут, 0 секунд -> должно стать 1 ч 40 мин 0 сек
+        TimeSpan t1 = new TimeSpan(0, 100, 0);
+        System.out.println("Создали (0, 100, 0): " + t1);
 
+        System.out.println("\n--- Тест метода add ---");
+        // Добавляем к t1 (1:40:00) еще 1 час 30 минут
+        TimeSpan t2 = new TimeSpan(1, 30, 0);
+        t1.add(t2);
+        System.out.println("После добавления (1 ч 30 мин): " + t1);
+        // Ожидаем: 3 ч 10 мин 0 сек
+
+        System.out.println("\n--- Тест метода subtract ---");
+        // Вычитаем 2 часа 15 минут 10 секунд
+        TimeSpan t3 = new TimeSpan(2, 15, 10);
+        t1.subtract(t3);
+        System.out.println("После вычитания (2 ч 15 мин 10 сек): " + t1);
+
+        System.out.println("\n--- Тест сеттеров ---");
+        // Устанавливаем 125 секунд
+        t1.setSeconds(125);
+        System.out.println("Установили 125 секунд: " + t1);
     }
-}
+}

task02/src/com/example/task02/TimeSpan.java

@@ -0,0 +1,113 @@
+package com.example.task02;
+
+/**
+ * Класс для хранения временного интервала
+ */
+public class TimeSpan {
+    private int hours;
+    private int minutes;
+    private int seconds;
+
+    // Конструктор
+    public TimeSpan(int hours, int minutes, int seconds) {
+        this.hours = hours;
+        this.minutes = minutes;
+        this.seconds = seconds;
+        normalize(); // Сразу приводим к нормальному виду
+    }
+
+    // --- Геттеры и Сеттеры ---
+    // В сеттерах обязательно вызываем normalize(), так как пользователь
+    // может установить, например, 100 минут.
+
+    public int getHours() {
+        return hours;
+    }
+
+    public void setHours(int hours) {
+        this.hours = hours;
+        // Часы могут быть любыми, нормализация не требуется (если не ограничиваем дни)
+    }
+
+    public int getMinutes() {
+        return minutes;
+    }
+
+    public void setMinutes(int minutes) {
+        this.minutes = minutes;
+        normalize();
+    }
+
+    public int getSeconds() {
+        return seconds;
+    }
+
+    public void setSeconds(int seconds) {
+        this.seconds = seconds;
+        normalize();
+    }
+
+    // --- Логика ---
+
+    /**
+     * Метод сложения интервалов.
+     * Меняем текущее состояние объекта.
+     */
+    void add(TimeSpan time) {
+        this.hours += time.hours;
+        this.minutes += time.minutes;
+        this.seconds += time.seconds;
+        normalize();
+    }
+
+    /**
+     * Метод вычитания интервалов.
+     */
+    void subtract(TimeSpan time) {
+        this.hours -= time.hours;
+        this.minutes -= time.minutes;
+        this.seconds -= time.seconds;
+        normalize();
+    }
+
+    /**
+     * Приватный метод для приведения времени к корректному формату.
+     * Обрабатывает и переполнение (секунд > 60), и отрицательные значения (при вычитании).
+     */
+    private void normalize() {
+        // 1. Обработка переполнения (например, 65 секунд -> 1 мин 5 сек)
+        if (seconds >= 60) {
+            minutes += seconds / 60;
+            seconds = seconds % 60;
+        }
+        if (minutes >= 60) {
+            hours += minutes / 60;
+            minutes = minutes % 60;
+        }
+
+        // 2. Обработка отрицательных значений (заем)
+        // Если секунд < 0, занимаем у минут
+        while (seconds < 0) {
+            minutes--;
+            seconds += 60;
+        }
+        // Если минут < 0, занимаем у часов
+        while (minutes < 0) {
+            hours--;
+            minutes += 60;
+        }
+
+        // Если часы ушли в минус, можно либо обнулить, либо оставить как есть (отрицательный интервал)
+        // В данном решении оставим 0, если интервал стал полностью отрицательным
+        if (hours < 0) {
+            hours = 0;
+            minutes = 0;
+            seconds = 0;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return String.format("%d ч %d мин %d сек", hours, minutes, seconds);
+    }
+}

task03/src/com/example/task03/ComplexNumber.java

@@ -0,0 +1,52 @@
+package com.example.task03;
+
+/**
+ * Класс комплексного числа вида a + bi
+ */
+public class ComplexNumber {
+    // Поля приватные для инкапсуляции
+    private final double real;      // Действительная часть
+    private final double imaginary; // Мнимая часть
+
+    // 1. Конструктор для инициализации
+    public ComplexNumber(double real, double imaginary) {
+        this.real = real;
+        this.imaginary = imaginary;
+    }
+
+    // Геттеры (на случай, если понадобятся)
+    public double getReal() {
+        return real;
+    }
+
+    public double getImaginary() {
+        return imaginary;
+    }
+
+    // 2. Сложение комплексных чисел
+    // Возвращает НОВЫЙ объект, не меняя текущий
+    public ComplexNumber add(ComplexNumber other) {
+        double newReal = this.real + other.real;
+        double newImaginary = this.imaginary + other.imaginary;
+        return new ComplexNumber(newReal, newImaginary);
+    }
+
+    // 3. Умножение комплексных чисел
+    // Формула: (ac - bd) + (ad + bc)i
+    public ComplexNumber multiply(ComplexNumber other) {
+        double newReal = (this.real * other.real) - (this.imaginary * other.imaginary);
+        double newImaginary = (this.real * other.imaginary) + (this.imaginary * other.real);
+        return new ComplexNumber(newReal, newImaginary);
+    }
+
+    // 4. Строковое представление
+    // Логика для красивого вывода знака (3 - 2i вместо 3 + -2i)
+    @Override
+    public String toString() {
+        if (imaginary >= 0) {
+            return String.format("%.1f + %.1fi", real, imaginary);
+        } else {
+            return String.format("%.1f - %.1fi", real, Math.abs(imaginary));
+        }
+    }
+}

task03/src/com/example/task03/Task03Main.java

@@ -2,6 +2,22 @@
 
 public class Task03Main {
     public static void main(String[] args) {
+        // Создаем два комплексных числа
+        ComplexNumber c1 = new ComplexNumber(2.0, 3.0);
+        ComplexNumber c2 = new ComplexNumber(1.0, -4.0);
 
+        System.out.println("Первое число: " + c1);
+        System.out.println("Второе число: " + c2);
+
+        System.out.println("--- Сложение ---");
+        ComplexNumber sum = c1.add(c2);
+        System.out.println("Сумма: " + sum);
+
+        // Проверка, что c1 не изменилось (иммутабельность)
+        System.out.println("Проверка c1 (должно остаться прежним): " + c1);
+
+        System.out.println("--- Умножение ---");
+        ComplexNumber product = c1.multiply(c2);
+        System.out.println("Произведение: " + product);
     }
-}
+}

task04/src/com/example/task04/Line.java

@@ -0,0 +1,51 @@
+package com.example.task04;
+
+public class Line {
+    private final Point p1;
+    private final Point p2;
+
+    public Line(Point p1, Point p2) {
+        this.p1 = p1;
+        this.p2 = p2;
+    }
+
+    public Point getP1() {
+        return p1;
+    }
+
+    public Point getP2() {
+        return p2;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("Line from %s to %s", p1, p2);
+    }
+
+    /**
+     * Проверяет, лежит ли точка p на прямой, содержащей этот отрезок.
+     * Используется уравнение прямой через две точки (без деления, чтобы избежать ошибок с 0).
+     */
+    public boolean isCollinearLine(Point p) {
+        // Координаты точек отрезка
+        int x1 = p1.getX();
+        int y1 = p1.getY();
+        int x2 = p2.getX();
+        int y2 = p2.getY();
+
+        // Координаты проверяемой точки
+        int x = p.getX();
+        int y = p.getY();
+
+        // Вычисляем разницы (проекции векторов)
+        long dxSegment = x2 - x1;
+        long dySegment = y2 - y1;
+        long dxPoint = x - x1;
+        long dyPoint = y - y1;
+
+        // Проверяем через перекрестное умножение:
+        // (x2 - x1) * (y - y1) == (y2 - y1) * (x - x1)
+        // Используем long, чтобы избежать переполнения при умножении больших чисел
+        return dxSegment * dyPoint == dySegment * dxPoint;
+    }
+}

task04/src/com/example/task04/Point.java

@@ -0,0 +1,27 @@
+package com.example.task04;
+
+/**
+ * Неизменяемый (Immutable) класс точки.
+ */
+public class Point {
+    private final int x;
+    private final int y;
+
+    public Point(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("(%d, %d)", x, y);
+    }
+}

task04/src/com/example/task04/Task04Main.java

@@ -2,6 +2,29 @@
 
 public class Task04Main {
     public static void main(String[] args) {
+        // Создаем точки для отрезка
+        Point p1 = new Point(1, 1);
+        Point p2 = new Point(3, 3);
 
+        // Создаем отрезок
+        Line line = new Line(p1, p2);
+        System.out.println("Отрезок: " + line);
+
+        // Тест 1: Точка лежит на прямой (и внутри отрезка)
+        Point pOnLine = new Point(2, 2);
+        System.out.println("Точка (2,2) коллинеарна? " + line.isCollinearLine(pOnLine)); // true
+
+        // Тест 2: Точка лежит на прямой (но за пределами отрезка)
+        Point pOnLineOutside = new Point(5, 5);
+        System.out.println("Точка (5,5) коллинеарна? " + line.isCollinearLine(pOnLineOutside)); // true
+
+        // Тест 3: Точка НЕ лежит на прямой
+        Point pNotOnLine = new Point(2, 3);
+        System.out.println("Точка (2,3) коллинеарна? " + line.isCollinearLine(pNotOnLine)); // false
+
+        // Тест 4: Вертикальная линия (защита от деления на ноль)
+        Line verticalLine = new Line(new Point(0, 0), new Point(0, 10));
+        Point verticalPoint = new Point(0, 50);
+        System.out.println("Вертикальная точка (0,50) коллинеарна? " + verticalLine.isCollinearLine(verticalPoint)); // true
     }
-}
+}