qq

java/lessons/pom.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
+		 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+    <parent>
+        <artifactId>practice</artifactId>
+        <groupId>ru.molokoin</groupId>
+        <version>1.0</version>
+    </parent>
+
+	<!-- lab03 info -->
+    <groupId>ru.molokoin</groupId>
+    <artifactId>lessons</artifactId>
+    <version>1.0</version>
+    <packaging>jar</packaging>
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.1</version>
+                 <configuration>
+                     <source>17</source>
+                     <target>17</target>
+                 </configuration>
+             </plugin>
+        </plugins>
+    </build>
+</project>

java/lessons/src/main/java/ru/molokoin/j110/lab01/task1/Area.java

@@ -0,0 +1,88 @@
+package ru.molokoin.j110.lab01.task1;
+
+public class Area {
+    private String name;
+    private int population;
+    private int square;
+
+    Area(){
+        this(null, null, null);
+    }
+    Area(Object name, Object population, Object square){
+        setName(name);
+        setPopulation(population);
+        setSquare(square);
+    }
+    public void print(){
+        if (name != "") System.out.println("name: " + name);
+        if (population > 0) System.out.println("population: " + population);
+        if (square > 0) System.out.println("square: " + square);
+    }
+    /**
+     * @param name the name to set
+     */
+    public void setName(Object name) {
+        //преобразование Object
+        try {
+            if (name == null) throw new NullPointerException(getName());
+        } catch (Exception e) {
+            e.printStackTrace();
+            this.name = "";
+        } finally{
+            if (name != null) this.name = (String)name;
+        }
+    }
+    /**
+     * @param population the population to set
+     */
+    public void setPopulation(Object population) {
+        try {
+            if (population == null) throw new NullPointerException("Параметр {население} не задан ...");
+            
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+            this.population = 0;
+        } finally{
+            this.population = (Integer) population;
+        }
+    }
+    /**
+     * @param square the square to set
+     */
+    public void setSquare(Object square) {
+        try {
+            if (square == null) throw new NullPointerException("Параметр {площадь} не задан ...");
+        } catch (NullPointerException e) {
+            System.out.println("Наименвание не установлено ...");
+            e.printStackTrace();
+            this.square = 0;
+        } finally{
+            this.square = (Integer) square;
+        }
+        try {
+            if (this.square < 0) throw new IllegalArgumentException("площадь не может быть отрицательной ...");
+        
+        } catch (IllegalArgumentException e) {
+            e.printStackTrace();
+            this.square = 0;
+        }
+    }
+    /**
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+    /**
+     * @return the population
+     */
+    public int getPopulation() {
+        return population;
+    }
+    /**
+     * @return the square
+     */
+    public int getSquare() {
+        return square;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab01/task1/Country.java

@@ -0,0 +1,58 @@
+package ru.molokoin.j110.lab01.task1;
+
+public class Country extends Area{
+    private Area capital;
+
+    public Country() {
+    }
+    Country(Object name, Object population, Object square){
+        super(name, population, square);
+    }
+    Country(String name, int population, int square, String capitalName, int capitalPopulation, int capitalSquare){
+        //параметры страны
+        super(name, population, square);
+        //параметры столицы
+        if (capitalName != null) setCapital(new Area(capitalName
+                , capitalPopulation
+                , capitalSquare));
+        if (capitalName == null){
+            setCapital(new Area(null
+                , 0
+                , 0));
+        }
+    }
+    public static void print(Country country){
+        System.out.println("-------------------------------------------");
+        Area a = (Country) country;
+        a.print();
+        country.getCapital().print();
+        System.out.println("-------------------------------------------");
+    }
+    public void getDanse(){
+        //плотность населения в стране
+        //population/square
+    }
+
+    public void clearCapital(){
+        //очистка данных о столице
+        
+    }
+
+    public void updateCapital(Country[] map){
+        //обновление данных о столице
+    }
+
+    /**
+     * @param сapital the сapital to set
+     */
+    public void setCapital(Area capital) {
+        this.capital = capital;
+    }
+
+    /**
+     * @return the сapital
+     */
+    public Area getCapital() {
+        return capital;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab01/task1/Map.java

@@ -0,0 +1,36 @@
+package ru.molokoin.j110.lab01.task1;
+
+public class Map {
+    public Country[] map; 
+    //заполняем поля данными
+    public void initDefaults(){
+        map = new Country[5];
+        //Россия
+        map[0] = new Country("Russia", 146700000, 17100000, "Moscow", 12600000, 0);
+        //Финляндия
+        map[1] = new Country("Finland", 5500000, 338000, "Helsinki", 655000, 0);
+        //Франция
+        map[4] = new Country("France", 67800000, 643800, "Paris", 2100000, 0);
+
+        //Андора
+        map[3] = new Country("Andorra", 85000, 647, "Andorra la Vella", 22600, 0);
+
+        //Сингапур
+        map[2] = new Country("Singapore", 5700000, 725, null, 0, 0);
+    }
+    public static void printAll(Country[] map){
+        System.out.println("printAll"); 
+        System.out.println("Количество государств, данные о которых включены в terra: " + map.length);
+        int i = 0;
+        while (i < map.length) {
+            Country.print(map[i]);
+            i++;
+        }
+    }
+    public static void main(String[] args) {
+        System.out.println("Map.main()");
+        Map terra = new Map();
+        terra.initDefaults();
+        printAll(terra.map);
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab01/task2/Book.java

@@ -0,0 +1,288 @@
+package ru.molokoin.j110.lab01.task2;
+
+public class Book {
+    private String name;
+    private Publisher publisher;
+    private int year;
+    private String[] authors;
+
+    Book(){}
+    Book(String name, int year, Publisher publisher){}
+    Book(String name, String author, int year, Publisher publisher){
+        this(name, year, publisher);
+        uppendAuthors(author);
+    }
+    Book(String name, String[] authors, int year, Publisher publisher){
+        this(name, year, publisher);
+        String[] a = authors;
+        setAuthors(a);
+    }
+    /**
+     * Создаем массив книг, заполняем книги данными по умолчанию
+     * и возвращаем массив книг
+     * @return
+     */
+    public static Book[] getDefaultArray(){
+        Book[] books = new Book[5];
+
+        //book 1
+        String name = "Computer Science: основы программирования на Java, ООП, алгоритмы и структуры данных";
+        books[0] = new Book();
+        books[0].setName(name);
+        books[0].uppendAuthors("Седжвик Роберт");
+        books[0].uppendAuthors("Уэйн Кевин");
+        books[0].setPublisher(Publisher.getPublisherByName(Publisher.getDefaultArray(), "Питер"));
+        books[0].setYear(2018);
+
+        //book 2
+        name = "Разработка требований к программному обеспечению. 3-е издание, дополненное";
+        books[1] = new Book();
+        books[1].setName(name);
+        books[1].uppendAuthors("Вигерс Карл");
+        books[1].setPublisher(Publisher.getPublisherByName(Publisher.getDefaultArray(), "БХВ"));
+        books[1].setYear(2019);
+
+        //book 3
+        name = "Java. Полное руководство, 10-е издание";
+        books[2] = new Book();
+        books[2].setName(name);
+        books[2].uppendAuthors("Шилдт Гербертт");
+        books[2].setPublisher(Publisher.getPublisherByName(Publisher.getDefaultArray(), "Диалектика"));
+        books[2].setYear(2018);
+
+        //book 4
+        name = "C/C++. Процедурное программирование";
+        books[3] = new Book();
+        books[3].setName(name);
+        books[3].uppendAuthors("Полубенцева М.И.");
+        books[3].setPublisher(Publisher.getPublisherByName(Publisher.getDefaultArray(), "БХВ"));
+        books[3].setYear(2017);
+
+        //book 5
+        name = "Конституция РФ";
+        books[4] = new Book();
+        books[4].setName(name);
+        books[4].setPublisher(Publisher.getPublisherByName(Publisher.getDefaultArray(), "Проспект"));
+        books[4].setYear(2020);
+
+        return books;
+    }
+    /**
+     * Печатть данных о книге в консоль
+     */
+    public void print(){
+        System.out.println("-------------------------------");
+        System.out.println("Наименование книги (name) :: " + name);
+        getPublisher().print();
+        System.out.println("Год издания (year) :: " + year);
+        System.out.println("Авторы: " + getAuthorsCount(authors) + " человек ...");
+        int i = 0;
+        while (i < getAuthorsCount(authors)){
+            System.out.println((i + 1) + ". " + getAuthors()[i]);
+            i++;
+        }
+        System.out.println("-------------------------------");
+    }
+    /**
+     * Добавляем авторов книги
+     * @param author
+     */
+    public void uppendAuthors(String author){
+        String[] result;
+        /**
+         * в случае, если массив authors еще не создан и писать нового автора некуда,
+         * создаем пустой массив, пишем в него данные нового автора
+         */
+        if (getAuthors() == null){
+            try {
+                throw new NullPointerException("в случае, если массив authors еще не создан и писать нового автора некуда, создаем пустой массив, пишем в него данные нового автора ...");
+            } catch (NullPointerException e) {
+                //e.printStackTrace();
+                System.out.println(e.getMessage());
+                result = new String[1];
+                result[0] = author;
+                setAuthors(result);
+            }
+        }
+        /**
+         * Если массив авторов книги уже существует, создаем новый массив с увеличенным на единицу
+         * количеством полей и переписываем в него данные старого массива,
+         * после чего добавляем в него новую запись.
+         */
+        else{
+            int count = getAuthorsCount(authors);
+            result = new String[count +1];
+            //переписываем данные старого массива
+            int i = 0;
+            while (i < count){
+                result[i] = getAuthors()[i];
+                i++;
+            }
+            //добавляем нового автора
+            result[count] = author;
+            setAuthors(result);
+        }
+    }
+    /**
+     * Возвращает данные поля author, по индексу поля в массиве
+     * индексы нумеруются с нуля и не могут быть отрицательными.
+     * @param index
+     * @return
+     */
+    public String getAuthorByIndex(int index){
+        //при получении отрицательного индекса, меняем его значение на ноль, сообщаем пользователю о проведеных изменениях
+        if (index < 0){
+            try {
+                throw new IllegalArgumentException("В метод public String getAuthorByIndex(int index) передано значение меньше нуля, массив не может содержать отрицательное количество полей. Значение индекса исправлено на значение по умолчанию: 0 ...");
+                
+            } catch (Exception e) {
+                e.printStackTrace();
+                index = 0;
+            }
+        }
+        String author = getAuthors()[index];
+        return author;
+    }
+    /**
+     * возвращает количество авторов книги
+     * @param authors
+     * @return
+     */
+    public static int getAuthorsCount(String[] authors){
+        //проверяем, имеется ли записи в перечне авторов
+        int count = 0;
+        try {
+            if (authors == null) throw new NullPointerException ("Авторы книги не установлены ...");
+        } catch (Exception e) {
+            //e.printStackTrace();
+            count = 0;
+        }
+        if (authors != null) count = authors.length;
+        return count;
+    }
+    /**
+     * Устанавливаем название книги
+     * @param name the name to set
+     */
+    public void setName(String name) {
+        // название книги не должно быть пустой ссылкой
+        if (name == null){
+            try {
+                throw new NullPointerException("В качестве названия книги передана пустая ссылка, полю установлено значение по умолчанию {noname book}");
+            } catch (NullPointerException e) {
+                System.out.println("Ошибка: " + e);
+                e.printStackTrace();
+                this.name = "noname book";
+            }
+        }else {
+            this.name = name;
+        }
+    }
+    /**
+     * Устанавливаем данные об издательстве.
+     * издательство не должно быть пустой ссылкой
+     * @param publisher the publisher to set
+     */
+    public void setPublisher(Publisher publisher) {
+        if (publisher == null){
+            try {
+                throw new NullPointerException("Передана пустая ссылка, при внесении данных об издательстве, что недопустимо. Установлено знаение издательства по умолчанию.");
+            } catch (NullPointerException e) {
+                e.printStackTrace();
+                System.out.println("Ошибка: " + e);
+                this.publisher = new Publisher();
+            }
+        }else{
+            this.publisher = publisher;
+        }
+    }
+    /**
+     * устанавливаем год издания книги
+     * - год издания должен быть строго больше нуля
+     * @param year the year to set
+     */
+    public void setYear(int year) {
+        if (year < 0){
+            try{
+                throw new IllegalArgumentException("В качестве года издания книги указан значение еньше нуля. Значение заменен на значение по умолчанию {1800}");
+            } catch (IllegalArgumentException e){
+                e.printStackTrace();
+                System.out.println("Ошибка: " + e);
+                year = 1800;
+            }
+        }else {
+            this.year = year;
+        }
+    }
+    /**
+     * Устанавливаем перечень авторов книги
+     * @param author the author to set
+     */
+    public void setAuthors(String[] authors) {
+        try {
+            if (authors == null) throw new NullPointerException("setAuthors() ... передан пустой список авторов");
+        } catch (NullPointerException e) {
+            e.printStackTrace();
+            this.authors = new String[0];
+        } finally {
+            this.authors = authors;
+        }
+    }
+    /**
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+    /**
+     * @return the publisher
+     */
+    public Publisher getPublisher() {
+        return publisher;
+    }
+    /**
+     * @return the year
+     */
+    public int getYear() {
+        return year;
+    }
+    /**
+     * @return the author
+     */
+    public String[] getAuthors() {
+        return this.authors;
+    }
+    public static void main(String[] args) {
+        Book[] books = Book.getDefaultArray();
+        //Вывод данных по умолчанию
+        int i = 0;
+        while (i < books.length){
+            books[i].print();
+            i++;
+        }
+        
+        //исправляем данные о городе издательства БХВ
+        String wrightSity = "Санкт-Петербург";
+        String wrongSity = "Санкт-Петебург";
+        i = 0;
+        while (i < books.length){
+            if (books[i].getPublisher().getSity() == wrongSity){
+                books[i].getPublisher().setSity(wrightSity);
+            }
+            i++;
+        }
+
+        //пояснения пользователю
+        System.out.println("#############################################");
+        System.out.println("Вывод изменился для всех книг, изданных издательством \"БХВ\".");
+        System.out.println("Устранена опечатка в наименовании города. \"Санкт-Петебург\" заменено на \"Санкт-Петербург\". " + "Была пропущена буква: \"Б\".");
+        System.out.println("#############################################");
+
+        //Вывод исправленных данных
+        i = 0;
+        while (i < books.length){
+            books[i].print();
+            i++;
+        }
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab01/task2/Publisher.java

@@ -0,0 +1,100 @@
+package ru.molokoin.j110.lab01.task2;
+
+public class Publisher {
+    private String name;
+    private String sity;
+    Publisher(){
+        this(null, null);
+    }
+
+    Publisher(String name, String sity){
+        setName(name);
+        setSity(sity);
+    }
+    /**
+     * Метод класса. Возвращает массив данных об издательствах по умолчанию
+     * @return
+     */
+    public static Publisher[] getDefaultArray(){
+        Publisher[] defaultPublishers = new Publisher[4];
+        defaultPublishers[0] = new Publisher("Проспект", "Москва");
+        defaultPublishers[1] = new Publisher("Питер", "Санкт-Петербург");
+        defaultPublishers[2] = new Publisher("БХВ", "Санкт-Петебург");
+        defaultPublishers[3] = new Publisher("Диалектика", "Киев");
+        return defaultPublishers;
+    }
+    /**
+     * выводим в консоль данные Издательства
+     */
+    public void print(){
+        System.out.println("Издательство: " + getName()  + " ----> " + "город: " + getSity());
+    }
+    /**
+     * @param name the name to set
+     * DONE: имя издательства не олжно быть пустой ссылкой
+     */
+    public void setName(String name) {
+        String defaultName = "noname publisher";
+        try {
+            if (name == null) throw new NullPointerException("Имя издательства не задано пользователем. Установлено значение поля по умолчанию {noname publisher} ...");
+        }catch (NullPointerException e){
+            setName(defaultName);
+        }finally {
+            this.name = name;
+        }
+    }
+    /**
+     * Устанавливаем наименование города - где находится издательство
+     * Наименование города издания не должно быть пустой ссылкой
+     * @param sity the sity to set
+     */
+    public void setSity(String sity) {
+        String defaultSity = "noname sity";
+        try {
+            if (sity == null) throw new NullPointerException("Наименование города не задано пользователем. Установлено значение поля по умолчанию {noname sity} ...");
+        } catch (Exception e) {
+            setSity(defaultSity);
+        }finally{
+            this.sity = sity;
+        }
+    }
+    /**
+     * @return the name
+     */
+    public String getName() {
+        return name;
+    }
+    /**
+     * @return the sity
+     */
+    public String getSity() {
+        return sity;
+    }
+    public static Publisher getPublisherByName(Publisher[] publishers, String name){
+        Publisher publisher = new Publisher();
+        boolean isAcsists = false;
+        int i = 0;
+        while (i < publishers.length){
+            if (name.equals((String)publishers[i].getName())){
+                publisher = publishers[i];
+                isAcsists = true;
+            }
+            i++;
+        }
+        try {
+            if(!isAcsists) throw new Exception("Указанное наименование издательства не найдено в каталоге. Установлено наименование города по умолчанию {noname sity} ...");
+        } catch (Exception e) {
+            publisher = new Publisher(name, null);
+        }
+        return publisher;
+    }
+    public static void main(String[] args) {
+        Publisher[] publishers = Publisher.getDefaultArray();
+        int i = 0;
+        while (i < publishers.length){
+            publishers[i].print();
+            i++;
+        }
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task1/Degree.java

@@ -0,0 +1,17 @@
+package ru.molokoin.j110.lab02.task1;
+
+public enum Degree {
+    PhD {
+        @Override
+        public String getDegree() {
+            return "PhD";
+        }
+    },
+    MSc {
+        @Override
+        public String getDegree() {
+            return "MSc";
+        }
+    };
+    public abstract String getDegree();
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task1/Gender.java

@@ -0,0 +1,39 @@
+package ru.molokoin.j110.lab02.task1;
+/**
+ * Перечисление gender,
+ * 
+ */
+public enum Gender {
+    MALE {
+        public String getPronoun(){
+            return "he";
+        }
+
+        @Override
+        public String getPronounOwn() {
+            return "his";
+        }
+    },
+    FEMALE{
+        public String getPronoun(){
+            return "she";
+        }
+        @Override
+        public String getPronounOwn() {
+            return "her";
+        }
+
+    },
+    TRANS{
+        public String getPronoun() {
+            return "it";
+        }
+
+        @Override
+        public String getPronounOwn() {
+            return "its";
+        }
+    };
+    public abstract String getPronoun();
+    public abstract String getPronounOwn();
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task1/Person.java

@@ -0,0 +1,207 @@
+package ru.molokoin.j110.lab02.task1;
+
+public class Person {
+    private String name;
+    private Gender gender;
+    private String department;
+    private Role role;
+    //для аспиранта
+    private String thesisTitle;
+    //для преподавателя
+    private Degree degree;
+    private String speciality;
+    //для студента
+    private Stage stage;
+    private String course;
+
+    /**
+     * Создаем персону
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     */
+    Person(String name, Gender gender, String department, Role role){
+        setName(name);
+        setGender(gender);
+        setDepartment(department);
+        setRole(role);
+    }
+    /**
+     * Создаем аспиранта
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     * @param thesisTitle
+     */
+    Person(String name, Gender gender, String department, Role role, String thesisTitle){
+        this(name, gender, department, role);
+        setThesisTitle(thesisTitle);
+    }
+
+    /**
+     * Создаем преподавателя
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     * @param degree
+     * @param speciality
+     */
+    Person(String name, Gender gender, String department, Role role, Degree degree, String speciality){
+        this(name, gender, department, role);
+        setDegree(degree);
+        setSpeciality(speciality);
+    }
+
+    /**
+     * Создаем студента
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     * @param stage
+     * @param course
+     */
+    Person(String name, Gender gender, String department, Role role, Stage stage, String course){
+        this(name, gender, department, role);
+        setStage(stage);
+        setCourse(course);
+    }
+
+    public static Person[] initDefaults(){
+        Person[] defaultList = new Person[6];
+        
+        defaultList[0] = new Person("Ronald Turner", Gender.MALE, "Computer science", 
+            Role.TEACHER, Degree.PhD, "Programming paradigms");
+
+        defaultList[1] = new Person("Ruth Hollings", Gender.FEMALE, "Jurisprudence", 
+            Role.TEACHER, Degree.MSc, "Domestic arbitration");
+
+        defaultList[2] = new Person("Leo Wilkinson", Gender.MALE, "Computer science", Role.STUDENT, Stage.bachelor, "III");
+
+        defaultList[3] = new Person("Anna Cunningham", Gender.FEMALE, "World economy", Role.STUDENT, Stage.bachelor, "I");
+
+        defaultList[4] = new Person("Jill Lundqvist", Gender.FEMALE, "Jurisprudence", Role.STUDENT, Stage.master, "I");
+
+        defaultList[5] = new Person("Ronald Correa", Gender.MALE, "Computer science", Role.ASPIRANT, "Design of a functional programming language.");
+
+        return defaultList;
+    }
+    /**
+     * Выводит общие данные в консоль
+     */
+    public void print(){
+        System.out.println("This is " + getName() + " " + 
+            getGender().getPronoun() + " " +
+            getRole().getVerb() + " at " + getDepartment());
+        //преподаватели
+        if (getRole().equals(Role.TEACHER)){
+            System.out.println(getGender().getPronoun() + " has " + 
+            getDegree() + " degree in " + 
+            getSpeciality() + ".");
+            System.out.println();
+        }
+        //студенты
+        if (getRole().equals(Role.STUDENT)){
+            System.out.println(getGender().getPronoun() + " is " + 
+                getCourse() + "‘th year " + getStage() + " student.");
+            System.out.println();
+        }
+
+        //аспиранты
+        if (getRole().equals(Role.ASPIRANT)){
+            System.out.println(getGender().getPronounOwn() + " thesis title is " + getThesisTitle() + ".");
+            System.out.println();
+        }
+    }
+    /**
+     * Выводит полный набор данных в консоль
+     */
+    public static void printAll(Person[] persons){
+        int i = 0;
+        while (i < persons.length){
+            persons[i].print();
+            i++;
+        }
+    }
+
+    /**
+     * Устанавливает значение поля name/Фамилия, Имя и Отчество человека
+     * @param name
+     * не может быть пустым, если передано пустое значение, устанавливается значение noname
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+    public void setGender(Gender gender) {
+        this.gender = gender;
+    }
+    public void setDepartment(String department) {
+        this.department = department;
+    }
+    public void setRole(Role role) {
+        this.role = role;
+    }
+    public void setThesisTitle(String thesisTitle) {
+        this.thesisTitle = thesisTitle;
+    }
+    public void setDegree(Degree degree) {
+        this.degree = degree;
+    }
+    public void setSpeciality(String speciality) {
+        this.speciality = speciality;
+    }
+    public void setStage(Stage stage) {
+        this.stage = stage;
+    }
+    public void setCourse(String course) {
+        this.course = course;
+    }
+    /**
+     * Возвращает имя человека,
+     * TODO имя не может быть пустым полем или отсутствовать
+     * @return
+     */
+     public String getName() {
+        return name;
+    }
+    /**
+     * возвращает пол/gender человека мужской/male или женский/female
+     * @return
+     * 
+     */
+    public Gender getGender() {
+        return gender;
+    }
+    /**
+     * Возвращает наименование департамента, в котором трудится человек (учится или преподает)
+     * @return 
+     * 
+     */
+    public String getDepartment() {
+        return department;
+    }
+    public Role getRole() {
+        return role;
+    }
+    public String getThesisTitle() {
+        return thesisTitle;
+    }
+    public Degree getDegree() {
+        return degree;
+    }
+    public String getSpeciality() {
+        return speciality;
+    }
+    public Stage getStage() {
+        return stage;
+    }
+    public String getCourse() {
+        return course;
+    }
+    public static void main(String[] args) {
+        Person.printAll(Person.initDefaults());
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task1/Role.java

@@ -0,0 +1,23 @@
+package ru.molokoin.j110.lab02.task1;
+
+public enum Role {
+    STUDENT {
+        @Override
+        public String getVerb() {
+            return "studies";
+        }
+    },
+    ASPIRANT {
+        @Override
+        public String getVerb() {
+            return "studies";
+        }
+    },
+    TEACHER {
+        @Override
+        public String getVerb() {
+            return "teaches";
+        }
+    };
+    public abstract String getVerb();
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task1/Stage.java

@@ -0,0 +1,17 @@
+package ru.molokoin.j110.lab02.task1;
+
+public enum Stage {
+    bachelor {
+        @Override
+        public String getStage() {
+            return "bachelor";
+        }
+    },
+    master {
+        @Override
+        public String getStage() {
+            return "master";
+        }
+    };
+    public abstract String getStage();
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Audio.java

@@ -0,0 +1,72 @@
+package ru.molokoin.j110.lab02.task2;
+
+/**
+ * Класс, хранящий данные о аудиотреке/audio
+ */
+public class Audio extends File{
+    private String format;
+    private String content;
+    private Duration duration;
+
+    /**
+     * Основной конструктор файлов аудио
+     * @param name
+     * @param size
+     * @param extension
+     * @param format
+     * @param content
+     * @param duration
+     */
+    public Audio(String name, int size, Extension extension, String format, String content, Duration duration) {
+        super(name, size, extension);
+        setFormat(format);
+        setContent(content);
+        setDuration(duration);
+    }
+    
+    @Override
+    public void print() {
+        System.out.println("--------------------------------------------");
+        super.print();
+        System.out.println("format: " + getFormat());
+        System.out.println("content: " + getContent());
+        System.out.println("duration: " + getDuration().getSeconds() + " sec.");
+    }
+    /**
+     * @return the format
+     */
+    public String getFormat() {
+        return format;
+    }
+    /**
+     * @param format the format to set
+     */
+    public void setFormat(String format) {
+        this.format = format;
+    }
+    /**
+     * @return the content
+     */
+    public String getContent() {
+        return content;
+    }
+    /**
+     * @param content the content to set
+     */
+    public void setContent(String content) {
+        this.content = content;
+    }
+    /**
+     * @return the duration
+     */
+    public Duration getDuration() {
+        return duration;
+    }
+    /**
+     * @param duration the duration to set
+     */
+    public void setDuration(Duration duration) {
+        this.duration = duration;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Dimensions.java

@@ -0,0 +1,22 @@
+package ru.molokoin.j110.lab02.task2;
+
+public class Dimensions {
+    private int width;
+    private int height;
+    Dimensions(int width, int height){
+        setWidth(width);
+        setHeight(height);
+    }
+    public void setWidth(int width) {
+        this.width = width;
+    }
+    public void setHeight(int height) {
+        this.height = height;
+    }
+    public int getWidth() {
+        return width;
+    }
+    public int getHeight() {
+        return height;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Document.java

@@ -0,0 +1,43 @@
+package ru.molokoin.j110.lab02.task2;
+
+/**
+ * Класс, хранящий метаданные о документе/document
+ */
+public class Document extends File{
+    private String format;
+    private int lists;
+
+    /**
+     * Основной конструктор документа
+     * @param name
+     * @param size
+     * @param extension
+     * @param format
+     * @param lists
+     */
+    public Document(String name, int size, Extension extension,String format, int lists) {
+        super(name, size, extension);
+        setFormat(format);
+        setLists(lists);
+    }
+
+    @Override
+    public void print(){
+        System.out.println("--------------------------------------------");
+        super.print();
+        System.out.println("format: " + getFormat());
+        System.out.println("lists: " + getLists());
+    }
+    public void setFormat(String format) {
+        this.format = format;
+    }
+    public String getFormat() {
+        return format;
+    }
+    public void setLists(int lists) {
+        this.lists = lists;
+    }
+    public int getLists() {
+        return lists;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Duration.java

@@ -0,0 +1,36 @@
+package ru.molokoin.j110.lab02.task2;
+
+/**
+ * Класс хранит данные о длительности (аудио/видео).
+ * TODO подготовить формат возвращаемого значения в виде: ХХ мин. ХХ сек.
+ */
+public class Duration {
+    private long milliseconds;
+    public Duration(long milliseconds){
+        setMilliseconds(milliseconds);
+    }
+    public void print(){
+        System.out.println(getSeconds() + "секунд.");
+    }
+    /**
+     * Возвращает время в секундах
+     * @return
+     */
+    public long getSeconds(){
+        return getMilliseconds()/1000;
+    }
+
+    /**
+     * @param milliseconds the milliseconds to set
+     */
+    public void setMilliseconds(long milliseconds) {
+        this.milliseconds = milliseconds;
+    }
+    /**
+     * @return the milliseconds
+     */
+    public long getMilliseconds() {
+        return milliseconds;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Extension.java

@@ -0,0 +1,9 @@
+package ru.molokoin.j110.lab02.task2;
+
+public enum Extension{
+    DOCUMENT,
+    IMAGE,
+    AUDIO,
+    VIDEO,
+    OTHER;
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/File.java

@@ -0,0 +1,39 @@
+package ru.molokoin.j110.lab02.task2;
+
+/**
+ * Класс - обертка
+ */
+public class File {
+    private String name;
+    private int size;
+    private Extension extension;
+    public File(String name, int size, Extension extension){
+        setName(name);
+        setSize(size);
+        setExtension(extension);
+    }
+    public void print(){
+        System.out.println("name: " + getName());
+        System.out.println("size: " + getSize() + "byte");
+        System.out.println("extension: " + extension);
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+    public void setSize(int size) {
+        this.size = size;
+    }
+    public void setExtension(Extension extension) {
+        this.extension = extension;
+    }
+    public String getName() {
+        return name;
+    }
+    public int getSize() {
+        return size;
+    }
+    public Extension getExtension() {
+        return extension;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Image.java

@@ -0,0 +1,38 @@
+package ru.molokoin.j110.lab02.task2;
+
+/**
+ * Класс, хранящий метаданные о изображении/image
+ */
+public class Image extends File{
+    private String format;
+    private Dimensions dimensions;
+
+    public Image(String name, int size, Extension extension, String format, Dimensions dimensions) {
+        super(name, size, extension);
+        init(format, dimensions);
+    }
+    @Override
+    public void print(){
+        System.out.println("--------------------------------------------");
+        super.print();
+        System.out.println("format: " + getFormat());
+        System.out.println("Dimensions: " + getDimensions().getHeight() + " x " + getDimensions().getWidth());
+    }
+    public void init(String format, Dimensions dimensions){
+        setFormat(format);
+        setDimensions(dimensions);
+    }
+    public void setFormat(String format) {
+        this.format = format;
+    }
+    public void setDimensions(Dimensions dimensions) {
+        this.dimensions = dimensions;
+    }
+    public String getFormat() {
+        return format;
+    }
+    public Dimensions getDimensions() {
+        return dimensions;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Storage.java

@@ -0,0 +1,61 @@
+package ru.molokoin.j110.lab02.task2;
+
+import java.util.Arrays;
+
+/**
+ * Класс - хранилище информации обо всех файлах
+ * предоставляет инструментарий обращения с массивом файлов
+ * TODO формат вывода преобразовать в табличный вид
+ */
+public class Storage {
+    private File[] files;
+    public Storage(){}
+    public Storage(File[] files){
+        setFiles(files);
+    }
+    public void setFiles(File[] files) {
+        this.files = files;
+    }
+    public File[] getFiles() {
+        return files;
+    }
+    public void print(){
+        int i = 0;
+        while (i < getFiles().length){
+            getFiles()[i].print();
+            i++;
+        }
+    }
+    /**
+     * Метод, добавляющий файл в хранилище/storage
+     * @param file
+     */
+    public void add(File file) {
+        if(getFiles() == null){
+            File[] result = new File[1];
+            result[0] = file;
+            setFiles(result);
+        }
+        else{
+            File[] result = Arrays.copyOf(getFiles(), getFiles().length+1);
+            result[result.length - 1] = file;
+            setFiles(result);
+        }
+    }
+    public static void main(String[] args) {
+        Storage storage = new Storage();
+        //Заполняем массив исходными данными
+        storage.add(new Document("myDocument", 10, Extension.DOCUMENT, "txt", 5));
+        storage.add(new Image("myImage", 15, Extension.IMAGE, "jpg", new Dimensions(12, 8)));
+        storage.add(new Audio("myAudio", 50, Extension.AUDIO, "mp3", "some melody", new Duration(20000)));
+        storage.add(new Video("myVideo"
+                , 100500
+                , Extension.VIDEO
+                , "mpeg"
+                , "some video content"
+                , new Duration(100500)
+                , new Dimensions(1024, 768)));
+        storage.print();
+    }
+
+}

java/lessons/src/main/java/ru/molokoin/j110/lab02/task2/Video.java

@@ -0,0 +1,31 @@
+package ru.molokoin.j110.lab02.task2;
+
+/**
+ * Класс, хранящий метаданные о видео/video
+ */
+public class Video extends Audio{
+    private Dimensions dimensions;
+
+    public Video(String name, int size, Extension extension, String format, String content, Duration duration, Dimensions dimensions) {
+        super(name, size, extension, format, content, duration);
+        setDimensions(dimensions);
+    }
+    @Override
+    public void print() {
+        super.print();
+        System.out.println(dimensions.getWidth() + " x " + dimensions.getHeight());
+    }
+    /**
+     * @param dimensions the dimensions to set
+     */
+    public void setDimensions(Dimensions dimensions) {
+        this.dimensions = dimensions;
+    }
+    /**
+     * @return the dimensions
+     */
+    public Dimensions getDimensions() {
+        return dimensions;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab03/task1/SimplyList/SimplyList.java

@@ -0,0 +1,195 @@
+package ru.molokoin.j110.lab03.task1.SimplyList;
+
+/**
+ * Класс содержащий инструменты управления списком и данными в нем
+ */
+public class SimplyList {
+    
+    private Node head;
+    private Node tail;
+    /**
+     * Добавление элемента в начало списка
+     * @param data
+     */
+    public void addFirst(Integer data){
+        if(head == null){
+            head = new Node();
+            head.data = data;
+            tail = head;
+        }else{
+            Node tmp = new Node();
+            tmp.data = data;
+            tmp.next = head;
+            head = tmp;
+        }
+    }
+    /**
+     * Добавление нового элемента в конец списка
+     */
+    public void addLast(Integer data){
+        if(head == null){
+            addFirst(data);
+        }else{
+            Node tmp = new Node();
+            tmp.data = data;
+            tail.next = tmp;
+            tail = tmp;
+        }
+    }
+    /**
+     * удаляет первый элемент списка и возвращает его данные
+     * @return
+     * TODO вдруг список пустой
+     * TODO вдруг список содержит только один элемент
+     */
+    public Integer executeHead(){
+        Integer tmp = null;
+        tmp = head.data;
+        head = head.next;
+        return tmp;
+    }
+    /**
+     * Удаление последнего элемента списка
+     * @return
+     */
+    public Integer executeTail(){
+        Integer tmp = tail.data;//готовы писать данные удаляемого элемента
+        Node bufNode = head;
+        //у предпоследнего элемента удаляем ссылку на tail
+        while (bufNode.next != tail){
+            bufNode = bufNode.next;
+        }
+        bufNode.next = null;
+        return tmp;
+    }
+    /**
+     * Преобразование массива в односвязный список
+     * @param array
+     * @return
+     * TODO в перспективе сделать преобразование массива
+     * */
+    public SimplyList arrayToList(Integer[] array){
+        SimplyList sl = new SimplyList();
+        return sl;
+    }
+    /**
+     * вывод в консоль всех элементов списка, по порядку
+     */
+    public void printAll(){
+        Node temp = head;
+        while (temp != null){
+            printNode(temp);
+            temp = temp.next;
+        }
+    }
+    /**
+     * Вывод в консоль данных указанной ноды
+     * @param node
+     */
+    public void printNode(Node node){
+        if (node == null){
+            System.out.println(">>> " + null);
+
+        }else{
+            System.out.println(">>> " + node.data);
+        }
+    }
+    public void deleteNodeByValue(Integer value){
+        //обработка случая, когда первый элемент списка подлежит удалению
+        while (head.data == value){
+            head = head.next;
+        }
+        //первый элемент списка точно не подлежит удалению
+        Node buf = new Node();
+        buf = head;
+        while(buf.next != null){
+            if (buf.next.data != value){
+                buf = buf.next;
+            }else{
+                buf.next = buf.next.next;
+            }
+        }
+    }
+    public void math(UseMath use, Integer value){
+        switch (use){
+            case INCREASE : {
+                Node buf = new Node();
+                buf = head;
+                buf.data = buf.data + value;
+                System.out.println("buf.data" + buf.data);
+                while (buf.next != null){
+                    buf.next.data = buf.next.data + value;
+                    System.out.println("buf.data" + buf.next.data);
+                    buf = buf.next;
+                }
+                break;
+            }
+            case DECREASE : {
+
+            }
+            
+        }
+        
+    }
+
+    /**
+     * Класс, объекты которого являются элементами списка (узлы / ноды / node) в которых хранятся основные данные и ссылка на следующий элемент списка. 
+     */
+    private class Node{
+        Integer data;
+        Node next;
+    }
+    public static void main(String[] args) {
+        System.out.println("Запущен поток: " + Thread.currentThread().getName());
+        //Создание списка
+        System.out.println("Создание списка ... ");
+        SimplyList list = new SimplyList();
+
+        //добавление элементов в список
+        System.out.println("Добавление данных в список ... ");
+        list.addFirst(23);
+        list.addLast(47);
+        list.addFirst(21);
+        list.addLast(50);
+        list.addFirst(18);
+        list.addLast(53);
+        list.addFirst(12);
+        list.addLast(64);
+
+        //вывод в консоль всех элементов списка
+        System.out.println("Вывод в консоль всех элементов списка ... ");
+        list.printAll();
+
+        //Вывод в консоль результатов обработки списка
+        System.out.println("Вывод в консоль результатов обработки списка ...");
+        
+        //печатаем первый и последний элементы списка
+        System.out.print("head ");
+        list.printNode(list.head);
+        System.out.print("tail ");
+        list.printNode(list.tail);
+
+        //удаление первого элемента списка
+        System.out.println("Удаление первого элемента списка: " + list.executeHead());
+        System.out.println("Итоговый список ... " );
+        list.printAll();
+
+        //удаление последнего элемента списка
+        System.out.println("Удаление последнего элемента списка: " + list.executeTail());
+        System.out.println("Итоговый список ... " );
+        list.printAll();
+        //
+        int i = 47;
+        System.out.println("Удаление из списка полей со значением: " + i );
+        list.deleteNodeByValue(i);
+        System.out.println("Итоговый список ... " );
+        list.printAll();
+
+        //действия над всеми элементами списка
+        System.out.println("действия над всеми элементами списка ... " + UseMath.INCREASE );
+        list.math(UseMath.INCREASE, 20);
+        System.out.println("Итоговый список ... " );
+        list.printAll();
+
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab03/task1/SimplyList/UseMath.java

@@ -0,0 +1,6 @@
+package ru.molokoin.j110.lab03.task1.SimplyList;
+
+public enum UseMath {
+    INCREASE,
+    DECREASE;
+}

java/lessons/src/main/java/ru/molokoin/j110/lab03/task1/SimplyList1/App.java

@@ -0,0 +1,49 @@
+package ru.molokoin.j110.lab03.task1.SimplyList1;
+public class App {
+    public static void main(String[] args) {
+        System.out.println("Запущен поток: " + Thread.currentThread().getName());
+        //данные
+        //int[] i = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        String i[] = {"one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"};
+        
+        //Хранилище
+        Pearl treasury = new Pearl();
+
+        //добавляем элементы в конец/последовательно
+        treasury.addLast(i[0]);
+        treasury.addLast(i[1]);
+        // treasury.addLast(i[2]);
+        // treasury.addLast(i[3]);
+        // treasury.addLast(i[4]);
+        // treasury.addLast(i[5]);
+        // treasury.addLast(i[6]);
+        // treasury.addLast(i[7]);
+        // treasury.addLast(i[8]);
+        // treasury.addLast(i[9]);
+
+        //добавляем элементы в начало списка
+        // treasury.addFirst(i[0]);
+        // treasury.addFirst(i[1]);
+        // treasury.addFirst(i[2]);
+        // treasury.addFirst(i[3]);
+        // treasury.addFirst(i[4]);
+        // treasury.addFirst(i[5]);
+        // treasury.addFirst(i[6]);
+        // treasury.addFirst(i[7]);
+        // treasury.addFirst(i[8]);
+        // treasury.addFirst(i[9]);
+        
+        //печать из хранилища
+        treasury.print();
+        //печать последнего элемента
+        System.out.print("Последний элемент списка (get): ");
+        treasury.getLast().print();
+
+        System.out.print("Последний элемент списка (execute): ");
+        treasury.executeLast().print();
+
+        //печать из хранилища
+        System.out.print("Оставшиеся в списке данные: ");
+        treasury.print();
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab03/task1/SimplyList1/Pearl.java

@@ -0,0 +1,139 @@
+package ru.molokoin.j110.lab03.task1.SimplyList1;
+
+/**
+ * Класс - реализация звена односвязного списка
+ * Односвязный список - 
+ * это структура, хранящая данные в виде цепочки, каждый узел которой хранит очередное значение списка и ссылку на следующий узел. 
+ * Ссылка на следующий узел последнего элемента списка равна null.
+ * 
+ * TODO обработать исключения:
+ * - 
+ * 
+ */
+public class Pearl {
+    private Object gem;
+    private Pearl next;
+
+    //использую для переписи данных массива
+    public Pearl(){
+        this(null, null);
+    }
+    public Pearl(Object gem){
+        this(gem, null);
+    }
+    public Pearl(Object gem, Pearl next){
+        setGem(gem);
+        setNext(next);
+    }
+    /**
+     * Удаляет с ожерелья последнюю жемчужину, 
+     * возвращает эту жемчужину
+     * @return
+     * TODO в списке может быть только один элемент
+     */
+    public Pearl executeLast(){
+        //получил последнюю жемчужину, можно удалять ее с ожерелья
+        Pearl last = getLast();//можно данные получать в том же переборе, где и удаление происходит (исключим один перебор)
+
+        /**
+         * удаление последней жемчужины.
+         * в предпоследней жемчужине next приравниваем null
+         */
+        int i = 0;
+        Pearl current = this;
+        while (i < lenght()-1){
+            current = current.next;
+            i++;
+        }
+        current.setNext(null);
+        return last;
+    }
+    public int lenght(){
+        int lenght = 0;
+        Pearl current = this;
+        while(current.next != null){
+            current = current.getNext();
+            lenght++;
+        }
+        return lenght;
+    }
+    /**
+     * Рекурсивно печатает данные, пока не упрется в next = null
+     */
+    public void print(){
+        System.out.println(gem);
+        if (next != null){
+            getNext().print();
+        }
+    }
+    /**
+     * Добавление элемента в конец списка
+     * перебирает жемчужины до  конца, последней присваивет в next новую жемчужину
+     * @param gem
+     */
+    public void addLast(Object gem){
+        if(this.gem == null){setGem(gem);}
+        else {
+            Pearl pearl = new Pearl(gem);
+            Pearl current = this;
+            while (current.next != null){
+                current = current.next;
+            }
+            current.next = pearl;
+        }
+    }
+    /**
+     * Добавление элемента в начало списка.
+     * 
+     * @param gem
+     */
+    public void addFirst(Object gem){
+        if(this.gem == null){setGem(gem);}
+        else {
+            //создаем новую жемчужину с параметрами первой
+            Pearl pearl = new Pearl(getGem());
+            pearl.setNext(getNext());
+            //пишем в текущую-первую жемчужину новые данные
+            setGem(gem);
+            //и устанавливаем ссылку на новую жемчужину
+            setNext(pearl);
+        }
+    }
+    /**
+     * возвращает последнюю жемчужину-Pearl
+     * getLast().getGem()//вернет данные последней жемчужины
+     * @return
+     */
+    public Pearl getLast(){
+        Pearl current = this;
+        while (current.next != null){
+            current = current.next;
+        }
+        return current;
+    }
+    /**
+     * @param gem the gem to set
+     */
+    public void setGem(Object gem) {
+        this.gem = gem;
+    }
+    /**
+     * Возвращает данные-gem жемчужины
+     * @return the gem
+     */
+    public Object getGem() {
+        return gem;
+    }
+    /**
+     * @param next the next to set
+     */
+    public void setNext(Pearl next) {
+        this.next = next;
+    }
+    /**
+     * @return the next
+     */
+    public Pearl getNext() {
+        return next;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab03/task2/DoublyList/DoublyList.java

@@ -0,0 +1,362 @@
+package ru.molokoin.j110.lab03.task2.DoublyList;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class DoublyList {
+    private Node head = null;
+    private Node tail = null;
+
+    /**
+     * метод проверяет пустой ли список и в случае,
+     * если в списке нет узла head, возвращает true.
+     * Если узел head есть, но в нем отсудствую данные, также возвращается true.
+     * @return
+     */
+    public boolean isEmpty(){
+        boolean isEmpty = false;
+            if((getHead() != null) || (getTail() != null)){
+                isEmpty = false;
+            }else{
+                isEmpty = true;
+            }
+        return isEmpty;
+    }
+    /**
+     * добавление данных в начало списка
+     * @param data
+     */
+    public void addFirst(Integer data){
+        if (isEmpty()) {
+            Node newNode = new Node();
+            newNode.data = data;
+            setHead(newNode);
+            setTail(newNode);
+        }else{
+            Node newNode = new Node();
+            newNode.data = data;
+            newNode.forvard = getHead();
+            getHead().backvard = newNode;
+            setHead(newNode);
+        }
+    }
+    /**
+     * добавление данных в конец списка
+     * @param data
+     */
+    public void addLast(Integer data){
+        if (isEmpty()) {
+            Node newNode = new Node();
+            newNode.data = data;
+            setHead(newNode);
+            setTail(newNode);
+        }else{
+            Node newNode = new Node();
+            newNode.data = data;
+            newNode.backvard = getTail();
+            getTail().forvard = newNode;
+            setTail(newNode);
+        }
+    }
+    /**
+     * вывод в консоль всех элементов списка, по порядку
+     * метод скопирован с односвязных списков
+     */
+    public void printForvard(){
+        Node tmp = getHead();
+        while (tmp != null){
+            printNode(tmp);
+            tmp = tmp.forvard;
+        }
+    }
+    public void printBackvard(){
+        Node tmp = getTail();
+        while(tmp != null){
+            printNode(tmp);
+            tmp = tmp.backvard;
+        }
+    }
+    /**
+     * Вывод в консоль данных указанной ноды
+     * Метод скопирован с односвязных списков
+     * @param node
+     */
+    public void printNode(Node node){
+        if (node == null){
+            System.out.println(">>> " + null);
+
+        }else{
+            System.out.println(">>> " + node.data);
+        }
+    }
+    /**
+     * извлечение данных с удалением первого элемента списка
+     * TODO исключения, когда список пустой
+     * @return
+     */
+    public Integer executeFirst(){
+        Integer executed = null;
+        if (isEmpty()){
+            return executed;
+        }
+        else{
+            try {
+                executed = getHead().data;
+                setHead(getHead().forvard);
+            }catch (NullPointerException e){
+                System.out.println("Обнаружена исключительная ситуация: " + e);
+            }
+        }
+        return executed;
+    }
+    /**
+     * извлечение данных с удалением последнего элемента списка
+     * @return
+     */
+    public Integer executeLast(){
+        Integer executed = null;
+        if (isEmpty()){
+            return executed;
+        }
+        else{
+            try {
+                executed = getTail().data;
+                setTail(getTail().backvard);
+                getTail().forvard = null;
+            }catch (NullPointerException e){
+                System.out.println("Обнаружена исключительная ситуация: " + e);
+            }
+        }
+        return executed;
+    }
+    /**
+     * Проверяем наличие в списке заданного в параметре метода значения
+     * @param value
+     * @return
+     */
+    public boolean isContain(Integer value){
+        boolean isContain = false;
+        if (isEmpty()){
+            isContain = false;
+            return isContain;
+        }
+        else{
+            Node tmp = getHead();
+            while (tmp.forvard != null){
+                if(tmp.data == value){
+                    isContain = true;
+                }
+                tmp = tmp.forvard;
+            }
+            if (getTail().data == value){
+                isContain = true;
+            }
+        }
+        return isContain;
+    }
+    /**
+     * удаляем ноды, содержащие данные совпадающие с указанным в методе значением
+     * @param value
+     */
+    public void deleteByValue(Integer value){
+        //проверяем наличие указанного значения в списке
+        if (isContain(value)){
+            //удаляем первые ноды, если они содержат указанное значение
+            Node tmp = getHead();
+            while (tmp.data == value){
+                executeFirst();
+                tmp = getHead();
+            }
+            //удаляем последние ноды, если они содержат указанное значение
+            tmp = getTail();
+            while(tmp.data == value){
+                executeLast();
+                tmp = getTail();
+            }
+            /**
+             * первая и последняя ноды точно не содержат указанное значение и не подлежат удалению
+             */
+            tmp = getHead();
+            //
+            while (tmp.forvard != null){
+                //если данные текущей ноды не подлежат удалению, переходим к следующей ноде
+                if (tmp.data != value){
+                    tmp = tmp.forvard;
+                }
+                /**
+                 * если текущая нода подлежит удалению
+                 * (точно не первая и не последняя)
+                 * 
+                 */
+                else{
+                    tmp.forvard.backvard = tmp.backvard;
+                    tmp.backvard.forvard = tmp.forvard;
+                    tmp = tmp.forvard;
+                }
+            }
+        }
+    }
+    /**
+     * добавление элементов массива в начало списка
+     * чтобы обеспечить последовательное размещение элементов массива в списке, элементы добавляются с последнего элемента массива
+     * @param array
+     */
+    public void arrayToHead(Integer[]array){
+        int i = array.length-1;
+        while (i >= 0){
+            addFirst(array[i]);
+            i--;
+        }
+    }
+    /**
+     * добавление элементов массива в хвост списка
+     * @param array
+     */
+    public void arrayToTail(Integer[]array){
+        int i = 0;
+        while (i < array.length){
+            addLast(array[i]);
+            i++;
+        }
+    }
+    /**
+     * добавление коллекции в начало списка
+     * @param collection
+     */
+    public void collectionToHead(ArrayList<Integer> collection){
+        for(int i = (collection.size()-1);i >= 0;i--) {
+            addFirst(collection.get(i));
+        }
+    }
+    /**
+     * добавление коллекции в хвост списка
+     * @param collection
+     */
+    public void collectionToTail(ArrayList<Integer> collection){
+        for(Integer c : collection){
+            addLast(c);
+        }
+    }
+    public Node getHead() throws NullPointerException {
+        return head;
+    }
+    public void setHead(Node head) {
+        this.head = head;
+    }
+    public Node getTail() throws NullPointerException{
+        return tail;
+    }
+    public void setTail(Node tail) {
+        this.tail = tail;
+    }
+
+    /**
+     * Вложенный класс, описывает узел двусвязного списка
+     */
+    private class Node{
+        Integer data;
+        Node forvard;
+        Node backvard;
+    }
+    public static void main(String[] args) {
+        System.out.println("Запущен поток: " + Thread.currentThread().getName());
+        //создаем пустой список
+        System.out.println("создаем новый список ...");
+        DoublyList list = new DoublyList();
+        //проверяем пустой ли список
+        System.out.println("проверяем пустой ли список ...");
+        System.out.println("isEmpty() >>> " + list.isEmpty());
+
+        //добавляем данные в начало списка
+        System.out.println("добавляем данные в начало списка ...");
+        list.addFirst(23);
+        list.addFirst(12);
+        list.addFirst(7);
+
+        //добавляем данные в конец списка
+        System.out.println("добавляем данные в конец списка ...");
+        list.addLast(27);
+        list.addLast(32);
+        list.addLast(34);
+        list.addLast(62);
+        list.addLast(117);
+        
+        //проверяем пустой ли список
+        System.out.println("проверяем пустой ли список ...");
+        System.out.println("isEmpty() >>> " + list.isEmpty());
+
+        //выводим в консоль данные списка
+        System.out.println("выводим в консоль данные списка ...");
+        list.printForvard();
+
+        //удаляем первый элемент списка
+        System.out.println("удаляем первый элемент списка ..." + list.executeFirst());
+        //выводим в консоль данные списка
+        System.out.println("выводим в консоль данные списка ...");
+        list.printForvard();
+
+        //удаляем последний элемент списка
+        System.out.println("удаляем последний элемент списка ..." + list.executeLast());
+        //выводим в консоль данные списка
+        System.out.println("выводим в консоль данные списка ...");
+        list.printForvard();
+
+        //проверяем наличие значения в списке
+        int i = 23;
+        System.out.println("Проверяем наличие значения в списке ... " + i);
+        System.out.println("результат проверки: " + list.isContain(i));
+        i = 0;
+        System.out.println("Проверяем наличие значения в списке ... " + i);
+        System.out.println("результат проверки: " + list.isContain(i));
+
+        //удаляем поле по заданному значению
+        i = 32;
+        System.out.println("удаляем элементы списка со значением ... " + i);
+        list.deleteByValue(i);
+        //выводим в консоль данные списка
+        System.out.println("выводим в консоль данные списка ...");
+        list.printForvard();
+
+        //массив с исходными данными
+        System.out.println("создаем новый массив arrays ...");
+        Integer[] array= {12, 22, 134,276,358,421,587,636,785,981};
+        System.out.println("содержащий данные: " + Arrays.toString(array));
+        System.out.println("добавляем массив в начало списка ...");
+        list.arrayToHead(array);
+        //выводим в консоль данные списка
+        System.out.println("выводим в консоль данные списка ...");
+        list.printForvard();
+        
+        //добавляем данные массива в конец списка
+        System.out.println("добавляем массив в конец списка ...");
+        list.arrayToTail(array);
+        //выводим в консоль данные списка
+        System.out.println("выводим в консоль данные списка ...");
+        list.printForvard();
+
+        //добавляем коллекцию в конец списка
+        System.out.println("добавляем коллекцию в конец списка ...");
+        ArrayList<Integer> collection = new ArrayList<Integer>();
+        collection.add(100);
+        collection.add(200);
+        collection.add(300);
+        collection.add(400);
+        collection.add(500);
+        collection.add(600);
+        list.collectionToTail(collection);
+        list.printForvard();
+
+        //добавляем коллекцию в начало списка
+        System.out.println("добавляем коллекцию в начало списка ...");
+        list.collectionToHead(collection);
+        list.printForvard();
+
+        //печатаем список в обратном порядке
+        System.out.println("печатаем список в обратном порядке ...");
+        list.printBackvard();
+        
+
+        
+
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab03/task3/ExpandedList/ExpandedList.java

@@ -0,0 +1,14 @@
+package ru.molokoin.j110.lab03.task3.ExpandedList;
+
+public class ExpandedList {
+    private Node head = null;
+    private Node tail = null;
+    private class Node{
+        Integer[] data = new Integer[10];
+        Node next;
+    }
+    public static void main(String[] args) {
+        System.out.println("run thread: " + Thread.currentThread().getName());
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab04/logic/BooleanCollection.java

@@ -0,0 +1,122 @@
+package ru.molokoin.j110.lab04.logic;
+
+public class BooleanCollection implements CollectionFace{
+    public Boolean[] collection = new Boolean[size];
+    BooleanCollection(){
+        for(int i = 0; i < size; i++){
+            collection[i] = false;
+        }
+        
+    }
+    /**
+     * возвращает значение хранящееся в поле булевого массива с порядковым номером index
+     */
+    @Override
+    public boolean isContain(int index) {
+        Boolean result = collection[index];
+        return result;
+    }
+
+    @Override
+    public void setTrueByIndex(int index)throws ArrayIndexOutOfBoundsException{
+        if (index > 1023 ){
+            throw new ArrayIndexOutOfBoundsException("Превышены границы массива, значение должно быть меньше 1024 ..." + "\n" + "метод setTrueByIndex(int index)" + " к полю с индексом " + index + " не применен ...");
+        }else{
+            if (index < 0){
+                throw new ArrayIndexOutOfBoundsException("Превышены границы массива, значение должно быть, больше или равно 0 ...");
+            }
+        }
+        collection[index] = true;
+    }
+
+    @Override
+    public void setFalseByIndex(int index) throws ArrayIndexOutOfBoundsException{
+        if (index > 1023 ){
+            throw new ArrayIndexOutOfBoundsException("Превышены границы массива, значение должно быть меньше 1024 ..." + "\n" + "метод setFalseByIndex(int index)" + " к полю с индексом " + index + " не применен ...");
+        }else{
+            if (index < 0){
+                throw new ArrayIndexOutOfBoundsException("Превышены границы массива, значение должно быть, больше или равно 0 ...");
+            }
+        }
+        collection[index] = false;
+        
+    }
+
+    /**
+     * value 0 => false
+     * value 1 => true
+     * в остальных вариантах вылетает исключение.
+     * так же ошибка будет, если index не попадает в границы массива
+     */
+    @Override
+    public void setValueByIndex(int index, int value) throws IllegalArgumentException{
+        switch (value) {
+            case 0:
+                try {
+                    setFalseByIndex(index);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    System.out.println(e.getMessage());
+                }
+                break;
+            case 1:
+                try {
+                    setTrueByIndex(index);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    System.out.println(e.getMessage());
+                }
+                break;
+            default:
+                String msg = "";
+                msg = msg + "Значение должно быть либо 0 (false), либо 1 (true)\n";
+                msg = msg + "Метод setValueByIndex(int index, int value) ";
+                msg = msg + "для поля (index) " + index + ", для значения (value): " + value + " - не выполнен ...";
+                throw new IllegalArgumentException(msg);
+        }
+    }
+
+    @Override
+    public void invertByIndex(int index) throws ArrayIndexOutOfBoundsException {
+        Boolean bool = (index < 0) || (index >= size);
+        if (bool){
+            String msg = "";
+            msg = msg + "Превышены границы массива, значение (index) должно быть:\n" +
+                        "- меньше 1024 ..." + "\n" +
+                        "- больше нуля ..." + "\n" +
+                        "метод invertByIndex(int index)" + " к полю с индексом " + index + " не применен ...";
+            throw new ArrayIndexOutOfBoundsException(msg);
+        }else{
+            /**
+             * проверять collection[index] на null не нужно,
+             * все значения инициированы в конструкторе класса
+             */
+            if (collection[index] == true){
+                collection[index] = false;
+            }else{
+                collection[index] = true;
+            }
+        }
+        
+    }
+
+    @Override
+    public int countOfTrue() {
+        int i = 0;
+        for(Boolean b : collection){
+            if(b == true){
+                i++;
+            }
+        }
+        return i;
+    }
+
+    @Override
+    public String toString() {
+        String result = new String();
+        // перебираем все поля булевого массива (0 : 1023) и выводим значения хранящиеся в этих полях
+        for (int i = 0; i < size; i ++){
+            result = result + isContain(i) + " : ";
+        }
+        return result;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j110/lab04/logic/CollectionFace.java

@@ -0,0 +1,53 @@
+package ru.molokoin.j110.lab04.logic;
+
+/**
+ * Интерфейс булевого массива
+ */
+public interface CollectionFace {
+    public static int size = 1024;
+
+    /**
+     * проверка элемента с заданным индексом
+     * @param index
+     * @return
+     */
+    public abstract boolean isContain(int index);
+
+    /**
+     * установка (в true) элемента с заданным индексом
+     * @param index
+     */
+    public abstract void setTrueByIndex(int index);
+
+    /**
+     * сброс (в false) элемента с заданным индексом
+     * @param index
+     */
+    public abstract void setFalseByIndex(int index);
+
+    /**
+     * установка элемента с заданным индексом заданным логическим значением
+     * @param index
+     */
+    public abstract void setValueByIndex(int index, int value);
+
+    /**
+     * инвертирование элемента с заданным индексом
+     * @param index
+     */
+    public abstract void invertByIndex(int index);
+
+    /**
+     * метод, возвращающий количество элементов, установленных в true
+     * @return
+     */
+    public abstract int countOfTrue();
+
+    /**
+     * метод toString(), возвращающий последовательность нулей и единиц, где каждый сим-
+вол представляет значение соответствующего элемента массива
+     */
+    public abstract String toString();
+
+
+}

java/lessons/src/main/java/ru/molokoin/j110/lab04/logic/IntCollection.java

@@ -0,0 +1,210 @@
+package ru.molokoin.j110.lab04.logic;
+
+/**
+ * Реализация интерфейса булевого массива
+ * Логические значения хранятся в битах массива целочисленных значений int
+ */
+public class IntCollection implements CollectionFace{
+    int size = 1024;//размер булевого массива
+    int box = 32;//количество бит выделенное под значение типа integer
+    int[] collection = new int[size/box];//1024 (размер булевого массива)/32 (размер блока, для формирования интового значения)
+
+    /**
+     * index - варьирует от 0 до 1024 (весь булевский массив)
+     * возвращает true, если в поле index содержится 1, или true
+     * возвращает false, если в поле index содержится 0
+     * TODO проверка границ index (0 --> 1023)
+     */
+    @Override
+    public boolean isContain(int index) throws ArrayIndexOutOfBoundsException{
+        /**
+         * indexOfBox - порядковый номер бокса в булевом массиве
+         * или индекс значения в интовом массиве
+         */
+        int indexOfBox = index/box;//результат целочисленного деления
+        //порядковый номер бита в боксе
+        int indexInBox = index%box;//остаток от деления
+        /**
+         * value - число, хранимое в интовом массиве, в битах которого зашифровано необходимое булевое значение
+         * при переводе значения этого числа в двоичный код, будет получен массив битов,
+         * где значение под номером indexInBox - будет искомое значение
+         */
+        int value = collection[indexOfBox];
+        /**
+         * Далее можно выводить в печать интовое значение, побитовое значение интового числа или обрабатывать  биты, хранимые в этом числе ...
+         */
+        /**
+         * двигаем единичку в позицию, где находится искомый бит в боксе
+         */
+        int mask = 1 << indexInBox;
+        /**
+         * сравниваем интовое значение, преобразованное в двоичный код с маской
+         * преобразование на сколько понимаю происходит автоматически.
+         *  0 0 1 0 0 0 0 0 mask
+         *  1 0 1 0 1 0 1 0 value
+         * после операции "И" получаем
+         *  0 0 1 0 0 0 0 0
+         * далее идет сравнение с mask
+         */
+        Boolean result = ((value&mask) == mask);
+        return result;
+    }
+
+    /**
+     * 0 0 1 0 0 0 0 0 mask
+     * 1 0 1 0 1 0 1 0 value
+     * после операции "&" : "И" получаем
+     * 0 0 1 0 0 0 0 0
+     * после "|" : "ИЛИ" получаем
+     * 1 0 1 0 1 0 1 0
+     * после "^" : "xor" получаем
+     * 1 0 0 0 1 0 1 0
+     */
+    @Override
+    public void setTrueByIndex(int index) throws ArrayIndexOutOfBoundsException{
+        //обработка исключений
+        Boolean b = (index < 0)&(index > 1023);
+        if(b){
+            String msg = "";
+            msg = msg + "Превышены границы массива, значение (index) должно быть:\n" +
+                        "- меньше 1024 ..." + "\n" +
+                        "- больше нуля ..." + "\n" +
+                        "метод setTrueByIndex(int index)" + " к полю с индексом " + index + " не применен ...";
+            throw new ArrayIndexOutOfBoundsException(msg);
+        }
+        //обработка значений массива
+        try {
+            if (isContain(index)){
+                return;
+            }else{
+                int indexOfBox = index/box;
+                int indexInBox = index%box;
+                int value = collection[indexOfBox];
+                int mask = 1 << indexInBox;
+                /**
+                 * не меняем значения value,
+                 * кроме замаскированного поля и только в случае, если там 0
+                 */
+                value = value | mask;
+                collection[indexOfBox] = value;
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    @Override
+    public void setFalseByIndex(int index) throws ArrayIndexOutOfBoundsException{
+        //обработка исключений
+        Boolean b = (index < 0)&(index > 1023);
+        if(b){
+            String msg = "";
+            msg = msg + "Превышены границы массива, значение (index) должно быть:\n" +
+                        "- меньше 1024 ..." + "\n" +
+                        "- больше нуля ..." + "\n" +
+                        "метод setFalseByIndex(int index)" + " к полю с индексом " + index + " не применен ...";
+            throw new ArrayIndexOutOfBoundsException(msg);
+        }
+        if (isContain(index) == false){
+            return;
+        }
+        /**
+         * в поле точно единица, которую надо заменить на 0, не меняя остальных значений в боксе.
+         * - все значения сравниваются с нулями и должны в результате не измениться
+         * - сравнивая единицу с единицей нужно получить ноль
+         * или - не заменит единицу, сохранив остальные значения
+         * и - не заменит единицу, затрет остальные единицы
+         * искл-или - заменит единицу, не изменив остальные значения (то, что надо)
+         */
+        else{
+            int indexOfBox = index/box;
+            int indexInBox = index%box;
+            int value = collection[indexOfBox];
+            int mask = 1 << indexInBox;
+            value = value ^ mask;
+            collection[indexOfBox] = value;
+        }
+    }
+
+    @Override
+    public void setValueByIndex(int index, int value) throws IllegalArgumentException, ArrayIndexOutOfBoundsException{
+        //обработка исключений
+        Boolean b = (index < 0)|(index > 1023);
+        if(b){
+            String msg = "";
+            msg = msg + "Превышены границы массива, значение (index) должно быть:\n" +
+                        "- меньше 1024 ..." + "\n" +
+                        "- больше нуля ..." + "\n" +
+                        "метод setValueByIndex(int index, int value)" + " к полю с индексом " + index + " не применен ...";
+            throw new ArrayIndexOutOfBoundsException(msg);
+        }
+        //логика метода
+        switch (value) {
+            case 0:
+                try {
+                    setFalseByIndex(index);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    System.out.println(e.getMessage());
+                }
+                break;
+            case 1:
+                try {
+                    setTrueByIndex(index);
+                } catch (ArrayIndexOutOfBoundsException e) {
+                    System.out.println(e.getMessage());
+                }
+                break;
+            default:
+                String msg = "";
+                msg = msg + "Значение должно быть либо 0 (false), либо 1 (true)\n";
+                msg = msg + "Метод setValueByIndex(int index, int value) ";
+                msg = msg + "для поля (index) " + index + ", для значения (value): " + value + " - не выполнен ...";
+                throw new IllegalArgumentException(msg);
+        }
+        
+    }
+
+    @Override
+    public void invertByIndex(int index) throws IndexOutOfBoundsException{
+        //обработка исключений
+        Boolean b = (index < 0) | (index > size);
+        if (b){
+            String msg = "";
+            msg = msg + "Превышены границы массива, значение (index) должно быть:\n" +
+                        "- меньше 1024 ..." + "\n" +
+                        "- больше нуля ..." + "\n" +
+                        "метод invertByIndex(int index)" + " к полю с индексом " + index + " не применен ...";
+            throw new IndexOutOfBoundsException(msg);
+        }
+        //логика метода
+        try {
+            if (isContain(index)){
+                setFalseByIndex(index);
+            }else {
+                setTrueByIndex(index);
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    @Override
+    public int countOfTrue() {
+        int count = 0;
+        for(int i = 0; i < size; i++){
+            if (isContain(i)){
+                count++;
+            }
+        }
+        return count;
+    }
+    @Override
+    public String toString() {
+        String result = new String();
+        // перебираем все поля булевого массива (0 : 1024) и выводим значения хранящиеся в этих полях
+        for (int i = 0; i < size; i ++){
+            result = result + isContain(i) + " : ";
+        }
+        return result;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lab04/logic/Runner.java

@@ -0,0 +1,189 @@
+package ru.molokoin.j110.lab04.logic;
+
+public class Runner {
+    public static void main(String[] args) {
+        System.out.println("Запущен основной поток: " + Thread.currentThread().getName() + " ...");
+        System.out.println("=====Работа с булевым массивом=====");
+        System.out.println("Создаем новую коллекцию ...");
+        BooleanCollection bc = new BooleanCollection();
+
+        //проверка метода setTrueByIndex(int index)
+        {
+            System.out.println("Проверка метода setTrueByIndex(int index) ...");
+            int index = 3;
+            System.out.println("index = " + index);
+            try {
+                bc.setTrueByIndex(index);
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println();
+            //проверка метода setTrueByIndex(int index) с предельными значениями
+            System.out.println("Проверка метода setTrueByIndex(int index) с предельными значениями (выше верхней границы) ...");
+            index = -5;
+            System.out.println("index = " + index);
+            try {
+                bc.setTrueByIndex(index);
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println();
+            System.out.println("проверка метода setTrueByIndex(int index) с предельными значениями (меньше нижней границы) ...");
+            index = 1024;
+            System.out.println("index = " + index);
+            try {
+                bc.setTrueByIndex(index);
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("--------------------------------------------");
+        }
+        
+        //проверка setValueByIndex(int index, int value)
+        {
+            System.out.println("проверка setValueByIndex(int index, int value) ...");
+            int index = 1;
+            int value = 1;
+            try {
+                bc.setValueByIndex(index, value);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("проверка setValueByIndex(int index, int value) с предельными значениями ...");
+            index = 1024;
+            value = 1;
+            try {
+                bc.setValueByIndex(index, value);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("проверка setValueByIndex(int index, int value) с предельными значениями ...");
+            index = 0;
+            value = 10;
+            try {
+                bc.setValueByIndex(index, value);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("--------------------------------------------");
+        }
+        
+        //проверка invertByIndex(int index)
+        {
+            System.out.println("проверка invertByIndex(int index) ...");
+            try {
+                int i = 5;
+                bc.invertByIndex(i);
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("проверка invertByIndex(int index) с предельными значениями аргументов ...");
+            try {
+                int i = 1024;
+                bc.invertByIndex(i);
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("--------------------------------------------");
+        }
+
+        //проверка метода countOfTrue()
+        {
+            String msg = "Количество полей в массиве, со значением true: " + bc.countOfTrue();
+            System.out.println(msg);
+            System.out.println("--------------------------------------------");
+        }
+
+        //вывод коллекции в консоль
+        {
+            System.out.println("Выводим коллекцию в консоль ...");
+            System.out.println();
+            System.out.println(bc.toString());
+            System.out.println();
+        }
+        
+        System.out.println("=====Работа с целочисленным массивом=====");
+        System.out.println("Создаем новую коллекцию ...");
+        IntCollection ic = new IntCollection();
+
+        //проверка метода isContain(int index)
+        {
+            //вывод коллекции в консоль по сути является проверкой метода
+        }
+
+        //проверка метода setTrueByIndex(int index)
+        {
+            System.out.println("Проверка метода setTrueByIndex(int index) ...");
+            int i = 1;
+            ic.setTrueByIndex(i);
+            ic.setTrueByIndex(0);
+            ic.setTrueByIndex(2);
+            System.out.println("--------------------------------------------");
+
+        }
+
+        //проверка метода setFalseByIndex(int index)
+        {
+            System.out.println("Проверка метода setFalseByIndex(int index) ...");
+            int i = 1;
+            ic.setFalseByIndex(i);
+            System.out.println("--------------------------------------------");
+        }
+
+        //проверка метода setValueByIndex(int index, int value)
+        {
+            System.out.println("Проверка метода setValueByIndex(int index, int value) ...");
+            int index = 3;
+            int value = 1;
+            try {
+                ic.setValueByIndex(index, value);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+            //проверка с предельными значениями
+            System.out.println("Проверка метода setValueByIndex(int index, int value) с предельными значениями ...");
+            System.out.println("превышение по value ...");
+            try {
+                ic.setValueByIndex(index, 5);
+            } catch (IllegalArgumentException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("превышение по index ...");
+            try {
+                ic.setValueByIndex(5000, value);
+            } catch ( ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("--------------------------------------------");
+        }
+
+        //проверка метода invertByIndex(int index)
+        {
+            System.out.println("Проверка метода invertByIndex(int index) ...");
+            int i = 5;
+            try {
+                ic.invertByIndex(i);
+            } catch (ArrayIndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("Проверка метода invertByIndex(int index). Проверка предельных значений...");
+            i = 2000;
+            try {
+                ic.invertByIndex(i);
+            } catch (IndexOutOfBoundsException e) {
+                System.out.println(e.getMessage());
+            }
+            System.out.println("--------------------------------------------");
+        }
+        
+        //проверка метода countOfTrue()
+        System.out.println("Количество полей со значением true: " + ic.countOfTrue());
+
+        //выводим коллекцию в консоль
+        {
+            System.out.println("Выводим коллекцию в консоль ...");
+            System.out.println();
+            System.out.println(ic.toString());
+        }
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lectures/A.java

@@ -0,0 +1,39 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package ru.molokoin.j110.lectures;
+
+/**
+ *
+ * @author (C)Y.D.Zakovryashin, 07.10.2022
+ */
+public class A {
+    private A a;
+    private A b;
+    
+    public A () {
+       this(null);
+       System.out.println ("A::A()"); 
+    }
+    
+    public A (A a) {
+        System.out.println("A::A(A)");
+    }
+    
+    public void a () {
+        System.out.println("A::a()");
+    }
+    
+    public void a (A a) {
+        System.out.println("A::a(A)");
+    }
+    
+    public static void main (String[] args) {
+        System.out.println("Hello, Java!!!");
+        A a = new A (null);
+        a.a(a);
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lectures/B.java

@@ -0,0 +1,29 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.molokoin.j110.lectures;
+
+/**
+ *
+ * @author (C)Y.D.Zakovryashin, 07.10.2022
+ */
+public class B extends A {
+
+    public B() {
+        super(null);  // this();
+        System.out.println("B::B()");
+    }
+
+    public static void main(String[] args) {
+        B b = new B();
+        b.a();
+    }
+
+    @Override
+    public void a() {
+        System.out.println("B::a()");
+        super.a();
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lectures/C.java

@@ -0,0 +1,28 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.molokoin.j110.lectures;
+
+/**
+ *
+ * @author (C)Y.D.Zakovryashin, 07.10.2022
+ */
+public class C implements I {
+
+    public void a() {
+        System.out.println("C::a()");
+    }
+
+    public void a(A a) {
+        System.out.println("C::a(A)");
+    }
+
+    public static void main(String[] args) {
+        C c = new C();
+        c.a();
+        c.a(null);
+        c.b();
+    }
+}

java/lessons/src/main/java/ru/molokoin/j110/lectures/I.java

@@ -0,0 +1,24 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package ru.molokoin.j110.lectures;
+
+/**
+ *
+ * @author (C)Y.D.Zakovryashin, 07.10.2022
+ */
+public interface I {
+
+    public static final A a = new A(null);
+    A b = null;
+
+    public abstract void a();
+
+    void a(A a);
+
+    default void b() {
+        System.out.println("I:b() - default");
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers01/Code.java

@@ -0,0 +1,61 @@
+package ru.molokoin.j120.lab01.task1.vers01;
+
+public class Code {
+    private int[]code;
+    public Code(int[]code){
+        setCode(code);
+    }
+    /**
+     * @param code the code to set
+     */
+    public void setCode(int[] code) {
+        this.code = code;
+    }
+    public static Code ofString(String codeString){
+        char[] c = codeString.toCharArray();
+        int[] code = new int[c.length-2];//исключили скобки
+        int codeIndex = 0;
+        for (char d : c) {
+            if ((d != "(".toCharArray()[0]) && (d != ")".toCharArray()[0])){
+                code[codeIndex] = Character.getNumericValue(d);
+                codeIndex++;
+            }
+        }
+        return new Code(code);
+    }
+    /**
+     * @return the code
+     */
+    public int[] getCode() {
+        return code;
+    }
+    @Override
+    public String toString() {
+        String result = "";
+        String code = "";
+        for (int i : this.code) {
+            code = code + i;
+        }
+        result = "(" + code + ")";
+        return result;
+    }
+    /**
+     * Проверка функционала класса
+     * @param args
+     */
+    public static void main(String[] args) {
+        {String nums = "0123456789";
+        char[] c = nums.toCharArray();
+        for (char d : c) {
+            System.out.println((int)d + " : " + Integer.toBinaryString(d));
+        }
+        System.out.println();}
+
+        {String art = "()";
+        char[] c = art.toCharArray();
+        for (char d : c) {
+            System.out.println((int)d + " : " + Integer.toBinaryString(d));
+        }
+        System.out.println();}
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers01/Number.java

@@ -0,0 +1,38 @@
+package ru.molokoin.j120.lab01.task1.vers01;
+
+public class Number {
+    private int[] number;
+
+    public Number(int[] number){
+        setNumber(number);
+    }
+    public static Number ofString(String numberString){
+        char[] c = numberString.toCharArray();
+        int[] number = new int[c.length - 2];//убрали тире из номера (две штуки)
+        if(number.length == 6){
+            //
+        }else{
+            //
+        }
+        
+
+
+        return null;
+    }
+
+    /**
+     * @param number the number to set
+     */
+    public void setNumber(int[] number) {
+        this.number = number;
+    }
+    /**
+     * @return the number
+     */
+    public int[] getNumber() {
+        return number;
+    }
+
+
+    
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers01/Phone.java

@@ -0,0 +1,117 @@
+package ru.molokoin.j120.lab01.task1.vers01;
+
+/**
+ * Класс для зранения телефонного номера. 
+ * 
+ */
+public class Phone {
+    private int[] number;//массив цифр номера телефона
+    private int[] code;//массив цифр кода региона
+    //преобразовать строку в массив int
+    public Phone(String phone){}
+    public Phone(int[] code, int[] number){
+        setCode(code);
+        setNumber(number);
+    }
+    
+    /**
+     * @param code the digit to set
+     */
+    public void setCode(int[] code) {
+        this.code = code;
+    }
+    /**
+     * @return the digit
+     */
+    public int[] getCode() {
+        return code;
+    }
+    /**
+     * @param number the number to set
+     */
+    public void setNumber(int[] number) {
+        this.number = number;
+    }
+    /**
+     * @return the number
+     */
+    public int[] getNumber() {
+        return number;
+    }
+    @Override
+    public String toString() {
+        String code = "";
+        for (int i : this.code) {
+            code = code + i;
+        }
+        String number = "";
+        for (int i : this.number) {
+            number = number + i;
+        }
+        String result;
+        result = "(" + code + ")" + number;
+        return result;
+    }
+    /**
+     * Метод преобразует строку в объект Phone
+     * содержимое скобок пишет в digit
+     * содержимое после скобок пишет в number
+     * @param phone
+     * @return
+     */
+    public static Phone ofString(String phoneString){
+        int[] code;
+        int[] number;
+        char[] c = phoneString.toCharArray(); 
+        int i = 0;
+        //определяем индексы плей, указывающих начало и окончание кода города
+        int codeStart = 0;
+        int codeStop = 0;
+        while(i < c.length){
+            if((c[i]) == "(".toCharArray()[0]){
+                codeStart = i;
+            }
+            if((c[i]) == ")".toCharArray()[0]){
+                codeStop = i;
+            }
+            i++;
+        }
+        System.out.println("digitStart : " + codeStart);
+        System.out.println("digitStop : " + codeStop);
+        //инициализация int[] number; определяем длину массива
+        number = new int[c.length - codeStop - 1];
+        //инициализация int[] digit
+        code = new int[codeStop - 1];
+        i = 0;
+        int indexNumber = 0;
+        int indexCode = 0;
+        while (i < c.length){
+            if (i > codeStop){
+                number[indexNumber] = Character.getNumericValue(c[i]) ;
+                indexNumber++;
+            }
+            if((i < codeStop)&&(i > codeStart)){
+                code[indexCode] = Character.getNumericValue(c[i]);
+                indexCode++;
+            }
+            i++;
+        }
+        Phone result = new Phone(code, number);
+        return result;
+    }
+    
+    /**
+     * тесты методов класса Phone
+     * @param args
+     */
+    public static void main(String[] args) {
+        int[] d = {8, 1, 2};
+        int[] n = {1, 2, 3, 4, 5, 6, 7};
+        Phone p = new Phone(d, n);
+        String phoneString = p.toString();
+        System.out.println("phone : " + phoneString);
+        System.out.println("phoneString.length() : " + phoneString.length());
+        Phone pos = Phone.ofString("(495)3678792");
+        System.out.println("pos : " + pos.toString());
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers01/PhoneBook.java

@@ -0,0 +1,8 @@
+package ru.molokoin.j120.lab01.task1.vers01;
+
+public class PhoneBook{
+    public static void main(String[] args) {
+        
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers02/Phone.java

@@ -0,0 +1,10 @@
+package ru.molokoin.j120.lab01.task1.vers02;
+
+/**
+ * Класс хранения телефонного номера.
+ * 
+ */
+public class Phone {
+    private int[] complete = new int[10];
+
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers03/Code.java

@@ -0,0 +1,53 @@
+package ru.molokoin.j120.lab01.task1.vers03;
+
+import java.util.Arrays;
+
+/**
+ * Класс хранит данные о коде региона, составляющем первую секцию полного номера тлефона,<p>
+ * и предоставляет методы, для обработки данных о коде региона.<p>
+ * Класс реализует интерфейс IPart, прдусматривающий основные методы,<p>
+ * для работы с секциями полного номера телефона
+ */
+public class Code implements IPart{
+    private int[] value;
+    /**
+     * Основной конструктор класса,<p>
+     * создающий объекты класса на основании строкового представления кода региона
+     * @param string
+     */
+    public Code(String string){
+        setValue(IPart.ofString(string));
+    }
+
+    @Override
+    public int[] getValue() {
+        return value;
+    }
+
+    @Override
+    public void setValue(int[] value) {
+        this.value = value;
+    }
+
+    /**
+     * Метод преобразует поле int[] value в строку
+     */
+    @Override
+    public String toString(){
+        String s = "(";
+        String string = "";
+        string = Arrays.toString(value).replaceAll(Regex.NON_DIGIT.get(), "");
+        s = s + string + ")";
+        return s;
+    }
+
+    @Override
+    public void print() {
+        System.out.println(toString());
+    }
+    public static void main(String[] args) {
+        Code code = new Code("(812)");
+        code.print();
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers03/IPart.java

@@ -0,0 +1,30 @@
+package ru.molokoin.j120.lab01.task1.vers03;
+
+/**
+ * интерфейс IPart, прдусматривает основные методы,<p>
+ * для работы с секциями полного номера телефона
+ */
+public interface IPart {
+    public abstract int[] getValue();
+    public abstract void setValue(int[] value);
+    public abstract String toString();
+    public abstract void print();
+    /**
+     * метод убирает все не числовые поля в строке, <p>
+     * преобразует полученную строку в int[],<p>
+     * который возвращает в качестве результата выполнения метода.
+     * @param string
+     * @return
+     */
+    public static  int[] ofString(String string){
+        String s = string.replaceAll(Regex.NON_DIGIT.get(), "");
+        int[] result = new int[s.length()];
+        int i = 0;
+        char[] chars = s.toCharArray();
+        for (char c : chars) {
+            result[i] = Character.getNumericValue(c);
+            i++;
+        }
+        return result;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers03/Number.java

@@ -0,0 +1,69 @@
+package ru.molokoin.j120.lab01.task1.vers03;
+
+import java.util.Arrays;
+
+/**
+ * Класс, хранящий данные о секции number полного номера телефона,
+ * реализует интерфейс IPart, прдусматривающий основные методы,<p>
+ * для работы с секциями полного номера телефона
+ */
+public class Number implements IPart{
+    /**
+     * Поле хранит набор цифр, составляющих секцию number полного номера телефона
+     */
+    private int[] value;
+
+    /**
+     * Основной конструктор класса, создает объекты<p>
+     * на основании строкового представления секции number полного номера телефона
+     * @param stringValue
+     */
+    Number(String stringValue){
+        setValue(IPart.ofString(stringValue));
+    }
+
+    @Override
+    public int[] getValue() {
+        return this.value;
+    }
+
+    @Override
+    public void setValue(int[] value) {
+        this.value = value;
+    }
+
+    /**
+     * выводит в консоль строковое представление секции number
+     */
+    @Override
+    public void print() {
+        System.out.println(toString());
+    }
+
+    /**
+     * Преобразование int[] в строку<p>
+     * с добавлением "-" перед последними двумя парами цифр<p>
+     * Примеры:<p>
+     * 000-00-00<p>
+     * 00-00-00
+     */
+    @Override
+    public String toString(){
+        String string = Arrays.toString(value).replaceAll(Regex.NON_DIGIT.get(), "");//получили строку цифр, без дефисов
+        int length = string.length();
+        String first = string.substring(0, length-4);
+        String second = string.substring(length-4, length-2);
+        String therd = string.substring(length-2, length);
+        String result = first + "-" + second + "-" + therd;
+        return result;
+    }
+    /**
+     * Метод создан, для проверки работоспособности класса
+     * @param args
+     */
+    public static void main(String[] args) {
+        Number number = new Number("123-34-45");
+        System.out.println(number.toString());
+        number.print();
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers03/Phone.java

@@ -0,0 +1,239 @@
+package ru.molokoin.j120.lab01.task1.vers03;
+
+import java.util.regex.Pattern;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+
+public class Phone{
+    private Code code;
+    private Number number;
+    
+    /**
+     * Основной конструктор класса Phone<p>
+     * @param code чтобы установить значение поля code
+     * @param number чтобы установить значение поля number
+     */
+    public Phone(Code code, Number number){
+        setCode(code);
+        setNumber(number);
+    }
+    /**
+     * Конструктор класса Phone, принимающий строковое значение номера телефона<p>
+     * Разбивает строку на две части: code, number и передает их в конструкторы соответствующих классов,<p>
+     * @param stringPhone
+     */
+    public Phone(String stringPhone){
+        String[] phone = stringPhone.split(Pattern.quote(")"));
+        code = new Code(phone[0]);
+        setCode(code);
+        number = new Number(phone[1]);
+        setNumber(number);
+    }
+    /**
+     * @param code the code to set
+     */
+    public void setCode(Code code) {
+        this.code = code;
+    }
+    /**
+     * @return the code
+     */
+    public Code getCode() {
+        return code;
+    }
+    /**
+     * @param number the number to set
+     */
+    public void setNumber(Number number) {
+        this.number = number;
+    }
+    /**
+     * @return the number
+     */
+    public Number getNumber() {
+        return number;
+    }
+    
+    /**
+     * Переопределенный (@Override) метод класса Object,<p>
+     * Проводит сравнение объекта у которого вызывается с переданным в качестве параметра метода объектом.<p>
+     * Рекомендовано: всегда переопределять этот метод.
+     */
+    @Override
+    public boolean equals(Object o){
+        /**
+         * Проверка, является ли переданный объект тем же,<p>
+         * у которого был вызван метод equals()
+         */
+        if (this == o) return true;
+        /**
+         * Проверяем, был ли объект, переданный в метод создан на основании класса Phone
+         */
+        if(!(o instanceof Phone)) return false;
+        Phone phone = (Phone) o;
+        /**
+         * Провеяем, совпадают ли значения полей объекта у которого был вызван метод<p>
+         * со значениями одноименных полей переданного в метод объекта
+         */
+        if ((this.code.getValue() == phone.code.getValue())&&(this.number.getValue() == phone.number.getValue())) return true;
+        int i = 0;
+        boolean bool = true;
+        while(i < Phone.toIntArray(this).length){
+            if(Phone.toIntArray(this)[i] != Phone.toIntArray(phone)[i]){
+                bool = false;
+            }
+            i++;
+        }
+        if(bool)return true;
+        return false;
+    }
+    /**
+     * Статический метод, преобразовывает переданный в него объект класса Phone и возвращает int[]<p>
+     * Предназначение - формирование ключевых полей, для передачи в hashMap
+     * @param phone
+     * @return
+     * TODO доделать
+     */
+    public static int[] toIntArray(Phone phone){
+        int[] code = phone.getCode().getValue();
+        int[] number = phone.getNumber().getValue();
+        int[] result = new int[code.length + number.length];
+        /**
+         * по хорошему надо найти метод, который добавляет поля нового массива к старому,
+         * но пока так сделал ...
+         */
+        int i = 0;
+        while (i < code.length){
+            result[i] = code[i];
+            i++;
+        }
+        int j = 0;
+        while(j < number.length){
+            result[i] = number[j];
+            i++;
+            j++;
+        }
+        return result;
+    }
+    /**
+     * Возвращает строковое представление полного номера, для вывода пользователю в форматах:<p>
+     * (000)000-00-00<p>
+     * (0000)00-00-00<p>
+     * <p>
+     * код региона заключен в круглые скобки<p>
+     * секции номера телефона разделены знаками "-"
+     */
+    public String toString(){
+        return (getCode().toString() + getNumber().toString());
+    }
+    /**
+     * Статический метод, дублирующий второй конструктор класса<p>
+     * на основании строкового представления полного номера телефона<p>
+     * формирует объект класса Phone и возвращает его в качестве результата выполнения метода
+     * @param stringPhone для преобразования в объект Phone
+     * @return Phone
+     */
+    public static Phone ofString(String stringPhone){
+        String[] phone = stringPhone.split(Pattern.quote(")"));
+        Code code = new Code(phone[0]);
+        Number number = new Number(phone[1]);
+        return new Phone(code, number);
+    }
+    /**
+     * выводит в консоль оформленную со всеми необходимыми разделителями строку,<p>
+     * содержащую полный номер телефона, хранящегося в текущем объекте
+     */
+    public void print(){
+        System.out.println(toString());
+    }
+    /**
+     * Возвращает уникальный(на период работы программы) идентификатор объекта,
+     * возможно, для использования в качестве ключевого поля параметризованного списка
+     */
+    public int hashCode(){
+        String s = Arrays.toString(Phone.toIntArray(this)).replaceAll(Regex.NON_DIGIT.get(), "");
+        int hash = 0;
+        try {
+            hash =  Integer.parseInt(s);
+        } catch (NumberFormatException e) {
+            System.out.println("Ошибка:" + e.getMessage());
+            hash = 0;
+        }
+        return hash;
+    }
+    /**
+     * На будущее: всегда переопределяем методы:<p>
+     * equals()<p>
+     * hashCode()<p>
+     * toString()<p>
+     * @param args
+     */
+    public static void main(String[] args) {
+        Phone phone01 = new Phone("(812)337-33-13");
+        System.out.println("Code array: " + Arrays.toString(phone01.getCode().getValue()));
+        System.out.println("Number array: " + Arrays.toString(phone01.getNumber().getValue()));
+        System.out.println("Тлефон в пользовательском виде: ");
+        phone01.toString();
+        phone01.print();
+        System.out.println("hash-01 :" + phone01.hashCode());
+        System.out.println("-------------------------------");
+        Phone phone02 = new Phone("(8123)37-33-13");
+        System.out.println("Code array: " + Arrays.toString(phone02.getCode().getValue()));
+        System.out.println("Number array: " + Arrays.toString(phone02.getNumber().getValue()));
+        System.out.println("Тлефон в пользовательском виде: ");
+        phone02.toString();
+        phone02.print();
+        System.out.println("hash-02 :" + phone02.hashCode());
+        System.out.println("-------------------------------");
+        System.out.println("-------------------------------");
+        System.out.println("Проверка взаимодействия класса с Асоциироанным массивом \"HashMap\"");
+        
+        //исходные номера телефонов
+        System.out.println("Исходные номера телефонов: ");
+        phone01 = new Phone("(812)337-33-13");
+        //phone02 = new Phone("(8123)12-34-45");
+        Phone phone03 = new Phone("(999)998-87-76");
+        Phone phone04 = new Phone("(9999)98-87-76");
+        phone01.print();
+        phone02.print();
+        phone03.print();
+        phone04.print();
+        System.out.println("-------------------------------");
+
+        //создаем и заполняем асоциированный массив
+        //не работает проверка уникальности ... проверяет хешкод int[], а не Phone
+        //метод equals надо доработать, чтобы в нем вызывался массив, для сравнения.
+        System.out.println("Создаем и заполняем асоциированный массив ...");
+        HashMap<Integer, Phone> listMap = new HashMap<>();
+        listMap.put(phone01.hashCode(), phone01);
+        listMap.put(phone02.hashCode(), phone02);
+        listMap.put(phone03.hashCode(), phone03);
+        listMap.put(phone04.hashCode(), phone04);
+        // выводим в консоль даные массива
+        System.out.println("Выводим в консоль даные асоциированного массива ...");
+        System.out.println(listMap);
+        System.out.println("-------------------------------");
+        
+        //создаем и заполняем множество
+        System.out.println("Создаем и заполняем множество ...");
+        HashSet<Phone> listSet = new HashSet<>();
+        listSet.add(phone01);
+        listSet.add(phone02);
+        listSet.add(phone03);
+        listSet.add(phone04);
+        // выводим в консоль даные множества
+        System.out.println("Выводим в консоль даные множества");
+        System.out.println(listSet);
+        System.out.println("-------------------------------");
+
+        //проверка equals
+        System.out.println("phone01.equals(null)" + phone01.equals(null));
+        System.out.println("phone01.equals(phone01)" + phone01.equals(phone01));
+        System.out.println("phone01.equals(phone02)" + phone01.equals(phone02));
+        System.out.println("phone01.equals(phone03)" + phone01.equals(phone03));
+
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers03/Regex.java

@@ -0,0 +1,43 @@
+package ru.molokoin.j120.lab01.task1.vers03;
+
+/**
+ * Перечисление содержит основные константные регулярные выражения,<p>
+ * для применения с классами:<p>
+ * - java.util.regex.Pattern<p>
+ * - java.lang.String
+ */
+public enum Regex {
+    /**
+     * DIGIT.get()<p>
+     * Регулярное выражение: [0-9]<p>
+     * Выбираем все числовые элементы
+     */
+    DIGIT("[0-9]"),
+    /**
+     * NON_DIGIT.get()<p>
+     * Регулярное выражение: [^0-9]<p>
+     * Выбираем все не числовые элементы
+     */
+    NON_DIGIT("[^0-9]");
+
+    /**
+     * Поле, хранящее строковое представление регулярного выражения
+     */
+    private String regex;
+    /**
+     * Основной конструктор перечисления регулярных выражений,<p>
+     * сопоставляет регулярное выражение с константным наименованием
+     * @param regex
+     */
+    Regex(String regex){
+        this.regex = regex;
+    }
+    /**
+     * Мтод возвращает строковое представление регулярного выражения
+     * @return
+     */
+    public String get(){
+        return regex;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task1/vers03/docs/class.puml

@@ -0,0 +1,54 @@
+@startuml
+Title "PhoneCatalog class-diagram"
+left to right direction
+interface IPart {
+    Regex regex
+    int[] getValue()
+    void setValue(int[] value)
+    int[] ofString (String string)
+    int[] ofIntArray (int[])
+    String toString()
+    void print()
+}
+class Code{
+    int[] value
+    Code()
+}
+class Number{
+    int[] value
+    Number()
+}
+Code -> IPart
+Number -> IPart
+
+interface IPhone{
+    void setCode(Code code)
+    void seNumber(Number number)
+    Code getCode()
+    Number getNumber()
+    Phone ofString(String string)
+    String toString(Phone phone)
+    int[] toIntArray(Phone phone)
+    boolean equals(Phone phone)
+}
+class Phone{
+    Code code
+    Number number
+    Phone()
+}
+
+Phone -> IPhone
+Phone *- Number
+Phone *- Code
+
+interface ICat{
+    void add(Phone phone)
+    void delete(Phone phone)
+    boolean isExist(Phone phone)
+}
+class Cat{}
+Cat -> ICat
+Phone -* Cat
+
+
+@enduml

java/lessons/src/main/java/ru/molokoin/j120/lab01/task2/vers01/generics/Runner.java

@@ -0,0 +1,128 @@
+package ru.molokoin.j120.lab01.task2.vers01.generics;
+
+public class Runner {
+    public static void main(String[] args) {
+        System.out.println("Запущен поток: " + Thread.currentThread().getName());
+        //Создание списка Integer
+        System.out.println("Создание списка Integer ... ");
+        SimplyGenericList<Integer> listInteger = new SimplyGenericList<Integer>(Integer.class);
+        System.out.println(listInteger.clazz);
+
+        //добавление элементов в список
+        System.out.println("Добавление данных в список ... ");
+        listInteger.addFirst(23);
+        listInteger.addLast(47);
+        listInteger.addFirst(21);
+        listInteger.addLast(50);
+        listInteger.addFirst(18);
+        listInteger.addLast(53);
+        listInteger.addFirst(12);
+        listInteger.addLast(64);
+
+        //вывод в консоль всех элементов списка
+        System.out.println("Вывод в консоль всех элементов списка ... ");
+        listInteger.printAll();
+
+        //Вывод в консоль результатов обработки списка
+        System.out.println("Вывод в консоль результатов обработки списка ...");
+        
+        //печатаем первый и последний элементы списка
+        System.out.print("head ");
+        listInteger.printNode(listInteger.getHead());
+        System.out.print("tail ");
+        listInteger.printNode(listInteger.getTail());
+
+        //удаление первого элемента списка
+        System.out.println("Удаление первого элемента списка: " + listInteger.executeHead());
+        System.out.println("Итоговый список ... " );
+        listInteger.printAll();
+
+        //удаление последнего элемента списка
+        System.out.println("Удаление последнего элемента списка: " + listInteger.executeTail());
+        System.out.println("Итоговый список ... " );
+        listInteger.printAll();
+        //
+        int i = 47;
+        System.out.println("Удаление из списка полей со значением: " + i );
+        listInteger.deleteNodeByValue(i);
+        System.out.println("Итоговый список ... " );
+        listInteger.printAll();
+
+        //действия над всеми элементами списка
+        System.out.println("действия над всеми элементами списка ... " + UseMath.INCREASE );
+        listInteger.math(UseMath.INCREASE, 20);
+        System.out.println("Итоговый список ... " );
+        listInteger.printAll();
+        System.out.println("for each : sout");
+        for (Integer in : listInteger) {
+            System.out.println(in);
+        }
+        //агрегирование - суммируем элементы списка
+        System.out.println("действия над всеми элементами списка ... " + UseMath.SUM);
+        listInteger.math(UseMath.SUM, 0);
+        
+
+        
+        System.out.println("----------------------------------");
+        System.out.println("----------------------------------");
+        //Создание списка String
+        System.out.println("Создание списка String ... ");
+        SimplyGenericList<String> listString = new SimplyGenericList<String>(String.class);
+        System.out.println(listString.clazz);
+
+        //добавление элементов в список
+        System.out.println("Добавление данных в список ... ");
+        listString.addFirst("aa");
+        listString.addLast("bb");
+        listString.addFirst("cc");
+        listString.addLast("dd");
+        listString.addFirst("ee");
+        listString.addLast("ff");
+        listString.addFirst("gg");
+        listString.addLast("dd");
+
+        //вывод в консоль всех элементов списка
+        System.out.println("Вывод в консоль всех элементов списка ... ");
+        listString.printAll();
+
+        //Вывод в консоль результатов обработки списка
+        System.out.println("Вывод в консоль результатов обработки списка ...");
+        
+        //печатаем первый и последний элементы списка
+        System.out.print("head ");
+        listString.printNode(listString.getHead());
+        System.out.print("tail ");
+        listString.printNode(listString.getTail());
+
+        //удаление первого элемента списка
+        System.out.println("Удаление первого элемента списка: " + listString.executeHead());
+        System.out.println("Итоговый список ... " );
+        listString.printAll();
+
+        //удаление последнего элемента списка
+        System.out.println("Удаление последнего элемента списка: " + listString.executeTail());
+        System.out.println("Итоговый список ... " );
+        listString.printAll();
+        //
+        String s = "47";
+        System.out.println("Удаление из списка полей со значением: " + s );
+        listString.deleteNodeByValue(s);
+        System.out.println("Итоговый список ... " );
+        listString.printAll();
+
+        //действия над всеми элементами списка
+        System.out.println("действия над всеми элементами списка ... " + UseMath.INCREASE );
+        listString.math(UseMath.INCREASE, "20");
+        System.out.println("Итоговый список ... " );
+        listString.printAll();
+        System.out.println("for each : sout");
+        for (String st : listString) {
+            System.out.println(st);
+        }
+         //агрегирование - суммируем элементы списка
+         System.out.println("действия над всеми элементами списка ... " + UseMath.SUM);
+         listString.math(UseMath.SUM, "");
+
+
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task2/vers01/generics/SimplyGenericList.java

@@ -0,0 +1,314 @@
+package ru.molokoin.j120.lab01.task2.vers01.generics;
+
+import java.util.Iterator;
+
+/**
+ * Класс содержащий инструменты управления списком и данными в нем
+ * @param <T>
+ */
+public class SimplyGenericList<T> implements Iterable<T> {
+    /**
+     * Поле элемента списка, хранит данные о первом элементе
+     */
+    private Node<T> head;
+    /**
+     * Поле элемента списка, хранит данные о последнем элементе
+     */
+    private Node<T> tail;
+    /**
+     * остаток не доделаной конфигурации,<p>
+     * Хранит данные о передаваемом в список типе данных,<p>
+     * предполагалось с помощью него реализовывать применение различных реализаций методов,<p>
+     * в завиимости от типов передаваемых пользователем даных.
+     */
+    Class<?> clazz;//для определения класса, с которым пользователь использует список
+
+    /**
+     * Конструктор списка, принимающий в качестве параметра тип данных, передаваемых пользователем в список.
+     * @param clazz
+     */
+    public SimplyGenericList(Class<?> clazz){
+        this.clazz = clazz;
+    }
+    /**
+     * @return the head
+     */
+    public Node<T> getHead() {
+        return head;
+    }
+    /**
+     * @param head the head to set
+     */
+    public void setHead(Node<T> head) {
+        this.head = head;
+    }
+    /**
+     * @return the tail
+     */
+    public Node<T> getTail() {
+        return tail;
+    }
+    /**
+     * @param tail the tail to set
+     */
+    public void setTail(Node<T> tail) {
+        this.tail = tail;
+    }
+    /**
+     * Добавление элемента в начало списка
+     * @param data
+     */
+    public void addFirst(T data){
+        if(head == null){
+            head = new Node<T>();
+            head.data = (T)data;
+            tail = head;
+        }else{
+            Node<T> tmp = new Node<T>();
+            tmp.data = (T)data;
+            tmp.next = head;
+            head = tmp;
+        }
+    }
+    /**
+     * Добавление нового элемента в конец списка
+     */
+    public void addLast(T data){
+        if(head == null){
+            addFirst((T)data);
+        }else{
+            Node<T> tmp = new Node<T>();
+            tmp.data = (T)data;
+            tail.next = tmp;
+            tail = tmp;
+        }
+    }
+    /**
+     * удаляет первый элемент списка и возвращает его данные
+     * @return
+     * TODO вдруг список пустой
+     * TODO вдруг список содержит только один элемент
+     */
+    public T executeHead(){
+        T tmp = null;
+        tmp = (T)head.data;
+        head = head.next;
+        return tmp;
+    }
+    /**
+     * Удаление последнего элемента списка
+     * @return
+     */
+    public T executeTail(){
+        T tmp = (T)tail.data;//готовы писать данные удаляемого элемента
+        Node<T> bufNode = head;
+        //у предпоследнего элемента удаляем ссылку на tail
+        while (bufNode.next != tail){
+            bufNode = bufNode.next;
+        }
+        bufNode.next = null;
+        return tmp;
+    }
+    /**
+     * Преобразование массива в односвязный список
+     * @param array
+     * @return
+     * TODO в перспективе сделать преобразование массива
+     * */
+    public SimplyGenericList<T> arrayToList(T[] array){
+        SimplyGenericList<T> sl = new SimplyGenericList<T>(clazz);
+        return sl;
+    }
+    /**
+     * вывод в консоль всех элементов списка, по порядку
+     */
+    public void printAll(){
+        Node<T> temp = head;
+        while (temp != null){
+            printNode(temp);
+            temp = temp.next;
+        }
+    }
+    /**
+     * Вывод в консоль данных указанной ноды
+     * @param node
+     */
+    public void printNode(Node<T> node){
+        if (node == null){
+            System.out.println(">>> " + null);
+
+        }else{
+            System.out.println(">>> " + (T)node.data);
+        }
+    }
+    public void deleteNodeByValue(T value){
+        //обработка случая, когда первый элемент списка подлежит удалению
+        while (head.data == (T)value){
+            head = head.next;
+        }
+        //первый элемент списка точно не подлежит удалению
+        Node<T> buf = new Node<T>();
+        buf = head;
+        while(buf.next != null){
+            if (buf.next.data != (T)value){
+                buf = buf.next;
+            }else{
+                buf.next = buf.next.next;
+            }
+        }
+    }
+    /**
+     * не понятно почему не работает,
+     * оператор "+" не предусмотрен для объектов класса Т
+     * как предусмотреть ???
+     * можно попробовать сделать еще один свитч по типу данных, передаваемых пользователем в список,
+     * но поля в списке всеравно окажутся <T> и к ним не понятно как получать доступ.
+     * с агрегированием аналогичная ситуация
+     * @param use
+     * @param value
+     */
+
+    public void math(UseMath use, T value){
+        try{
+            switch (use){
+                case SUM :{
+                    Node<T> buf = head;
+                    if (buf.data instanceof String){
+                        /**
+                         * работает быстрее, потомучто под капотом static поля,<p>
+                         * обработка идет в  стеке
+                         */
+                        StringBuilder mid = new StringBuilder(buf.toString());
+                        while (buf.next != null){
+                            mid =  mid.append(buf.next.toString())  ;
+                            buf = buf.next;
+                        }
+                        System.out.println("SUM-String: " + mid);
+                    }
+                    /**
+                     * тоже работает
+                     */
+                    // if (buf.data instanceof String){
+                    //     String mid = buf.toString();
+                    //     while (buf.next != null){
+                    //         mid = "" +mid + buf.next.toString();
+                    //         buf = buf.next;
+                    //     }
+                    //     System.out.println("SUM-String: " + mid);
+                    // }
+
+                    //по той же причине mid объявлен как int
+                    if (buf.data instanceof Integer){
+                        int mid = buf.toInteger();
+                        while (buf.next != null){
+                            mid = mid + buf.next.toInteger();
+                            buf = buf.next;
+                        }
+                        System.out.println("SUM-INTEGER: " + mid);
+                    }
+                    
+                    break;
+                }
+                case INCREASE : {
+                    Node<T> buf = head;
+                    if (buf.data instanceof Number){
+                        Integer midl = buf.toInteger() + (Integer)value;
+                        System.out.println("(Integer)mid :" + midl);
+                        buf.data = (T)midl;
+                        while (buf.next != null){
+                            midl = buf.next.toInteger() + (Integer)value;
+                            buf.next.data = (T)midl;
+                            buf = buf.next;
+                        }
+                    }
+                    if (buf.data instanceof String){
+                        String midl = buf.toString() + (String)value;
+                        System.out.println("(String)mid :" + midl);
+                        buf.data = (T)midl;
+                        while (buf.next != null){
+                            midl = buf.next.toString() + (String)value;
+                            buf.next.data = (T)midl;
+                            buf = buf.next;
+                        }
+                    }
+                    break;
+                }
+                case DECREASE : {
+                    break;
+                }
+            }
+        }catch(Exception e){
+            System.out.println(e.getMessage());
+        }
+    }
+    /**
+     * Метод интерфейса Iterable, рализует функционирование итератора,
+     * возможность перебора списка циклом foreach
+     */
+    @Override
+    public Iterator<T> iterator(){
+        return new SimplyGenericListIterator<T>(head);
+    }
+    public int size() {
+        int index = 1;
+        Node<T> current = head;
+        while (current.next != null){
+            current = current.next;
+            index++;
+        }
+        return index;
+    }
+
+    /**
+     * Класс, объекты которого являются элементами списка (узлы / ноды / node) в которых хранятся основные данные и ссылка на следующий элемент списка. 
+     * не понятно, почему создаются объекты, если класс статический ...
+     */
+    public static class Node<T>{
+        private T data;
+        private Node<T> next;
+
+        public Integer toInteger(){
+            if (data instanceof Integer){
+                return (Integer)data;
+            }else{
+                throw new IllegalArgumentException("IllegalArgumentException: даные не относятся к типу Integer");
+            }
+        }
+        public String toString(){
+            if (data instanceof String){
+                return (String)data;
+            }else{
+                throw new IllegalArgumentException("IllegalArgumentException: даные не относятся к типу String");
+            }
+        }
+    }
+
+    /**
+     * Класс, устанавливающий методы рализации интерфейса Iterator,
+     * устанавливает методы, испльзуемые при реализации метода iterator() интерфейса Iterable
+     * !! скопировал рализацию с практики, на много проще моей получилась .. 
+     */
+    public static class SimplyGenericListIterator<T> implements Iterator<T> {
+        Node<T> nextNode;
+
+        /**
+         * Конструктор итератора, передаем в него головную ноду.
+         * @param nextNode
+         */
+        public SimplyGenericListIterator(Node<T> nextNode) {
+            this.nextNode = nextNode;
+        }
+        @Override
+        public boolean hasNext() {
+            if(nextNode!=null) return true;
+            return false;
+        }
+        @Override
+        public T next() {
+            T value = (T)nextNode.data;
+            nextNode = nextNode.next;
+            return value;
+        }
+    }
+
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task2/vers01/generics/UseMath.java

@@ -0,0 +1,8 @@
+package ru.molokoin.j120.lab01.task2.vers01.generics;
+
+public enum UseMath {
+    SUM,
+    INCREASE,
+    DECREASE;
+
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task2/vers01/samples/LinkedList.java

@@ -0,0 +1,97 @@
+package ru.molokoin.j120.lab01.task2.vers01.samples;
+
+import java.util.Iterator;
+
+public class LinkedList <T> implements Iterable<T>{
+    private Node head;
+    private Node tail;
+    
+    public LinkedList(){}
+
+    //Добавление элемента в конец списка
+    public void add(T item){
+        if(head==null){
+            head = new Node();
+            tail = head;
+            head.data = item;
+        }
+        else {
+            Node tempNode = new Node();
+            tempNode.data = item;
+            tempNode.previous = tail;
+            tail.next = tempNode;
+            tail = tempNode;
+        }
+    }
+
+    //Получение значения элемента по его индексу
+    public T get(int index){
+        if(index<0) throw new IllegalArgumentException();
+        int tempIndex = 0;
+        Node tempNode = head;
+        while(tempNode!=null){
+            if(tempIndex==index) return (T)tempNode.data;
+            tempNode = tempNode.next;
+            tempIndex++;
+        }
+        throw new IndexOutOfBoundsException();
+    }
+
+    //Получение размера списка
+    public int size(){
+        int size = 0;
+        Node tempNode = head;
+        while (tempNode!=null){
+            size++;
+            tempNode = tempNode.next;
+        }
+        return size;
+    }
+
+    //Получение первого элемента
+    public T getHead(){
+        if(head==null) return null;
+        return (T)head.data;
+    }
+
+    //Получение последнего элемента
+    public T getTail(){
+        if(tail==null) return null;
+        return (T)tail.data;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return new LinkedIterator<>(head);
+    }
+    
+    private static class LinkedIterator <T> implements Iterator<T>{
+        Node nextNode;
+
+        public LinkedIterator(Node nextNode) {
+            this.nextNode = nextNode;
+        }
+        
+
+        @Override
+        public boolean hasNext() {
+            if(nextNode!=null) return true;
+            return false;
+        }
+
+        @Override
+        public T next() {
+            T value = (T)nextNode.data;
+            nextNode = nextNode.next;
+            return value;
+        }
+        
+    }
+
+    //Внутренний класс, хранящий полезное значение и ссылки на следующий узел и предыдущий
+    private static class Node <T> {
+        T data;
+        Node next;
+        Node previous;
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task2/vers01/samples/MainClass.java

@@ -0,0 +1,38 @@
+package ru.molokoin.j120.lab01.task2.vers01.samples;
+
+import java.util.Iterator;
+
+public class MainClass {
+
+    public static void main(String[] args) {
+        LinkedList<Integer> list = new LinkedList<>();
+        list.add(5);
+        list.add(15);
+        list.add(23);
+        list.add(45);
+        list.add(432);
+        list.add(67);
+        list.add(87);
+        list.add(124);
+        System.out.println("Last item = " + list.getTail());
+        System.out.println("Index item = " + list.get(7));
+        System.out.println("List size = " + list.size());
+        
+        System.out.println("Вывод с помощью метода forEach");
+        list.forEach(e -> System.out.print(e + ", "));
+        Iterator<Integer> iter = list.iterator();
+        System.out.println();
+        
+        System.out.println("Вывод с помощью итератора");
+        
+        while(iter.hasNext()){
+            System.out.print(iter.next() + ", ");
+        }
+        System.out.println();
+        
+        System.out.println("Вывод с помощью цикла forEach");
+        for(Integer num : list){
+            System.out.print(num + ", ");
+        }
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task3/person/Degree.java

@@ -0,0 +1,17 @@
+package ru.molokoin.j120.lab01.task3.person;
+
+public enum Degree {
+    PhD {
+        @Override
+        public String getDegree() {
+            return "PhD";
+        }
+    },
+    MSc {
+        @Override
+        public String getDegree() {
+            return "MSc";
+        }
+    };
+    public abstract String getDegree();
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task3/person/Gender.java

@@ -0,0 +1,39 @@
+package ru.molokoin.j120.lab01.task3.person;
+/**
+ * Перечисление gender,
+ * 
+ */
+public enum Gender {
+    MALE {
+        public String getPronoun(){
+            return "he";
+        }
+
+        @Override
+        public String getPronounOwn() {
+            return "his";
+        }
+    },
+    FEMALE{
+        public String getPronoun(){
+            return "she";
+        }
+        @Override
+        public String getPronounOwn() {
+            return "her";
+        }
+
+    },
+    TRANS{
+        public String getPronoun() {
+            return "it";
+        }
+
+        @Override
+        public String getPronounOwn() {
+            return "its";
+        }
+    };
+    public abstract String getPronoun();
+    public abstract String getPronounOwn();
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task3/person/Person.java

@@ -0,0 +1,246 @@
+package ru.molokoin.j120.lab01.task3.person;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Person {
+    private String name;
+    private Gender gender;
+    private String department;
+    private Role role;
+    //для аспиранта
+    private String thesisTitle;
+    //для преподавателя
+    private Degree degree;
+    private String speciality;
+    //для студента
+    private Stage stage;
+    private String course;
+
+    /**
+     * Создаем персону
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     */
+    Person(String name, Gender gender, String department, Role role){
+        setName(name);
+        setGender(gender);
+        setDepartment(department);
+        setRole(role);
+    }
+    /**
+     * Создаем аспиранта
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     * @param thesisTitle
+     */
+    Person(String name, Gender gender, String department, Role role, String thesisTitle){
+        this(name, gender, department, role);
+        setThesisTitle(thesisTitle);
+    }
+
+    /**
+     * Создаем преподавателя
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     * @param degree
+     * @param speciality
+     */
+    Person(String name, Gender gender, String department, Role role, Degree degree, String speciality){
+        this(name, gender, department, role);
+        setDegree(degree);
+        setSpeciality(speciality);
+    }
+
+    /**
+     * Создаем студента
+     * @param name
+     * @param gender
+     * @param department
+     * @param role
+     * @param stage
+     * @param course
+     */
+    Person(String name, Gender gender, String department, Role role, Stage stage, String course){
+        this(name, gender, department, role);
+        setStage(stage);
+        setCourse(course);
+    }
+
+    public static Person[] initDefaults(){
+        Person[] defaultList = new Person[6];
+        
+        defaultList[0] = new Person("Ronald Turner", Gender.MALE, "Computer science", 
+            Role.TEACHER, Degree.PhD, "Programming paradigms");
+
+        defaultList[1] = new Person("Ruth Hollings", Gender.FEMALE, "Jurisprudence", 
+            Role.TEACHER, Degree.MSc, "Domestic arbitration");
+
+        defaultList[2] = new Person("Leo Wilkinson", Gender.MALE, "Computer science", Role.STUDENT, Stage.bachelor, "III");
+
+        defaultList[3] = new Person("Anna Cunningham", Gender.FEMALE, "World economy", Role.STUDENT, Stage.bachelor, "I");
+
+        defaultList[4] = new Person("Jill Lundqvist", Gender.FEMALE, "Jurisprudence", Role.STUDENT, Stage.master, "I");
+
+        defaultList[5] = new Person("Ronald Correa", Gender.MALE, "Computer science", Role.ASPIRANT, "Design of a functional programming language.");
+
+        return defaultList;
+    }
+    public static List<Person> initPersons(){
+        List<Person> list = new ArrayList<>();
+        list.add(new Person("Ronald Turner", Gender.MALE, "Computer science", 
+        Role.TEACHER, Degree.PhD, "Programming paradigms"));
+
+        list.add(new Person("Ruth Hollings", Gender.FEMALE, "Jurisprudence", 
+        Role.TEACHER, Degree.MSc, "Domestic arbitration"));
+
+        list.add(new Person("Leo Wilkinson", Gender.MALE, "Computer science", Role.STUDENT, Stage.bachelor, "III"));
+
+        list.add(new Person("Anna Cunningham", Gender.FEMALE, "World economy", Role.STUDENT, Stage.bachelor, "I"));
+
+        list.add(new Person("Jill Lundqvist", Gender.FEMALE, "Jurisprudence", Role.STUDENT, Stage.master, "I"));
+
+        list.add(new Person("Ronald Correa", Gender.MALE, "Computer science", Role.ASPIRANT, "Design of a functional programming language."));
+        return list;
+    }
+    /**
+     * Выводит общие данные в консоль
+     */
+    public void print(){
+        System.out.println("This is " + getName() + " " + 
+            getGender().getPronoun() + " " +
+            getRole().getVerb() + " at " + getDepartment());
+        //преподаватели
+        if (getRole().equals(Role.TEACHER)){
+            System.out.println(getGender().getPronoun() + " has " + 
+            getDegree() + " degree in " + 
+            getSpeciality() + ".");
+            System.out.println();
+        }
+        //студенты
+        if (getRole().equals(Role.STUDENT)){
+            System.out.println(getGender().getPronoun() + " is " + 
+                getCourse() + "‘th year " + getStage() + " student.");
+            System.out.println();
+        }
+
+        //аспиранты
+        if (getRole().equals(Role.ASPIRANT)){
+            System.out.println(getGender().getPronounOwn() + " thesis title is " + getThesisTitle() + ".");
+            System.out.println();
+        }
+    }
+    /**
+     * Выводит полный набор данных в консоль<p>
+     * @param persons массив элементов Person, для печати в консоль
+     */
+    public static void printAll(Person[] persons){
+        int i = 0;
+        while (i < persons.length){
+            persons[i].print();
+            i++;
+        }
+    }
+    /**
+     * Метод принимает параметризованную коллекцию,
+     * перебирает foreach все элементы и вызывает методы print() у каждого элемента.
+     * !!!чтобы передавать параметризованную коллекцию, ее нужно заранее создать
+     */
+    public static void printAll(List<? extends Person> list){
+        for (Person person : list) {
+            person.print();
+        }
+    }
+
+    /**
+     * Устанавливает значение поля name/Фамилия, Имя и Отчество человека
+     * @param name
+     * не может быть пустым, если передано пустое значение, устанавливается значение noname
+     */
+    public void setName(String name) {
+        this.name = name;
+    }
+    public void setGender(Gender gender) {
+        this.gender = gender;
+    }
+    public void setDepartment(String department) {
+        this.department = department;
+    }
+    public void setRole(Role role) {
+        this.role = role;
+    }
+    public void setThesisTitle(String thesisTitle) {
+        this.thesisTitle = thesisTitle;
+    }
+    public void setDegree(Degree degree) {
+        this.degree = degree;
+    }
+    public void setSpeciality(String speciality) {
+        this.speciality = speciality;
+    }
+    public void setStage(Stage stage) {
+        this.stage = stage;
+    }
+    public void setCourse(String course) {
+        this.course = course;
+    }
+    /**
+     * Возвращает имя человека,
+     * TODO имя не может быть пустым полем или отсутствовать
+     * @return
+     */
+     public String getName() {
+        return name;
+    }
+    /**
+     * возвращает пол/gender человека мужской/male или женский/female
+     * @return
+     * 
+     */
+    public Gender getGender() {
+        return gender;
+    }
+    /**
+     * Возвращает наименование департамента, в котором трудится человек (учится или преподает)
+     * @return 
+     * 
+     */
+    public String getDepartment() {
+        return department;
+    }
+    public Role getRole() {
+        return role;
+    }
+    public String getThesisTitle() {
+        return thesisTitle;
+    }
+    public Degree getDegree() {
+        return degree;
+    }
+    public String getSpeciality() {
+        return speciality;
+    }
+    public Stage getStage() {
+        return stage;
+    }
+    public String getCourse() {
+        return course;
+    }
+    public static void main(String[] args) {
+        System.out.println("----------------------------");
+        System.out.println("Печать из массива ...");
+        Person.printAll(Person.initDefaults());
+        System.out.println("----------------------------");
+        System.out.println("Печать из параметризованного списка >>>Persons<<<");
+        Person.printAll(Person.initPersons());
+        System.out.println("----------------------------");
+        System.out.println("Печать из параметризованного списка >>>Personable<<<");
+        Person.printAll(Personable.initPersonables());
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task3/person/Personable.java

@@ -0,0 +1,38 @@
+package ru.molokoin.j120.lab01.task3.person;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Personable extends Person{
+    Personable(String name, Gender gender, String department, Role role){
+        super(name, gender, department, role);
+    }
+    Personable(String name, Gender gender, String department, Role role, String thesisTitle){
+        super(name, gender, department, role);
+    }
+    Personable(String name, Gender gender, String department, Role role, Degree degree, String speciality) {
+        super(name, gender, department, role, degree, speciality);
+    }
+    Personable(String name, Gender gender, String department, Role role, Stage stage, String course){
+        super(name, gender, department, role, stage, course);
+    }
+    
+    public static List<Personable> initPersonables(){
+        List<Personable> list = new ArrayList<>();
+        list.add(new Personable("Ronald Turner", Gender.MALE, "Computer science", 
+        Role.TEACHER, Degree.PhD, "Programming paradigms"));
+
+        list.add(new Personable("Ruth Hollings", Gender.FEMALE, "Jurisprudence", 
+        Role.TEACHER, Degree.MSc, "Domestic arbitration"));
+
+        list.add(new Personable("Leo Wilkinson", Gender.MALE, "Computer science", Role.STUDENT, Stage.bachelor, "III"));
+
+        list.add(new Personable("Anna Cunningham", Gender.FEMALE, "World economy", Role.STUDENT, Stage.bachelor, "I"));
+
+        list.add(new Personable("Jill Lundqvist", Gender.FEMALE, "Jurisprudence", Role.STUDENT, Stage.master, "I"));
+
+        list.add(new Personable("Ronald Correa", Gender.MALE, "Computer science", Role.ASPIRANT, "Design of a functional programming language."));
+        return list;
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task3/person/Role.java

@@ -0,0 +1,23 @@
+package ru.molokoin.j120.lab01.task3.person;
+
+public enum Role {
+    STUDENT {
+        @Override
+        public String getVerb() {
+            return "studies";
+        }
+    },
+    ASPIRANT {
+        @Override
+        public String getVerb() {
+            return "studies";
+        }
+    },
+    TEACHER {
+        @Override
+        public String getVerb() {
+            return "teaches";
+        }
+    };
+    public abstract String getVerb();
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task3/person/Stage.java

@@ -0,0 +1,17 @@
+package ru.molokoin.j120.lab01.task3.person;
+
+public enum Stage {
+    bachelor {
+        @Override
+        public String getStage() {
+            return "bachelor";
+        }
+    },
+    master {
+        @Override
+        public String getStage() {
+            return "master";
+        }
+    };
+    public abstract String getStage();
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task4/RegularStudent.java

@@ -0,0 +1,5 @@
+package ru.molokoin.j120.lab01.task4;
+
+public class RegularStudent {
+    
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task4/task.md

@@ -0,0 +1,8 @@
+# 4. Заполнение параметризованной коллекции.
+**Реализуйте в классе RegularStudent из соответствующей задачи 110-го курса статический метод:**
+* заполняющий  заданную  коллекцию типа Collection<RegularStudent> данными  о некоторых студентах (например: данными, приведёнными в примере в задаче 110-го курса).
+* Сделайте  так,  чтобы  метод  мог  корректно  использоваться  как  с  коллекциями типа Сollection<RegularStudent>,
+* так и с коллекциями, параметризованными другими типами.
+* Подумайте, какими типами может быть параметризована такая коллекция.
+* Проиллюстрируйте использование метода.
+* **Доработайте класс односвязного списка, чтобы методы «выполнять заданное действие» и «агрегировать значения» соответствовали правилам PECS при использовании вспомогательных типов.**

java/lessons/src/main/java/ru/molokoin/j120/lab01/task5/DoublyGenericList.java

@@ -0,0 +1,432 @@
+package ru.molokoin.j120.lab01.task5;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+public class DoublyGenericList <T> implements Iterable<T>, Cloneable{
+    private Node<T> head = null;
+    private Node<T> tail = null;
+
+    /**
+     * метод проверяет пустой ли список и в случае,
+     * если в списке нет узла head, возвращает true.
+     * Если узел head есть, но в нем отсудствую данные, также возвращается true.
+     * @return true, если список пуст
+     */
+    public boolean isEmpty(){
+        boolean isEmpty = false;
+            if((getHead() != null) || (getTail() != null)){
+                isEmpty = false;
+            }else{
+                isEmpty = true;
+            }
+        return isEmpty;
+    }
+    /**
+     * добавление данных в начало списка
+     * @param data
+     */
+    public void addFirst(T data){
+        if (isEmpty()) {
+            Node<T> newNode = new Node<T>();
+            newNode.data = data;
+            setHead(newNode);
+            setTail(newNode);
+        }else{
+            Node<T> newNode = new Node<T>();
+            newNode.data = data;
+            newNode.forvard = getHead();
+            getHead().backvard = newNode;
+            setHead(newNode);
+        }
+    }
+    /**
+     * добавление данных в конец списка
+     * @param data
+     */
+    public void addLast(T data){
+        if (isEmpty()) {
+            Node<T> newNode = new Node<T>();
+            newNode.data = data;
+            setHead(newNode);
+            setTail(newNode);
+        }else{
+            Node<T> newNode = new Node<T>();
+            newNode.data = data;
+            newNode.backvard = getTail();
+            getTail().forvard = newNode;
+            setTail(newNode);
+        }
+    }
+    /**
+     * вывод в консоль всех элементов списка, по порядку
+     * метод скопирован с односвязных списков
+     */
+    public void printForvard(){
+        Node<T> tmp = getHead();
+        while (tmp != null){
+            printNode(tmp);
+            tmp = tmp.forvard;
+        }
+    }
+    public void printBackvard(){
+        Node<T> tmp = getTail();
+        while(tmp != null){
+            printNode(tmp);
+            tmp = tmp.backvard;
+        }
+    }
+    /**
+     * Вывод в консоль данных указанной ноды
+     * Метод скопирован с односвязных списков
+     * @param node
+     */
+    public void printNode(Node<T> node){
+        if (node == null){
+            System.out.println(">>> " + null);
+
+        }else{
+            System.out.println(">>> " + node.data);
+        }
+    }
+    /**
+     * извлечение данных с удалением первого элемента списка
+     * TODO исключения, когда список пустой
+     * @return
+     */
+    public T executeFirst(){
+        T executed = null;
+        if (isEmpty()){
+            return executed;
+        }
+        else{
+            try {
+                executed = (T) getHead().data;
+                setHead(getHead().forvard);
+            }catch (NullPointerException e){
+                System.out.println("Обнаружена исключительная ситуация: " + e);
+            }
+        }
+        return executed;
+    }
+    /**
+     * извлечение данных с удалением последнего элемента списка
+     * @return
+     */
+    public T executeLast(){
+        T executed = null;
+        if (isEmpty()){
+            return executed;
+        }
+        else{
+            try {
+                executed = (T)getTail().data;
+                setTail(getTail().backvard);
+                getTail().forvard = null;
+            }catch (NullPointerException e){
+                System.out.println("Обнаружена исключительная ситуация: " + e);
+            }
+        }
+        return executed;
+    }
+    /**
+     * Проверяем наличие в списке заданного в параметре метода значения
+     * @param value
+     * @return
+     */
+    public boolean isContain(T value){
+        boolean isContain = false;
+        if (isEmpty()){
+            isContain = false;
+            return isContain;
+        }
+        else{
+            Node<T> tmp = getHead();
+            while (tmp.forvard != null){
+                if(tmp.data == value){
+                    isContain = true;
+                }
+                tmp = tmp.forvard;
+            }
+            if (getTail().data == value){
+                isContain = true;
+            }
+        }
+        return isContain;
+    }
+    /**
+     * удаляем ноды, содержащие данные совпадающие с указанным в методе значением
+     * @param value
+     */
+    public void deleteByValue(T value){
+        //проверяем наличие указанного значения в списке
+        if (isContain(value)){
+            //удаляем первые ноды, если они содержат указанное значение
+            Node<T> tmp = getHead();
+            while (tmp.data == value){
+                executeFirst();
+                tmp = getHead();
+            }
+            //удаляем последние ноды, если они содержат указанное значение
+            tmp = getTail();
+            while(tmp.data == value){
+                executeLast();
+                tmp = getTail();
+            }
+            /**
+             * первая и последняя ноды точно не содержат указанное значение и не подлежат удалению
+             */
+            tmp = getHead();
+            //
+            while (tmp.forvard != null){
+                //если данные текущей ноды не подлежат удалению, переходим к следующей ноде
+                if (tmp.data != value){
+                    tmp = tmp.forvard;
+                }
+                /**
+                 * если текущая нода подлежит удалению
+                 * (точно не первая и не последняя)
+                 * 
+                 */
+                else{
+                    tmp.forvard.backvard = tmp.backvard;
+                    tmp.backvard.forvard = tmp.forvard;
+                    tmp = tmp.forvard;
+                }
+            }
+        }
+    }
+    /**
+     * добавление элементов массива в начало списка
+     * чтобы обеспечить последовательное размещение элементов массива в списке, элементы добавляются с последнего элемента массива
+     * @param array
+     */
+    public void arrayToHead(T[]array){
+        int i = array.length-1;
+        while (i >= 0){
+            addFirst(array[i]);
+            i--;
+        }
+    }
+    /**
+     * добавление элементов массива в хвост списка
+     * @param array
+     */
+    public void arrayToTail(T[]array){
+        int i = 0;
+        while (i < array.length){
+            addLast(array[i]);
+            i++;
+        }
+    }
+    /**
+     * добавление коллекции в начало списка
+     * @param collection
+     */
+    public void collectionToHead(ArrayList<T> collection){
+        for(int i = (collection.size()-1);i >= 0;i--) {
+            addFirst(collection.get(i));
+        }
+    }
+    /**
+     * добавление коллекции в хвост списка
+     * @param collection
+     */
+    public void collectionToTail(ArrayList<T> collection){
+        for(T c : collection){
+            addLast(c);
+        }
+    }
+    public Node<T> getHead() throws NullPointerException {
+        return head;
+    }
+    public void setHead(Node<T> head) {
+        this.head = head;
+    }
+    public Node<T> getTail() throws NullPointerException{
+        return tail;
+    }
+    public void setTail(Node<T> tail) {
+        this.tail = tail;
+    }
+    
+    /**
+     * метод возвращает список,<p>
+     * в котором элеметы расположены в обратной последовательности
+     * TODO метод может возвращать  void, а в теле еще одним циклом переписывать текущий список.<p>
+     * хотя и сейчас можно текущему списку присвоить преобразованный список.
+     * list = list.reverce();
+     * .. в общем шило на мыло, меняется только способ использования метода.
+     * рально в reverce() обращаться к объектам исходного списка только при клонировании элементов списка,
+     * но сам список при этом всеровно окажется новым экземпляром.
+     * @return
+     */
+    public DoublyGenericList<T> reverce(){
+        DoublyGenericList<T> reverce = new DoublyGenericList<>();
+        for (T t : this) {
+            reverce.addFirst(t);
+        }
+        return reverce;
+    }
+
+    /**
+     * Возвращает количество звеньев в текущем списке
+     * @return
+     */
+    private int size() {
+        Node<T> next = head;
+        int i = 0;
+        while (next.forvard != null){
+            i++;
+            next = next.forvard;
+        }
+        return i + 1;
+    }
+    /**
+     * метод, осуществляющий перебр элементов списка<p>
+     * используется циклом foreach, или при прочих способах перебора списка
+     */
+    @Override
+    public Iterator<T> iterator() {
+        return new GenericIterator<T>(head);
+    }
+    /**
+     * Клонируем список, без использования метода клонирования
+     * по сути создаем новый список и копируем в него данные.
+     * @param source
+     * @return
+     */
+    public DoublyGenericList<T> clone(){
+        DoublyGenericList<T> target  = new DoublyGenericList<>();
+        for (T t : this) {
+            target.addLast((T)t);
+        }
+        return target;
+    }
+
+    /**
+     * клонирование списка
+     * можно доработать, если клонировать node.data,<p>
+     * в остальных случаях будут клонироваться ссылки на объекты исходного списка
+     * в таком варианте можно осуществить реверс списка, который будет ссылаться на те же объекты
+     */
+    // public DoublyGenericList<T> clone(){
+    //     try{
+    //         return (DoublyGenericList<T>)super.clone();//возвращает новый список со ссылка ми на старые объекты
+    //     }catch (CloneNotSupportedException e){
+    //         System.out.println("Ошибка: Клонирование не удалось...");
+    //         System.out.println("DoublyGenericList<T> clone() вернул ссылку на тот же объект.");
+    //         return this;
+    //     }
+    // }
+
+    /**
+     * добавляем value  к каждому значению в списке
+     * работает с integer или string
+     * @param value
+     */
+    public void increase(T value){
+        Node<T> buf = head;
+        if (buf.data instanceof Number){
+            Integer midl = buf.toInteger() + (Integer)value;
+            buf.data = (T)midl;
+            while (buf.forvard != null){
+                midl = buf.forvard.toInteger() + (Integer)value;
+                buf.forvard.data = (T)midl;
+                buf = buf.forvard;
+            }
+        }
+        if (buf.data instanceof String){
+            String midl = buf.toString() + (String)value;
+            buf.data = (T)midl;
+            while (buf.forvard != null){
+                midl = buf.forvard.toString() + (String)value;
+                buf.forvard.data = (T)midl;
+                buf = buf.forvard;
+            }
+        }
+    }
+    /**
+     * Агрегирование элементов списка
+     * метод возвращает сумму всех полей списка
+     * - для Integer полей
+     * - для String полей
+     * @param value
+     */
+    public T agregate() throws IllegalArgumentException{
+        /**
+         * обрабатываем значения Integer
+         */
+        Node<T> next = head;
+        if (next.data instanceof Number){
+            Integer sum = next.toInteger();//возвращает Integer data
+            while (next.forvard != null){
+                sum = (sum + next.forvard.toInteger());
+                next = next.forvard;
+            }
+            return (T)sum;
+        }
+        /**
+         * обрабатываем значения String
+         */
+        if (next.data instanceof String){
+            String sum = next.toString();
+            while (next.forvard != null){
+                sum = sum + next.forvard.toString();
+                next = next.forvard;
+            }
+            return (T)sum;
+        }
+        throw new IllegalArgumentException("В список передан недопустимый объект, не предусмаривающий возможность проведения операции суммирования ");
+    }
+    /**
+     * Методы итератора списка
+     */
+    private static class GenericIterator<T> implements Iterator<T>{
+        Node<T> next;
+        GenericIterator(Node<T> next){
+            this.next = next;
+        }
+        @Override
+        public boolean hasNext() {
+            if(next!=null) return true;
+            return false;
+        }
+        @Override
+        public T next() {
+            T value = (T)next.data;
+            next = next.forvard;
+            return value;
+        }
+    }
+    /**
+     * Вложенный класс, описывает узел двусвязного списка
+     */
+    private static class Node <T>{
+        T data;//данные ячейки списка
+        Node<T> forvard;//следующая ячейка списка
+        Node<T> backvard;//предыдущая ячейка списка
+
+        /**
+         * Возвращает данные узла типа Integer
+         * @return
+         */
+        public Integer toInteger(){
+            if (data instanceof Integer){
+                return (Integer)data;
+            }else{
+                throw new IllegalArgumentException("IllegalArgumentException: даные не относятся к типу Integer");
+            }
+        }
+        /**
+         * возвращает данные узла типа String
+         */
+        public String toString(){
+            if (data instanceof String){
+                return (String)data;
+            }else{
+                throw new IllegalArgumentException("IllegalArgumentException: даные не относятся к типу String");
+            }
+        }
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task5/Runner.java

@@ -0,0 +1,85 @@
+package ru.molokoin.j120.lab01.task5;
+
+import java.util.Arrays;
+
+public class Runner {
+    public static void main(String[] args) {
+        System.out.println("--------------------------------------");
+        System.out.println("--------------------------------------");
+        System.out.println("Доработка списка DoublyGenericList");
+        System.out.println("--------------------------------------");
+        System.out.println("--------------------------------------");
+
+        //исходные данные в массиве
+        Integer[] array = {9, 12, 24,38, 43, 51, 62, 79, 81, 99};
+        //создали новый список
+        DoublyGenericList<Integer> listInteger = new DoublyGenericList<Integer>();
+        //занесли данные массива в список
+        listInteger.arrayToHead(array);
+        //вывели данные списка в консоль
+        for (Integer integer : listInteger) {
+            System.out.println("integer : " + integer);
+        }
+        //выводим данные списка в обратном порядке
+        for (Integer integer : listInteger.reverce()) {
+            System.out.println("integer.reverce() : " + integer);
+        }
+        //клонируем список
+        System.out.println("клонируем список ...");
+        DoublyGenericList<Integer> listIntegerClone = listInteger.clone();
+        listIntegerClone.addLast(700);
+        listIntegerClone.addLast(800);
+        listIntegerClone.addLast(900);
+        System.out.println("Добавили новые данные в клона ...");
+        System.out.println("listInteger:");
+        listInteger.printForvard();
+        System.out.println();
+        System.out.println("listIntegerClone:");
+        listIntegerClone.printForvard();
+
+        /**
+         * выполняем заданное действие с каждым элементом списка
+         * (добавим 500)
+         */
+        System.out.println("Добавляем по 500 к каждому элементу списка ...");
+        listInteger.increase(500);
+        System.out.println("listInteger + 500:");
+        listInteger.printForvard();
+        System.out.println("listIntegerClone:");
+        listIntegerClone.printForvard();
+        System.out.println("Изменение основного списка не отразилось на клоне!!!");
+
+        /**
+         * добавим данных к строковым значениям
+         */
+        System.out.println("--------------------------------------");
+        System.out.println("Добавление данных к строковому массиву ...");
+        //исходные данные в массиве
+        String[] arr = {"one", "two", "three", "four", "five"};
+        System.out.println(Arrays.toString(arr));
+        //создали новый список
+        DoublyGenericList<String> listString = new DoublyGenericList<String>();
+        //занесли данные массива в список
+        listString.arrayToHead(arr);
+        //получаем список, в обратном порядке
+        DoublyGenericList<String> listStringReverce = listString.reverce();
+        
+        //добавили smth в основной список
+        listString.increase(" + smth");
+        System.out.println("listString.increase(smth);");
+        listString.printForvard();
+
+        //добавили smth в перевернутый список
+        listStringReverce.increase(" + smth-else");
+        System.out.println("listStringReverce.increase(smth-else);");
+        listStringReverce.printForvard();
+        /**
+         * агрегирование (суммируем элементы списка)
+         */
+        System.out.println("Агрегированное значение sum(listString): " + listString.agregate());
+        System.out.println("Агрегированное значение sum(listString.reverce()): " + listString.reverce().agregate());
+        System.out.println("Агрегированное значение sum(listInteger): " + listInteger.agregate());
+
+
+    }
+}

java/lessons/src/main/java/ru/molokoin/j120/lab01/task5/task.md

@@ -0,0 +1,12 @@
+# 5. Generic двусвязного списка, его использование в «for-each» 
+Доработайте класс двусвязного списка из соответствующей задачи 110-го курса, чтобы он поз-
+волял: 
+* сохранять и извлекать значения заданного типа; 
+* перебирать при помощи оператора «for-each»: 
+    - всё содержимое списка; 
+    - всё содержимое списка в обратном порядке от последнего элемента к первому; 
+* выполнять  заданное  действие  для  каждого значения списка в прямом/обратном порядке (два метода); 
+* агрегировать значения (см. выше в задаче 2) в прямом/обратном порядке (два метода); 
+* клонировать  список  (последующие  операции  с  исходным  списком  или  его  копией  не должны влиять друг на друга).
+
+**При реализации заданий «выполнять заданное действие» и «агрегировать значения» учитывайте правила PECS при использовании вспомогательных типов.**

java/lessons/src/main/java/ru/molokoin/package00/App.java

@@ -0,0 +1,7 @@
+package ru.molokoin.package00;
+
+public class App {
+    public static void main(String[] args) {
+        System.out.println("qw");
+    }
+}

java/lessons/src/main/java/ru/molokoin/package01/App.java

@@ -0,0 +1,7 @@
+package ru.molokoin.package01;
+
+public class App {
+    public static void main(String[] args) {
+        System.out.println("Thread.main");
+    }
+}

java/lessons/src/main/java/ru/molokoin/package01/Binary.java

@@ -0,0 +1,30 @@
+package ru.molokoin.package01;
+import java.util.Objects;
+
+public class Binary {
+    int size = 64/32;
+    int[] ints = new int[size];
+
+    public boolean getByIndex(int index){
+        int indexElement = index/32;
+        int element = ints[indexElement];
+        int indexBit = index%32;//остаток от деления
+        int mask = 1<<indexBit;
+        return (element&mask)==mask;
+    }
+    @Override
+    public String toString() {
+        String[] tmp = new String[size];
+        for (int i = 0; i < size; i ++){
+            int x = getByIndex(i) ? 1:0;
+            tmp[i] = Objects.toString(tmp);
+
+        }
+        return super.toString();
+    }
+
+    public static void main(String[] args) {
+        Binary binary = new Binary();
+    }
+    
+}

java/lessons/src/main/java/ru/molokoin/package02/App.java

@@ -0,0 +1,7 @@
+package ru.molokoin.package02;
+
+public class App {
+    public static void main(String[] args) {
+        
+    }
+}

java/lessons/src/main/java/ru/molokoin/package03/Runner.java

@@ -0,0 +1,5 @@
+package ru.molokoin.package03;
+
+public class Runner {
+    
+}

java/lessons/src/main/java/ru/molokoin/package03/theme.md

@@ -0,0 +1 @@
+# mysql работа с базами данных