• 0.23

  • +1.35

  • ,

Общение с иностранцами в качестве тренировки английского

Здравствуйте. Вроде где-то тут кто-то когда-то писал, что есть какие-то нормальные ресурсы, где можно пообщаться с иностранцами. Никто не знает таких ресурсов? Хочется потренироваться в английском. Мне кажется, это реальная вещь.

Мои ответы на вопросы собеседований из 40 уровня

Собственно, такие вопросы были на этом уровне:
1. Что такое IP-адрес?
2. В чем отличие host и domain?
3. Какие методы в HTTP вы знаете
4. Чем отличаются методы GET, POST и HEAD?
5. Что такое REST?
6. Зачем нужен класс Calendar в Java?
7. Как преобразовать дату в Java к нужному формату?
8. В чем отличие URI и URL?
9. Что такое сокеты?
10. Отличие классов Socket и URL?

А вот мои ответы:
1. IP-адрес — это уникальный сетевой адрес узла в компьютерной сети, построенной на стеке протоколов TCP/IP. В сети Интернет требуется глобальная уникальность адреса; в случае работы в локальной сети требуется уникальность адреса в пределах сети. В версии протокола IPv4 IP-адрес имеет длину 4 байта, а в версии протокола IPv6 IP-адрес имеет длину 16 байт. Обычно IP-адрес в версии протокола IPv4 записывают в виде четырёх десятичных чисел со значениями от 0 до 255, разделённых точкой, например, 192.168.0.3.

2. Домен — это адрес сайта или определённая зона, которая имеет своё имя, не похожее ни на какое другое имя в системе доменных имён. Домены бывают первого уровня, второго уровня, третьего уровня и т.д. Обычно домен первого уровня не доступен обычным пользователям для регистрации (примеры доменов первого уровня — ".ru", ".com", ".net"). Обычно домены третьего и следующих уровней называют субдоменами.
Хост — это определённый компьютер или сервер, подключенный к локальной или глобальной сети. Хост обладает обладает уникальным адресом в среде сервисов TCP/IP (IP-адресом).

3.GET, POST, PUT, DELETE, OPTIONS, HEAD, PATCH, TRACE, LINK, UNLINK, CONNECT.

4.

                        GET	POST	HEAD
---------------------------------------------
Тело Запроса            Нет	Есть	Нет
Тело Ответа             Да	Да	Нет
Кеширование
результата Запроса      Да	Нет	Да, заголовки	
Идемпотентность         Да	Нет	Да


Метод GET используется для запроса содержимого указанного ресурса. Метод POST применяется для передачи пользовательских данных заданному ресурсу. Метод HEAD обычно применяется для извлечения метаданных, проверки наличия ресурса (валидация URL) и чтобы узнать, не изменился ли он с момента последнего обращения. Метод HEAD аналогичен методу GET, за исключением того, что в ответе сервера отсутствует тело. Метода GET считает упрощённой версией POST, потому как метод GET не предполагает полноценного запроса, только URL в качестве такового.

5. REST — это архитектурный стиль взаимодействия компонентов распределённого приложения в сети. Термин был введён Роем Филдингом в 2000 году. Также им были введены требования, которым должно удовлетворять распределённое приложение, чтобы соответствовать архитектуре REST (такие приложения ещё называют RESTful). Вот эти требования:
1) Модель «Клиент-Сервер» (означает, что сеть должна состоять из клиента и сервера; сервер — это тот, кто обладает ресурсами, клиент — тот, который их запрашивает))
2) Отсутствие состояния (означает, что ни клиент, ни сервер не отслеживают состояния друг друга)
3) Кеширование (клиенты и промежуточные узлы могут кешировать результаты запросов; сооответственно, ответы сервера должны иметь явное или неявное обозначение, что они кешируемые или некешируемые)
4) Единообразие интерфейса (означает, что между клиентами и серверами существует общий язык взаимодействия, который позволяет им быть заменяемыми или изменяемыми, без нарушения целостности системы):
а) Определение ресурса (означает, что каждый ресурс должны быть обозначен постоянным идентефикатором)
б) Управление ресурсами через представление (означает, что клиент хранит ресурс в виде его представления, и при желании изменения ресурса он отправляет серверу информацию о том, в каком виде он хотел бы видеть этот ресурс; сервер же рассматривает этот как запрос как предложение, и сам решает, что делать ему с хранимым ресурсом)
в) Самодостаточные сообщения (каждое сообщение содержит достаточно информации, чтобы понять, как его обрабатывать)
г) Гипермедиа (означает, что клиенты изменяют состояние системы только через действия, которые динамически определены в гипермедиа на сервер)
5) Система слоёв (означает, что в системе может быть больше двух слоёв (клиент и сервер), и при этом каждый такой слой знает только о своих соседних слоях, и не знает об остальных слоях, и взаимодействует только с соседними слоями)
6) Код по требованию (означает, что функциональность клиента может быть расширения за счёт загрузки кода с сервера в виде апплетов или сценариев)

Удовлетворение этим требованиям позволяет добиться следующего:
* Надёжность
* Производительность
* Масштабируемость
* Прозрачность взаимодействия
* Простота интерфейсов
* Портативность компонентов
* Лёгкость внесения изменений
* Способность эволюционировать, приспасабливаясь к новым требованиям

6. Он нужен для более удобной работы с датой и временем. Он позволяет работать с датой в рамках календаря, то есть позволяет прибавлять и отнимать дни от какой-то конкретной даты, причём будут учитывать и високосные года. Кроме того, он позволяет представить время миллисекундах в удобном виде — год, месяц, день, часы, минуты, секунды. Также есть много методов для установки и получения разных параметров даты и времени, например: день недели, день месяца, день в году, номер недели в месяце, номер недели в году.

7. Для этого существует удобный класс SimpleDateFormat. Экземпляру этого класс можно передать шаблон представления даты, и тогда он в таком виде будет возвращать дату (в формате строки String), либо считывать дату (из строки String). Выглядит это всё следющим образом:
Date date = new Date(); // получаем текущую дату
SimpleDateFormat formatter = new SimpleDateFormat(«d-MM-yy HH:mm:ss»); //создаём экземпляр класса SimpleDateFormat
//и передаём ему шаблон представления даты и времени
String dateAsString = formatter.format(date); //преобразуем дату в строку заданного формата

Date dateAfterConversion = formatter.parse(dateAsString); //преобразуем строку обратно в дату

8. URI расшифровывается как Uniform Resource Identifier и переводится как «унифицированный идентификатор ресурса». URI — это последовательность символов, идентифицирующая абстрактный или физический ресурс. URL расшифровывается как Uniform Resource Locator. То есть это некий унифицированный указатель на ресурс, однозначно определяющий его месторасположение. URL служит стандартизированным способом записи адреса ресурса в сети Интернет.
Их отличия в том, что URI — это некоторый идентификатор ресурса, который позволяет этот ресурс как-то идентифицировать, а URL — это указатель на ресурс, он даёт информацию о том, где находится ресурс. Таким образом URL — это URI, который помимо индетификации ресурса, даёт информацию о его местонахождении.

9. Сокеты — это связка IP-адрес + порт, позволяющая из внешней сети однозначно идентифицировать программу на компютере или сервере. В Java для работы с сокетами есть два класса Socket и ServerSocket. Экземпляры первого класса играют роль клиента, экземпляры второго — роль сервера. Клиент может отправлять и принимать сообщения через сокет. Сервер же постоянно отслеживает запросы пользователей и отвечает на них.
Для того, чтобы отправить данные через сокет, в классе Socket существует класс getOutnputStream(), возвращающий исходящий поток, с которым уже можно работать как обычно. Для приёма информациию нужно воспользоваться методом getInputStream(), который возвращает входящий поток. Дальше с этим потоком можно работать как с обычно потом ввода. Также стоит отметить, что при создании клиентского сокета (экземпляра класса Socket) в конструктор нужно передать ip-адрес сервера и порт, на котором он работает принимающая программа-сервер.
При создании серверного сокета (экземпляра класса ServerSocket) нужно указывать только порт, через который будет работать программа. После этого вызывается метод accept(). Этот метод ожидание подключение клиента, а после этого возвращает экземпляр класса Socket, необходимый для взаимодействия с этим клиентом. Дальше работать идёт с экземпляром класса Socket, как в первом случае (в случае клиента).

10. Главное отличие в том, что класс URL предназначен для работы с URL-строкой (парсинг URL-строки), а Socket используется для соединения с удалённым сервером и отправки информации на сервер и/или приёма информации от сервера (хотя, используя класс URL, можно получить доступ к ресурсу, на который указывает сам URL; но делается это не напрямую, а через объект класса URLConnection). Также, если смотреть в общем, то Socket используется для связи с сервером (другой программой), а URL — для доступа к ресурсу (например, к файлу). Кроме того, URL и URLConnection ориентированы в основном на работу с HTTP, тогда как Socket может работать с любыми протоколами.

Мои ответы на вопросы собеседований из 39 уровня

Список вопросов:
1. Что такое web-сервер?
2. Что такое Tomcat?
3. Что такое сервлеты и где они используются?
4. Какие режимы запуска приложений в IDEA вы знаете?
5. Можно ли дебажить приложение/сервлет, которое запущено внутри Tomcat’а?
6. Как в IDEA установить точку остановки?
7. Как в IDEA посмотреть список всех точек остановки?
8. Можно ли с помощью IDEA поменять значение переменной в процессе работы программы?
9. Как в IDEA настроить отступы?
10. Как в IDEA настроить, чтобы { отображалось на той же строке, а не на новой?

Мои ответы:
1. Веб-сервер — это сервер, принимающий HTTP-запросы от клиенты (чаще всего — браузеров) и выдающий им HTTP-ответы, как правило вместе с HTML-страницей, изображений, файлом, медиа-потоком и другими данными.

2. Apache Tomcat — это контейнер сервлетов, разработанный компанией Apache Software Foundation. Реализует спецификацию сервлетов и спецификацию JSP (JavaServer Pages) и JSF(JavaServer Faces). Позволяет запускать веб-приложения, содержит ряд программ для самоконфигурирования. Может выступать в качестве самостоятельного веб-сервера, в качестве контента (в сочении с Apache HTP Server), а также в качестве контейнера сервлетов в серверах приложений JBoss и GlassFish.

3. Сервлет — это Java-класс, наследуемый от класса HttpServlet и реализующий любые из методов: doGet(), doPost(), doPut(), doDelete(), а также init() и destroy(). Этот класс используется веб-сервером для обработки запросов и формирования ответов на эти запросы. Каждый запрос обрабатывается в отдельном потоке. Контейнер контейнер вызывает метод service() для каждого запроса. Этот метода смотрит на тим входящего запроса и пересылает его соответствующему методу. Если данный метода не реализован в сервлете, то этот метод вызывается у супер-класса, и обычно завершается возвращение ошибки инициатору запроса.

4. Приложение в IDEA можно запустить в двух режимах: обычный запуск приложения и запуск в режиме отладки. Обычный запуск приложения — это обычно его выполнение. В режиме отладки же приложение можно выполнять построчно. Также в этом режиме можно ставить точки останова (breakpoints) на некоторые строчки кода (программа будет выполнять как обычно, пока не встретит такую точку; как она её встретит, она остановится). Кроме того, этот режим позволяет смотреть значения переменных во время выполнения программы.

5. Да, это можно делать, и это можно делать даже из самой IDE. Например, чтобы запустить отладку сервлета из IDEA, нужно сделать следующее:
1) Зайти в найстроки отладки/запуска приложения
2) Добавить конфигурацию Remote
3) Далее выводится страница, где нужно изменить адрес хоста, на котором находится Tomcat, и порт
4) Открыть файл catalina.bat (для Windows) и исправить в нём строчку «set DEBUG_OPTS=». Туда нужно дописать следующее "-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=1985". Последнее число — это адрес порта, который мы указали на шаге 3.
5) Перестартовать Tomcat
6) Выставить точки останова в коде в нужных местах
7) Нажать Debug в IDEA
8) Отправить запрос
9) Произвести отладку из среды разработки

6. Либо можно нажать мышкой в поле между номером строчки и началом строки, либо встать на какую-то строчку и нажать на клавиатуре ctrl+F8, либо встать на строку и вверху в меню выбрать Run -> Toggle line BreakPoint.

7. Либо сочетанием клавиш ctrl+shift+F8, либо выбрать в меню Run -> View Breakpoints…

8. Да, есть такая возможность. Это можно сделать в режиме отладки. Во время отладки нужно в окне переменных выбрать нужную переменную и нажать F2, либо щёлкнуть по переменной правой кнопкой мыши и в открывшемся меню выбрать «set value», и ввести нужное значение переменной.

9. Нужно зайти в настройки (Settings), там выбрать Editor, потом — Code Style. Там уже можно изменить общий опции, либо изменить найстройки отступов для каждого поддерживаемого формата файла.

10. Нужно перейти по следующему пути Settings -> Editor -> Code Style -> Java -> Wrapping and Braces, и дальше в разделе Braces Placement изменять найстройки (для класса, метода, лямбда-выражений, других случаев).

Мои ответы на вопросы собеседований из 38 уровня

Здравсвтвуйте. Опять-таки, похоже нет ответов на вопросы из этого уровня. Поэтому, как обычно, выкладываю свои. Вдруг, кому помогут (или кто-то что-то дополнит или ответит лучше).
Итак, были такие вопросы:
1. Что такое Agile?
2. Что такое Scrum?
3. Какие роли Scrum вы знаете?
4. Что такое спринт? Расскажите с подробностями
5. Кто такие QA?
6. Кто такой product owner?
7. Расскажите об иерархии исключений
8. Что делать если JVM выкинула Error?
9. Какие нововведения в области исключений из Java 7 вы знаете?
10. Зачем нужны аннотации? Как ими пользоваться?

А теперь мои ответы:
1. Agile — это серия подходов к разработке программного обеспечения, ориентированных на использование итеративной разработки, динамическое формирование требований и обеспечение их реализации в результате взаимодействия внутри самооранизующихся рабочих групп, состоящих из специалистов разных профилией. Существует несколько методик, относящих к гибкой методологии разработки, в частности экстремальное программирование, DSDM, Scrum, FDD.

Основные концепции agile-методов:
* люди и взаимодействие важнее процессов и инструментов;
* работающий продукт важнее исчерпывающей документации;
* сотрудничество с заказчиком важнее согласование условий контракта;
* готовность к изменениям важнее следованию первоначального плана.

Также были сформулированы основные приципы такого подхода:
* удовлетвореие клиента за счёт ранней и бесперебойной поставки ценного программного обеспечения;
* приветствие изменений требований даже в конце разработки (это может повысить конкурентноспособность продукта на рынке);
* частая поставка рабочего программного обеспечения (каждый месяц или каждую неделю, или даже ещё чаще);
* тесное, ежедневно общение заказчика с разработчика на протяжении всего проекта;
* проектом занимаются мотивированные личности, обеспеченые нужные условиями работы, поддержкой и доверием;
* рекомендуемый метода передачи информации — личный разговор (лицом к лицу);
* работающее программное обеспечение — лучший измеритель прогресса;
* спонсоры, разработчики и пользователи должны поддерживать постоянный темп на неопределённый срок;
* постоянно внимание улучшению технического мастерства и удобному дизайну;
* простота — искусство не делать лишней работы;
* лучшие технические требования, архитектура и дизайн полуются у самороорганизованной команды;
* постоянная адаптация к изменяющимся условиям.

Основной проблемой разработки было признано то, что никто из участников ни на одном этапе не обладает всей полнотой информации о том, что делать.

2. Scrum — это одна из методик гибкой разработки. Она делает акцент на качественном контроле процесса разработки. Основая особенность скрама — это разбиение процесса разработки на итерации имеющий чёткую протажённость по времени (обычно 2-6 недель; их называют «спринтами»).
В начале спринта проводится «планирование спринта» — совещание на 3-4 часа, где обсуждаются основные задачи, которые будут решаться на протяжении спринта. В конце спринта проводится «демо» — демонтрация результатов работы команды за этот спринт.
Перед самым первым спринтом заказчик (или его представитель) формирует список требований, предъявляемых к будущему продукту. Такие требования называются «user story», а самого заказчика называют «product owner». Также в этом списке заказчик (PO) указывает приоритет для каждой задачи. Сначала будут реализовываться задачи с более высоким приоритетом. Весь список называется «product backlog», или «резерв продукта».
Кроме product owner, среди участников ещё выделяют scrum-мастера: он проводит все совещания, следит за соблюдением всех принципов скрама, разрешает противоречения и защищает команду от отвлекающих факторов. Обычно в качестве скрам-мастера выступает кто-то из команды.
На первом совещании в начале спринта каждой задаче, кроме того, что назчается приоритет, даётся ещё приблизительная оценка в «абстрактных человеко-днях», которые ещё называют «story point». Затем команда решает, сколько она успеет выполнить задач за время спринта. Например, заказчик отобрал 7 задач, а команда сможет сделать только 5. Тогда остальные две задачи пойдут на следующий спринт. Если заказчику это не нравится, он может повысить их приоритет, но тогда другие задачи выпадут из спринта. Кроме того, скрам-мастер может разбить некоторые задачи на более мелкие и расставить им различные приоритеты, чтобы заказчик остался доволен.
Список отобраных задач на спринт называются «sprint backlog», или «резерв спринта». Для лучшей наглядности обычно составляется таблица, в которой указываются задачи, которые нужно реализовать, которые находятся в процессе реализации, и те которые уже выполнены. Также строится диаграмма «сгорания задач». Она графическ показывает, сколько ещё задач осталось выполнить. В идеале график сгорания задач к концу спринта должен опустится до нуля.
Также в течение спринта каждый день или через день проводятся небольшие совещания внутри команды на 5-15 минут, где каждый участник команды рассказывает, что сделал за этот день (или эти два дня), что ещё ему предстоит сделать, а также рассказывает о том, что ему мешает что-то сделать.
Когда спринт завершается, scrum-master проводит demo, на котором демонстрируется список всего, что полностью сделано. Затем проводится «разбор полетов» — совещание тоже на пару часов. На нем обычно пытаются выяснить, что было сделано хорошо, а что (и как) можно было сделать лучше.
Обычно за 2-3 спринта можно выявить основные проблемы, которые мешают команде работать эффективнее, и устранить их. Это приводит к большей продуктивности, не увеличивая нагрузку на команду. Такое было невозможным до эры гибких методологий.
Также в середине спринта, иногда еще проводят «вычесывание» — совещание посвященное планированию следующего спринта. На нем обычно уточняют приоритеты задач, а так же могут разбить некоторые задачи на части и/или добавить новые задачи в product backlog – резерв продукта.

3. В крам участников делят на «свиней» и «кур». «Свиньи» полностью задействованы в процессе, «куры» — только частично. К категории «свиней» относят следующие роли:
* Скрам-мастер (проводит совещания, следит за выполнением принципов скрама и пр.; это кто-то из команды, produst owner не может быть скрам-мастером);
* Владелей продукта (Product Owner) (представляет интересы конечных пользователей и других заинтересованных в продукте сторон);
* Команда разработки (Development Team) (кросс-функциональная команда, состоящая из специалистов разных профилей: разработчиков, тестировщиков, дизайнеров, архитекторов и т.д. Размер команды в идеале составляет от 3 до 9 человек. Команда является единственные полностью вовлечённым участником разработки и отвечает за результат как единое целое. Никто, кроме команды, не может вмешиваться в процесс разработки на протяжении спринта).

К «курам» относятся следующие роли:
* Пользователи (Users)
* Клиенты, продавцы (Stakeholders) (лица, которые инициируют проект и для кого проект будет приносить выгоду. Они вовлечены в скрам только во время обзорного совещания по спринту (Sprint Review));
* Управляющие (Managers) (люди, которые управляют персоналом);
* Эксперты-консультанты (Consulting Experts).

4. Спринт — это одна итерация цикла разработки программного обеспечения в Скраме. Обычно спринт жёстко фиксирован по времени. Продолжительность спринта выбирается на основании размера команды, специфики работы, требований, размера проекта. Чаще всего это подбирается опытным путём, на основании проб и ошибок. В среднем спринт может быть продолжительность от 2 недель до 4 (хотя в некоторых компания его продолжительность бывает равна и 6 неделям). Для оценка объёма работ в спринте может быть использована предварительная оценка, измеряемая в очках истории. Предварительная оценка фиксируется в беклоге проекта.

5. QA расшифровывается как Quality Assuarance (то есть «Гарантия качества», если перевести дословно). К этой категории относятся тестировщики. Это люди, которые выявляют в программе баги и ошибки. Для этого они используют разные средства, как ручные, так и автоматические. После выявления багов и ошибок они сообщают об этом разработчикам, и те исправляют эти ошибки.

6. Product Owner (владелец проекта) — это заказчик или представитель заказчика. Это либо кто-то со стороны клиента (сторонняя фирма или физ.лицо), либо какой-то другой сотрудник фирмы, определящий требования к конечному продукту и следяющий за их выполнений (например, бизнес-аналитик). Как уже было сказано, он определяет требования к продукту и задачи, которые дожна решить команда разработки, чтобы получить конечный продукт. Список требований (или задач) он оформляет в определённым порядке и с заданным приоритетом для каждого требования (задачи). Обычно он участвует в планировании спринта (перед началом спринта) и в демонтрации результатов спринта (после окончания спринта).

7. Во главе иерархии исключений в Java стоит класс Throwable. От не наследуются два класса: Error и Exception. Объекты первого класс выбрасываются, когда возникают какие-то серьёзные ошибки в работе программы и джава-машины в целом (а также в работе ОС и аппаратной части копьютера), так, что программа больше не может продолжать работать и закрывается. Это может быть недостаток памяти (OutOfMemoryError) или переполнение стека (StackOverflowError).
Экземпляры второго класса могут выбраться при самых различных исключительных ситуаций. Собственно от этого класса наследуется класс RuntimeException и все остальные классы. Первый класс так выделяют, потому что, во-первых, исключительные ситуации такого типа являются непроверяемые (unchecked), а, во-вторых, к данным исключительным ситуациям относятся ошибки выполнения программы. Обычно это возникает из-за несовершенства кода. Все остальные исключительные ситуации обычно являются следствием непредвиденного стечения обстоятельств, например, ошибки ввода-вывода.
Также исключения делятся на проверяемые (checked) и непроверяемые (unchecked). Первые необходимо либо отлавливать в блоке try-catch, либо указывать в качестве выбрасываемых в сигнатуре метода (используя слово throws). Непроверяемые этого не требуют, и выбор остаётся за программистом. К проверяемым относятся исключения типа Throwable (а также наследуемые от него) и типа Exception (и наследуемые от него, кроме исключений типа RuntimeException). К непроверяемым относятся исключения типа Error (а также наследуемые от него) и исключения типа Runtime (и наследуемые от него).

8. Ничего, программа просто закроется. Обычно это критические ошибки, не всегда возникшие по вине программиста (например, выход из строя жёсткого диска или сбой операционной системе). Правда, среди них есть две ошибки, которые могу следствием несовершенства кода — это StackOverflowError и OutOfMemoryError. Первый тип ошибок возник, при переполнении стека вызовов — то есть, когда вызывается слишком много методов и стек вызовов становится слишком больший (типичный пример — бесконечная рекурсия или рекурсия с большим количеством итераций). Вторая ошибка — OutOfMemoryError — возникает, когда переполняет память отведённая под объекты, то есть когда создаётся слишком много тяжеловесных объектов, и они все держатся в памяти (или когда сборщик мусора не успевает их уничтожать).

9. В Java 7 в плане исключение были введены три новых «вещи»:
* Multicatching. Это когда в одном catch-блоке сразу обрабатывается несколько исключений:
try {
} catch (Exception1|Exception2|Exception3|… | ExceptionN ex) {}
В таком случае параметр ex будет неявно иметь модификатор final. Кроме того, байт-код, сгенерированный компиляцией такого кода (с единым catch-блоком) будет короче, чем байт-код, сгенерированный компиляцией кода с несколькими catch-блоками.

* Try-with-resources. Эта контрукция позволяет после слова try в скобках указать открываемые ресурсы, которые сами закроются после окончания конструкции try () {} catch{}. В качестве ресурса в данной конструкции может быть использован любой объект, реализующий интерфейс AutoCloseable.
Во время закрытия ресурсов тоже может быть брошено исключение. В try-with-resources добавлена возможность хранения «подавленных» исключений, и брошенное try-блоком исключение имеет больший приоритет, чем исключения, получившиеся во время закрытия. Получить последние можно вызовом метода getSuppressed() от исключения, брошенного try-блоком.

* Rethrowing. Перебрасывание исключений с улучшенной проверкой соответствия типов.
Компилятор Java SE 7 тщательнее анализирует перебрасываемые исключения. Рассмотрим следующий пример:

static class FirstException extends Exception { }
static class SecondException extends Exception { }
public void rethrowException(String exceptionName) throws Exception {
try {
if («First».equals(exceptionName)) {
throw new FirstException();
} else {
throw new SecondException();
}
} catch (Exception ex) {
throw e;
}
}

В примере try-блок может бросить либо FirstException, либо SecondException. В версиях до Java SE 7 невозможно указать эти исключения в декларации метода, потому что catch-блок перебрасывает исключение ex, тип которого — Exception.

В Java SE 7 вы можете указать, что метод rethrowException бросает только FirstException и SecondException. Компилятор определит, что исключение Exception ex могло возникнуть только в try-блоке, в котором может быть брошено FirstException или SecondException. Даже если тип параметра catch — Exception, компилятор определит, что это экземпляр либо FirstException, либо SecondException:

public void rethrowException(String exceptionName) throws FirstException, SecondException {
try {
//…
} catch (Exception e) {
throw e;
}
}

Если FirstException и SecondException не являются наследниками Exception, то необходимо указать и Exception в объявлении метода.

10. Аннотации используются для размещения рядом с классом, полем, методом или переменой какой-то дополнительной, служебной информации (метаданных), относящейся к ней. Чтобы указать аннотацию, надо над заголовком класса или метода, либо надо объявлением поля или переменной, написать после @ название аннотации (класса аннотации), например так:

@Override
public void doSomeThing() {
}


Кроме того, у аннотации могут быть свойства, они указывают в скобках через запятую в виде пар «ключ=значение», где в качестве ключа выступает название свойства, а качестве значения — собственно, значение, которое должно принять это свойство. Выглядит это так:
@CatInfo(manager=Catmanager.class, unique=true)
class Cat {}
Если указывается указывает значение только для одного свойства, то имя свойства и знак равно можно не писать: @SuppressWarnings(«unchecked).
Также можно вообще не ставить скобки, если никаким свойствам не присваиваются никакие значения.
Чтобы создать свою аннотацию, надо указать модификатор доступа, потом после пробела ключевое слово „@interface“ и дальше опять после пробела имя аннотации (принять начинать его с большой буква). Дальше идёт тело аннотации в фигурных скобках. Внутри тела указываются свойства в виде объявлений методов (как в интерфейсах). Также у свойств можно указать значения по умолчанию (они их будут принимать, если при указании аннотации в нужном месте, этому свойству не будет присвоено какое-то значение). Всё вместе это выглядит так:
@interface CatManager
{
Class manager();
boolean unique();
String name() default „Unknown Cat“;
}

Аннотации выполняют следующие функции:
а) дают необходимую информацию для компилятора;
б) дают информацию различным инструментам для генерации другого кода, конфигураций и т. д.;
в) могут использоваться во время работы кода;
е) повышают читабельность кода и его понимание программистами.
На данный момент компилятором используют три аннотации: @Deprecated, @Override и @SuppressWarnings. Первой аннотацией помечаются устаревшие методы и классы, нерекомендованные к использованию (комплятор по их поводу показывает предупреждение). Вторая аннтоцая ставится над переопределёнными методами класса-наследника (это позволяет контролировать связь между исходным методом и переопределённым). Третья аннотация позволяет подавлять (не выводить) некоторые исключительные предупреждения, обычно выводимые компилятором в связи с данным методом или классом (например, что он уже устарел и нерекомендован к использованию).

Не нашёл ответов на вопросы собеседований из уровня 37 - выкладываю свои

Здравствуйте. Опять-таки, не нашёл ответов и на эти вопросы. Решил выложить ответы, которые я составил для себя.

Вот, собственно вопросы:
Вопросы к собеседованию:
1. Что такое паттерны проектирования?
2. Какие паттерны проектирования вы знаете?
3. Расскажите про паттерн Singleton? Как сделать его потокобезопасным?
4. Расскажите про паттерн Factory?
5. Расскажите про паттерн AbstractFactory
6. Расскажите про паттерн Adaper, его отличия от Wrapper?
7. Расскажите про паттерн Proxy
8. Что такое итератор? Какие интерфейсы, связанные с итератором, вы знаете?
9. Зачем нужен класс Arrays?
10. Зачем нужен класс Collections?

А вот мои ответы:
Мои ответы:

1. Паттерны проектирования — это устоявшиеся удачные решения самых распространнёх проблем, возникающих при проектировании и разработке программ или их частей.

2. Singleton, Factory, Abstract Factory, Template method, Strategy, Pool, Adapter, Proxy, Bridge, MVC.

3. Когда нужно, чтобы в программе существовал только один экземпляр какого-то класса, то применяют паттерн Singleton. Он выглядит так (lazy initialization):
clas Singleton {
private Singleton instance;
private Singleton() {}
public static Singletot getInstance() {
if (instance == null)
instance = new Singleton();
return instance;
}
}

Чтобы сделать его потокобезопасным, можно добавить к методу getInstance() модификатор synchronized. Но это будет не самым лучшим решением (зато самым простым). Гораздно лучшее решение — это написать метод getInstance таким образом (double-checked locking):
public static synchronized Singleton getInstance() {
if (instance == null)
synchronized(Singleton.class) {
instance = new Singleton();
}
return instance;
}

4. Паттерн Factory — это порождающий паттерн. Он позволяет создавать объекты по требованию (например, при определённых условиях). Выглядит это так:
class Factory{
public static Object1 getObject1() {
return new Object1();
}

public static Object2 getObject2() {
return new Object2();
}

public static Object3 getObject3() {
return new Object3();
}
}

Также существует разновидность этого паттерна под названием FactoryMethod. Согласно этому паттерну, в одном методе создаются разные объекты, в завимости от поступающих входных данных (значений параметров). Все эти объекты должны иметь общего предка (или один общий реализуемый интерфейс). Выглядит он так:

class FactoryMethod {
public enum TypeObject {
TYPE1,
TYPE2,
TYPE3
}

public static CommonClass getObject(TypeObject type) {
switch(type) {
case TYPE1:
return new Object1();
case TYPE2:
return new Object2();
case TYPE3:
return new Object3();
default:
return null;
}
}
}

Классы Object1, Object2 и Object3 наследуются от класса CommonClass.

5. Паттерн Abstract Factory — это также порождающий шаблон проектирования. Согласно этому паттерну, создаётся некоторая абстрактная фабрика, служащая шаблоном для нескольких конкретных фабрик. Можно привести такой пример:
class Human {}

class Boy extends Human {}
class TeenBoy extends Human {}
class Man extends Human {}
class OldMan extends Human {}

class Girl extends Human {}
class TeenGirl extends Human {}
class Woman extends Human {}
class OldWoman extends Human {}

interface AbstractFactory {
Human getPerson(int age);
}

class FactoryMale implements AbstractFactory {
public Human getPerson(int age) {
if (age < 12)
return new Boy();
if (age >= 12 && age <= 20)
return new TeenBoy();
if (age > 20 && age < 60)
return new Man();
return new OldMan();
}
}

сlass FactoryFemale implements AbstractFactory {
public Human getPerson(int age) {
if (age < 12)
return new Girl();
if (age >= 12 && age <= 20)
return new TeenGirl();
if (age > 20 && age < 60)
return new Woman();
return new OldWoman();
}
}

6. Паттерн Adapter — это структурный паттерн. Его реализация позволяет использовать объект одного типа там, где требуется объект другого типа (обычно это абстрактные типы). Пример реализации этого паттерна:
interface TotalTime {
int getTotalSeconds();
}
interface Time {
int getHours();
int getMinutes();
int getSeconds();
}

class TimeAdapter extends TotalTime {
private Time time;
public TimeAdapter(Time time) {
this.time = time;
}
public int getTotalTime() {
return time.getSeconds + time.getMinutes * 60 + time.getHours * 60 * 60;
}
}

class TotalTimeAdapter extends Time {
private TotalTime totalTime;
public TotalTimeAdapter(TotalTime totalTime) {
this.totalTime = totalTime;
}

public int getSeconds() {
return totalTime % 60;
}

public int getMinutes() {
return (totalTime / 60) % 60;
}

public int getHours() {
return totaltime/ (60 * 60);
}
}

class Main {
public static void main(String[] args) {
Time time = new Time() {
public int getSeconds() {
return LocalTime.now().getSecond();
}

public int getMinutes() {
return LocalTime.now().getMinute();
}

public int getHours() {
return LocalTime.now().getHour();
}
};

TotalTime totalTime = new TimeAdapter(time);
System.out.println(totalTime.getTotalSeconds());

TotalTime totalTime2 = new TotalTime() {
public int getTotalSeconds() {
LocalTime currTime = LocalTime.now();
return currTime.getSecond() + currTime.getMinute * 60 + currTime.getHour * 60 * 60;
}
};

Time time2 = new TotalTimeAdapter(totalTime2);
System.out.println(time2.getHours + ":" + time2.getMinutes() + ":" + time2.getSeconds());
}
}

При реализации паттерна Wrapper создаётся класс, который оборачивает исходный класс и реализует тот же интерфейс, который реализует исходный класс. Таким образом, это позволяет расширить функциональность исходного класса и использовать новый класс там, где ожидается использование исходного класса. Это отличается от реализации паттерна Adapter тем, что в данном случае используется один интерфейс (тот же, что есть у исходного класса). В паттерне Adapter же используется два интерфейса, и класс, который оборачивает экземпяр исходного класса, реализует совсем другой инферфейс, не интерфейс исходного класса.

7. Паттерн Proxy — это структурный паттерн проектирования. Он нужен для того, чтобы контролировать доступ к какому-то объекту. Для этого пишется класс по типу «обёртка», то есть внутрь класса передаётся исходный объект, реализующий некий интерфейс, сам класс тоже реализует этот интерфейс, и в каждом методе этого класса вызывается похожий метод у исходного объекта. Реализация того же интерфейса, что и у исходного объекта, позволяет подменить исходный объект прокси-объектом. Также это позволяет, не меняя исходного объекта, «навешивать» на его методы какуют-то специальную дополнительную функциональность (например, логирование, проверка прав доступа, кэширование и т.д.). Пример:
interface Bank {
void setUserMoney(User user, double money);
double getUserMoney(User user);
}

class CitiBank implements Bank { //оригинальный класс
public void setUserMoney(User user, double money) {
UserDAO.update(user,money);
}

public double getUserMoney(User user) {
UserDAO.getUserMoney(user);
}
}

class SecurityProxyBank implements Bank {
private Bank bank;

public SecurityProxyBank(Bank bank) {
this.bank = bank;
}
public void setUserMoney(User user, double money) {
if (!SecurityManager.authorize(user,BankAccounts.Manager)
throw new SecurityException(«User can't change money value»);

UserDAO.update(user,money);
}

public double getUserMoney(User user) {
if (!SecurityManager.authorize(user,BankAccounts.Manager)
throw new SecurityException(«User can't get money value»);

UserDAO.getUserMoney(user);
}

8. Итератор — это специальный внутренний объект коллекции, который позволяет последовательно перебирать элементы этой коллекций. Этот объект должен реализовывать интерфейс Iterator, либо ListIterator(для списков). Также, для того, чтобы перебирать элементы коллекции, коллекция должна поддерживать интерфейс Iterable. Интерфейс Iterableсодержит всего один метод — iterator(), который позволяет извне получить доступ к итератору коллекции. Интерфейс Iteratorсодержит следующие методы:

boolean hasNext() — проверяет, есть ли в коллекции ещё какой-то элемент
E next() — позволяет получить очередной элемент коллекции (после получения элемента, внутренний курсор итератора передвигается на следующий элемент коллекции)
void remove() — удаляет текущий элемент из коллекции

Интерфейс же ListIteratorсодержит такие методы:
boolean hasNext() — проверяет, существуют ли ещё один элемент в коллекции (следующий за текущим)
E next() — возвращает очередной элемент коллекции (и передвигает внутренний курсок итератора на следующий элемент)
int nextIndex() — возвращает индекс следующего элемента
void set(E e) — устанавливает значение текущего элементаvoid add(E e) Добавляет элемент в конец списка.
boolean hasPrevious() — проверяет, существует ли какой-то элемент в коллекции перед данным элементом
E previous() — возвращает текущий элемент коллекции и переводит курсор на предыдущий элемент коллекции
int previousIndex — возвращает индекс предыдущего элемента коллекции
void remove() — удаляет текущий элемент коллекции
void add(E e) — добавляет элемент e после текущего элемента коллекции

9. Класс Arrays — это утилитарный класс, предназначенный для разнообразных манипуляций с массивами. В этом классе есть методы превращения массива в список, поиска по массиву, копирования массива, сравнения массивов, получения хешкода массива, представление массива в виде строки и др.

10. Класс Collections — это утилитарный класс для работы с коллекциями. В этом классе есть методы добавления элементов в коллекцию, наполнения коллекции элементами, поиска по коллекции, копировании коллекции, сравнения коллекции, нахождения максимального и минимального элементов коллекции, а также методы получения специфический модификаций коллекций известных типов (например, можно получить потокобезопасную коллекции или неизменяемую коллекцию с одним элементом).

36 уровень - тоже не нашёл ответы на вопросы из собеседований.

Опять-таки всё перерыл, ответов не нашёл. Что ж. Выложу свои, хотя я писал их чисто для себя, и по возможности — кратко. Но всё лучше, чем ничего. Итак, были такие вопросы:
Вопросы к собеседованию:
1. Что такое MVC?
2. Что такое DAO и DTO?
3. Что такое POJO?
4. Что такое Entity?
5. Какие коллекции-списки вы знаете?
6. Какие коллекции-множества вы знаете?
7. Что такое map, чем он отличается от «словаря»?
8. Что такое Queue и Dequeue?
9. Какие классы, реализующие интерфейс Queeue вы знаете?
10. Что такое дерево?

А теперь мои ответы:
1. MVC — это такой паттерн проектирования приложение, при котором приложение разделяется на три отдельные части: модель (model), представление (view) и контроллер (controller). Модель предоставляет данные и реагируется на команды контроллера, изменяя своё состояние. Представление отвечает за отображение данных модели пользователю, реагируя на изменения модели. А контроллер интерпретирует действия пользователя, оповещая модель о необходимости изменений. Таким образом каждый из компонентов этой схемы слабо связан с другими компонентами, за счёт чего достигается гибкость программы. Чаще всего вся бизнес-логика размещается в модели, хотя иногда она содержится и в контроллере. В первом случае модель называют тонкой, в последнем — толстой.

2. DAO (Data Access Object) — это объект, основная задача которого сохранять данные в базу данные, а также извлекать их из неё. DTO (Data Transfer Object) — это объект, предназначенный для транспортировки данных. Поэтому его основная задача — хранить эти данные. Никакой логики он не содержится. Кроме того, он должен быть сериализуемым, так как транспортировка объектов обычно происходит с помощью сериализации-десериализации.

3. POJO переводится как «объект Java в старом стиле». Их противопоставляют EJB-объектами. Последние следуют специальной конвенции и обычно жёстко привязаны к какому-то конкретному enterprise-фреймворку (например, у них должен быть публичный конструктор без параметров, должен быть геттеры и сеттеры для полей, они должны быть сериализуемыми и т.д.). POJO — это, соответственно, обычный класс, не наследующий ни от каких специальных классов и не реализующий никаких специальных библиотек. Обычно POJO ничего особенного не делает, и содержит только состояние.

4. Entity Bean – это бин, цель которого хранить некоторые данные. В логику такого бина встроен механизм сохранения себя и своих полей в базу данных. Такой объект может быть уничтожен, а потом воссоздан из базы заново. Но кроме хранения данных у него нет никакой логики. А бин в свою очередь — это особый класс, которые должен выполнять следующие правила:
а) Класс должен иметь конструктор без параметров, с модификатором доступа public. Такой конструктор позволяет инструментам создать объект без дополнительных сложностей с параметрами.
б) Свойства класса должны быть доступны через get, set и другие методы (так называемые методы доступа), которые должны подчиняться стандартному соглашению об именах. Это легко позволяет инструментам автоматически определять и обновлять содержание bean’ов. Многие инструменты даже имеют специализированные редакторы для различных типов свойств.
в) Класс должен быть сериализуем. Это даёт возможность надёжно сохранять, хранить и восстанавливать состояние bean независимым от платформы и виртуальной машины способом.
г) Класс должен иметь переопределенные методы equals(), hashCode() и toString().

5. Все коллекции-списки реализуют интерфейс Listи наследуются от абстрактного класса AbstractList. Среди них можно выделить ArrayListи LinkedList. ArrayList — это список, основаный на массиве, а LinkedList — это классический двусвязный список.

6. Коллекции-множества в Java реализуют интерфейс Setи наследуются от AbstractSet. Множества — это такие наборы данных, в которых все элементы уникальны. Среди них в Java есть HashSet, LinkedHashSet и TreeSet. Первая коллекция хранит свои объекты на основе хеш-кодов. Вторая — это модифицированная первая, в ней элементы ещё к тому же располагаются в связном списке, поэтому они все расположены в порядке добавления. Третья коллекция обеспечивает сортировку своих элементов.

7. Map — это вид коллекций, хранящих свои элементы в виде пар «ключ — значения». Причём все ключи должны быть уникальными. Среди реализаций есть HashMap и TreeMap. Первая реализация хранит элементы с использованием хэш-кодов. Вторая — хранит элементы в отсортированном по ключу порядке.

8. Очередь (Queue) — это структура данных, работающая по принципу «Первый вошёл — первый вышел». То есть элементы в очередь добавляются с одного конца, а извлекаются — с другого. Deque — это двусторонняя очередь. В этой очереди элементы можно добавлять как в начало, так и в конец, а также брать элементы тоже можно и из начала, и из конца очереди. Соответственно есть методы, которые позволяю положить элемент (это методы add(e) и offer(e)), и есть методы, позволяющие извлечь элемент из очереди (это такие методы, как remove() и poll()). Кроме того, есть методы, которые позволяют просто получить элемент из очереди без его удаления оттуда (это методы element() и peek()). В интерфейсе Deque дополнительно есть методы для добавления элементов в начало и конец очереди, извлечения элементов из начала или конца, а также получения элементов из начала или конца очереди (без их удаления из очереди).

9. Среди простых реализаций можно отметить ArrayDeque, LinkedList и PriorityQueue. Также существуют много классов в Concurrent Collections, которые реализуют эти два интерфейса (оба сразу или только один из них).

10. Дерево — это связный граф без петель и кратных рёбер. Обычно, если в дереве N вершин, то количество рёбер как минимум — N-1. Также одну вершину в дереве выбирают в качестве корня. Остальные вершины объявляют ветвями. Ветви, у которых нет своих ветвей, называются листьями дерева.
В программировании деревья используются довольно широко, и придумано уже много видов этого дерева. Одно из самых широкоприменяемых деревьев — это бинарное дерево. В этом дереве у каждого элемента имеется не больше двух потомков (то есть может быть от 0 до 2). Одной из разновидностью двоичного дерева является BST — бинарное дерево поиска. В этом дереве на элементы накладывается правило: левый потомок элемента должны быть по значению меньше его, а правый — по значению больше его или равен ему.
Также ещё существуют красно-чёрные деревья. Это разновидность двоичных деревьев поиска. В красно-чёрных деревьх вводится ещё одно свойство элемента — цвет. Цвет может быть чёрный или красный. Также каждое красно-чёрное дерево должно удовлетворять следующим требованиям:
1) корень дерева — чёрный;
2) узел либо красный, либо чёрный;
3) все листья дерева — чёрные;
4) оба потомка красно узла — чёрные;
5) всякий путь от данного узла до любого листового узла, являющегося его потомка, содержит одинаковое количество чёрных узлов.

Эти правила позволяют добиться сбалансированности дерева. Дерево сбалансированно, когда длина пути от корня до любого листового узла отличается не более, чем на 1. (То есть по-простому, в дереве нет перекосов и длинных ветвей.)

Что-то не нашёл ответов на вопросы из собеседований на 34 левеле

Поискал на сайте родным поиском и с помощью гугла всё облазил — нет ответов на вопросы из этого левела. Может я что-то пропустил, и они всё-такие где-то есть здесь на сайте!?

На всякий случай прикладываю ответы, которые я написал для себя:
Вопросы к собеседованию:
1. Что такое сборка мусора?
2. Когда вызывается метод finalize?
3. Что произойдет, если в методе finalize возникнет исключение?
4. Что такое SoftReference?
5. Что такое WeakReference?
6. Что такое PhantomReference?
7. Как работает WeakHashMap? Где он используется?
8. Зачем нужно передавать очередь в конструктор PhantomReference?
9. Зачем нужен логгер?
10. Какие настройки логгера вы знаете?


Мои ответы:
1. Это механизм уничтожения ненужных объектов. Ненужные объекты — это неиспользуемые объекты. Существует два способа поиска таких объектов: подсчёт ссылок и трассировка. В первом случае с каждым объектом связывается некоторая переменная, которая хранит количество ссылок на этот объект. Если это количество опускается до нуля, то объект считается мёртвым. Во втором случае сборщик мусора идёт по ссылкам объектов из корневых точек до конца (до значения нулл), обходя всё это дерево. Объекты, до которых он не может добраться из корневых точек, считаюся мёртвыми. Корневыми точками считаются все активные нити, метод main, аргументы метода main(), а также все статические переменные класса, в которой находится метод main().
Определение объектов, пригодных к уничтожению — это только первая часть работы сборщика мусора. Вторая часть — это собственно их удаление и работа с памятью. Здесь используется гибридный подход. Вся доступная для объектов память разделяется на три области: область молодых объектов, область старых объектов и область перманентных объектов (это классы, метаданные, интернированные строки и т.д.). Первая область разделяется ещё на три подобласти: на Eden и suvivor space 1 и 2. В Eden хранятся все только созданные объекты. В остальных двух зонах хранятся объекты, выживщие после последней сборки мусора. Сборщик мусора работает со всей этой областью (областью молодых объектов) следующим образом. Во время очередной сборки мусора он находит живые объекты в области Eden и копирует их во вторую область выживших. После этого он в первой области также ищет живые объекты и копирует их либо в вторую область выживших, либо, если они уже достаточно «старые» — область старого поколения. После этого он очищает область Eden и первую область выживших. Дальше он считает вторую область выживших первой. И всё, на это сборка мусора заканчивается для этой области.
Для второй области сборка мусора идёт несколько по-другому. Там есть одна большая область, она ни на что не делится, но сборщик мусора все живые объекты в ней во время своей работы перемещает в начало области. Соответственно, вторая часть области будет состоять только из пустого пространства и мёртвых объектов. После этого сборщик мусора завершает свою работу.

2. Перед уничтожение объекта сборщиком мусора. Также можно вручную запустить вызовы этого метода у всех недостижимых объектов, для этого надо вызвать метод System.runFinalization() или Runtime.getRuntime().runFinalization().

3. Это исключение будет проигнорировано, и произойдёт выход из метода.

4. SoftReference переводится как «мягкая ссылка». Эта ссылка на объект, но более слабая, чем обычная ссылка (StrongReference). Объекты, на которые сущесвуют только мягкие ссылки, называются мягкодостижимыми. Такие объекты не уничтожаются в обычном случае. Но если у JVM закочиналась память, то сборщик мусоры удаляет все такие объекты.

5. WeakReference — это так называемая слабая ссылка на объект. Она ещё слабее Soft-ссылки. Все объекты, на которые существуют только слабые ссылки, будут удалены при ближайщей сборке мусора.

6. PhantomReference — это самая слабая ссылка. Механизм работы с такими ссылка запускается только если на объект нет больше никаких других ссылок. Призрачные ссылки используются для сложной процедуры удаления объекта. Это может быть необходимо, если объект делает что за граница Java-машины, например, вызывает низкоуровневые функции ОС или пишет своё состояние в файл, или делает ещё что-то важное и сложное.
Механизм работы с такими ссылками следующий. Если на объект не осталось больше никаких других ссылок, и у него переопределён метода finalize(), то этот метода будет вызван во время ближащей сборки мусора. Если же этот метод не переопределён, то этот объект пропускает текущую сборку мусора, и попадает только в следующую. Во время этой (следующей) сборки мусора данный объект помещается в очередь призрачных объектов, из которой будет удалён, когда у его призрачной ссылки вызовут метод clear(). Также стоит отметить, что метода get() у призрачной ссылка всегда возвращает null (в отличие от двух других несильных ссылок, у которых он возвращает null, только если объект уже уничтожен).

7. WeakHashMap — это HashMap, у которого ключами являются слабые ссылки. Поэтому, если во время ближайшей сборки мусора будет обнаружено, что на объект существует только ссылка в WeakHashMap, то из WeakHashMap будет удалена вся пара «ключ-значение», связанная с этим объектом.
В связи с этим данная коллекция может быть использована для хранения какой-то дополнительной, не очень важной информации об объекте. Также её удобно использоваться для хранения какой-то временной информации (которая нужная только в рамках данной операции).

8. Эта очередь используется для отслеживания того, что объект больше не нужен. Может быть использовано для закрытия ресурсов, открытых данным объектом (например, удаление созданных файлов).

9. Логгер нужен для сохранения информации о поведении программы, а также некоторых её состояниях. Может быть использован для отладки и выявления ошибок в работе программы и сбоев. Также логгер является позволяет разработчику получать обратную связь от своей программы во время её работы. Кроме того, при критических сбоях логгер может оперативно оповещать нужных людей (например, разработчиков, клиентов, менеджеров проектов, службу техподдержки и т.д.) об этих сбоях.

10. При настройки логгрирования можно указать следующие вещи:
а) место, куда будет писаться информация (файл, консоль, база данных, сеть и т.д.)
б) сообщения какого уровня будут записываться
в) вид записей в логе
г) для файлов можно указать: путь к файлу и каталогу, размер файлов, количество файлов
е) указать для каждого отдельного пакета свой уровень сообщений, которые будут писаться в лог

task40.task4008 | level40.lesson40.task02 - РЕШЕНО

Не могу пройти валидацию. Одно требование я выполнил, из тех, что не проходили, но ещё два — никак. Уже не знаю, что делать.

Вот условие задачи:

Работа с Java 8 DateTime API
Выполни задание, используя Java 8 DateTime API.
Реализуй метод printDate(String date).
Он должен в качестве параметра принимать дату (в одном из 3х форматов)
и выводить ее в консоль в соответствии с примером:
1) Для «21.4.2014 15:56:45» вывод должен быть:
День: 21
День недели: 1
День месяца: 21
День года: 111
Неделя месяца: 4
Неделя года: 17
Месяц: 4
Год: 2014
AM или PM: PM
Часы: 3
Часы дня: 15
Минуты: 56
Секунды: 45
2) Для «21.4.2014»:
День: 21
День недели: 1
День месяца: 21
День года: 111
Неделя месяца: 4
Неделя года: 17
Месяц: 4
Год: 2014
3) Для «17:33:40»:
AM или PM: PM
Часы: 5
Часы дня: 17
Минуты: 33
Секунды: 40

А вот мой код:

public static void printDate(String date) {
            //напишите тут ваш код
            if (date == null || (date != null && date.isEmpty()))
                return;
            try {
                LocalDate localDate = LocalDate.parse(date,DateTimeFormatter.ofPattern("d.M.u"));
                System.out.println("День: " + localDate.get(ChronoField.DAY_OF_MONTH));
                System.out.println("День недели: " + localDate.getDayOfWeek().getValue());
                System.out.println("День месяца: " + localDate.getDayOfMonth());
                System.out.println("День года: " + localDate.getDayOfYear());
                System.out.println("Неделя месяца:  " + localDate.format(DateTimeFormatter.ofPattern("W")) /*+ " " +  (localDate.get(ChronoField.ALIGNED_WEEK_OF_MONTH) + 1 )*/);
                System.out.println("Неделя года: " + (localDate.get(ChronoField.ALIGNED_WEEK_OF_YEAR) + 1));
                System.out.println("Месяц: " + localDate.getMonthValue());
                System.out.println("Год: " + localDate.getYear());
                return;
            } catch (DateTimeParseException e) {
            }
            try {
                LocalTime localTime = LocalTime.parse(date,DateTimeFormatter.ofPattern("H:m:s"));
                System.out.println("AM или PM: " + ((localTime.get(ChronoField.AMPM_OF_DAY) == 0)? "AM":"PM"));
                System.out.println("Часы: " + localTime.get(ChronoField.HOUR_OF_AMPM));
                System.out.println("Часы дня: " + localTime.get(ChronoField.HOUR_OF_DAY));
                System.out.println("Минуты: " + localTime.getMinute());
                System.out.println("Секунды: " + localTime.getSecond());
                return;
            } catch (DateTimeParseException e) {
            }
            try {
                LocalDateTime dateTime = LocalDateTime.parse(date,DateTimeFormatter.ofPattern("d.M.u H:m:s"));
                System.out.println("День: " + dateTime.get(ChronoField.DAY_OF_MONTH));
                System.out.println("День недели: " + dateTime.getDayOfWeek().getValue());
                System.out.println("День месяца: " + dateTime.getDayOfMonth());
                System.out.println("День года: " + dateTime.getDayOfYear());
                System.out.println("Неделя месяца:  " + dateTime.format(DateTimeFormatter.ofPattern("W")) /*(dateTime.get(ChronoField.ALIGNED_WEEK_OF_MONTH) + 1 )*/);
                System.out.println("Неделя года: " + (dateTime.get(ChronoField.ALIGNED_WEEK_OF_YEAR) + 1));
                System.out.println("Месяц: " + dateTime.getMonthValue());
                System.out.println("Год: " + dateTime.getYear());
                System.out.println("AM или PM: " + ((dateTime.get(ChronoField.AMPM_OF_DAY) == 0)? "AM":"PM"));
                System.out.println("Часы: " + dateTime.get(ChronoField.HOUR_OF_AMPM));
                System.out.println("Часы дня: " + dateTime.get(ChronoField.CLOCK_HOUR_OF_DAY));
                System.out.println("Минуты: " + dateTime.getMinute());
                System.out.println("Секунды: " + dateTime.getSecond());
                return;
            } catch (DateTimeParseException e) {
            }
        }


Не проходят эти требования:
1. Если в метод printDate передана дата в формате «дата время», он должен вывести: День, День недели, День месяца, День года, Неделя месяца, Неделя года, Месяц, Год, AM или PM, Часы, Часы дня, Минуты, Секунды.
2. Если в метод printDate передана дата в формате «дата», он должен вывести: День, День недели, День месяца, День года, Неделя месяца, Неделя года, Месяц, Год.

А эти — проходят:

3. Если в метод printDate передана дата в формате «время», он должен вывести: AM или PM, Часы, Часы дня, Минуты, Секунды.
4. Используй статический метод parse классов LocalDate и LocalTime.


Сам думаю на вывод дня и вывод номера недели (в месяце). Также может быть что-то в выводе номера недели в году. Но это всё работает. Сравнивал с предыдущей задачей, которая прошла.

Level36.lesson06.task01 | tast36.task3602

Не получается решить. Условие задачи:
Найти класс по описанию

Описание класса:

1. Реализует интерфейс List;

2. Является приватным статическим классом внутри популярного утилитного класса;

3. Доступ по индексу запрещен — кидается исключение IndexOutOfBoundsException.

Используя рефлекшн (метод getDeclaredClasses), верни подходящий тип в методе getExpectedClass.

Вот мой код:

public static Class getExpectedClass() {

        Class[] classes = Collections.class.getDeclaredClasses();
        for (Class classOfClasses: classes) {
            if (!List.class.isAssignableFrom(classOfClasses))
                continue;

            int modifiersOfClass = classOfClasses.getModifiers();
            boolean hasPrivateStaticModifiers = false;
            if (Modifier.isPrivate(modifiersOfClass) && Modifier.isStatic(modifiersOfClass))
                hasPrivateStaticModifiers = true;

            if (! hasPrivateStaticModifiers)
                continue;

            Method[] methodsOfClass = classOfClasses.getDeclaredMethods();
            boolean isDisallowedAccessByIndex = false;
            for (Method methodOfClass: methodsOfClass) {

                Class[] params = methodOfClass.getParameterTypes();

                boolean hasIntegerParam = false;
                for (Class paramClass: params) {
                    if (paramClass.equals(int.class) || paramClass.equals(Integer.class)) {
                        hasIntegerParam = true;
                        break;
                    }
                }

                boolean throwsIndexOutOfBoundsException = false;
                if (hasIntegerParam) {
                    Object[] inputObjects  = new Object[params.length];
                    for (int i = 0; i < inputObjects.length; i++) {
                        try {
                            boolean isLong = params[i].equals(long.class);
                            boolean isInt = params[i].equals(int.class);
                            boolean isShort = params[i].equals(short.class);
                            boolean isByte = params[i].equals(byte.class);
                            boolean isChar = params[i].equals(char.class);
                            boolean isFloat = params[i].equals(float.class);
                            boolean isDouble = params[i].equals(double.class);
                            boolean isBoolean = params[i].equals(boolean.class);
                            boolean isString = params[i].equals(String.class);


                            if (isLong || isInt || isShort || isByte)
                                inputObjects[i] = 1;
                            else if (isChar)
                                inputObjects[i] = 'a';
                            else if(isFloat || isDouble)
                                inputObjects[i] = 1.0f;
                            else if (isBoolean)
                                inputObjects[i] = true;
                            else if (isString)
                                inputObjects[i] = "aaa";
                            else
                                inputObjects[i] = params[i].newInstance();

                        } catch (InstantiationException|IllegalAccessException e) {
                            e.printStackTrace();
                        }
                    }

                    if (Modifier.isPrivate(methodOfClass.getModifiers()))
                        methodOfClass.setAccessible(true);
                    if (Modifier.isStatic(methodOfClass.getModifiers())) {
                        try {
                            methodOfClass.invoke(null, inputObjects);
                        } catch (IllegalAccessException|InvocationTargetException e) {
                            e.printStackTrace();
                        } catch (IndexOutOfBoundsException e) {
                            throwsIndexOutOfBoundsException = true;
                        }
                    }
                    else {
                        try {
                            Object instanceOfClass = null;
                            try {
                                instanceOfClass = classOfClasses.newInstance();
                            } catch (InstantiationException e) {
                                Constructor constructor = classOfClasses.getDeclaredConstructors()[0];
                                Class[] paramsConstr = constructor.getParameterTypes();
                                Object[] inputObjectsInConstr  = new Object[paramsConstr.length];
                                for (int i = 0; i < inputObjectsInConstr.length; i++) {
                                    try {
                                        boolean isLong = paramsConstr[i].equals(long.class);
                                        boolean isInt = paramsConstr[i].equals(int.class);
                                        boolean isShort = paramsConstr[i].equals(short.class);
                                        boolean isByte = paramsConstr[i].equals(byte.class);
                                        boolean isChar = paramsConstr[i].equals(char.class);
                                        boolean isFloat = paramsConstr[i].equals(float.class);
                                        boolean isDouble = paramsConstr[i].equals(double.class);
                                        boolean isBoolean = paramsConstr[i].equals(boolean.class);
                                        boolean isString = paramsConstr[i].equals(String.class);


                                        if (isLong || isInt || isShort || isByte)
                                            inputObjects[i] = 1;
                                        else if (isChar)
                                            inputObjects[i] = 'a';
                                        else if(isFloat || isDouble)
                                            inputObjects[i] = 1.0f;
                                        else if (isBoolean)
                                            inputObjects[i] = true;
                                        else if (isString)
                                            inputObjects[i] = "aaa";
                                        else
                                            inputObjects[i] = paramsConstr[i].newInstance();

                                    } catch (InstantiationException|IllegalAccessException ex) {
                                        ex.printStackTrace();
                                    }
                                }
                                if (Modifier.isPrivate(constructor.getModifiers()))
                                    constructor.setAccessible(true);
                                try {
                                    instanceOfClass = constructor.newInstance(inputObjectsInConstr);
                                } catch (IllegalAccessException|InstantiationException e1) {
                                    e1.printStackTrace();
                                }

                            }

                            methodOfClass.invoke(instanceOfClass, inputObjects);
                        } catch (IllegalAccessException|InvocationTargetException e) {
                            e.printStackTrace();
                        } catch (IndexOutOfBoundsException e) {
                            throwsIndexOutOfBoundsException = true;
                        }

                    }
                }

                if (hasIntegerParam && throwsIndexOutOfBoundsException)
                    isDisallowedAccessByIndex = true;
            }

            if (isDisallowedAccessByIndex)
                return classOfClasses;
        }


        return null;
    }

Одна строчка выкидывает IllegalAccessException. Такая:

instanceOfClass = constructor.newInstance(inputObjectsInConstr);

Список недобросовестных работодателей

Интересно, а есть среди работодателей недобросовестные!? Или в этой сфере такого не бывает? Слышал, что дают тестовые задания, принимают эти решения, используют их в своих проектах, а тем, кто написал решения этих тестовых заданий — просто отказывают.
Ну это кроме всяких задержек зарплаты и прочего, что есть везде.
Интересует существуют ли такой список где-то здесь или ещё на каких сайтов айтишников.

Пока, собственно интересует Санкт-Петербург. Просто уже месяца два или три периодически мониторю вакансии в этом городе, и уже несколько месяцев висят вакансии одних и тех же фирм. Вот, странно, чего это они там висят!? То ли вакансии липовые, то ли там так хреново, что никто не остаётся надолго, то ли у самой фирмы слишком запредельные требования… странно…

Что такое мьютекс и что такое монитор?

Задался вопросом понять, что есть что. Так как в разных источниках по-разному используют эти термины. И часто даже бывает, что в одной статье что-либо, например, кусок кода, называют монитором, в другой — это называют мьютексом (и бывает наоборот — объект, связанный с данным, и отвечающий на синхронизацию нитей, называют то мьютексом, то монитором). Вот и хочу разобраться, что есть что. (могу, конечно, привести множество цитат из этих источников, где употребляются эти термины, но думаю, это будет избыточно.)
  • ,

level22.lesson05.task01 (task2202) - работает, не проходит проверку - РЕШЕНО

Условие задачи:

Найти подстроку
Метод getPartOfString должен возвращать подстроку начиная с символа после 1-го пробела и до конца слова,
которое следует после 4-го пробела.

Пример:
«JavaRush — лучший сервис обучения Java.»

Результат:
«— лучший сервис обучения»

На некорректные данные бросить исключение TooShortStringException (сделать исключением).

Требования:
1. Класс TooShortStringException должен быть потомком класса RuntimeException.
2. Метод getPartOfString должен принимать строку в качестве параметра.
3. В случае, если строка, переданная в метод getPartOfString содержит менее 4 пробелов должно возникнуть исключение TooShortStringException.
4. Метод getPartOfString должен возвращать подстроку начиная с символа после 1-го пробела и до конца слова, которое следует после 4-го пробела.
Мой код:
package com.javarush.task.task22.task2202;

/* 
Найти подстроку
*/
public class Solution {
    public static void main(String[] args) {
        System.out.println(getPartOfString("JavaRush - лучший сервис обучения Java."));
        System.out.println(getPartOfString("JavaRush - лучший сервис обучения."));
        System.out.println(getPartOfString("JavaRush - лучший сервис."));

    }

    public static String getPartOfString(String string) throws TooShortStringException {
        int index = 0;
        /*for (int i = 0, j = 0; i < 4; i++) {
            index = string.indexOf(' ',j);
            if (index < 0) throw  new TooShortStringException();
            j = index + 1;
        }*/
        int count = 0, j = 0;
        while (true) {
            index = string.indexOf(' ',j);
            if (index < 0) break;
            else count++;
            if (count == 4) break;
            j = index + 1;
        }
        //if (count < 4) throw new TooShortStringException();
        int i = index + 1;
        while (!string.substring(i,i+1).matches("^(\\p{Punct}| )$")) {
            i++;
        }
        try {
            String result = string.substring(string.indexOf(' ') + 1, i);
            return result;
        } catch (Exception e) {
            throw new TooShortStringException();
        }
    }

    public static class TooShortStringException extends RuntimeException {
    }
}