Lesson_1

.gitignore

@@ -0,0 +1 @@
+.idea

HomeWork.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+ <component name="NewModuleRootManager" inherit-compiler-output="true">
+ <exclude-output />
+ <content url="file://$MODULE_DIR$">
+ <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+ </content>
+ <orderEntry type="inheritedJdk" />
+ <orderEntry type="sourceFolder" forTests="false" />
+ </component>
+</module>

README(Lesson_1).md

@@ -0,0 +1,14 @@
+# Урок 1. Принципы ООП: Инкапсуляция, наследование, полиморфизм
+
+
+**Реализовать, с учетом ооп подхода, приложение.
+Для проведения исследований с генеалогическим древом.
+Идея: описать некоторое количество компонент, например:
+модель человека и дерева
+Под “проведением исследования” можно понимать например получение всех детей выбранного человека.**
+
+
+
+## Группа: Программист - 21.05.2024
+
+## Студент: Овчинников Максим Сергеевич

README(Lesson_2).md

@@ -0,0 +1,10 @@
+# Урок 2. Принципы ООП Абстракция и интерфейсы. Пример проектирования
+
+**Дополнить проект методами записи в файл и чтения из файла. Для этого создать отдельный класс и реализовать в нем нужные методы. Для данного класса сделайте интерфейс, который и используйте в своей программе. Пример работы с интерфейсом Serialazable можно найти в материалах к уроку.
+Поправить замечания к первому уроку**
+
+
+
+## Группа: Программист - 21.05.2024
+
+## Студент: Овчинников Максим Сергеевич

src/AbstractPerson.java

@@ -0,0 +1,58 @@
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractPerson implements Serializable {
+ protected String name;
+ protected AbstractPerson father;
+ protected AbstractPerson mother;
+ protected List<AbstractPerson> children;
+ protected String gender;
+ protected LocalDate dateOfBirth;
+
+ public AbstractPerson(String name, String gender, LocalDate dateOfBirth) {
+ this.name = name;
+ this.gender = gender;
+ this.dateOfBirth = dateOfBirth;
+ this.children = new ArrayList<>();
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public AbstractPerson getFather() {
+ return father;
+ }
+
+ public void setFather(AbstractPerson father) {
+ this.father = father;
+ }
+
+ public AbstractPerson getMother() {
+ return mother;
+ }
+
+ public void setMother(AbstractPerson mother) {
+ this.mother = mother;
+ }
+
+ public List<AbstractPerson> getChildren() {
+ return children;
+ }
+
+ public void addChild(AbstractPerson child) {
+ this.children.add(child);
+ }
+
+ public String getGender() {
+ return gender;
+ }
+
+ public LocalDate getDateOfBirth() {
+ return dateOfBirth;
+ }
+
+ public abstract String getFullInfo();
+}

src/FamilyResearch.java

@@ -0,0 +1,51 @@
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FamilyResearch implements IFamilyResearch {
+ private FamilyTree familyTree;
+
+ public FamilyResearch(FamilyTree familyTree) {
+ this.familyTree = familyTree;
+ }
+
+ @Override
+ public List<Person> getChildren(String name) {
+ AbstractPerson person = familyTree.findPerson(name);
+ if (person != null) {
+ return person.getChildren().stream()
+ .map(child -> (Person) child)
+ .collect(Collectors.toList());
+ }
+ return null;
+ }
+
+ @Override
+ public Person[] getParents(String name) {
+ AbstractPerson person = familyTree.findPerson(name);
+ if (person != null) {
+ return new Person[]{(Person) person.getFather(), (Person) person.getMother()};
+ }
+ return null;
+ }
+
+ @Override
+ public List<Person> getSiblings(String name) {
+ AbstractPerson person = familyTree.findPerson(name);
+ if (person != null) {
+ AbstractPerson father = person.getFather();
+ AbstractPerson mother = person.getMother();
+ if (father != null) {
+ return father.getChildren().stream()
+ .filter(child -> !child.equals(person))
+ .map(child -> (Person) child)
+ .collect(Collectors.toList());
+ } else if (mother != null) {
+ return mother.getChildren().stream()
+ .filter(child -> !child.equals(person))
+ .map(child -> (Person) child)
+ .collect(Collectors.toList());
+ }
+ }
+ return null;
+ }
+}

src/FamilyTree.java

@@ -0,0 +1,38 @@
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class FamilyTree implements Serializable {
+ private static final long serialVersionUID = 1L;
+ private List<AbstractPerson> people;
+
+ public FamilyTree() {
+ this.people = new ArrayList<>();
+ }
+
+ public void addPerson(AbstractPerson person) {
+ people.add(person);
+ }
+
+ public List<AbstractPerson> getPeople() {
+ return people;
+ }
+
+ public AbstractPerson findPerson(String name) {
+ for (AbstractPerson person : people) {
+ if (person.getName().equals(name)) {
+ return person;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ for (AbstractPerson person : people) {
+ sb.append(person.getFullInfo()).append("\n");
+ }
+ return sb.toString();
+ }
+}

src/FileOperations.java

@@ -0,0 +1,27 @@
+import java.io.*;
+
+public class FileOperations implements IFileOperations {
+ private FamilyTree familyTree;
+
+ public FileOperations(FamilyTree familyTree) {
+ this.familyTree = familyTree;
+ }
+
+ @Override
+ public void saveToFile(String fileName) throws IOException {
+ try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName))) {
+ oos.writeObject(familyTree);
+ }
+ }
+
+ @Override
+ public void loadFromFile(String fileName) throws IOException, ClassNotFoundException {
+ try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName))) {
+ this.familyTree = (FamilyTree) ois.readObject();
+ }
+ }
+
+ public FamilyTree getFamilyTree() {
+ return familyTree;
+ }
+}

src/IFamilyResearch.java

@@ -0,0 +1,7 @@
+import java.util.List;
+
+public interface IFamilyResearch {
+ List<Person> getChildren(String name);
+ Person[] getParents(String name);
+ List<Person> getSiblings(String name);
+}

src/IFileOperations.java

@@ -0,0 +1,9 @@
+public class IFileOperations {
+
+}
+import java.io.IOException;
+
+public interface IFileOperations {
+ void saveToFile(String fileName) throws IOException;
+ void loadFromFile(String fileName) throws IOException, ClassNotFoundException;
+}

src/Main.java

@@ -0,0 +1,71 @@
+import java.time.LocalDate;
+import java.time.Period;
+import java.io.IOException;
+
+public class Main {
+ public static void main(String[] args) {
+ FamilyTree familyTree = new FamilyTree();
+
+ Person ivan = new Person("Иван", "Мужской", LocalDate.of(1980, 6, 15));
+ Person maria = new Person("Мария", "Женский", LocalDate.of(1982, 3, 20));
+ Person anna = new Person("Анна", "Женский", LocalDate.of(2005, 11, 10));
+ Person boris = new Person("Борис", "Мужской", LocalDate.of(2007, 7, 5));
+ Person sergey = new Person("Сергей", "Мужской", LocalDate.of(2009, 9, 1));
+
+ ivan.setMother(maria);
+ anna.setFather(ivan);
+ anna.setMother(maria);
+ boris.setFather(ivan);
+ boris.setMother(maria);
+ sergey.setFather(ivan);
+ sergey.setMother(maria);
+
+ ivan.addChild(anna);
+ ivan.addChild(boris);
+ ivan.addChild(sergey);
+ maria.addChild(anna);
+ maria.addChild(boris);
+ maria.addChild(sergey);
+
+ familyTree.addPerson(ivan);
+ familyTree.addPerson(maria);
+ familyTree.addPerson(anna);
+ familyTree.addPerson(boris);
+ familyTree.addPerson(sergey);
+
+ IFamilyResearch research = new FamilyResearch(familyTree);
+
+ System.out.println("Дети Ивана: " + research.getChildren("Иван"));
+ System.out.println("Родители Анны: " + java.util.Arrays.toString(research.getParents("Анна")));
+ System.out.println("Братья и сестры Бориса: " + research.getSiblings("Борис"));
+ System.out.println("Информация об Иване: " + ivan);
+ System.out.println("Информация о Марии: " + maria);
+ System.out.println("Возраст Ивана: " + calculateAge(ivan.getDateOfBirth()) + " лет");
+ System.out.println("Возраст Марии: " + calculateAge(maria.getDateOfBirth()) + " лет");
+
+ IFileOperations fileOps = new FileOperations(familyTree);
+
+ try {
+ fileOps.saveToFile("family_tree.ser");
+ System.out.println("Семейное дерево сохранено в файл.");
+
+ fileOps.loadFromFile("family_tree.ser");
+ System.out.println("Семейное дерево загружено из файла.");
+
+ FamilyTree loadedTree = ((FileOperations) fileOps).getFamilyTree();
+ IFamilyResearch loadedResearch = new FamilyResearch(loadedTree);
+
+ System.out.println("Проверка загруженных данных:");
+ System.out.println("Дети Ивана: " + loadedResearch.getChildren("Иван"));
+ System.out.println("Родители Анны: " + java.util.Arrays.toString(loadedResearch.getParents("Анна")));
+ System.out.println("Братья и сестры Бориса: " + loadedResearch.getSiblings("Борис"));
+
+ } catch (IOException | ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private static int calculateAge(LocalDate birthDate) {
+ return Period.between(birthDate, LocalDate.now()).getYears();
+ }
+}

src/Man.java

@@ -0,0 +1,10 @@
+public class Man extends Person {
+ public Man(String name) {
+ super(name);
+ }
+
+ @Override
+ public String getGender() {
+ return "Мужской";
+ }
+}

src/Person.java

@@ -0,0 +1,17 @@
+import java.time.LocalDate;
+
+public class Person extends AbstractPerson {
+ public Person(String name, String gender, LocalDate dateOfBirth) {
+ super(name, gender, dateOfBirth);
+ }
+
+ @Override
+ public String getFullInfo() {
+ return name + " (Пол: " + gender + ", Дата рождения: " + dateOfBirth + ")";
+ }
+
+ @Override
+ public String toString() {
+ return getFullInfo();
+ }
+}

src/Research.java

@@ -0,0 +1,46 @@
+import java.util.List;
+
+public class Research implements FamilyResearch {
+ private FamilyTree familyTree;
+
+ public Research(FamilyTree familyTree) {
+ this.familyTree = familyTree;
+ }
+
+ @Override
+ public List<Person> getChildren(String name) {
+ Person person = familyTree.findPerson(name);
+ if (person != null) {
+ return person.getChildren();
+ }
+ return null;
+ }
+
+ @Override
+ public Person[] getParents(String name) {
+ Person person = familyTree.findPerson(name);
+ if (person != null) {
+ return new Person[]{person.getFather(), person.getMother()};
+ }
+ return null;
+ }
+
+ @Override
+ public List<Person> getSiblings(String name) {
+ Person person = familyTree.findPerson(name);
+ if (person != null) {
+ Person father = person.getFather();
+ Person mother = person.getMother();
+ if (father != null) {
+ return father.getChildren().stream()
+ .filter(child -> !child.equals(person))
+ .toList();
+ } else if (mother != null) {
+ return mother.getChildren().stream()
+ .filter(child -> !child.equals(person))
+ .toList();
+ }
+ }
+ return null;
+ }
+}