fix(guide): simplify directory structure

guide/russian/java/ExceptionHandling

@@ -0,0 +1,34 @@
+---
+title: Exceptions in Java
+localeTitle: Исключения в Java
+---
+## Что такое исключение?
+
+Исключением является нежелательное или неожиданное событие, которое происходит во время выполнения программы, то есть во время выполнения, что нарушает нормальный поток инструкций программы.
+
+## Ошибка против исключения
+
+Ошибка: ошибка указывает на серьезную проблему, которую разумное приложение не должно пытаться поймать. Исключение: Исключение указывает условия, которые разумное приложение может попытаться поймать.
+
+## Иерархия исключений
+
+Все типы исключений и ошибок являются подклассами класса Throwable, который является базовым классом иерархии. Одна ветвь возглавляет Exception. Этот класс используется для исключительных условий, которые пользовательские программы должны улавливать. NullPointerException - пример такого исключения. Другая ветка, ошибка используется системой времени выполнения Java (JVM), чтобы указать на ошибки, связанные с самой средой времени выполнения (JRE). StackOverflowError является примером такой ошибки.
+
+## Как использовать предложение try-catch
+```
+try { 
+ // block of code to monitor for errors 
+ // the code you think can raise an exception 
+ } 
+ catch (ExceptionType1 exOb) { 
+ // exception handler for ExceptionType1 
+ } 
+ catch (ExceptionType2 exOb) { 
+ // exception handler for ExceptionType2 
+ } 
+ // optional 
+ finally { 
+ // block of code to be executed after try block ends 
+ } 
+
+```

guide/russian/java/abstract-class/index.md

@@ -0,0 +1,26 @@
+---
+title: Abstract Classes in Java
+localeTitle: Абстрактные классы в Java
+---
+Давайте обсудим абстрактные классы. Прежде чем погрузиться в этот учебник, вам лучше понять понятия классов и наследование.
+
+Абстрактные классы - это классы, которые могут быть подклассифицированы (т.е. расширены), но не могут быть созданы. Вы можете думать о них как о **классе** интерфейсов, или как о интерфейсе с фактическим кодом, привязанным к методам.
+
+Рассмотрим следующий пример, чтобы понять абстрактные классы: У вас есть класс Vehicle, который определяет определенные базовые функции (методы) и определенные компоненты (объектные переменные), которые должны иметь машины, чтобы их классифицировали как транспортное средство. Вы не можете создать объект транспортного средства, потому что само транспортное средство является абстрактным понятием. Однако вы можете расширить функциональность класса автомобиля, чтобы создать автомобиль или мотоцикл.
+
+\`\` \`java абстрактный класс Автомобиль { // переменная, которая используется для объявления no. колес в транспортном средстве частные внутренние колеса;
+
+// Переменная для определения типа используемого двигателя частный моторный двигатель;
+
+// абстрактный метод, который только объявляет, но не определяет начало // функциональность, поскольку каждый автомобиль использует другой пусковой механизм abstract void start (); }
+
+Открытый автомобиль { ... }
+
+Общественный класс Мотоцикл расширяет автомобиль { ... }
+```
+You cannot create an object of Vehicle class anywhere in your program. You can however, extend the abstract vehicle class and create objects of the child classes; 
+```
+
+Ява Автомобиль newVehicle = новый автомобиль (); // Недействительным Автомобиль car = новый автомобиль (); // действительный Автомобиль mBike = новый мотоцикл (); // действительный
+
+Автомобиль carObj = новый автомобиль (); // действительный Мотоцикл mBikeObj = новый мотоцикл (); // действительный \`\` \`

guide/russian/java/access-modifiers/index.md

@@ -0,0 +1,123 @@
+---
+title: Access Modifiers
+localeTitle: Модификаторы доступа
+---
+# Модификаторы доступа
+
+Вы когда-нибудь хотели определить, как люди будут обращаться к некоторым вашим свойствам? Вы не хотите, чтобы кто-то использовал ваше нижнее белье. Однако ваши близкие друзья и родственники могут использовать ваш свитер и, может быть, ваш автомобиль.
+
+Аналогично тому, как вы устанавливаете уровень доступа к вашим задачам, Java также контролирует доступ. Вы хотите определить уровень доступа для переменных, методов и классов в зависимости от того, к каким другим классам вы хотите получить доступ.
+
+Java предоставляет 4 уровня модификаторов доступа. Это означает, что вы можете изменить доступ к переменной, методу или классу четырьмя способами. Эти 4 способа являются частными, общедоступными, защищенными и дефолтными.
+
+Эти модификаторы доступа могут применяться к полям, методам и классам (классы - это особый случай, мы рассмотрим их в конце этой статьи). Вот краткий обзор 1 того, что `Access Levels` для каждого `Access Modifier` :
+
+#### Модификаторы доступа Таблица Ссылка:
+
+![Таблица модификаторов доступа](https://i.imgur.com/zoMspyn.png)
+
+#### Модификатор частного доступа
+
+Позволяет доступ к переменной или методу только в классе, в котором она была создана. Никакой другой класс за пределами класса, который создал переменную или метод, не может получить к нему доступ. Это близко похоже на ваши внутренние органы. Они доступны только владельцу. Чтобы сделать переменную или метод закрытыми, вы просто добавляете ключевое слово private перед переменной или типом метода. Давайте используем private в примере кодирования. Если банк хочет предоставить процентную ставку в размере 10% по своим кредитам, он будет следить за тем, чтобы переменная процентной ставки (предположим, что `int int_rate;` ) останется частной, так как никто другой класс не попытается получить к ней доступ и не изменит ее. Например;
+
+`private String name;`
+
+В приведенном выше примере создается переменная с именем name и гарантирует, что она доступна только в классе, из которого она была создана.
+
+Другим примером метода является `java private void setAge(){ System.out.println("Set Age"); }` Вышеприведенный пример гарантирует, что метод setAge доступен только в пределах класса, из которого он был создан, и нигде больше.
+
+#### Модификатор общественного доступа
+
+Модификатор открытого доступа является прямой противоположностью модификатора частного доступа. Класс, метод или переменная могут быть объявлены как общедоступные, а это значит, что они доступны из любого класса. Модификатор общедоступного доступа можно сравнить с общеобразовательной школой, где каждый может искать прием и быть допущенным.
+
+Доступ к общедоступному классу, методу или переменной можно получить из любого другого класса в любое время.
+
+Например, чтобы объявить класс общедоступным, все, что вам нужно, это:
+
+```java
+public class Animal{ 
+ 
+ } 
+```
+
+Таким образом, класс Animal может быть доступен любым другим классом.
+
+```java
+public int age; 
+ public int getAge(){ 
+ } 
+```
+
+Выше указаны способы указания переменной и метода как общедоступные.
+
+#### Модификатор доступа по умолчанию
+
+Модификатор доступа по умолчанию отличается от всех других модификаторов доступа тем, что у него нет ключевого слова. Чтобы использовать модификатор доступа по умолчанию, вы просто не используете ни один из других модификаторов доступа, а просто означает, что вы используете модификатор доступа по умолчанию.
+
+Например, чтобы использовать модификатор доступа по умолчанию для класса, вы используете
+
+```java
+class Bird{ 
+ } 
+```
+
+Это в основном означает, что вы используете модификатор доступа по умолчанию. Модификатор доступа по умолчанию позволяет доступным переменным, методам или классам другим классам в одном пакете. Пакет представляет собой набор связанных классов в каталоге файлов. Дополнительные сведения о пакетах см. В разделе о пакетах.
+
+Любая переменная, метод или класс, объявленные для использования модификатора доступа по умолчанию, не могут быть доступны каким-либо другим классом за пределами пакета, из которого он был объявлен.
+
+```java
+int age; 
+ void setNewAge(){ 
+ } 
+```
+
+Выше приведены некоторые способы использования модификатора доступа по умолчанию для переменной или метода. Не забывайте, что модификатор доступа по умолчанию не имеет ключевого слова. Отсутствие трех других модификаторов доступа означает, что вы используете модификатор доступа по умолчанию.
+
+#### Модификатор защищенного доступа
+
+Модификатор защищенного доступа тесно связан с модификатором доступа по умолчанию. Модификатор защищенного доступа имеет свойства модификатора доступа по умолчанию, но с небольшим улучшением.
+
+Переменная и метод - единственные, кто использует модификатор защищенного доступа. Небольшое улучшение заключается в том, что класс вне пакета классов, из которого была объявлена ​​переменная или метод, может получить доступ к указанной переменной или методу. Однако это возможно ТОЛЬКО, если оно наследуется от Класса.
+
+Класс из другого пакета, который может видеть защищенные переменные или методы, должен расширить класс, создавший переменные или методы.
+
+Примечание без преимущества Inheritance, модификатор доступа по умолчанию имеет точно такой же доступ, как и защищенный модификатор доступа.
+
+Примеры использования защищенного модификатора доступа показаны ниже:
+
+```java
+protected int age; 
+ protected String getName(){ 
+  return "My Name is You"; 
+ } 
+```
+
+#### Модификаторы доступа в классах
+
+По умолчанию классы могут иметь только 2 модификатора:
+
+*   общественности
+*   нет модификатора (модификатор по умолчанию)
+
+Таким образом, это означает, что классы никогда не могут быть настроены на `private` или `protected` ?
+
+Это логично, почему вы хотите создать частный класс? Ни один другой класс не сможет его использовать. Но иногда вы можете внедрять класс в другой класс. Эти специальные классы, `inner classes` , могут быть настроены на закрытые или защищенные, чтобы доступ к нему мог только его окружающий класс:
+
+```java
+public class Car { 
+    private String brand; 
+    private Engine engine; 
+    // ... 
+    private class Engine { 
+        // ... 
+    } 
+ } 
+```
+
+В приведенном выше примере только класс `Car` может использовать класс `Engine` . Это может быть полезно в некоторых случаях.
+
+Другие классы никогда не могут быть `protected` и `private` , потому что это не имеет смысла. Модификатор `protected` доступа используется для создания `package-private` но с возможностью доступа к подклассам. В java нет такой концепции, как «подпакеты» или «наследование пакетов».
+
+### источники
+
+[1\. Документы Oracle по модификаторам доступа](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html "Документы Oracle")

guide/russian/java/arraylist/index.md

@@ -0,0 +1,23 @@
+---
+title: ArrayList
+localeTitle: ArrayList
+---
+# ArrayList
+
+ArrayList является частью чего-то, называемого _Framework Collection_ .
+
+Структура _Collection_ состоит из всех интерфейсов и классов, которые могут содержать набор значений (аналогично [массивам](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html) ). **ArrayList** - это класс, который находится в этой иерархии и известен как _**объект Collection**_ . Он реализует интерфейс _List,_ который, в свою очередь, реализует интерфейс _Collection_ . Этот интерфейс _Collection_ можно найти в пакете `java.util` . Вам нужно будет импортировать этот пакет.
+
+ArrayList - это класс, который используется для создания динамических массивов. Он медленнее, чем обычные массивы, но допускает много манипуляций. Его можно инициализировать, чтобы иметь определенный размер, или он будет иметь размер по умолчанию 10 единиц.
+
+`java ArrayList<String> names = new ArrayList<>(); ArrayList<Integer> ages = new ArrayList<>(5);`
+
+В приведенном выше фрагменте угловые брекеты `<>` принимают общий тип данных как аргумент, определяющий тип данных элементов в ArrayList. Первые `names` ArrayList указаны как содержащие элементы _String_ . Таким образом, будет разрешено содержать только элементы String. Его размер не указан, поэтому он будет иметь размер по умолчанию 10. Второй `ages` ArrayList указал, что он будет содержать целые числа. Но ArrayList не может содержать примитивы, он содержит только объекты. Таким образом, чтобы он мог хранить целые числа, поплавки и т. Д., Мы можем использовать классы-оболочки. `names` будут иметь заданный размер 5.
+
+Поскольку ArrayList реализует _List_ , ArrayList может быть создан с использованием следующего синтаксиса: `java List<Integer> students = new ArrayList<>();`
+
+ArrayList является динамическим, то есть он будет увеличиваться по размеру, если потребуется, и аналогичным образом уменьшить размер, если элементы будут удалены из него. Это то, что делает его лучше использовать, чем обычные массивы.
+
+ArrayList позволяет нам случайным образом обращаться к элементам. ArrayList очень похож на _Vector_ во многих отношениях. Но это быстрее, чем векторы. Главное отметить, что - векторы быстрее, чем массивы, но ArrayLists - нет.
+
+Поэтому, когда дело доходит до выбора между двумя - если скорость критическая, следует учитывать Vectors, иначе ArrayLists лучше, когда дело доходит до хранения большого количества элементов и эффективного доступа к ним.

guide/russian/java/arrays/index.md

@@ -0,0 +1,186 @@
+---
+title: Arrays
+localeTitle: Массивы
+---
+# массив
+
+Массив представляет собой набор значений (или объектов) похожих типов данных (примитив и ссылка на оба вида типов данных разрешены), которые хранятся в адресах последовательной памяти. Массив используется для хранения коллекции похожих типов данных. Массивы всегда начинаются с индекса 0 и создаются с заданным числом индексов. Все переменные в массиве должны быть одного типа, объявленного при создании экземпляра.
+
+**Синтаксис:**
+
+```java
+dataType[] arrayName;   // preferred way 
+```
+
+Здесь `java datatype[]` описывает, что все переменные, указанные после него, будут созданы как массивы указанного типа данных. Итак, если мы хотим создать экземпляр большего массива аналогичного типа данных, нам просто нужно добавить их после указанного `java arrayName` (не забудьте разделить их только через запятую). Пример приведен ниже в следующем разделе для справки.
+
+```java
+dataType arrayName[];  //  works but not preferred way 
+```
+
+Здесь `java datatype` описывает только то, что переменные, указанные после него, относятся к этому типу данных. Кроме того, `java []` после имени переменной описывает, что переменная представляет собой массив указанного типа данных (а не только значение или объект этого типа данных). Итак, если мы хотим создать экземпляр большего массива аналогичного типа данных, мы добавим имена переменных сразу после уже указанного, разделенные запятыми, и каждый раз нам придется добавлять `java []` после имени переменной, иначе переменная будет экземпляр как обычная переменная хранения значений (а не массив). Для лучшего понимания пример приведен в следующем разделе.
+
+## Фрагменты кода выше синтаксиса:
+
+```java
+double[] list1, list2; // preferred way 
+```
+
+Над фрагментом кода создается два массива двойных имен типов list1 и list2.
+
+```java
+double list1[], list2; // works but not preferred way 
+```
+
+Над фрагментом кода выделяется массив типа данных double named list1 и простая переменная типа datatype double named list2 (не путайте с именем **list2** . Имена переменных не имеют ничего общего с типом переменной).
+
+Примечание. `double list[]` стиля `double list[]` не является предпочтительным, поскольку он исходит из языка C / C ++ и был принят на Java для размещения программистов на C / C ++. Кроме того, это более читаемо: вы можете прочитать, что это «двойной массив с именем list», отличный от «двойного названного списка, который представляет собой массив»,
+
+## Создание массивов:
+
+```java
+dataType[] arrayName = new dataType[arraySize]; 
+```
+
+## Фрагменты кода из приведенного выше синтаксиса:
+
+```java
+double[] List = new double[10]; 
+```
+
+## Другой способ создания массива:
+
+```java
+dataType[] arrayName = {value_0, value_1, ..., value_k}; 
+```
+
+## Фрагменты кода выше синтаксиса:
+
+```java
+double[] list = {1, 2, 3, 4}; 
+ 
+ The code above is equivalent to: 
+ double[] list = new double[4]; 
+ *IMPORTANT NOTE: Please note the difference between the types of brackets 
+ that are used to represent arrays in two different ways. 
+```
+
+## Доступ к массивам:
+
+```java
+arrayName[index]; // gives you the value at the specified index 
+```
+
+## Фрагменты кода выше синтаксиса:
+
+```java
+System.out.println(list[1]); 
+```
+
+Вывод:
+```
+2.0 
+```
+
+## Изменение массивов:
+
+```java
+arrayName[index] = value; 
+```
+
+Примечание. После инициализации вы не можете изменить размер или тип массива. Примечание. Однако вы можете сбросить массив так, как показано ниже.
+
+```java
+arrayName = new dataType[] {value1, value2, value3}; 
+```
+
+## Размер массивов:
+
+Можно найти количество элементов в массиве, используя атрибут length. Здесь следует заметить, что `java length` - это **атрибут** каждого массива, то есть имя переменной, сохраняющее длину переменной. Его нельзя путать для **метода** массива, так как имя такое же, как метод `java length()` соответствующий классам String.
+
+```java
+int[] a = {4, 5, 6, 7, 8}; // declare array 
+ System.out.println(a.length); //prints 5 
+```
+
+## Фрагменты кода выше синтаксиса:
+
+```java
+list[1] = 3; // now, if you access the array like above, it will output 3 rather than 2 
+```
+
+_Пример кода:_
+
+```java
+int[] a = {4, 5, 6, 7, 8}; // declare array 
+ for (int i = 0; i < a.length; i++){ // loop goes through each index 
+    System.out.println(a[i]); // prints the array 
+ } 
+```
+
+Вывод:
+
+```java
+    4 
+    5 
+    6 
+    7 
+    8 
+```
+
+### Многомерные массивы
+
+Двумерные массивы (2D-массивы) можно рассматривать как таблицу со строками и столбцами. Хотя это представление является лишь способом визуализации массива для лучшего решения проблем. Значения фактически сохраняются только в последовательных адресах памяти.
+
+```java
+int M = 5; 
+ int N = 5; 
+ double[][] a = new double [M][N]; //M = rows N = columns 
+ for(int i = 0; i < M; i++) { 
+    for (int j = 0; j < N; j++) { 
+        //Do something here at index 
+    } 
+ } 
+```
+
+Этот цикл будет выполнять M ^ N раз и построит это:
+
+\[0 | 1 | 2 | 3 | 4\]  
+\[0 | 1 | 2 | 3 | 4\]  
+\[0 | 1 | 2 | 3 | 4\]  
+\[0 | 1 | 2 | 3 | 4\]  
+\[0 | 1 | 2 | 3 | 4\]
+
+Аналогичным образом можно также создать 3D-массив. Его можно представить в виде кубоида вместо прямоугольника (как указано выше), разделенного на кубики меньшего размера, причем каждый куб хранит некоторое значение. Его можно инициализировать следующим образом:
+
+```java
+int a=2, b=3, c=4; 
+ int[][][] a=new int[a][b][c]; 
+```
+
+Аналогичным образом, массив, имеющий столько же размеров, сколько он хочет, но визуализирующий массив из более чем трех измерений, трудно визуализировать определенным образом.
+
+### Жесткие массивы
+
+Жесткие массивы - это многомерные массивы, которые имеют заданное количество строк, но различное количество столбцов. Жесткие массивы используются для экономии памяти в массиве. Вот пример кода:
+
+```java
+int[][] array = new int[5][]; //initialize a 2D array with 5 rows 
+ array[0] = new int[1]; //creates 1 column for first row 
+ array[1] = new int[2]; //creates 2 columns for second row 
+ array[2] = new int[5]; //creates 5 columns for third row 
+ array[3] = new int[5]; //creates 5 columns for fourth row 
+ array[4] = new int[5]; //creates 5 columns for fifth row 
+```
+
+Вывод:
+
+\[0\]  
+\[0 | 1\]  
+\[0 | 1 | 2 | 3 | 4\]  
+\[0 | 1 | 2 | 3 | 4\]  
+\[0 | 1 | 2 | 3 | 4\]
+
+#### Дополнительная информация:
+
+*   Источник: [Java-массивы](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/arrays.html)

guide/russian/java/basic-operations/bitwise-operators/index.md

@@ -0,0 +1,61 @@
+---
+title: bitwise operator example
+localeTitle: пример побитового оператора
+---
+# Побитовые операторы
+
+## Таблица истины
+
+![truth table](https://4.bp.blogspot.com/-0KPDI41veH0/V-OtObm_UWI/AAAAAAAAAso/CkTS0zUMGKIjlE3gUD0fMhmp-B0zcfBmACLcB/s1600/Bitwise-truthtable-Javaform.jpg "таблица истинности")
+
+Побитовые операторы аналогичны логическим операторам, за исключением того, что они работают в меньшем масштабе - двоичные представления данных. Любые данные могут быть преобразованы в бинарный эквивалент. Хотя двоичные операторы работают на двоичном уровне, но они работают только между нормальными десятичными значениями.
+
+## Типы побитовых операторов
+
+### Побитовое ИЛИ
+
+Побитовое ИЛИ является двоичным оператором (работает с двумя операндами). Это обозначается |. | оператор сравнивает соответствующие биты двух операндов. Если любой из бит равен 1, он дает 1. Если нет, он дает 0.
+
+### Побитовое И
+
+Побитовое И является двоичным оператором (работает с двумя операндами). Это обозначается символом &. Оператор & сравнивает соответствующие биты двух операндов. Если оба бита равны 1, он дает 1. Если один из битов не равен 1, он дает 0.
+
+### Побитовое дополнение
+
+Побитовое дополнение является унарным оператором (работает только с одним операндом). Он обозначается через ~. Оператор ~ инвертирует бит-шаблон. Он составляет от 0 до 1 и от 1 до 0.
+
+### Побитовое XOR
+
+Побитовое XOR является двоичным оператором (работает с двумя операндами). Это обозначается через ^. Оператор ^ сравнивает соответствующие биты двух операндов. Если соответствующие биты отличаются друг от друга, это дает 1. Если соответствующие биты одинаковы, он дает 0.
+
+### Сдвиг влево
+
+Оператор сдвига влево << сдвигает бит влево на определенное количество заданных бит, а нулевые биты сдвигаются в позиции низкого порядка.
+
+### Правый сдвиг
+
+Оператор правого сдвига >> сдвигает битовый шаблон вправо на определенное количество указанных битов. Если число является номером, дополненным дополнением 2, бит знака смещается в позиции высокого порядка.
+
+### Беззнаковый правый сдвиг
+
+Беззнаковый оператор сдвига вправо >>> сдвигает ноль в крайнее левое положение.
+
+### Пример побитовых операторов:
+
+```java
+    int a = 60;          /* 60 = 0011 1100 represents 60 in binary*/ 
+    int b = 13;          /* 13 = 0000 1101 */ 
+    int c = 0; 
+ 
+    c = a & b;        /* 12 = 0000 1100 */ 
+    c = a | b;        /* 61 = 0011 1101 */ 
+    c = a ^ b;        /* 49 = 0011 0001 */ 
+    c = ~a;           /*-61 = 1100 0011  :Invert all bits */ 
+ 
+    // shift operators : zeros are shifted in to replace the discarded bits 
+    c = a << 2;       /* 240 = 1111 0000 : Shift left 2 bits*/ 
+    c = a >> 2;       /* 15 = 1111 */ 
+    c = a >>> 2;      /* 15 = 0000 1111 : Zero fill right shift*/ 
+```
+
+**ДЛЯ ДОПОЛНИТЕЛЬНОЙ ИНФОРМАЦИИ:** [Нажмите здесь](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/op3.html)

guide/russian/java/basic-operations/index.md

@@ -0,0 +1,44 @@
+---
+title: Basic Operations
+localeTitle: Основные операции
+---
+# Основные операции
+
+Java поддерживает следующие операции над переменными:
+
+*   **Арифметика** : `Addition (+)` , `Subtraction (-)` , `Multiplication (*)` , `Division (/)` , `Modulus (%)` , `Increment (++)` , `Decrement (--)` .
+*   **Конкатенация строк** : `+` может использоваться для конкатенации строк, но вычитание `-` на Строке не является допустимой операцией.
+*   **Реляционная:** `Equal to (==)` , `Not Equal to (!=)` , `Greater than (>)` , `Less than (<)` , `Greater than or equal to (>=)` , `Less than or equal to (<=)`
+*   **Побитовое** `Bitwise And (&)` , `Bitwise Or (|)` , `Bitwise XOR (^)` , `Bitwise Compliment (~)` , `Left shift (<<)` , `Right Shift (>>)` , `Zero fill right shift (>>>)`
+*   **Логический** : `Logical And (&&)` , `Logical Or (||)` , `Logical Not (!)`
+*   **Назначение** : `=` , `+=` , `-=` , `*=` , `/=` , `%=` , `<<=` , `>>=` , `&=` , `^=` , `|=`
+*   **Другие** : `Conditional/Ternary(?:)` , `instanceof`
+
+Хотя большинство операций не требуют пояснений, Условный (тройной) оператор работает следующим образом:
+
+`expression that results in boolean output ? return this value if true : return this value if false;`
+
+Пример: Истинное состояние:
+
+```java
+    int x = 10; 
+    int y = (x == 10) ? 5 : 9; // y will equal 5 since the expression x == 10 evaluates to true 
+```
+
+Ложно Состояние:
+
+```java
+    int x = 25; 
+    int y = (x == 10) ? 5 : 9; // y will equal 9 since the expression x == 10 evaluates to false 
+```
+
+Экземпляр оператора используется для проверки типов. Его можно использовать для проверки, является ли объект экземпляром класса, подкласса или интерфейса. Общий формат - _**экземпляр** объекта класса / подкласса / интерфейса_
+
+Вот программа для иллюстрации instanecof оператора: \`\` \`Java Person obj1 = new Person (); Person obj2 = new Boy ();
+```
+    // As obj is of type person, it is not an 
+    // instance of Boy or interface 
+    System.out.println("obj1 instanceof Person: " +  (obj1 instanceof Person)); /*it returns true since obj1 is an instance of person */ 
+```
+
+\`\` \`

guide/russian/java/build-tools/index.md

@@ -0,0 +1,25 @@
+---
+title: Build Tools
+localeTitle: Инструменты сборки
+---
+# Инструменты сборки
+
+Инструменты сборки Java позволяют настраивать ваши сборки для выполнения таких задач, как указание, какие файлы должны быть включены в вашу банку, добавление зависимостей из Интернета и автоматическое выполнение таких задач, как тесты или github. Инструменты сборки также упрощают модульные проекты. Популярные инструменты сборки включают [Gradle](https://gradle.org/) и [Maven](https://maven.apache.org/)
+
+## Gradle
+
+Сценарии сборки Gradle могут быть написаны в Groovy или Kotlin и очень настраиваемы. В большинстве проектов используется оболочка Gradle, позволяющая создавать их на любой системе, даже без установки Gradle. Gradle - рекомендуемый инструмент для разработки Android.
+
+## специалист
+
+Файлы сборки Maven написаны с использованием XML. Как и Gradle, многие плагины написаны для Maven, чтобы настроить ваши сборки, однако Maven не так настраивается, потому что вы не можете напрямую взаимодействовать с API Maven.
+
+### Дополнительная информация:
+
+https://gradle.org/
+
+https://en.wikipedia.org/wiki/Gradle
+
+https://maven.apache.org/what-is-maven.html
+
+https://en.wikipedia.org/wiki/Apache\_Maven

guide/russian/java/built-in-functions/index.md

@@ -0,0 +1,14 @@
+---
+title: Built-In Functions
+localeTitle: Встроенные функции
+---
+# Встроенные функции
+
+Java также имеет множество встроенных или предопределенных функций, которые обычно хранятся в пакетах java.lang и java.io, которые автоматически импортируются в редакторы, такие как BlueJ, или могут быть импортированы с использованием следующей команды Syntax-
+
+```java
+import java.lang.*; 
+ import java.io.*; 
+```
+
+Они включают в себя функции, которые упрощают выполнение более длительной и трудной задачи.

guide/russian/java/classes-and-objects/index.md

@@ -0,0 +1,85 @@
+---
+title: Classes and Objects
+localeTitle: Классы и объекты
+---
+# Классы и объекты
+
+Классы - это группы переменных и операции над ними. Класс может иметь переменные, методы (или функции) и конструкторы (или методы, которые используются для инициирования, подробнее об этом позже!).
+
+Класс может содержать любой из следующих типов переменных.
+
+*   Переменные класса. Это переменные, которые объявляются внутри определения класса, вне любого метода, с ключевым словом static. Переменная класса используется для всех экземпляров класса. Переменные класса также известны как статические переменные, они инициализируются только один раз во время компиляции класса, поэтому для всех экземпляров доступна только одна копия.
+*   Переменные экземпляра. Разница с переменными класса заключается в том, что переменные экземпляра инициализируются внутри конструктора классов, и они не используются для всех объектов. Во время создания экземпляра создается новая копия переменной экземпляра.
+
+```java
+public class Example { 
+ 
+    private static int myVar = 1; // Class Variable 
+ 
+    private int mySecondVar; // Instance Variable 
+    Example(int mySecondVar) { 
+            this.mySecondVar = mySecondVar; // An instance variable must be initialized inside the constructor 
+```
+
+Подумайте о `Class` как о плане создания чего-то конкретного. `Class` сообщает вам, как будет выглядеть `instantiated` «что» и «как» `object` указанного класса. По сути, он определяет `properties` (например, цвет, мощность двигателя) и `behavior` (остановка, ускорение, переключения передач, хонк и т. Д.) Для автомобиля в приведенном ниже случае.
+
+Объекты - это _экземпляры_ класса. Все объекты являются экземплярами определенного класса. Представьте, что класс является «шаблоном», из которого копируется каждый объект. Когда вы создаете объект, он в основном создает новый объект в проекте класса. Теперь давайте рассмотрим это в небольшом фрагменте кода:
+
+```java
+// Car class 
+ public class Car { 
+    // car name 
+    private String name; 
+ 
+    // car manufacturer name 
+    private String manufacturerName; 
+ 
+    // constructor 1 
+    public Car() { 
+    } 
+ 
+    // constructor 2 
+    public Car(String name, String man) { 
+        this.name = name; 
+        this.manufacturerName = man; 
+    } 
+ 
+    // getter name method 
+    public String getName() { 
+        return name; 
+    } 
+ 
+    // getter manufacture method 
+    public String getManufacturerName() { 
+        return manufacturerName; 
+    } 
+ 
+    //setter name method 
+    public void setName(String name){ 
+        this.name = name; 
+    } 
+ 
+    //setter manufacture method 
+    public void setManufacture(String man){ 
+        this.manufacturerName = man; 
+    } 
+ } 
+ 
+ // sample code 
+ 
+ Car modelS = new Car("Model S","Tesla"); 
+ // prints Tesla Model S 
+ System.out.println("Full Car Model S= " + modelS.getManufacturerName() + " : " + modelS.getName()); 
+ 
+ Car modelX = new Car(); 
+ modelX.setName("Model X"); 
+ modelX.setManufacture("BMW"); 
+ // prints Tesla Model X 
+ System.out.println("Full Car Model X= " + modelX.getManufacturerName() + " : " + modelX.getName()); 
+```
+
+![:rocket:](https://forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZP/0)
+
+Итак, `Car` - это класс, который имеет `name` полей или свойств и `name` `manufacturerName` . `modelS` является объектом класса `Car` . Таким образом, `modelS` также имеет те же свойства и методы.
+
+Это почти стандарт, чтобы обеспечить «информацию» объекта, в этом случае `name` переменных `manufacturerName` , быть приватным и доступ к ним только через эти геттеры и сеттеры. Это предотвращает проблему с кодом отладки, которая включает переменные-члены объекта. Если переменные-члены были опубликованы, и по какой-либо причине программа выйдет из строя, вы можете получить довольно сложную трассировку стека, которая может быть трудно указать на ошибку. Сохранение переменных в частном порядке и доступ только через геттеры и сеттеры упростит это сообщение об ошибке.

guide/russian/java/collections/index.md

@@ -0,0 +1,125 @@
+---
+title: Collections
+localeTitle: Коллекции
+---
+# Коллекции
+
+Коллекция в Java - это группа объектов, которые могут быть упорядочены (LinkedList) или неупорядочены (Set). Интерфейс Collection находится в верхней части иерархии, и все остальные классы и интерфейсы распространяются на этот интерфейс. Он находится в пакете java.util.
+
+Интерфейс Collection также расширяет интерфейс Iterable, что означает, что каждая коллекция в java должна быть итерируемой. Это, в свою очередь, означает, что для каждого цикла можно использовать для каждого цикла.
+
+```java
+public interface Collection<E> extends Iterable<E> 
+```
+
+Некоторые из наиболее распространенных методов, предоставляемых этим интерфейсом:
+
+```java
+boolean add(E e) // Adds the specified element to the collection if not present and returns true if this collection changed. 
+ 
+ void clear() // Removes all the elements from the collection. 
+ 
+ boolean contains(Object o) // Returns true if the specified element is in the collection else false 
+ 
+ boolean isEmpty() // Returns true if the collection is empty else false 
+ 
+ boolean remove(Object o) // Removes the specifies element and return true on successful removal else false. 
+ 
+ int size() // Returns number of items in the collection. 
+```
+
+Эти и различные другие методы должны быть реализованы любым классом, реализующим интерфейс Collection.
+
+## Интерфейсы, расширяющие интерфейс коллекции
+
+Другими важными интерфейсами, расширяющими интерфейс коллекции, являются:
+
+Задавать: Коллекция, содержащая только уникальные элементы.
+
+Очередь: Реализуйте поведение очереди, когда элементы добавляются только в начале и удаляются с конца.
+
+Список: Эта коллекция обрабатывает список / последовательность объектов.
+
+Эти четыре интерфейса (Collection, Set, Queue, List) вместе с SortedSet, Deque и NavigableSet образуют коллективную иерархию Collection.
+
+# Класс LinkedList
+
+LinkedList - один из самых важных классов Collection, который обеспечивает реализацию двусвязного списка. Он реализует интерфейсы List, Deque, Cloneable и Serializable.
+
+**Создать LinkedList**
+
+```java
+LinkedList<Integer> intList = new LinkedList<Integer>(); // Creates a new list of Integer objects. 
+```
+
+Вы также можете создать список любого другого типа объекта. Напр.
+
+```java
+LinkedList<String> stringList = new LinkedList(); 
+ 
+ LinkedList<LinkedList<Integer>> listOfList = new LinkedList(); 
+```
+
+Примечание. Все коллекции в Java были преобразованы в общие типы, поскольку JDK 1.5
+
+**Добавить элементы в список**
+
+```java
+intList.add(new Integer(1)); // Add 1 to the end. 
+ 
+ intList.add(2); // This works as Java provides autoboxing and unboxing of primitive datatypes and their respective wrapper classes 
+ 
+ intList.addFirst(3); // Add to the beginning of the list 
+ 
+ intList.addLast(2); // Add to the end of the list 
+ 
+ intList.add(2, 5); // Add element 5 at index 2 
+```
+
+Распечатаем список
+
+```java
+System.out.println(intList); // toString() method is automatically called on the list 
+```
+
+Вывод: \[3, 1, 5, 2, 2\]
+
+**Извлечение элементов из списка**
+
+```java
+intList.get(3); // Returns element at index 3 ie 2 
+ 
+ intList.getFirst(); // Get the first element ie 3 
+ 
+ intList.getLast(); // Returns last element ie 2 
+ 
+ intList.indexOf(2); // Returns first occured index of 2 ie 3 
+ 
+ intList.lastIndexOf(2); // Returns last occured index of 2 ie 4 
+```
+
+**LinkedList как стек**
+
+Поскольку Java не предоставляет отдельную
+
+```java
+intList.push(5); // Add element to the end of list. Works same as addLast() 
+ 
+ intList.pop(); // Removes and returns the last element of the list. 
+```
+
+**Удалить элементы из списка**
+
+```java
+intList.remove(3); // Removes the element at index 3 of the list 
+ 
+ intList.removeFirst(); // Removes first element of the list 
+ 
+ intList.removeLast(); // Removes last element of the list 
+```
+
+Примечание. Все вышеупомянутые методы удаления и извлечения элемента возвращают NoSuchElementException в пустой список.
+
+#### Дополнительная информация:
+
+*   Источник: [Java-документация](https://docs.oracle.com/javase/9/docs/api/overview-summary.html)

guide/russian/java/comments-in-java/index.md

@@ -0,0 +1,64 @@
+---
+title: Comments in Java
+localeTitle: Комментарии в Java
+---
+## Комментарии в Java
+
+Комментарии в java похожи на записи в реальной жизни, которые используются для отображения некоторой информации, которую другие программисты или разработчики могут читать и понимать.
+
+Хорошая практика - добавлять комментарии к вашему коду, особенно при работе с командой или в компании. Это помогает будущим разработчикам или товарищам по команде узнать, что происходит более легко, когда они смотрят на ваш код. Комментарии делают ваш код более аккуратным и организованным.
+
+Комментарии Java не выполняются компилятором и интерпретатором.
+
+### Типы комментариев Java
+
+#### 1\. Одиночный комментарий
+
+Чтобы создать однострочный комментарий просто добавить два `//` слэши перед текстом.
+
+```java
+// This is how single line comment looks like 
+```
+
+#### 2\. Комментарий Multi Line
+
+Чтобы создать многострочный комментарий, заверните строки между `/*` линиями здесь `*/`
+
+```java
+public class MyFirstJava { 
+    public static void main(String[] args) { 
+    /* This Java Code 
+       Prints out "Hello world" 
+       and you are looking at a multi line comment 
+    */ 
+        System.out.println("Hello World"); 
+    } 
+ } 
+```
+
+#### 3\. Комментарий к документации
+
+Комментарий к документации используется инструментом Javadoc для создания документации для кода. Документация Комментарий используется разработчиками для документирования кода, например, что делает класс или что делает метод. Это используется инструментом javadoc, который будет компилировать предварительно отформатированный набор html-файлов, содержащих всю информацию, доступную в комментарии.
+
+```java
+/** 
+ * The Following Java program displays a random between 0 - 50 
+ * Most Developer dont document simple program like this 
+ * 
+ * @author      Quincy Larson 
+ * @version     1.0 
+ */ 
+ 
+ public class RandomNumbers{ 
+    public static void main(String[] args) { 
+        int random = (int)(Math.random() * 50 + 1); 
+        System.out.println("Hello World"); 
+    } 
+ } 
+```
+
+#### Дополнительная информация:
+
+*   [Ресурсы Java](http://guide.freecodecamp.org/java/resources/)
+    
+*   [Скомпилированный пример Javadoc](https://docs.oracle.com/javase/8/docs/api/)

guide/russian/java/constructors/index.md

@@ -0,0 +1,181 @@
+---
+title: Constructors
+localeTitle: Конструкторы
+---
+Если объект копирует из класса, в чем смысл? Я должен иметь возможность хранить данные в нем правильно?
+
+Именно тогда мы используем методы **getter** (например, getName ()) / **setter** (например, setName ()) или в этом случае конструкторы для инициализации класса. В принципе, каждый класс Java имеет конструктор, который является методом, называемым первым, когда инициализируется любой объект класса. Подумайте об этом как о стартовом коде.
+
+Когда вы пишете класс без какого-либо конструктора, компилятор Java создает конструктор по умолчанию:
+
+```java
+public class Car { 
+    private String name; 
+ } 
+ 
+ Car modelS = new Car(); 
+```
+
+Эта инициализация без параметров - способ вызова конструктора по умолчанию. Вы также можете написать конструктор по умолчанию:
+
+```java
+public class Car { 
+    private String name; 
+ 
+    // User Specified Default Constructor 
+    public Car() { 
+        name = "Tesla"; 
+    } 
+ } 
+```
+
+Затем при вызове `new Car()` `name` переменной будет автоматически инициализировано для «Tesla» для этого экземпляра объекта Car.
+
+Ясно, что конструкторы в точности такие, какие они звучат: они используются для `construct` т. Е. Создают экземпляр объекта определенного класса.  
+Конструкторы похожи на объявления методов, но немного отличаются в том смысле, что они:
+
+1.  Названы точно так же, как класс.
+2.  Не используйте тип возврата.
+
+Следовательно, целью использования `constructors` является обеспечение:
+
+1.  Способ создания объекта.
+2.  Предоставить начальные значения свойствам объекта.
+3.  Контролируйте, как создается объект.
+
+Давайте посмотрим на другой пример. Скажем, Honda (производитель автомобилей) хочет, чтобы все ее автомобили назывались `Honda <a name>` . Чтобы обеспечить это, мы можем представить это с помощью класса следующим образом:
+
+```java
+public class Car { 
+ 
+    private String name; 
+ 
+    // Constructor. 
+    public Car(String model){ 
+        this.name = "Honda " + model; 
+    } 
+ 
+    public String getName(){ 
+        return this.name; 
+    } 
+ 
+    public static void main(String args[]){ 
+        Car car = new Car("Civic"); 
+        System.out.println( car.getName() ); 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CTJ4/1)
+
+Обратите внимание: когда мы пишем конструктор таким образом, то есть, предоставляя параметр, мы контролируем (пункт № 3) способ создания экземпляра `Car` . Короче говоря, мы говорим в этом примере, что **вы ДОЛЖНЫ предоставить имя модели, чтобы получить экземпляр класса Car** .
+
+Почему это важно? Бывают случаи, когда вам нужен `one and only one` экземпляр класса для использования во всем приложении. Одним из способов достижения этого является использование `private` конструктора.
+
+Предположим, вам нужен класс для представления банка. Вы бы не хотели, чтобы люди когда-либо создавали экземпляр `Bank` . Итак, вы разрабатываете свой класс:
+
+```java
+public class Bank { 
+ 
+    private static Bank instance; 
+ 
+    private Bank(){ 
+    } 
+ 
+    public static Bank getInstance(){ 
+        if(null == instance){ 
+            instance = new Bank(); 
+        } 
+        return instance; 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CTJz/0)
+
+Обратите внимание, что конструктор является `private` . Это подтверждает тот факт, что никто другой не может создать экземпляр Банка.  
+На самом деле, если в другом классе вы пытаетесь:
+
+```java
+Bank account = new Bank(); // Throws a compilation error: Bank() has private access in Bank. 
+```
+
+Таким образом, единственный способ получить доступ к экземпляру - использовать `Bank.getInstance()` . Такие экземпляры называются `Singleton` так как вы получаете ровно один экземпляр (на каждую VM, чтобы быть точным) на протяжении всего срока действия вашего приложения.
+
+В классе может быть много конструкторов. Но они должны отличаться в параметрах метода. Это перегрузка конструктора. Если быть точным, мы говорим, что перегрузка конструктора произошла, когда есть два или более конструктора с одинаковым именем, но разные параметры метода. В результате две функции имеют разные сигнатуры методов и полностью обрабатываются Java как разные конструкторы. Например:
+
+```java
+public class Car { 
+ 
+    private String name; 
+    private String carType; 
+ 
+    // Constructor. 
+    public Car(){ 
+        this.name = "No Name"; 
+        this.carType = "No Type"; 
+    } 
+    public Car(String model){ 
+        this.name = "Honda " + model; 
+    } 
+ 
+    public Car(String model, String carType){ 
+        this.name = model; 
+        this.carType = carType; 
+    } 
+ 
+    public String getName(){ 
+        return this.name; 
+    } 
+ 
+    public String getCarType(){ 
+        return this.name; 
+    } 
+ 
+    public static void main(String args[]){ 
+        Car car = new Car("Civic"); 
+        System.out.println( car.getName() ); 
+ 
+        // Other Way To Initialize 
+        Car car = new Car("Civic","Sedan"); 
+        System.out.println( car.getName() + " "+ car.getCarType() ); 
+ 
+    } 
+ } 
+```
+
+Таким образом, единственный способ получить доступ к экземпляру - использовать `Bank.getInstance()` . Такие экземпляры называются `Singleton` так как вы получаете ровно один экземпляр (на каждую VM, чтобы быть точным) на протяжении всего срока действия вашего приложения.
+
+## Копировать конструктор
+
+Конструктор копирования - это конструктор, который создает объект, инициализируя его объектом того же класса, который был создан ранее. Конструктор копирования используется для-
+
+1.  Инициализировать объект из другого типа.
+2.  Скопируйте объект, чтобы передать его в качестве аргумента функции.
+3.  Скопируйте объект, чтобы вернуть его из функции. Вот программа, которая показывает простое использование конструктора копирования:
+
+```Java
+class Complex { 
+ 
+    private double re, im; 
+ 
+    // A normal parametrized constructor 
+    public Complex(double re, double im) { 
+        this.re = re; 
+        this.im = im; 
+    } 
+ 
+    // Copy constructor 
+    Complex(Complex c) { 
+        System.out.println("Copy constructor called"); 
+        re = c.re; 
+        im = c.im; 
+    } 
+ 
+    } 
+ } 
+```
+
+[запустить полный код](https://repl.it/MwnJ)
+
+// ## Цепочка конструктора

guide/russian/java/control-flow/index.md

@@ -0,0 +1,111 @@
+---
+title: Control Flow
+localeTitle: Поток управления
+---
+# Поток управления
+
+Операторы потока управления - это именно то, что означает этот термин. Это инструкции, которые изменяют поток выполнения на основе решений, циклов и ветвлений, чтобы программа могла условно выполнять блоки кода.
+
+Прежде всего, Java имеет следующие конструкции для управления потоком:
+
+*   `if`
+    
+    ```java
+    if( <expression that results in a boolean> ){ 
+        //code enters this block if the above expression is 'true' 
+     } 
+    
+    ```
+    
+*   `if...else`
+    
+    ```java
+    if( <expression that results in a boolean> ){ 
+        //execute this block if the expression is 'true' 
+     } else{ 
+        //execute this block if the expression is 'false' 
+     } 
+    
+    ```
+    
+*   `switch`
+    
+
+Коммутатор является альтернативой конструкции `if...else` когда есть несколько значений и случаев для проверки.
+
+```java
+switch( <integer / String / Enum > ){ 
+    case <int/String/Enum>: 
+        <statements> 
+        break; 
+    case <int/String/Enum>: 
+        <statements> 
+        break; 
+    default: 
+        <statements> 
+ } 
+```
+
+Примечание. Поток программы проходит `falls through` следующий `case` если оператор `break` отсутствует. например, скажем, вы говорите стандарт «Привет» всем в офисе, но вы очень милы с девушкой, которая сидит рядом с вами и звучит сердито вашему боссу. Способ представления будет выглядеть примерно так:
+
+```java
+switch(person){ 
+    case 'boss': 
+        soundGrumpy(); 
+        break; 
+    case 'neighbour': 
+        soundExtraNice(); 
+        break; 
+    case 'colleague': 
+        soundNormal(); 
+        break; 
+    default: 
+        soundNormal(); 
+ } 
+```
+
+```
+Note: The `default` case runs when none of the `case` matches. Remember that when a case has no `break` statement, it `falls through` to the next case and will continue to the subsequent `cases` till a `break` is encountered. Because of this, make sure that each case has a `break` statement. The `default` case does not require a `break` statement. 
+```
+
+*   `nested statements`
+
+Любой из предыдущих потоков управления может быть вложен. Это означает, что вы можете иметь вложенные, `if` `if..else` и `switch..case` . т. е. вы можете иметь любую комбинацию этих утверждений внутри другой, и нет ограничений на глубину `nesting` .
+
+Например, рассмотрим следующий сценарий:
+
+*   Если у вас меньше 25 баксов, вы получаете себе чашку кофе.
+*   Если у вас более 25 баксов, но менее 60 баксов, вы получаете приличную еду.
+*   Если у вас более 60 баксов, но менее 100, вы получаете приличную еду вместе с бокалом вина.
+*   Однако, когда у вас есть более 100 баксов, в зависимости от того, с кем вы работаете, вы либо отправляетесь на ужин, освещенный свечами (с женой), либо отправляетесь в спортивный бар (с друзьями).
+
+Один из способов представить это будет:
+
+```java
+int cash = 150; 
+ String company = "friends"; 
+ 
+ if( cash < 25 ){ 
+    getCoffee(); 
+ } else if( cash < 60 ){ 
+    getDecentMeal(); 
+ } else if( cash < 100 ){ 
+    getDecentMeal(); 
+    getGlassOfWine(); 
+ } else { 
+    switch(company){ 
+        case "wife": 
+            candleLitDinner(); 
+            break; 
+        case "friends": 
+            meetFriendsAtSportsBar(); 
+            break; 
+        default: 
+            getDecentMeal(); 
+    } 
+ } 
+```
+
+В этом примере будет выполняться `meetFriendsAtSportsBar()` .
+
+![:rocket:](https://forum.freecodecamp.org/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZi/1)

guide/russian/java/data-abstraction/index.md

@@ -0,0 +1,16 @@
+---
+title: Data Abstraction
+localeTitle: Абстракция данных
+---
+## Определение
+
+Согласно словарю абстракция - это качество общения с идеями, а не с событиями.
+
+Аналогично в объектно-ориентированном программировании абстракция - это процесс скрытия деталей реализации от пользователя, пользователю предоставляется только функциональность. Другими словами, пользователь будет иметь информацию о том, что делает объект, а не о том, как он это делает.
+
+В Java абстракция достигается с использованием абстрактных классов и интерфейсов.
+
+## Ресурсы
+
+[Tutorials Point - Java Абстрактные классы и интерфейсы](https://www.tutorialspoint.com/java/java_abstraction.htm)  
+[Учебники Java - Java Абстрактные методы и классы](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)

guide/russian/java/data-types/index.md

@@ -0,0 +1,206 @@
+---
+title: Data Types
+localeTitle: Типы данных
+---
+# Типы данных
+
+Java - это строго типизированный язык. Это означает, что в Java каждый тип данных имеет собственное строгое определение. Нет никаких неявных преобразований типа данных при возникновении конфликтов между типами данных. Любое изменение типов данных должно быть явно объявлено программистом.
+
+Java определяет 8 примитивных типов данных: `byte` , `short` , `int` , `long` , `char` , `float` , `double` и `boolean` .
+
+Они делятся на следующие категории:
+
+*   Целые
+*   Числа с плавающей запятой
+*   Персонажи
+*   Булевский тип
+
+Подробности каждого из типов данных приведены ниже:
+
+## Целые:
+
+Они имеют четыре типа: `byte` , `short` , `int` , `long` . Важно отметить, что это подписанные положительные и отрицательные значения. Подписанные целые числа хранятся в компьютере с использованием [дополнения 2](http://www.ele.uri.edu/courses/ele447/proj_pages/divid/twos.html) . Он содержит как отрицательные, так и положительные значения, но в разных форматах, таких как `(-1 to -128)` или `(0 to +127)` . Целочисленное целое число без знака может содержать большее положительное значение и не имеет отрицательного значения `(0 to 255)` . В отличие от C ++ целых чисел без знака в Java нет.
+
+### байт:
+
+Тип данных байта - это 8-битное целое число дополнений, дополненное двумя символами.
+```
+Wrapper Class: Byte 
+ 
+ Minimum value: -128 (-2^7) 
+ 
+ Maximum value: 127 (2^7 -1) 
+ 
+ Default value: 0 
+ 
+ Example: byte a = 10 , byte b = -50; 
+```
+
+### короткая:
+
+Короткий тип данных - это 16-разрядное целое число дополнений, подписанное двумя.
+```
+Wrapper Class: Short 
+ 
+ Minimum value: -32,768 (-2^15) 
+ 
+ Maximum value: 32,767 (2^15 -1) 
+ 
+ Default value: 0. 
+ 
+ Example: short s = 10, short r = -1000; 
+```
+
+### INT:
+
+int - это 32-разрядное целое число дополнений, подписанное двумя. Он обычно используется в качестве типа данных по умолчанию для интегральных значений, если не возникает озабоченность по поводу памяти.
+```
+Wrapper Class: Integer 
+ 
+ Minimum value: (-2^31) 
+ 
+ Maximum value: (2^31 -1) 
+ 
+ The default value: 0. 
+ 
+ Example: int a = 50000, int b = -20 
+```
+
+### долго:
+
+Длинный тип данных - это целое число дополнений, состоящее из 64 бит.
+```
+Wrapper Class: Long 
+ 
+ Minimum value: (-2^63) 
+ 
+ Maximum value: (2^63 -1) 
+ 
+ Default value: 0L. 
+ 
+ Example: long a = 100000L, long b = -600000L; 
+ 
+ By default all integer type variable is "int". So long num=600851475143  will give an error. 
+ But it can be specified as long by appending the suffix L (or l) 
+```
+
+## Плавающая точка:
+
+Они также называются действительными числами и используются для выражений с дробной точностью. Они бывают двух типов: `float` , `double` . Поплавок фактически избегают в случае точных данных, таких как данные о валюте или исследованиях.
+
+### плавать:
+
+Тип данных float представляет собой 32-битную 32-битную [IEEE 754 с плавающей точкой](http://steve.hollasch.net/cgindex/coding/ieeefloat.html) .
+```
+Wrapper Class: Float 
+ 
+ Float is mainly used to save memory in large arrays of floating point numbers. 
+ 
+ Default value: 0.0f. 
+ 
+ Example: float f1 = 24.5f; 
+ 
+ The default data type of floating-point number is double. So float f = 24.5 will introduce an error. 
+ However, we can append the suffix F (or f) to designate the data type as float. 
+```
+
+### дважды:
+
+двойной тип данных - это 64-битная 64-битная [плавающая точка IEEE 754](http://steve.hollasch.net/cgindex/coding/ieeefloat.html) с двойной точностью. Этот тип данных обычно является выбором по умолчанию. Этот тип данных никогда не должен использоваться для точных значений, таких как валюта.
+```
+Wrapper Class: Double 
+ 
+ This data type is generally used as the default data type for decimal values. 
+ 
+ Default value: 0.0d. 
+ 
+ Example: double d1 = 123.400778; 
+```
+
+## Символ:
+
+Мы используем этот тип данных для хранения символов. Это не то же самое, что символ в C / C ++. Java использует `UNICODE` , международно принятый набор символов. Char на Java длится 16 бит, а в C / C ++ - 8 бит.
+```
+Wrapper Class: Character 
+ 
+ Minimum value: '\u0000' (or 0). 
+ 
+ Maximum value: '\uffff' (or 65,535). 
+ 
+ Default value: null ('\u0000'). 
+ 
+ Example: char letterA ='a'; 
+```
+
+## Boolean:
+
+Это используется для хранения логических значений. Логический тип может иметь значение true или false. Этот тип обычно возвращается реляционными операторами.
+```
+There are only two possible values: true and false. 
+ 
+ Wrapper Class: Boolean 
+ 
+ This data type is used for simple flags that track true/false conditions. 
+ 
+ Default value is false. 
+ 
+ Example: boolean b = true, boolean b1 = 1(this is not possible in java and give incompatible type error), boolean b2; 
+```
+
+## Типы ссылочных данных:
+
+Помимо примитивных типов данных существуют ссылочные переменные, созданные с использованием конструкторов разных классов. Референтные переменные используются для любого класса, а также для массива, String, Scanner, Random, Die и т. Д. Ссылочные переменные инициализируются с использованием нового ключевого слова.
+
+Пример :
+
+```java
+public class Box{ 
+ 
+    int length, breadth, height; 
+ 
+    public Box(){ 
+        length=5; 
+        breadth=3; 
+        height=2; 
+    } 
+ } 
+ 
+ class demo{ 
+ 
+    public static void main(String args[]) { 
+        Box box1 = new Box();                //box1 is the reference variable 
+        char[] arr = new char[10];           //arr is the reference variable 
+    } 
+ } 
+```
+
+## Строка:
+
+Строка не является примитивным типом данных, но позволяет хранить несколько типов данных символов в массиве и имеет множество методов, которые можно использовать. Он используется довольно часто, когда пользователь вводит данные, и вам приходится манипулировать им.
+
+В приведенном ниже примере мы пытаемся удалить все буквы из строки и вывести их:
+
+```java
+String input = "My birthday is 10 January 1984 and my favorite number is 42"; 
+ String output = ""; 
+ 
+ for(int i=0;i<input.length();i++){ 
+ 
+ //if the character at index i on the string is a letter or a space, move on to the next index 
+ if(Character.isLetter(input.charAt(i)) || input.charAt(i)==' '){ 
+ 
+    continue; 
+ } 
+ 
+ output = output + input.charAt(i); //the number is added onto the output 
+ 
+ } 
+ 
+ System.out.println(output); 
+```
+
+Вывод:
+```
+10198442 
+
+```

guide/russian/java/defining-attributes/index.md

@@ -0,0 +1,50 @@
+---
+title: Defining Attributes
+localeTitle: Определение атрибутов
+---
+## Определение атрибутов
+
+Класс имеет атрибуты и методы. Атрибуты являются в основном переменными внутри класса.
+
+**_Пример:_**
+
+```java
+public class Vehicle { 
+  int maxSpeed; 
+  int wheels; 
+  String color; 
+ 
+  void horn() { 
+    System.out.println("Beep beep!"); 
+  } 
+ } 
+```
+
+`maxSpeed` , `wheels` и `color` - все атрибуты нашего класса Vehicle, а метод `horn()` - единственный.
+
+### Создание объектов
+
+Мы можем создать несколько объектов нашего класса Vehicle и использовать точечный синтаксис для доступа к их атрибутам и методам.
+
+```java
+class MyClass { 
+  public static void main(String[] args) { 
+    Vehicle v1 = new Vehicle(); 
+    Vehicle v2 = new Vehicle(); 
+    v1.color = "red"; 
+    v2.horn(); 
+  } 
+ } 
+```
+
+### Модификаторы видимости
+
+В приведенном выше примере транспортного средства атрибуты объявляются без модификатора видимости (например, открытого, закрытого или защищенного). Когда модификатор не включен в разделение атрибута, он по умолчанию имеет значение, называемое «private package», что означает, что к этому атрибуту можно получить доступ напрямую, используя «.». точечная нотация любым другим классом внутри одного пакета.
+
+Доступ к «общедоступным» переменным можно получить из любого класса «Защищенные» переменные могут быть доступны любым классом внутри одного и того же пакета, а также подклассами в любых других пакетах, имеющих родительские дочерние отношения «частные» переменные могут быть доступны только из класса, в котором они объявлены Доступ к частным частям пакета можно получить по классам в одном пакете
+
+«public», переменные, методы, конструкторы и классы (только один) объявляются как общедоступные. «protected», переменные, методы и конструкторы могут быть объявлены частными, а не классами и интерфейсами. «private», переменные, методы и конструкторы могут быть объявлены частными, а не классами и интерфейсами. «default», переменные, методы, конструкторы и классы могут быть типа по умолчанию (объявлены, не записывая ничего).
+
+#### public> protected> default> private (на основе удобства доступности)
+
+Как правило, рекомендуется использовать все атрибуты класса private и контролировать доступ к ним с помощью методов «getter» и «setter».

guide/russian/java/equality/index.md

@@ -0,0 +1,64 @@
+---
+title: Checking for Equality
+localeTitle: Проверка равенства
+---
+# Проверка равенства
+
+В Java существует два способа проверить, являются ли две переменные «одинаковыми»: `==` и `.equals()` . Однако эти два метода не работают одинаково.
+
+## Оператор `==`
+
+Основная операция равенства в Java, `==` как в `var1 == var2` , проверяет, указывают ли `var1` и `var2` одну и ту же _ссылку на объект_ . То есть, если `var1` является одним и тем же _экземпляром_ класса в памяти как `var2` , то `var1 == var2` является истинным.
+
+Однако, если `var1` и `var2` были созданы как два отдельных экземпляра класса (т.е. с `new` ключевым словом), то `var1 == var2` будет false. Даже если оба объекта содержат одни и те же свойства и значения, сравнение `==` не пройдет, потому что они не указывают на один и тот же объект в памяти.
+
+Для примитивных типов переменных, таких как `int` и `double` , оператор `==` всегда может использоваться для проверки равенства, так как их значения хранятся непосредственно с переменной (а не как ссылка на другой слот в памяти).
+
+```java
+int var1 = 1; 
+ int var2 = 1; 
+ System.out.println(var1 == var2) // true 
+ 
+ MyObject obj1 = new MyObject(); 
+ MyObject obj2 = obj1; 
+ MyObject obj3 = new MyObject(); 
+ 
+ System.out.println(obj1 == obj2) // true 
+ System.out.println(obj1 == obj3) // false 
+ System.out.println(obj2 == obj3) // false 
+```
+
+## Метод `.equals()`
+
+Встроенный класс `Object` в Java, который все остальные классы автоматически расширяют, содержит ряд полезных встроенных методов. Одним из таких методов является `equals()` , который принимает в качестве своего аргумента другой объект и возвращает, следует ли считать два объекта «равными» в соответствии с соответствующей логикой для этого класса.
+
+Класс String является одним из наиболее распространенных примеров класса, который переопределяет метод equals (). При сравнении двух «строк для равенства» вам нужно использовать метод «equals ()», поскольку «==» не будет работать так, как вы ожидаете.
+
+```java
+String s1 = "Bob"; 
+ String s2 = "ob"; 
+ s2 = "B" + s2; //s2 now is also "Bob" 
+ System.out.println(s1 == s2); //false 
+ System.out.println(s1.equals(s2)); //true 
+```
+
+Когда вы создаете новый класс в Java, вам часто нужно переопределить метод `equals()` , чтобы обеспечить более осмысленный способ сравнения двух объектов одного и того же класса. Как этот метод реализован полностью зависит от суждения разработчика.
+
+Например, вы можете решить, что два `Person` должны считаться «равными», если их `name` и `dateOfBirth` одинаковы. Эта логика будет реализована в методе `equals()` класса `Person` :
+
+```java
+public class Person { 
+    public String name; 
+    public Date dateOfBirth; 
+ 
+    public boolean equals(Person person) { 
+        return this.name.equals(person.name) && this.dateOfBirth.equals(person.dateOfBirth); 
+    } 
+ } 
+```
+
+Большинство встроенных классов в Java, а также классы, предоставляемые популярными библиотеками, будут реализовывать метод `equals()` значимым образом.
+
+Например, интерфейс `java.util.Set` указывает, что метод `equals()` `Set` возвращает true, если «указанный объект также является набором, два набора имеют одинаковый размер и каждый член указанного набора содержится в этом наборе ".
+
+Однако, если класс не переопределяет реализацию `equals()` по умолчанию, применяется реализация по умолчанию, которая просто использует оператор `==` для сравнения двух объектов.

guide/russian/java/final-keyword/index.md

@@ -0,0 +1,60 @@
+---
+title: Final
+localeTitle: окончательный
+---
+## окончательный
+
+Вы используете ключевое слово `final` чтобы пометить константу переменной, чтобы ее можно было назначить только один раз. Таким образом, вы должны инициализировать конечную переменную со значением. Если его не инициализировать (когда объявлено, внутри Constructor или внутри статических блоков), произойдет ошибка времени компиляции.
+
+**_Пример:_**
+
+```java
+class MyClass { 
+  public static final double PI = 3.14; 
+  public static void main(String[] args){ 
+    System.out.println(PI); 
+  } 
+ } 
+```
+
+PI теперь является константой. Любая попытка присвоить ему значение вызовет ошибку.
+
+* * *
+
+Если вы сделаете какой-либо метод окончательным, вы не сможете его переопределить.
+
+```java
+class Bike{ 
+  final void run(){System.out.println("running");} 
+ } 
+ 
+ class Honda extends Bike{ 
+   void run(){System.out.println("running safely with 100kmph");} 
+ 
+   public static void main(String args[]){ 
+   Honda honda= new Honda(); 
+   honda.run(); 
+   } 
+ } 
+```
+
+Выход будет - Выход: ошибка времени компиляции
+
+* * *
+
+Если вы сделаете какой-либо класс окончательным, вы не сможете его продлить.
+
+```java
+final class Bike{} 
+ 
+ class Honda1 extends Bike{ 
+  void run(){System.out.println("running safely with 100kmph");} 
+ 
+  public static void main(String args[]){ 
+  Honda1 honda= new Honda(); 
+  honda.run(); 
+  } 
+ } 
+```
+
+Выход будет - Выход: ошибка времени компиляции

guide/russian/java/finally-keyword/index.md

@@ -0,0 +1,22 @@
+---
+title: Finally
+localeTitle: в заключение
+---
+## в конце концов
+
+Блок finally всегда выполняется, когда блок try завершается. Это гарантирует, что блок finally будет выполнен, даже если произойдет непредвиденное исключение. Но, наконец, полезно не только для обработки исключений - это позволяет программисту избежать случайного обхода кода очистки путем возврата, продолжения или разрыва. Включение кода очистки в блок finally всегда является хорошей практикой, даже если не ожидается никаких исключений.
+
+**_Пример:_**
+
+```java
+try { 
+   // Normal execution path 
+   throw new EmptyStackException(); 
+ } catch (ExampleException ee) { 
+   //  deal with the ExampleException 
+ } finally { 
+   // This optional section is executed upon termination of any of the try or catch blocks above, 
+   //  except when System.exit() is called in "try" or "catch" blocks; 
+ } 
+
+```

guide/russian/java/garbage-collection/index.md

@@ -0,0 +1,108 @@
+---
+title: Garbage Collection
+localeTitle: Вывоз мусора
+---
+# Коллекция мусора в Java
+
+В таких языках, как C / C ++, разработчик обязан создавать и уничтожать объекты. Но если программист не выполняет свой долг, достаточная память может быть недоступна для создания нового объекта, и программа может закончиться **вызовом OutOfMemoryErrors** .
+
+Java освобождает программиста от задачи управления памятью и сама восстанавливает память, занятую объектами, которые больше не используются. Сбор мусора в java осуществляется демонами, называемыми **сборщиком мусора** . **JVM (виртуальная машина Java)** вызывает его, когда нехватка памяти (кучи) для новых объектов.
+
+## Когда объект становится пригодным для сбора мусора?
+
+*   Объект становится подходящим для коллекции мусора, если он недоступен ни от каких живых потоков или от каких-либо статических ссылок.
+*   Объект становится подходящим для коллекции мусора, если все ссылки являются нулевыми.
+
+```java
+         Integer n = new Integer(); 
+         n = null;                                //the Integer object is no longer accessible 
+```
+
+*   Циклические зависимости не считаются ссылкой, поэтому, если объект X имеет ссылку объекта Y, а объект Y имеет ссылку объекта X, и у них нет другой ссылки на живые ссылки, то оба объекта X и Y будут иметь право на сбор мусора.
+
+## Как вручную сделать объект подходящим для коллекции мусора?
+
+*   Несмотря на то, что программист не уничтожает объекты, это хорошая практика программирования, чтобы сделать объект недоступным (таким образом, подходящим для GC) после его использования.
+*   Как правило, существует четыре разных способа сделать объект подходящим для сбора мусора.
+
+1.  Обнуление ссылочной переменной
+2.  Повторное присвоение ссылочной переменной
+3.  Объект создается внутри блока, и ссылка выходит за пределы области действия после того, как управление выйдет из этого блока.
+4.  [Остров изоляции](http://www.geeksforgeeks.org/island-of-isolation-in-java/)
+
+## Способы обращения к JVM для запуска сборщика мусора 1
+
+*   Хотя создание объекта, имеющего право на сбор мусора, зависит от единственного усмотрения JVM, чтобы запустить сборщик мусора, чтобы его уничтожить.
+*   Мы также можем запросить JVM для запуска сборщика мусора. Это можно сделать двумя способами:
+
+1.  Использование метода _**System.gc ()**_ : системный класс содержит статический метод gc () для запроса JVM для запуска сборщика мусора.
+2.  Использование _**метода Runtime.getRuntime (). Gc ()**_ : класс Runtime позволяет приложению взаимодействовать с JVM, в котором работает приложение. Следовательно, используя свой метод gc (), мы можем запросить JVM для запуска Collector мусора.
+
+```java
+         // Java program to request 
+    // JVM to run Garbage Collector 
+ public class Test 
+ { 
+    public static void main(String[] args) throws InterruptedException 
+    { 
+        Test test1 = new Test(); 
+        Test test2 = new Test(); 
+ 
+        // Nullifying the reference variable 
+        test1 = null; 
+ 
+        // requesting JVM for running Garbage Collector 
+        System.gc(); 
+ 
+        // Nullifying the reference variable 
+        test2 = null; 
+ 
+        // requesting JVM for running Garbage Collector 
+        Runtime.getRuntime().gc(); 
+ 
+    } 
+ 
+    @Override 
+    // finalize method is a method which is called on object once 
+    // before garbage collector is destroying it and reclaiming its memory 
+    protected void finalize() throws Throwable 
+    { 
+        System.out.println("Garbage collector is called"); 
+        System.out.println("Object garbage collected : " + this); 
+    } 
+ } 
+```
+
+```java
+  OUTPUT - 
+    Garbage collector called 
+    Object garbage collected : Test@46d08f12 
+    Garbage collector called 
+    Object garbage collected : Test@481779b8 
+```
+
+Заметка :
+
+1.  Нет никакой гарантии, что любой из двух вышеперечисленных методов определенно будет запускать сборщик мусора.
+2.  Вызов System.gc () фактически эквивалентен вызову: Runtime.getRuntime (). Gc ()
+
+## Финализация объектов
+
+*   Объекты имеют ресурсы, связанные с ними. Это их обязанность освобождать ресурсы.
+*   Finalize () объявляется в классе Object и вызывается сборщиком мусора один раз, перед уничтожением объекта. Объект может предпринять любое последнее действие, используя этот метод jst, прежде чем его область будет исправлена ​​сборщиком мусора.
+*   finalize () присутствует в классе Object со следующим прототипом.
+
+```java
+    protected void finalize() throws Throwable 
+```
+
+## ПРИМЕЧАНИЕ 1 :
+
+1.  Метод finalize (), вызываемый сборщиком мусора, а не JVM. Хотя Garbage Collector является одним из модулей JVM.
+2.  Метод finalize () класса объекта имеет пустую реализацию, поэтому рекомендуется переопределить метод finalize () для утилизации системных ресурсов или для выполнения другой очистки.
+3.  Метод finalize () никогда не вызывается более одного раза для любого заданного объекта.
+4.  Если исключенное исключение выбрано методом finalize (), исключение игнорируется и завершается завершение этого объекта.
+
+### ИСТОЧНИКИ
+
+1.  [geeksforgeeks.](http://www.geeksforgeeks.org/garbage-collection-java/) Доступ: 24 октября 2017 года.

guide/russian/java/generics/index.md

@@ -0,0 +1,79 @@
+---
+title: Generics
+localeTitle: Дженерики
+---
+# Дженерики
+
+Java Generics - это способ для удобного использования коллекций и классов для конкретных типов данных, из-за необходимости возвращать данные в исходный тип данных. Это предотвращает большую головную боль в виде времени компиляции и ошибок времени выполнения.
+
+Проще говоря, Generics позволяет вам прямо сказать, что, например, объект ArrayList содержит целые числа, поэтому при вызове метода get вам не нужно преобразовывать объекты Object и Integer. Ниже приведен пример того, как вы использовали ArrayList до Generics.
+
+```java
+import java.util.ArrayList; 
+ 
+ public class Example { 
+  private ArrayList classNames; 
+ 
+  public Example() { 
+    classNames = new ArrayList(); 
+  } 
+ 
+  public void addName(String name) { 
+    classNames.add(name); 
+  } 
+ 
+  public String getNameAtIndex(int index) { 
+    return (String) classNames.get(index); 
+  } 
+ } 
+```
+
+Основная проблема с вышеизложенным заключается в том, что если какой-либо объект типа типа String был добавлен в ArrayList, тогда метод `getNameAtIndex(int index)` приведет к ошибке выполнения. Чтобы решить эту проблему, мы используем Generics.
+
+Синтаксис для Generics очень прост. Ниже приведен пример создания экземпляра ArrayList.
+
+```java
+import java.util.ArrayList; 
+ 
+ public class Example { 
+  private ArrayList<String> classNames; 
+ 
+  public Example() { 
+    classNames = new ArrayList<String>(); 
+  } 
+ 
+  public void addName(String name) { 
+    classNames.add(name); 
+  } 
+ 
+  public String getNameAtIndex(int index) { 
+    return classNames.get(index); 
+  } 
+ } 
+```
+
+Синтаксис для создания собственного Generic-класса будет следующим.
+
+```java
+import java.util.ArrayList; 
+ 
+ public class Example <T> { 
+  private ArrayList<T> classNames; 
+ 
+  public Example() { 
+    classNames = new ArrayList<T>(); 
+  } 
+ 
+  public void addName(T name) { 
+    classNames.add(name); 
+  } 
+ 
+  public T getNameAtIndex(int index) { 
+    return classNames.get(index); 
+  } 
+ } 
+```
+
+Обратите внимание, что внутри угловых скобок при присвоении имени классу вы можете убедиться, что тип Generic - это то, что вы хотите. Например, если вы хотите убедиться, что тип может быть прочитан как форма String, вы должны пойти `<T extends String>` .
+
+Обратите внимание, что буква `T` является заполнителем, вы можете сделать все, что угодно, до тех пор, пока вы используете тот же самый во всем классе.

guide/russian/java/getters-and-setters/index.md

@@ -0,0 +1,73 @@
+---
+title: Getters & Setters
+localeTitle: Getters & Setters
+---
+# Getters & Setters
+
+Getters и Setters используются для эффективной защиты ваших данных, особенно при создании классов. Для каждой переменной экземпляра метод getter возвращает свое значение, в то время как метод setter устанавливает или обновляет его значение. Геттеры и сеттеры также известны как аксессоры и мутаторы, соответственно.
+
+По соглашению, getters начинаются с get, за которым следует имя переменной, с первой буквой имени переменной с заглавной буквы. Стартеры начинаются с набора, за которым следует имя переменной, с первой буквой имени переменной с заглавной буквы.
+
+**_Пример:_**
+
+```java
+public class Vehicle { 
+  private String color; 
+ 
+  // Getter 
+  public String getColor() { 
+  return color; 
+  } 
+ 
+  // Setter 
+  public void setColor(String c) { 
+  this.color = c; 
+  } 
+ } 
+```
+
+Метод getter возвращает значение атрибута. Метод setter принимает параметр и присваивает его атрибуту.
+
+Как только геттер и сеттер были определены, мы используем его в нашей основной:
+
+```java
+public stativ void main(String[] args) { 
+  Vehicle v1 = new Vehicle(); 
+  v1.setColor("Red"); 
+  System.out.println(v1.getColor()); 
+ } 
+ 
+ // Outputs "Red" 
+```
+
+* * *
+
+Getters и seters позволяют контролировать значения. Вы можете проверить данное значение в настройщике, прежде чем устанавливать значение.
+
+## Почему геттер и сеттер?
+
+Используя геттер и сеттер, программист может контролировать доступ и обновление важных переменных, например изменение значения переменной в заданном диапазоне. Рассмотрим следующий код метода сеттера:
+
+```java
+public void setNumber(int num) { 
+    if (num < 10 || num > 100) { 
+        throw new IllegalArgumentException(); 
+    } 
+    this.number = num; 
+ } 
+```
+
+Это гарантирует, что значение числа всегда устанавливается между 10 и 100. Если программист позволяет напрямую изменять значение переменной, вызывающий может установить для него любое произвольное значение:
+
+```java
+obj.number = 3; 
+```
+
+Это нарушает ограничение для значений от 10 до 100 для этой переменной. Поскольку мы не ожидаем, что это произойдет, скрытие номера переменной как частного и использование setter предотвращает ее. С другой стороны, метод getter - единственный способ для внешнего мира прочитать значение переменной:
+
+```java
+public int getNumber() { 
+    return this.number; 
+ } 
+
+```

guide/russian/java/index.md

@@ -0,0 +1,119 @@
+---
+title: Java
+localeTitle: Ява
+---
+**Что такое Java?**
+
+[Java](https://www.oracle.com/java/index.html) - это язык программирования, разработанный [Sun Microsystems](https://en.wikipedia.org/wiki/Sun_Microsystems) в 1995 году, который позже получил [Oracle](http://www.oracle.com/index.html) . Теперь это полноценная платформа с множеством стандартных API-интерфейсов, API-интерфейсов с открытым исходным кодом, инструментов, огромного сообщества разработчиков и используется для создания наиболее надежных корпоративных решений как крупными, так и небольшими компаниями. Разработка приложений для [Android](https://www.android.com/) полностью реализована с помощью Java и его экосистемы. Чтобы узнать больше о Java, прочитайте [это](https://java.com/en/download/faq/whatis_java.xml) и [это](http://tutorials.jenkov.com/java/what-is-java.html) .
+
+## Версия
+
+Последняя версия - это [Java 11](http://www.oracle.com/technetwork/java/javase/overview) , выпущенная в 2018 году с [различными улучшениями по](https://www.oracle.com/technetwork/java/javase/11-relnote-issues-5012449.html) сравнению с предыдущей версией Java 10. Но для всех целей и задач мы будем использовать Java 8 в этой вики для всех обучающих программ.
+
+Java также разделен на несколько «Изданий»:
+
+*   [SE](http://www.oracle.com/technetwork/java/javase/overview/index.html) - Standard Edition - для настольных и автономных серверных приложений
+*   [EE](http://www.oracle.com/technetwork/java/javaee/overview/index.html) - Enterprise Edition - для разработки и выполнения компонентов Java, которые внедряются в Java-сервер
+*   [ME](http://www.oracle.com/technetwork/java/embedded/javame/overview/index.html) - Micro Edition - для разработки и выполнения приложений Java на мобильных телефонах и встроенных устройствах
+
+## Установка: JDK или JRE?
+
+Загрузите последние Java-файлы с [официального сайта](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) . Здесь вы можете столкнуться с вопросом, какой из них скачать, JDK или JRE? JRE означает Java Runtime Environment, которая является платформой, зависящей от Java Virtual Machine, для запуска Java-кодов, а JDK - Java Development Kit, который состоит из большинства инструментов разработки, а самое главное - `javac` компилятора, а также JRE. Таким образом, для обычного пользователя JRE будет достаточно, но поскольку мы будем разрабатывать Java, мы будем загружать JDK.
+
+## Инструкции по установке на платформе
+
+### Windows
+
+*   Загрузите соответствующий [.msi-](https://en.wikipedia.org/wiki/Windows_Installer) файл (x86 / i586 для 32 бит, x64 для 64 бит)
+*   Запустите файл .msi. Это сам извлекающий исполняемый файл, который установит Java в вашей системе!
+
+### Linux
+
+*   Загрузите соответствующий [tar.gz-](http://www.cyberciti.biz/faq/linux-unix-bsd-extract-targz-file/) файл для вашей системы и установите:
+
+`bash $ tar zxvf jdk-8uversion-linux-x64.tar.gz`
+
+*   [RPM-платформы Linux](https://en.wikipedia.org/wiki/List_of_Linux_distributions#RPM-based) загружают соответствующий файл [.rpm](https://en.wikipedia.org/wiki/RPM_Package_Manager) и устанавливают:
+
+`bash $ rpm -ivh jdk-8uversion-linux-x64.rpm`
+
+*   Пользователи имеют возможность установить версию с открытым исходным кодом Java, OpenJDK или Oracle JDK. Хотя OpenJDK находится в активной разработке и синхронизируется с Oracle JDK, они просто отличаются [лицензированием](http://openjdk.java.net/faq/) . Однако немногие разработчики жалуются на стабильность Open JDK. Инструкции для **Ubuntu** :
+
+Открытая установка JDK:  
+`bash sudo apt-get install openjdk-8-jdk`
+
+Установка Oracle JDK:  
+`bash sudo add-apt-repository ppa:webupd8team/java sudo apt-get update sudo apt-get install oracle-java8-installer`
+
+### макинтош
+
+*   Или загрузите исполняемый файл Mac OSX .dmg из Oracle Downloads
+*   Или используйте [Homebrew](http://brew.sh/) для [установки](http://stackoverflow.com/a/28635465/2861269) :
+
+`bash brew tap caskroom/cask brew install brew-cask brew cask install java`
+
+### Проверить установку
+
+Убедитесь, что Java правильно установлена ​​в вашей системе, открыв командную строку (Windows) / Windows Powershell / Terminal (Mac OS и \* Unix) и проверив версии Java runtime и компилятора:
+```
+$ java -version 
+ java version "1.8.0_66" 
+ Java(TM) SE Runtime Environment (build 1.8.0_66-b17) 
+ Java HotSpot(TM) 64-Bit Server VM (build 25.66-b17, mixed mode) 
+ 
+ $ javac -version 
+ javac 1.8.0_66 
+```
+
+**Совет** . Если вы получаете сообщение об ошибке «Команда не найдена» ни на `java` ни на `javac` ни на то и другое, не паникуйте, просто ваша система PATH неправильно настроена. Для Windows см. [Этот ответ StackOverflow](http://stackoverflow.com/questions/15796855/java-is-not-recognized-as-an-internal-or-external-command) или [эту статью](http://javaandme.com/) о том, как это сделать. Также есть руководства для [Ubuntu](http://stackoverflow.com/questions/9612941/how-to-set-java-environment-path-in-ubuntu) и [Mac](http://www.mkyong.com/java/how-to-set-java_home-environment-variable-on-mac-os-x/) . Если вы все еще не можете понять это, не волнуйтесь, просто спросите нас в нашей [комнате Гиттера](https://gitter.im/FreeCodeCamp/java) !
+
+## JVM
+
+Хорошо, так как мы закончили установку, давайте начнем сначала понимать nitty gritty экосистемы Java. Java - это [интерпретируемый и скомпилированный](http://stackoverflow.com/questions/1326071/is-java-a-compiled-or-an-interpreted-programming-language) язык, то есть код, который мы пишем, компилируется в байт-код и интерпретируется для запуска. Мы пишем код в .java-файлах, Java компилирует их в [байт-коды,](https://en.wikipedia.org/wiki/Java_bytecode) которые запускаются на виртуальной машине Java или JVM для выполнения. Эти байт-коды обычно имеют расширение .class.
+
+Java - довольно безопасный язык, так как он не позволяет вашей программе работать непосредственно на машине. Вместо этого ваша программа запускается на виртуальной машине под названием JVM. Эта виртуальная машина предоставляет несколько API для низкоуровневых взаимодействий с машиной, которые вы можете сделать, но кроме этого вы не можете играть с машинными инструкциями явно. Это добавляет огромный бонус к безопасности.
+
+Кроме того, как только ваш байт-код будет скомпилирован, он может работать на любой виртуальной машине Java. Эта виртуальная машина зависит от машины, то есть она имеет разные реализации для Windows, Linux и Mac. Но ваша программа гарантирована для работы в любой системе благодаря этой виртуальной машине. Эта философия называется [«Write Once, Run Anywhere»](https://en.wikipedia.org/wiki/Write_once,_run_anywhere) .
+
+## Привет, мир!
+
+Давайте напишем образец приложения Hello World. Откройте любой редактор / IDE по выбору и создайте файл `HelloWorld.java` .
+```
+public class HelloWorld { 
+ 
+    public static void main(String[] args) { 
+        // Prints "Hello, World" to the terminal window. 
+        System.out.println("Hello, World"); 
+    } 
+ 
+ } 
+```
+
+**NB** Имейте в виду, что имя файла Java должно быть **точно таким же именем открытого класса** для компиляции!
+
+Теперь откройте терминал / Командная строка. Измените текущий каталог в терминале / Командная строка в каталог, в котором находится ваш файл. И скомпилируйте файл:
+```
+$ javac HelloWorld.java 
+```
+
+Теперь запустите файл с помощью команды `java` !
+```
+$ java HelloWorld 
+ Hello, World 
+```
+
+Congrats! Ваша первая Java-программа успешно запущена. Здесь мы просто печатаем строку, передающую ее в API `System.out.println` . Мы рассмотрим все концепции в коде, но вы можете более [внимательно ознакомиться](https://docs.oracle.com/javase/tutorial/getStarted/application/) ! Если у вас есть какие-либо сомнения или вам нужна дополнительная помощь, не стесняйтесь обращаться к нам в любое время в нашем [Gitter Chatroom](https://gitter.im/FreeCodeCamp/java) !
+
+## Документация
+
+Java сильно [документирована](https://docs.oracle.com/javase/8/docs/) , поскольку она поддерживает огромное количество API. Если вы используете какую-либо большую среду IDE, такую ​​как Eclipse или IntelliJ IDEA, вы можете найти документацию Java, включенную внутри.
+
+Кроме того, здесь приведен список бесплатных IDE для Java-кодирования:
+
+*   [NetBeans](https://netbeans.org/)
+*   [Затмение](https://eclipse.org/)
+*   [IntelliJ IDEA](https://www.jetbrains.com/idea/features/)
+*   [Android Studio](https://developer.android.com/studio/index.html)
+*   [BlueJ](https://www.bluej.org/)
+*   [jEdit](http://www.jedit.org/)
+*   [Oracle JDeveloper](http://www.oracle.com/technetwork/developer-tools/jdev/overview/index-094652.html)

guide/russian/java/inheritance-basics/index.md

@@ -0,0 +1,53 @@
+---
+title: Inheritance Basics
+localeTitle: Основы наследования
+---
+# Основы наследования
+
+Настолько замечательно, что вы успешно создали класс Car. Но, подожди, не являются ли машины Тесла электрическими вариантами? Я хочу класс Electric car, но он также должен обладать свойствами оригинального класса `Car` .
+
+Решение: **Наследование** . Java обеспечивает опрятный способ «наследовать» родительские свойства:
+
+```java
+public class Car { 
+ 
+    private String name; 
+    private String manufacturerName; 
+ 
+    public Car(String name, String man) { 
+        this.name = name; 
+        this.manufacturerName = man; 
+    } 
+    // Getter method 
+    public String getName() { 
+        return name; 
+    } 
+    // Getter method 
+    public String getManufacturerName() { 
+        return manufacturerName; 
+    } 
+ } 
+ 
+ public class ElectricCar extends Car { 
+ 
+    public ElectricCar(String name, String man) { 
+        super(name, man); 
+    } 
+ 
+    public void charge() { 
+     System.out.println("Charging ..."); 
+    } 
+ } 
+ 
+ ElectricCar modelS = new ElectricCar("Model S","Tesla"); 
+ // prints Tesla 
+ System.out.println(modelS.getManufacturerName()); 
+ // prints Charging ... 
+ modelS.charge(); 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZY/0)
+
+См. Здесь, что класс `ElectricCar` наследует или `extends` общедоступные методы класса `Car` , а также имеет свои собственные методы и свойства. Прохладный способ передать информацию!
+
+Также обратите внимание на использование ключевого слова [super](https://docs.oracle.com/javase/tutorial/java/IandI/super.html) . Поскольку наш класс `Car` имел конструктор, мы должны инициализировать этот конструктор и из дочернего класса. Мы делаем это, используя ключевое слово `super` . Узнайте больше о Наследовании здесь .

guide/russian/java/inheritance/index.md

@@ -0,0 +1,192 @@
+---
+title: Inheritance
+localeTitle: наследование
+---
+# наследование
+
+Наследование Java относится к способности класса Java `inherit` свойства другого класса. Подумайте об этом, как о ребенке, наследующем свойства от своих родителей, концепция очень похожа на это. В Java lingo он также называется _расширением_ класса. Некоторые простые вещи, которые нужно запомнить:
+
+*   Класс, который распространяется или наследуется, называется **подклассом**
+*   Класс, который расширяется или унаследован, называется **суперклассом**
+
+Таким образом, наследование дает Java отличную возможность _повторного использования_ кода или обмена кодами между классами!
+
+Давайте опишем его с классическим примером класса `Vehicle` класса `Car` :
+
+```java
+public class Vehicle { 
+    public void start() { 
+        // starting the engine 
+    } 
+ 
+    public void stop() { 
+        // stopping the engine 
+    } 
+ } 
+ 
+ public class Car extends Vehicle { 
+    int numberOfSeats = 4; 
+ 
+    public int getNumberOfSeats() { 
+        return numberOfSeats; 
+    } 
+ } 
+```
+
+Здесь мы можем увидеть класс `Car` наследующий свойства класса `Vehicle` . Таким образом, нам не нужно писать один и тот же код для методов `start()` и `stop()` для `Car` , так как эти свойства доступны из его родительского или суперкласса. Поэтому объекты, созданные из класса `Car` , _также_ будут обладать этими свойствами!
+
+```java
+Car tesla = new Car(); 
+ 
+ tesla.start(); 
+ 
+ tesla.stop(); 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJXz/0)
+
+Но имеет ли родительский класс методы для ребенка? Нет, нет.
+
+Следовательно, всякий раз, когда вам нужно разделить некоторые общие части кода между несколькими классами, всегда полезно иметь родительский класс, а затем распространять этот класс всякий раз, когда это необходимо! Сокращает количество строк кода, делает код модульным и упрощает тестирование.
+
+## Что можно унаследовать?
+
+*   Все `protected` и `public` поля и методы от родительских
+
+## Что нельзя унаследовать?
+
+*   `private` поля и методы
+*   Конструкторы. Хотя конструктор подкласса _должен_ вызывать конструктор суперкласса, если он определен (подробнее об этом позже!)
+*   Несколько классов. Java поддерживает только **одно наследование** , то есть вы можете наследовать только один класс за раз.
+*   Поля. Отдельные поля класса не могут быть переопределены подклассом.
+
+## Тип литья и ссылки
+
+В Java можно ссылаться на подкласс как _экземпляр_ его суперкласса. Он называется _полиморфизмом_ в объектно-ориентированном программировании (ООП), возможностью для объекта принимать различные формы. Например, объект класса `Car` можно называть экземпляром класса `Vehicle` следующим образом:
+
+```java
+Vehicle car = new Car(); 
+```
+
+Хотя, наоборот, невозможно:
+
+```java
+Car car = new Vehicle(); // ERROR 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYB/0)
+
+Поскольку вы можете ссылаться на подкласс Java как экземпляр суперкласса, вы можете легко передать экземпляр объекта подкласса в экземпляр суперкласса. Можно включить объект суперкласса в тип подкласса, но _только если объект действительно является экземпляром подкласса_ . Поэтому имейте это в виду:
+
+```java
+Car car = new Car(); 
+ Vehicle vehicle = car; // upcasting 
+ Car car2 = (Car)vechile; //downcasting 
+ 
+ Bike bike = new Bike(); // say Bike is also a subclass of Vehicle 
+ Vehicle v = bike; // upcasting, no problem here. 
+ Car car3 = (Car)bike; // Compilation Error : as bike is NOT a instance of Car 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYM/0)
+
+Теперь вы знаете, как делиться кодом через отношения родитель-ребенок. Но что, если вам не нравится реализация определенного метода в дочернем классе и хотите написать для него новый? Что вы делаете тогда?
+
+## Переопределите это!
+
+Java позволяет вам _переопределять_ или переопределять методы, определенные в суперклассе. Например, ваш класс `Car` имеет другую реализацию `start()` чем исходный `Vehicle` , поэтому вы делаете это:
+
+```java
+public class Vehicle { 
+    public void start() { 
+      System.out.println("Vehicle start code"); 
+    } 
+ } 
+ 
+ public class Car extends Vehicle { 
+    public void start() { 
+      System.out.println("Car start code"); 
+  } 
+ } 
+ 
+ Car car = new Car(); 
+ car.start(); // "Car start code" 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYZ/1)
+
+Таким образом, довольно просто переопределить методы в подклассе. Хотя, есть _улов_ . Только этот метод суперкласса с той _же сигнатурой метода,_ что и метод подкласса, будет переопределен. Это означает, что определение метода подкласса должно иметь одно и то же имя, одинаковое количество и тип параметров и в той же последовательности. Таким образом, `public void start(String key)` не будет отменять `public void start()` .
+
+**Примечания** :
+
+*   Вы не можете переопределить частные методы суперкласса. (Совершенно очевидно, не так ли?)
+*   Что делать, если метод суперкласса, который вы переопределяете в подклассе, внезапно исчезает или меняются методы? Это не сработает во время выполнения! Поэтому Java предоставляет вам замечательную аннотацию `@Override` которую вы можете разместить над методом подкласса, который будет предупреждать компилятор об этих инцидентах!
+
+Аннотации на Java - хорошая практика кодирования, но они не являются необходимостью. Компилятор достаточно умен, чтобы разобраться в себе. В отличие от других языков ООП, аннотации в Java не обязательно изменят метод или добавляют дополнительные функции.
+
+## Как назвать методы суперкласса?
+
+Забавно, что вы спрашиваете об этом! Просто используйте ключевое слово `super` :
+
+```java
+public class Vehicle() { 
+    public void start() { 
+      System.out.println("Vehicle start code"); 
+    } 
+ } 
+ 
+ public class Car extends Vehicle { 
+    public void run() { 
+      super.start(); 
+  } 
+ } 
+ 
+ Car car = new Car(); 
+ car.run(); // "Vehicle start code" 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJY4/0)
+
+**NB** : Хотя вы можете вызвать родительский метод, используя `super` , вы не можете подойти к иерархии наследования с помощью прикованных `super` вызовов.
+
+## Как узнать тип класса?
+
+Использование ключевого слова `instanceof` . Обладая множеством классов и подклассов, было бы немного смутно знать, какой класс является подклассом, из которых один во время выполнения. Таким образом, мы можем использовать `instanceof` для определения того, является ли объект экземпляром класса, экземпляром подкласса или экземпляром интерфейса.
+
+```java
+Car car = new Car(); 
+ 
+ boolean flag = car instanceof Vehicle; // true in this case! 
+```
+
+## Конструкторы и наследование
+
+Как упоминалось ранее, конструкторы не могут быть непосредственно унаследованы подклассом. Хотя подкласс _требуется_ для вызова конструктора своего родителя в качестве [первой операции](http://stackoverflow.com/questions/1168345/why-does-this-and-super-have-to-be-the-first-statement-in-a-constructor) в своем собственном конструкторе. Как? Вы догадались, используя `super` :
+
+```java
+public class Vehicle { 
+    public Vehicle() { 
+        // constructor 
+    } 
+    public void start() { 
+      System.out.println("Vehicle start code"); 
+    } 
+ } 
+ 
+ public class Car extends Vehicle { 
+    public Car() { 
+      super(); 
+    } 
+    public void run() { 
+      super.start(); 
+  } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJY8/0)
+
+Помните, что если суперкласс не имеет определенных конструкторов, вам не нужно его явно указывать в подклассе. Java обрабатывает это внутренне для вас! Вызов в `super` выполняется в случае, когда суперкласс должен вызываться с любым другим конструктором, отличным от _конструктора_ по _умолчанию_ .
+
+Если никакие другие конструкторы не определены, то Java вызывает конструктор суперкласса по умолчанию ( _даже если он явно не определен_ ).
+
+Поздравляю, теперь вы все знаете о Наследии! Подробнее о расширенных способах наследования вещей в абстрактных классах и [интерфейсах](//forum.freecodecamp.com/t/java-docs-interfaces) !

guide/russian/java/instanceof-operator/index.md

@@ -0,0 +1,16 @@
+---
+title: instanceof Operator
+localeTitle: instanceof Operator
+---
+# оператор `instanceof`
+
+`instanceof` оператор позволяет проверить действительность `IS A` отношение. Если в какой-то момент времени мы не уверены в этом, и мы хотим проверить это во время выполнения, мы можем сделать следующее:
+
+```java
+//assuming vehicle is an instance of Class `Car` the expression inside the 'if' will  return true 
+ if(vehicle instanceof Car){ 
+    //do something if vehicle is a Car 
+ } 
+```
+
+**Примечание** . Если вы примените оператор instanceof с любой переменной, которая имеет нулевое значение, она возвращает false.

guide/russian/java/interfaces/index.md

@@ -0,0 +1,265 @@
+---
+title: Interfaces
+localeTitle: Интерфейсы
+---
+# Интерфейсы
+
+Интерфейс в Java немного похож на класс, но с существенной разницей: `interface` может иметь _только_ сигнатуры методов, поля и методы по умолчанию. Начиная с Java 8, вы также можете создавать [методы по умолчанию](https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html) . В следующем блоке вы можете увидеть пример интерфейса:
+
+```java
+public interface Vehicle { 
+    public String licensePlate = ""; 
+    public float maxVel 
+    public void start(); 
+    public void stop(); 
+    default void blowHorn(){ 
+      System.out.println("Blowing horn"); 
+   } 
+ } 
+```
+
+Интерфейс выше содержит два поля, два метода и метод по умолчанию. В одиночку это не очень полезно, но они обычно используются вместе с классами. Как? Простой, вы должны убедиться, что какой-то класс `implements` его.
+
+```java
+public class Car implements Vehicle { 
+    public void start() { 
+        System.out.println("starting engine..."); 
+    } 
+    public void stop() { 
+        System.out.println("stopping engine..."); 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CItd/0)
+
+Теперь существует **основное правило** : класс должен реализовать **все** методы в интерфейсе. Методы должны иметь _одну и ту же_ подпись (имя, параметры и исключения), как описано в интерфейсе. Класс _не_ обязательно должен объявлять поля, но только методы.
+
+## Экземпляры интерфейса
+
+После создания класса Java, который `implements` любой интерфейс, экземпляр объекта может ссылаться как экземпляр интерфейса. Эта концепция аналогична концепции экземпляра Inheritance.
+
+```java
+// following our previous example 
+ 
+ Vehicle tesla = new Car(); 
+ 
+ tesla.start(); // starting engine ... 
+```
+
+Интерфейс **не может** содержать методы конструктора, поэтому вы **не можете** создать экземпляр самого интерфейса. Вы должны создать экземпляр некоторого класса, реализующего интерфейс для его ссылки. Подумайте о интерфейсах в виде пустой формы контракта или шаблона.
+
+Что вы можете сделать с этой функцией? Полиморфизм! Вы можете использовать только интерфейсы для обращения к экземплярам объектов!
+
+```java
+class Truck implements Vehicle { 
+    public void start() { 
+        System.out.println("starting truck engine..."); 
+    } 
+    public void stop() { 
+        System.out.println("stopping truck engine..."); 
+    } 
+ } 
+ 
+ class Starter { 
+    // static method, can be called without instantiating the class 
+    public static void startEngine(Vehicle vehicle) { 
+        vehicle.start(); 
+    } 
+ } 
+ 
+ Vehicle tesla = new Car(); 
+ Vehicle tata = new Truck(); 
+ 
+ Starter.startEngine(tesla); // starting engine ... 
+ Starter.startEngine(tata); // starting truck engine ... 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CItm/0)
+
+## Но как насчет нескольких интерфейсов?
+
+Да, вы можете реализовать несколько интерфейсов в одном классе. В то время как в [Inheritance](//forum.freecodecamp.com/t/java-docs-inheritance) внутри Classes вам было запрещено наследовать только один класс, здесь вы можете расширить любое количество интерфейсов. Но не забудьте реализовать _все_ методы всех интерфейсов, иначе компиляция завершится неудачно!
+
+```java
+public interface GPS { 
+    public void getCoordinates(); 
+ } 
+ 
+ public interface Radio { 
+    public void startRadio(); 
+    public void stopRadio(); 
+ } 
+ 
+ public class Smartphone implements GPS,Radio { 
+    public void getCoordinates() { 
+        // return some coordinates 
+    } 
+    public void startRadio() { 
+      // start Radio 
+    } 
+    public void stopRadio() { 
+        // stop Radio 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CIto/0)
+
+## Некоторые функции интерфейсов
+
+*   Вы можете размещать переменные в интерфейсе, хотя это не будет разумным решением, поскольку классы не должны иметь одну и ту же переменную. Короче говоря, избегайте размещения переменных!
+*   Все переменные и методы в интерфейсе являются общедоступными, даже если вы не используете ключевое слово `public` .
+*   Интерфейс не может указать реализацию конкретного метода. Это до Классы, чтобы сделать это. Несмотря на недавнее исключение (см. Ниже).
+*   Если класс реализует несколько интерфейсов, тогда существует дистанционная вероятность перекрытия сигнатуры метода. Так как Java не допускает нескольких методов одной и той же сигнатуры, это может привести к проблемам. См. [Этот вопрос](http://stackoverflow.com/questions/2598009/method-name-collision-in-interface-implementation-java) для получения дополнительной информации.
+
+## Методы интерфейса по умолчанию
+
+До Java 8 у нас не было никакого способа направить интерфейс для реализации конкретного метода. Это приводит к большому путанице и разрыву кода, если определение интерфейса внезапно изменяется.
+
+Предположим, вы написали библиотеку с открытым исходным кодом, которая содержит интерфейс. Скажем, ваши клиенты, т.е. практически все разработчики по всему миру, используют его в большой степени и счастливы. Теперь вам нужно обновить библиотеку, добавив новое определение метода в интерфейс для поддержки новой функции. Но это сломает _все_ сборки, поскольку все классы, реализующие этот интерфейс, должны теперь измениться. Какая катастрофа!
+
+К счастью, Java 8 теперь предоставляет нам методы по `default` для интерфейсов. Метод по `default` _может_ содержать собственную реализацию _непосредственно_ в интерфейсе! Итак, если класс не реализует метод по умолчанию, компилятор выполнит реализацию, упомянутую в интерфейсе. Приятно, не так ли? Поэтому в вашей библиотеке вы можете добавить любое количество методов по умолчанию в интерфейсах, не опасаясь ничего сломать!
+
+```java
+public interface GPS { 
+    public void getCoordinates(); 
+    default public void getRoughCoordinates() { 
+        // implementation to return coordinates from rough sources 
+        // such as wifi & mobile 
+        System.out.println("Fetching rough coordinates..."); 
+    } 
+ } 
+ 
+ public interface Radio { 
+    public void startRadio(); 
+    public void stopRadio(); 
+ } 
+ 
+ public class Smartphone implements GPS,Radio { 
+    public void getCoordinates() { 
+        // return some coordinates 
+    } 
+    public void startRadio() { 
+      // start Radio 
+    } 
+    public void stopRadio() { 
+        // stop Radio 
+    } 
+ 
+    // no implementation of getRoughCoordinates() 
+ } 
+ 
+ Smartphone motoG = new Smartphone(); 
+ motog.getRoughCoordinates(); // Fetching rough coordinates... 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CItp/0)
+
+### Но что произойдет, если два интерфейса имеют одну и ту же подпись метода?
+
+Удивительный вопрос. В этом случае, если вы не предоставите реализацию в классе, плохой компилятор будет запутан и просто провалится! Вы также должны обеспечить реализацию метода по умолчанию в классе. Существует также отличный способ использовать `super` чтобы назвать, какая реализация вам нравится:
+
+```java
+public interface Radio { 
+    // public void startRadio(); 
+    // public void stopRadio(); 
+ 
+    default public void next() { 
+        System.out.println("Next from Radio"); 
+    } 
+ } 
+ 
+ public interface MusicPlayer { 
+    // public void start(); 
+    // public void pause(); 
+    // public void stop(); 
+ 
+    default public void next() { 
+        System.out.println("Next from MusicPlayer"); 
+    } 
+ } 
+ 
+ public class Smartphone implements Radio, MusicPlayer { 
+    public void next() { 
+        // Suppose you want to call MusicPlayer next 
+        MusicPlayer.super.next(); 
+    } 
+ } 
+ 
+ Smartphone motoG = new Smartphone(); 
+ motoG.next(); // Next from MusicPlayer 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CIts/0)
+
+## Статические методы в интерфейсах
+
+Также новым для Java 8 является возможность добавления статических методов в интерфейсы. Статические методы в интерфейсах почти идентичны статическим методам в конкретных классах. Единственное большое различие заключается в том, что `static` методы не наследуются в классах, реализующих интерфейс. Это означает, что интерфейс ссылается при вызове статического метода, а не в классе, который его реализует.
+
+```java
+interface MusicPlayer { 
+  public static void commercial(String sponsor) { 
+    System.out.println("Now for a message brought to you by " + sponsor); 
+  } 
+ 
+  public void play(); 
+ } 
+ 
+ 
+ class Smartphone implements MusicPlayer { 
+    public void play() { 
+        System.out.println("Playing from smartphone"); 
+    } 
+ } 
+ 
+ class Main { 
+  public static void main(String[] args) { 
+    Smartphone motoG = new Smartphone(); 
+    MusicPlayer.commercial("Motorola"); // Called on interface not on implementing class 
+    // motoG.commercial("Motorola"); // This would cause a compilation error 
+  } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CIts/9)
+
+## Наследование интерфейса
+
+В Java также возможно, чтобы интерфейс _наследовал_ другой интерфейс, используя, как вы уже догадались, `extends` ключевое слово:
+
+```java
+public interface Player { 
+    public void start(); 
+    public void pause(); 
+    public void stop(); 
+ } 
+ 
+ public interface MusicPlayer extends Player { 
+    default public void next() { 
+        System.out.println("Next from MusicPlayer"); 
+    } 
+ } 
+```
+
+Это означает, что класс, реализующий интерфейс `MusicPlayer` должен реализовывать _все_ методы `MusicPlayer` а также `Player` :
+
+```java
+public class SmartPhone implements MusicPlayer { 
+    public void start() { 
+        System.out.println("start"); 
+    } 
+    public void stop() { 
+        System.out.println("stop"); 
+    } 
+    public void pause() { 
+        System.out.println("pause"); 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CIty/0)
+
+Ой, я забыл `next()` ? См., Поскольку это был метод по `default` , мне не пришлось реализовывать реализацию вообще. (Не будет работать для JDK <8)
+
+Итак, теперь у вас есть хорошее понимание интерфейсов! Познакомьтесь с абстрактными классами, чтобы узнать, как Java дает вам еще один способ определения контрактов.

guide/russian/java/java-bean/index.md

@@ -0,0 +1,11 @@
+---
+title: Java Bean
+localeTitle: Java Bean
+---
+## Java Bean
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация:

guide/russian/java/javafx/index.md

@@ -0,0 +1,37 @@
+---
+title: JavaFX
+localeTitle: JavaFX
+---
+## Введение
+
+JavaFX - это графическая среда, созданная Sun Microsystems, используемая для разработки богатых настольных и интернет-приложений. JavaFX был создан для замены значительно более старых библиотек Swing and Abstract Window Toolkit (AWT) и служит стандартным графическим API-интерфейсом Java для Java Standard Edition.
+
+## Инструменты разработки
+
+### Gulon SceneBuilder
+
+Gulon Scene Builder - это приложение, используемое для интерфейса пользовательского интерфейса (UI) в JavaFX. Приложение использует drag-and-drop для быстрого дизайна пользовательского интерфейса, что позволяет визуализировать интерфейс, который вы создаете при его разработке.
+
+#### Screeenshots:
+
+![Пользовательский интерфейс Scene Builder](https://i.imgur.com/3d9SqBR.png)
+
+### FXML
+
+FXML - это язык разметки на основе XML, используемый для определения структур в JavaFX. Документ FXML излагает различные объекты в классе в дереве, аналогичном размещению тегов в документах XML.
+
+#### Пример:
+
+```XML
+<HBox spacing="10" alignment="bottom_right" > // Creates an HBox Object 
+        <Button text="Sign In"/> // Nested inside the HBox is a Button object with the text 'Sign In' 
+ </HBox> 
+```
+
+### Рекомендации:
+
+[Документация FXML](https://docs.oracle.com/javase/8/javafx/api/javafx/fxml/doc-files/introduction_to_fxml.html)
+
+[Учебник по созданию сцен](https://docs.oracle.com/javase/8/scene-builder-2/get-started-tutorial/overview.htm#JSBGS164)
+
+[Официальная документация по JavaFX](https://docs.oracle.com/javase/8/javase-clienttechnologies.htm)

guide/russian/java/lambda-expressions/index.md

@@ -0,0 +1,37 @@
+---
+title: Lambda Expressions 
+localeTitle: Лямбда-выражения
+---
+## Лямбда-выражения
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+Stream Api используется в java для обеспечения последовательности последовательных и агрегатных операций. Потоковые операции являются промежуточными или конечными.
+
+В этом маленьком примере вы можете увидеть, что одна из утилит потока - получить определенное свойство всех объектов в списке и вернуть его в другой список, используя промежуточные и терминальные операции.
+
+Предположим, что у вас есть класс объекта Student. \`\` Ява публичный класс Студент { int studentId; String studentName;
+
+public String getStudentName () { return this.studentName; }
+
+public int getStudentId () { return this.studentId; } // сеттеры } \`\`
+
+Теперь предположим, что в некотором методе у вас есть список всех учеников и вы хотите получить список всех имен учеников. Традиционно это может выглядеть примерно так.
+
+\`\` Ява Список students = некоторый список объектов студента
+
+Список studentNames = new ArrayList <> (); для (Студенческий студент: студенты) { studentNames.add (student.getStudentName ()); } \`\` Хотя это не страшно, это может быть упрощено. Используя потоки, это возможно с одной строкой кода.
+
+\`\` Ява Список students = некоторый список объектов студента
+
+Список studentNames = students.stream (). map (String :: getStudentName) .collect (Collectors.toList ()); \`\`
+
+Студенческий поток api перебирает список учеников и использует промежуточную функцию карты для возврата нового списка потоков, используя любой метод справа от ::
+
+Операция сбора терминала собирает поток в виде списка строк.
+
+Это только одно использование Streams Api, используемое в java 8. Существует много других приложений потоков, использующих другие операции, как показано здесь в документации. [Потоки api doc](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html)
+
+#### Дополнительная информация:

guide/russian/java/loops/break-control-statement/index.md

@@ -0,0 +1,77 @@
+---
+title: Break Control Statement
+localeTitle: Заявление о нарушении правил
+---
+# Заявление о нарушении правил
+
+Завершает цикл и запускает выполнение кода, который сразу же следует за циклом. Если у вас есть вложенные циклы, оператор `break` заканчивает цикл, в который он помещается.
+
+```java
+// Loop 1 
+ for (int i = 0; i < 10; i++) 
+ { 
+    // Loop 2 
+    for (int j = 0; j < 10; j++) 
+    { 
+        if (i == 5 && j == 5) 
+        { 
+            break; // Will terminate Loop 2, but Loop 1 will keep going 
+        } 
+    } 
+ } 
+```
+
+Но если вы хотите выйти из внешнего цикла, вы можете использовать метку для выхода:
+
+```java
+loop1: // This is a label 
+ for (int i = 0; i < 10; i++) 
+ { 
+    // Loop 2 
+    for (int j = 0; j < 10; j++) 
+    { 
+        if (i == 5 && j == 5) 
+        { 
+            break loop1; // Will break out of Loop 1, instead of Loop 2 
+        } 
+    } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZA/0)
+
+операторы `break` могут быть особенно полезны при поиске элемента в массиве. Использование `break` в следующем коде повышает эффективность, поскольку цикл останавливается, как только элемент, который мы ищем ( `searchFor` ), найден, а не продолжается до конца `arrayInts` .
+
+```java
+int j = 0; 
+ int[] arrayOfInts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ int searchFor = 5; 
+ 
+ for (int i : arrayOfInts) 
+ { 
+    if (arrayOfInts[j] == searchFor) 
+    { 
+        break; 
+    } 
+    j++; 
+ } 
+ 
+ System.out.println("j = " + j); 
+```
+
+Оператор break также может использоваться под оператором while.
+
+```java
+int i = 0; 
+ int[] arrayOfInts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ int searchFor = 5; 
+ 
+ while(i < 10){ 
+ System.out.println("i = " + j); 
+ if(arrayOfInts[i] > 7){ 
+  break; 
+  } 
+ } 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZC/0)

guide/russian/java/loops/continue-control-statement/index.md

@@ -0,0 +1,51 @@
+---
+title: Continue Control Statement
+localeTitle: Продолжить контрольное заявление
+---
+# Продолжить контрольное заявление
+
+Оператор `continue` заставляет цикл пропускать все следующие строки после продолжения и перейти к началу следующей итерации. В цикле `for` управление переходит к оператору обновления, а через некоторое `while` или `do while` цикл while, управление переходит к логическому выражению / условию.
+
+```java
+for (int j = 0; j < 10; j++) 
+ { 
+    if (j == 5) 
+    { 
+        continue; 
+    } 
+    System.out.print (j + " "); 
+ } 
+```
+
+Значение `j` будет напечатано для каждой итерации, за исключением случаев, когда оно равно `5` . Оператор печати будет пропущен из-за `continue` и вывода:
+```
+0 1 2 3 4 6 7 8 9 
+```
+
+Скажем, вы хотите подсчитать количество `i` s в слове `mississippi` . Здесь вы можете использовать цикл с инструкцией `continue` следующим образом:
+
+```java
+String searchWord = "mississippi"; 
+ 
+ // max stores the length of the string 
+ int max = searchWord.length(); 
+ int numPs = 0; 
+ 
+ for (int i = 0; i < max; i++) 
+ { 
+    // We only want to count i's - skip other letters 
+    if (searchWord.charAt(i) != 'i') 
+    { 
+        continue; 
+    } 
+ 
+    // Increase count_i for each i encountered 
+    numPs++; 
+ } 
+ 
+ System.out.println("numPs = " + numPs); 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJZH/0)
+
+Кроме того, вы можете использовать метки для выбора определенного цикла из вложенного набора, чтобы перейти к следующей итерации.

guide/russian/java/loops/control-statements/index.md

@@ -0,0 +1,49 @@
+---
+title: Jump Statements
+localeTitle: Перейти к началу страницы
+---
+# Перейти к началу страницы
+
+Операторы перехода - это тип операторов [_потока управления_](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/flow.html) . В основном вы можете использовать их для изменения порядка выполнения операторов из обычного хода выполнения. По сути, эти утверждения заставляют программный контроль «прыгать» от следующей ожидаемой точки выполнения в другое место в программе.
+
+Следующие операторы перехода обычно используются с циклами:
+
+*   [перерыв](http://forum.freecodecamp.com/t/java-loops-break-control-statement)
+*   [Продолжить](http://forum.freecodecamp.com/t/java-loops-continue-control-statement)
+
+Оператор управления «break» выходит из цикла, когда выполняется условие. Это означает, что остальная часть цикла не будет работать. Например, в цикле ниже, если я достигает 5, цикл прерывается, поэтому он не продолжается.
+
+```java
+for(int i=0;i<10;i++){ 
+ 
+  if(i == 5){ //if i is 5, break out of the loop. 
+    break; 
+  } 
+ 
+ System.out.println(i); 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 
+```
+
+Операция «continue» является менее интенсивной версией «break». Он только вырывается из текущего экземпляра цикла и продолжается. В цикле ниже, если i равно 5, цикл продолжается, поэтому он пропустит приведенный ниже оператор печати и продолжит движение до тех пор, пока не достигнет 10, и цикл остановится.
+
+```java
+for(int i=0;i<10;i++){ 
+ 
+  if(i == 5){ //if i is 5, break out of the current instance loop. 
+    continue; 
+  } 
+ 
+ System.out.println(i); 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 6 7 8 9 
+
+```

guide/russian/java/loops/do-while-loop/index.md

@@ -0,0 +1,55 @@
+---
+title: Do...While Loop
+localeTitle: Do ... While Loop
+---
+# Do ... While Loop
+
+`do while` в `while` `do while` это похоже на `while` цикл, но группа отчетности гарантирована запустить по крайней мере один раз перед проверкой данного состояния. Важно отметить, что цикл «while» представляет собой цикл управления выходом. while (это не обязательно будет выполнено), «do while» - это контур, управляемый записью (он будет выполнен хотя бы один раз, даже если условие не соответствует действительности).
+
+```java
+do 
+ { 
+    // Statements 
+ } 
+ while (condition); 
+```
+
+## пример
+
+```java
+int iter_DoWhile = 20; 
+ do 
+ { 
+    System.out.print (iter_DoWhile + " "); 
+ 
+    // Increment the counter 
+    iter_DoWhile++; 
+ } 
+ while (iter_DoWhile < 10); 
+ System.out.println("iter_DoWhile Value: " + iter_DoWhile); 
+```
+
+Вывод:
+```
+    20 
+    iter_DoWhile Value: 21 
+```
+
+**Помните** : условие цикла `do-while` while проверяется после того, как тело кода выполняется один раз.
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYl/0)
+
+## Упражнение
+
+Можете ли вы угадать вывод следующего фрагмента кода?
+
+```java
+int i = 10; 
+ do 
+ { 
+    System.out.println("The value of i is " + i); 
+    i--; 
+ } 
+ while (i >= 10); 
+
+```

guide/russian/java/loops/for-each-loop/index.md

@@ -0,0 +1,85 @@
+---
+title: For Each Loop
+localeTitle: Для каждого цикла
+---
+# Для каждого цикла
+
+Также называемый расширенным циклом `for` , это чрезвычайно полезный и простой способ перебора каждого элемента в коллекции, массиве или любом объекте, который реализует интерфейс `Iterable` .
+
+```java
+for (object : iterable) 
+ { 
+    // Statements 
+ } 
+```
+
+Цикл читается как «для каждого элемента в `iterable` (может быть массив, собираемый и т. Д.)». Тип `object` должен соответствовать типу элемента `iterable` .
+
+```java
+int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ 
+ for (int numbers : number_list) 
+ { 
+    System.out.print(numbers + " "); 
+    // Iterated 10 times, numbers 0,1,2...9 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 5 6 7 8 9 
+```
+
+: ракета: [Код запуска](https://repl.it/CJYs/0)
+
+Сравнивая это с традиционными `for` петель:
+
+```java
+int[] number_list = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; 
+ 
+ for(int i=0;i < number_list.length;i++) 
+ { 
+  System.out.print(number_list[i]+" "); 
+      // Iterated 10 times, numbers 0,1,2...9 
+ 
+ } 
+```
+
+Вывод:
+```
+    0 1 2 3 4 5 6 7 8 9 
+```
+
+: ракета: [Код запуска](https://repl.it/NJfG/0)
+
+Однако обе части фрагментов кода выполняют одну и ту же работу, однако, очевидно, что для каждой петли есть преимущества в упрощении итерации и доступа элементов коллекции (массива в нашем случае).
+
+С улучшенными циклами циклов нам больше не нужно упоминать начальные и конечные точки цикла, что уменьшает ошибки OutofBounds. Потребность в счетчиках контуров и ручном индексировании удаляется, а читаемость кода улучшается.
+
+Важно отметить, что внесение изменений в переменную итерации для расширенных циклов в цикле не приводит к изменениям исходных элементов коллекции.
+
+Улучшенные для циклов также могут использоваться с многомерными массивами или другими наборами Java. Пример его использования с массивами с несколькими расширениями показан ниже:
+
+```java
+int number_list_new[][]={  {  0,  1, 2}, 
+                  {  3, 4, 5}, 
+                  { 6, 7, 8} }; 
+ 
+ // Because 2d arrays are implemented as "arrays of arrays",the first iteration variable iterates 
+ // through 3 such arrays(that is, the 3 rows of testarr[][]) 
+ for(int i[] : number_list_new) 
+ { 
+  for(int j : i){ 
+    System.out.print(j+" "); 
+  } 
+ } 
+```
+
+Вывод:
+```
+0 1 2 3 4 5 6 7 8 
+```
+
+: ракета: [Код запуска](https://repl.it/NJhP/0)
+
+В приведенных выше фрагментах кода `number_list` является массивом. Если вы не знаете, что это такое, не беспокойтесь об этом. Массив - это контейнерный объект, который содержит фиксированное число значений одного типа, но больше об этом позже.

guide/russian/java/loops/for-loop/index.md

@@ -0,0 +1,73 @@
+---
+title: For Loop
+localeTitle: Для цикла
+---
+# Для цикла
+
+Цикл `for` дает вам компактный способ итерации по целому ряду значений. Базовый `for` оператора состоит из трех частей: инициализации переменных, булевского выражения и выражения инкремента.
+
+```java
+for (variable initialization; boolean expression; increment expression) 
+ { 
+    // Statements 
+ } 
+```
+
+*   `initialization` - инициализирует цикл и выполняется только один раз, в начале.
+
+Вы можете инициализировать более одной переменной того же типа в первой части основных `for` декларации контура; каждая инициализация должна быть разделена запятой.
+
+*   `expression` - оценивается в начале каждой итерации. Если `expression` оценивается как `true` , `Statements` будут выполнены.
+*   `increment` - вызывается после каждой итерации через цикл. Здесь вы можете увеличить / уменьшить значение переменных. Убедитесь, что приращение работает над значением выражения, чтобы избежать бесконечного цикла.
+
+Общим способом использования цикла `for` является то, что вам нужно повторять ваш код определенное количество раз. Например, если вы хотите вывести числа 0-10, вы должны инициализировать переменную для вашего счетчика равным 0, а затем проверить, меньше ли это значение 10, и добавить один к счетчику после каждой итерации.
+
+Обратите внимание, что вы проверите, будет ли значение меньше 10, не менее или равно 10, так как вы начинаете свой счетчик с 0.
+
+```java
+for (int iter_For = 0; iter_For < 10; iter_For++) 
+ { 
+    System.out.print(iter_For + " "); 
+    // Iterated 10 times, iter_For 0,1,2...9 
+ } 
+ 
+ System.out.println("iter_For Value: " + iter_For); 
+```
+
+Примечание. Также допустимо объявить переменную в цикле for как один оператор.
+
+```java
+for (int iter_For = 0; iter_For < 10; iter_For++) 
+ { 
+    System.out.print (iter_For + " "); 
+    // Iterated 10 times, iter_For 0,1,2...9 
+ } 
+```
+
+Вывод:
+```
+0 1 2 3 4 5 6 7 8 9 
+ iter_For Value: 10 
+```
+
+Другой пример цикла for, который добавляет первые 50 номеров, будет таким. i ++ означает i = i + 1.
+
+```java
+int addUntil = 50; 
+ int sum 0; 
+ 
+ for (int i = 1; i <= addUntil; i++) 
+ { 
+    sum+=i 
+ } 
+ 
+ System.out.println("The sum of the first 50 numbers is: " + 50); 
+```
+
+![:rocket:](https://forum.freecodecamp.org/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYr/0)
+
+### Дополнительно
+
+Вы не можете использовать число (старая конструкция языка C-стиля) или что-либо, что не оценивает логическое значение как условие для оператора if или цикла. Вы не можете, например, сказать if (x), если x не является логической переменной.
+
+Кроме того, важно иметь в виду, что булево выражение должно в какой-то момент оценить значение true. В противном случае ваша программа застрянет в бесконечном цикле.

guide/russian/java/loops/index.md

@@ -0,0 +1,24 @@
+---
+title: Loops
+localeTitle: Loops
+---
+# Loops
+
+Всякий раз, когда вам нужно выполнить блок кода несколько раз, цикл будет часто пригодиться.
+
+Java имеет 4 типа циклов:
+
+*   [Пока цикл](loops/while-loop)
+*   [Do ... While Loop](loops/do-while-loop)
+*   [Для цикла](loops/for-loop)
+*   [Для каждого цикла](loops/for-each-loop)
+
+Поведение петлей можно настроить, используя:
+
+*   [Контрольные заявления](loops/control-statements)
+    *   [Заявление о нарушении правил](loops/break-control-statement)
+    *   [Продолжить контрольное заявление](loops/continue-control-statement)
+
+Частный случай петель:
+
+*   [Бесконечные петли](loops/infinite-loops)

guide/russian/java/loops/infinite-loops/index.md

@@ -0,0 +1,65 @@
+---
+title: Infinite Loops
+localeTitle: Бесконечные петли
+---
+# Бесконечные петли
+
+Инфинитный цикл представляет собой оператор цикла ( `for` , `while` , `do-while` ), который не заканчивается сам по себе.
+
+Условие проверки оператора цикла определяет, будет ли тело цикла выполняться или нет. Таким образом, условие проверки, которое всегда верно, будет продолжать выполнять тело цикла, навсегда. Так обстоит дело в петле infinte.
+
+Примеры:
+
+```java
+// Infinite For Loop 
+ for ( ; ; ) 
+ { 
+    // some code here 
+ } 
+ 
+ // Infinite While Loop 
+ while (true) 
+ { 
+    // some code here 
+ } 
+ 
+ // Infinite Do While Loop 
+ do 
+ { 
+    // some code here 
+ } while (true); 
+```
+
+Обычно, если ваш цикл работает бесконечно, это ошибка, которая не должна возникать, поскольку бесконечный цикл не останавливается и предотвращает запуск остальной части программы.
+
+```java
+for(int i=0;i<100;i++){ 
+ 
+    if(i==49){ 
+    i=0; 
+    } 
+ 
+ } 
+```
+
+Цикл выше работает бесконечно, потому что каждый раз, когда я приближаюсь к 49, он устанавливается равным 0. Это означает, что я никогда не достигаю 100, чтобы завершить цикл, поэтому цикл представляет собой бесконечный цикл.
+
+Но программа, застрявшая в таком цикле, будет бесконечно использовать компьютерные ресурсы. Это нежелательно и является типом «ошибки времени выполнения».
+
+Чтобы предотвратить ошибку, программисты используют оператор break для выхода из цикла. Разрыв выполняется только при определенном условии. Использование команды выбора, такой как if-else, обеспечивает то же самое.
+
+```java
+while (true) 
+ { 
+    // do something 
+ 
+    if(conditionToEndLoop == true) 
+        break; 
+ 
+    // do more 
+ } 
+```
+
+Основным преимуществом использования бесконечного цикла над регулярным циклом является читаемость.
+
+Иногда тело петли легче понять, если петля заканчивается посередине, а не в конце / начале. В такой ситуации лучшим выбором будет бесконечный цикл.

guide/russian/java/loops/while-loop/index.md

@@ -0,0 +1,42 @@
+---
+title: While Loop
+localeTitle: Пока цикл
+---
+# Пока цикл
+
+В `while` цикл многократно выполняет блок операторов , пока условие , указанное в скобках не принимает значение `false` . Например:
+
+```java
+while (some_condition_is_true) 
+ { 
+    // do something 
+ } 
+```
+
+Каждая «итерация» (выполнения блока операторов) предшествует оценке условия, указанного в круглых скобках. Операторы выполняются только в том случае, если условие имеет значение `true` . Если он оценивает значение `false` , выполнение программы возобновляется из инструкции сразу после блока `while` .
+
+**Примечание:** Для во `while` цикла , чтобы начать выполнение, нужно требовать условия , чтобы быть `true` изначально. Однако, чтобы выйти из цикла, вы должны сделать что-то внутри блока операторов, чтобы в итоге достичь итерации, когда условие оценивается как `false` (как показано ниже). В противном случае цикл будет выполняться вечно. (На практике он будет работать до тех пор, пока в [JVM не](https://guide.freecodecamp.org/java/the-java-virtual-machine-jvm) закончится память.)
+
+## пример
+
+В следующем примере `expression` дается `iter_While < 10` . Мы увеличиваем `iter_While` по `1` каждый раз, когда цикл выполняется. В `while` цикл прерывается , когда `iter_While` значение достигает `10` .
+
+```java
+int iter_While = 0; 
+ while (iter_While < 10) 
+ { 
+    System.out.print(iter_While + " "); 
+    // Increment the counter 
+    // Iterated 10 times, iter_While 0,1,2...9 
+    iter_While++; 
+ } 
+ System.out.println("iter_While Value: " + iter_While); 
+```
+
+Вывод:
+```
+0 1 2 3 4 5 6 7 8 9 
+ iter_While Value: 10 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ": Ракета:") [Код запуска](https://repl.it/CJYj/0)

guide/russian/java/methods/index.md

@@ -0,0 +1,89 @@
+---
+title: Methods
+localeTitle: методы
+---
+# методы
+
+Наиболее узнаваемый метод в Java - это, вероятно, `public static void main(String[]args)` где `public` означает, что пользователи имеют доступ к методу, `static` означает, что метод основан на «классе», а не в «экземпляре», `void` означает что от метода к другому (более высокий уровень) ничего не будет возвращено, а `main` - имя этого конкретного метода.
+
+`getName()` и `getManufacturerName()` - два метода «Getter», которые мы использовали здесь. Как правило, методы в Java состоят из этих частей -
+
+*   Модем доступа (необязательно) - `public` , `private` или `protected` . По умолчанию пакет закрывается, если не указывается
+*   Тип возврата. Это требуется, это означает, какое значение возвращает метод, или `void` если ничего не возвращается
+*   Имя метода - следует за соглашением camelCase
+*   Список параметров - список параметров с их именем и типом, пустой, если параметры не приняты
+*   Тело метода, окруженное `{ }`
+
+Кроме того, методы могут также иметь ключевое слово `static` , то есть оно связано с самим классом, а не с экземпляром класса ex- `public static void main()` .
+
+Обратите внимание: в отличие от JavaScript мы **должны** определить тип возвращаемого значения любого метода, который мы пишем, иначе он не будет работать во время компиляции. Если вы не хотите, чтобы метод возвращал что-либо, используйте тип возврата `void` .
+
+Каждый метод имеет подпись, которая представляет собой комбинацию типа данных, имени и количества аргументов, которые принимает метод. В `public static void main` метод не имеет указанного типа данных и вместо этого использует `void` чтобы объявить, что данные не возвращаются. В методе `public static double ave(double val, double val)` тип данных «double» (0.0), имя «ave» (среднее), а метод принимает 2 аргумента. Каждый метод **должен** иметь уникальную подпись.
+
+```java
+public class Car { 
+    private String name; 
+    private String manufacturersName; 
+ 
+    public void changeName() { 
+        name = "Tesla"; 
+    } 
+ 
+    public String getName(){ 
+        return name; 
+    } 
+ 
+    public String getManufacurername(){ 
+        return manufacturersName; 
+    } 
+ 
+ } 
+```
+
+Параметры могут быть переданы в методы. Параметры объявляются сразу после имени метода внутри скобок. Синтаксис объявления параметра - \[Тип данных\] \[Имя\].
+
+```java
+public class Car { 
+    private String name; 
+ 
+    public void changeName(String newName) { 
+        name = newName; 
+    } 
+ } 
+```
+
+Как и на любом другом языке, методы (или функции, если вы здесь из мира JS) часто используются для их модульности и повторного использования.
+
+Методы часто служат многим целям, таким как обновление информации в объекте или предоставление данных обратно вызывающему абоненту. Вот несколько примеров.
+
+```java
+public class Car { 
+    private int numberOfWheels; 
+ 
+    public void setNumberOfWheels(int newNumberOfWheels) { 
+        numberOfWheels = newNumberOfWheels; 
+    } 
+ 
+    public int getNumberOfWheels() { 
+        return numberOfWheels; 
+    } 
+ } 
+```
+
+В случае `getNumberOfWheels()` тип возврата - `int` который является целым числом. `return` ключевого слова сообщает java, чтобы передать значение переменной экземпляра `numberOfWheels` . `setNumberOfWheels(int newNumberOfWheels)` однако, не имеет возвращаемого типа, поскольку это метод сеттера, как это было ранее показано. В этом случае, хотя он принимает аргумент типа `int` и делает экземпляр varible `numberOfWheels` равным `newNumberOfWheels` .
+
+Существует также специальный метод, называемый конструктором, который позволяет устанавливать данные или выполнять операции при создании экземпляра класса. Этот конструктор не имеет типа возврата.
+
+```java
+public class Car { 
+    private String model; 
+    private int numberOfWheels; 
+ 
+    public Car(String model, int numberOfWheels) { 
+        this.model = model; 
+        this.numberOfWheels = numberOfWheels; 
+    } 
+ } 
+```
+
+Класс `Car` и метод `Car(String model, int numberOfWheels)` должны иметь одно и то же имя, чтобы Java знал, что это конструктор. Теперь, когда вы создаете экземпляр нового экземпляра `Car` с `new` ключевым словом, вам нужно будет вызвать этот конструктор и передать необходимые данные.

guide/russian/java/multithreading/index.md

@@ -0,0 +1,35 @@
+---
+title: Multithreading
+localeTitle: Многопоточность
+---
+## Многопоточность
+
+Многопоточность - это процесс одновременного выполнения нескольких процессов. Java запускает программу с основным потоком, и дальнейшие потоки добавляются в основной поток всякий раз, когда любой пользователь создает ее. Основной поток - это первый пользовательский поток в любой Java-программе. Кроме того, JVM гарантирует, что все пользовательские потоки будут закрыты до завершения программы.
+
+Нить имеет как преимущества, так и недостатки.
+
+## Преимущества:
+
+*   Запуск кода независимо от других потоков.
+*   Создание модульного дизайна.
+
+## Недостатки:
+
+Условия гонки и Deadlock, если потоки не синхронизированы должным образом.
+
+Темы можно разделить на два класса:
+
+*   Пользовательские темы
+*   Темы Демона
+
+Нить может быть создана двумя способами:
+
+1.  реализация интерфейса Runnable: В интерфейсе Runnable существует только один метод, т.е. public void run (). Внедрение этого метода гарантирует, что всякий раз, когда этот поток запускает код внутри run (), выполняется.
+    
+2.  расширяющий класс резьбы. Этот класс также содержит открытый void run (), который нам нужно переопределить, чтобы запустить наш собственный код. Недостаток использования этого метода заключается в том, что у нас есть суперкласс в Thread и не может распространять любой другой класс, который мы можем захотеть.
+    
+
+Код для обоих можно найти здесь: http://ide.geeksforgeeks.org/k7GjcA.
+
+Вы заметите, что если этот код запускается несколько раз, результаты могут отличаться. и это определяется ОС, на которой она запущена. ОС может выбрать любой поток из состояния runnable и запустить его. У нас нет НИКАКОГО УПРАВЛЕНИЯ. Если в запущенном состоянии есть несколько потоков (готово к запуску), любой может быть выбран. Это даже не зависит от приоритета.
+

guide/russian/java/pojo/index.md

@@ -0,0 +1,39 @@
+---
+title: POJO
+localeTitle: POJO
+---
+## POJO
+
+POJO означает «Обычный объект Java Java». Это отличается от _обычных_ объектов _Javascript_ . Обычный простой Java-объект относится к парадигме объектно-ориентированного программирования (ООП), которая используется на языке программирования Java. Модель [ООП](https://en.wikipedia.org/wiki/Object-oriented_programming) рассматривает данные как «объекты». Каждый «объект» является экземпляром «класса», который представляет архетип или шаблон, из которого все объекты наследуют свои свойства и атрибуты.
+
+Поэтому POJO просто является Java-объектом. Однако он также должен удовлетворять следующим дополнительным критериям:
+
+1.  он не должен распространять предустановленные Java-классы;
+
+```java
+public class Foo extends javax.servlet.http.HttpServlet { 
+ ...// body ... 
+ } 
+```
+
+2.  он не должен реализовывать предустановленные интерфейсы;
+
+```java
+public class Bar implements javax.ejb.EntityBean { 
+  ...  // body 
+ } 
+```
+
+3.  он не должен содержать предустановленные аннотации.
+
+```java
+@javax.persistence.Entity public class Baz { 
+  ... // body ... 
+ } 
+```
+
+Поэтому объект Java квалифицируется как POJO только тогда, когда он свободен от указанных выше изменений. Отсюда следует, что POJO не «связан никакими ограничениями», кроме тех, которые предписаны официальной спецификацией языка Java.
+
+#### Дополнительная информация:
+
+[Википедия - POJO](https://en.wikipedia.org/wiki/Plain_old_Java_object)

guide/russian/java/regular-expressions/index.md

@@ -0,0 +1,11 @@
+---
+title: Regular Expressions
+localeTitle: Регулярные выражения
+---
+## Регулярные выражения
+
+Это заглушка. [Помогите нашему сообществу расширить его](https://github.com/freecodecamp/guides/tree/master/src/pages/mathematics/quadratic-equations/index.md) .
+
+[Это руководство по быстрому стилю поможет вам принять ваш запрос на тягу](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Дополнительная информация:

guide/russian/java/resources/index.md

@@ -0,0 +1,49 @@
+---
+title: Resources
+localeTitle: Ресурсы
+---
+# Ресурсы
+
+Java является торговой маркой и лицензируется Oracle. Большинство из них являются неофициальными ресурсами, если только они не размещены в Oracle.
+
+## Учебники
+
+*   [Официальный учебный курс Java Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+*   [Думайте о Java](http://greenteapress.com/wp/think-java/)
+*   [Учебники Java Jenkov](http://tutorials.jenkov.com/java/index.html)
+*   [Учебники Java & Spring от Mkyong](http://www.mkyong.com/)
+*   [Vogella's Java Tutorials](http://www.vogella.com/tutorials/java.html)
+*   [Учебник Java 8](https://github.com/winterbe/java8-tutorial)
+*   [Лучшая Java](https://github.com/cxxr/better-java)
+*   [Замечания по программированию Java от NTU](http://www3.ntu.edu.sg/home/ehchua/programming/index.html#Java)
+*   [HackerRank за 30 дней Code Challenge с видеоуроками в Java <](https://www.hackerrank.com/domains/tutorials/30-days-of-code)
+*   [Введение Принстона в программирование на Java](http://introcs.cs.princeton.edu/java/home/)
+*   [Введение в программирование с использованием Java](http://math.hws.edu/javanotes/)
+*   [Практика Java](http://javapractices.com/home/HomeAction.do)
+*   [Шаблоны проектирования Java](https://github.com/iluwatar/java-design-patterns/)
+*   [Алгоритмы в Java](https://github.com/pedrovgs/Algorithms)
+*   [Официальные руководства весны](https://spring.io/guides)
+*   [TutorialsPoint - Java](http://www.tutorialspoint.com/java/)
+*   [Java для небольших команд](https://www.gitbook.com/book/ncrcoe/java-for-small-teams/details)
+
+## проблемы
+
+*   [Java Koans](https://github.com/matyb/java-koans)
+*   [Кодирование задач Bat Java](http://codingbat.com/java)
+*   [Экстремизм Java-вызовы](http://exercism.io/languages/java)
+*   [Проект Эйлера](https://projecteuler.net/)
+*   [Практикуйте это! - Проблемы Java](http://practiceit.cs.washington.edu/)
+*   [Codewars - Java Katas](https://www.codewars.com/?language=java)
+*   [Проблемы с HackerRank Java](https://www.hackerrank.com/domains/java/java-introduction)
+*   [LeetCode](https://leetcode.com/)
+*   [CodeAbbey](http://www.codeabbey.com/)
+
+## сообщество
+
+*   [Сообщество Oracle Java](http://www.oracle.com/technetwork/java/community/index.html)
+*   [Awesome Java](https://github.com/akullpp/awesome-java)
+*   [/ г / Java](https://www.reddit.com/r/Java)
+*   [/ г / LearnJava](https://www.reddit.com/r/learnjava)
+*   [Java Ranch](http://www.javaranch.com/)
+*   [Java-код Geeks](https://www.javacodegeeks.com/)
+*   [Поиск Java 8 API](http://javasearch.org)

guide/russian/java/static/index.md

@@ -0,0 +1,132 @@
+---
+title: Static
+localeTitle: статический
+---
+# статический
+
+Когда вы объявляете переменную или метод статическими, она принадлежит классу, а не конкретному экземпляру. Это означает, что существует только один экземпляр статического члена, даже если вы создаете несколько объектов класса или если вы его не создаете. Он будет использоваться всеми объектами.
+
+Статическое ключевое слово можно использовать с переменными, методами, блоками кода и вложенными классами.
+
+## Статические переменные
+
+**_Пример:_**
+
+```java
+public class Counter { 
+  public static int COUNT = 0; 
+  Counter() { 
+    COUNT++; 
+  } 
+ } 
+```
+
+Переменная `COUNT` будет использоваться всеми объектами этого класса. Когда мы создаем объекты нашего класса Counter в main и получаем доступ к статической переменной.
+
+```java
+public class MyClass { 
+  public static void main(String[] args) { 
+    Counter c1 = new Counter(); 
+    Counter c2 = new Counter(); 
+    System.out.println(Counter.COUNT); 
+  } 
+ } 
+ // Outputs "2" 
+```
+
+Outout равно 2, потому что переменная `COUNT` статична и увеличивается каждый раз при создании нового объекта класса Counter. Вы также можете получить доступ к статической переменной с помощью любого объекта этого класса, такого как `c1.COUNT` .
+
+## Статические методы
+
+Статический метод относится к классу, а не к экземплярам. Таким образом, его можно вызвать без создания экземпляра класса. Он используется для изменения статического содержимого класса. Существуют некоторые ограничения статических методов:
+
+1.  Статический метод не может использовать нестатические элементы (переменные или функции) класса.
+2.  Статический метод не может использовать `this` или `super` ключевые слова.
+
+**_Пример:_**
+
+```java
+public class Counter { 
+  public static int COUNT = 0; 
+  Counter() { 
+    COUNT++; 
+  } 
+ 
+  public static void increment(){ 
+    COUNT++; 
+  } 
+ } 
+```
+
+Статические методы также можно вызывать из экземпляра класса.
+
+```java
+public class MyClass { 
+  public static void main(String[] args) { 
+    Counter.increment(); 
+    Counter.increment(); 
+    System.out.println(Counter.COUNT); 
+  } 
+ } 
+ // Outputs "2" 
+```
+
+Выходной сигнал равен 2, поскольку он увеличивается с помощью статического метода `increament()` . Подобно статическим переменным, статические методы также могут быть доступны с использованием переменных экземпляра.
+
+## Статические блоки
+
+Статические блоки кода используются для инициализации статических переменных. Эти блоки выполняются сразу после объявления статических переменных.
+
+**_Пример:_**
+
+```java
+public class Saturn { 
+  public static final int MOON_COUNT; 
+ 
+  static { 
+    MOON_COUNT = 62; 
+  } 
+ } 
+```
+
+```java
+public class Main { 
+  public static void main(String[] args) { 
+    System.out.println(Saturn.MOON_COUNT); 
+  } 
+ } 
+ // Outputs "62" 
+```
+
+Вывод равен 62, потому что переменной `MOON_COUNT` присваивается это значение в статическом блоке.
+
+## Статические вложенные классы
+
+Класс может иметь статический вложенный класс, к которому можно получить доступ, используя внешнее имя класса.
+
+**_Пример:_**
+
+```java
+public class Outer { 
+ 
+  public Outer() { 
+  } 
+ 
+  public static class Inner { 
+    public Inner() { 
+    } 
+  } 
+ } 
+```
+
+В приведенном выше примере класс `Inner` может быть напрямую доступен как статический член класса `Outer` .
+
+```java
+public class Main { 
+  public static void main(String[] args) { 
+    Outer.Inner inner = new Outer.Inner(); 
+  } 
+ } 
+```
+
+Один из вариантов использования статических вложенных классов в [шаблоне Builder,](https://en.wikipedia.org/wiki/Builder_pattern#Java) широко используемом в java.

guide/russian/java/streams/index.md

@@ -0,0 +1,99 @@
+---
+title: Streams
+localeTitle: Streams
+---
+# Streams
+
+В Java 8 Streams добавлена ​​новая функция Java toolbox. Потоки позволяют быстро и чисто обрабатывать коллекции.
+
+Перед продолжением прочитайте главу о лямбдах и функциональном программировании.
+
+## Как это устроено
+
+Поток обходит элементы коллекции для вас. Каждое промежуточное и терминальное действие вызывается для каждого объекта. После завершения всех операций для первых объектов, загружается второй объект.
+
+## Важные методы
+
+### Создание
+
+*   `Collection.stream()` : создать поток из любого объекта из любого класса, реализующего `Collection`
+*   `Arrays.stream(array)` : создать поток из массива
+
+### Промежуточные операции
+
+Эти операции каким-то образом преобразуют объекты Stream.
+
+*   `Stream.map(Function<In,Out> function)` : примените функцию для преобразования In to Out
+*   `Stream.filter(Predicate<In> predicate)` : удалить объекты из потока, для которых предикат не проверяет true
+*   `Stream.distinct()` : удалить объекты из потока, которые являются дубликатами
+*   `Stream.sorted()` : сортировка объектов в потоке
+*   `Stream.limit(int n)` : конец потока после n объектов
+
+### Терминальные операции
+
+Эти операции принимают объекты Stream и завершают поток.
+
+*   `Stream.collect(Collector<In,?,Out> collector)` : собирать все объекты в потоке в объект
+*   `Stream.forEach(Consumer<In> consumer)` : потребляет все объекты в потоке, используя функцию пользователя
+*   `Stream.count()` : считать все объекты в потоке
+*   `Stream.findFirst()` : возвращает первый объект Stream и останавливается
+*   `Stream.anyMatch(Predicate<In> predicate)` : возвращает true, если какой-либо объект в потоке проверяет true для предиката
+*   `Stream.allMatch(Predicate<In> predicate)` : возвращает true, если весь объект в потоке test true для предиката
+
+## Примеры
+
+```java
+// print the length of all Strings in a List 
+ for (String string : Arrays.asList("abc", "de", "f", "abc")) { 
+    int length = string.length(); 
+    System.out.println(length); 
+ } 
+ 
+ Arrays.asList("abc", "de", "f", "abc") 
+        .stream() 
+        .map(String::length) 
+        .forEach(System.out::println); 
+ 
+ // output: 3 2 1 3 
+```
+
+```java
+// print all Strings in a List with a Length greater than 2 
+ for (String string : Arrays.asList("abc", "de", "f", "abc")) { 
+    if (string.length() > 2) { 
+        System.out.println(string); 
+    } 
+ } 
+ 
+ Arrays.asList("abc", "de", "f", "abc") 
+        .stream() 
+        .filter(string -> string.length() > 2) 
+        .forEach(System.out::println); 
+ 
+ // output: abc abc 
+```
+
+```java
+// create a sorted List with all unique Strings from another List which are longer than or requal 2 
+ List<String> result = new ArrayList<>(); 
+ for (String string : Arrays.asList("de", "abc", "f", "abc")) { 
+    if (string.length() >= 2 
+            && ! result.contains(string)) { 
+        result.add(string); 
+    } 
+ } 
+ Collections.sort(result); 
+ 
+ List<String> result2 = Arrays.asList("de", "abc", "f", "abc") 
+        .stream() 
+        .filter(string -> string.length() >= 2) 
+        .distinct() 
+        .sorted() 
+        .collect(Collectors.toList()); 
+ 
+ // result: abc de 
+```
+
+### источники
+
+1.  [Обработка данных с помощью потоков Java SE 8, часть 1](http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html)

guide/russian/java/strings/index.md

@@ -0,0 +1,140 @@
+---
+title: Strings
+localeTitle: Струны
+---
+# Струны
+
+Строки - это последовательности символов. В Java `String` является `Object` . Строки не следует путать с символом `char` как символы имеют буквально значение 1, а не последовательность символов. Вы все равно можете использовать 1 значение в пределах String, однако предпочтительно использовать `char` когда вы проверяете 1 символ.
+
+```java
+String course = "FCC"; 
+ System.out.println(course instanceof Object); 
+```
+
+Вывод:
+```
+true 
+```
+
+Вы можете создать объект String следующими способами:
+
+1.  `String str = "I am a String"; //as a String literal`
+2.  `String str = "I am a " + "String"; //as a constant expression`
+3.  `String str = new String("I am a String"); //as a String Object using the constructor`
+
+Возможно, вы думаете: в чем разница между тремя?
+
+Ну, используя `new` ключевое слово гарантирует, что будет создан новый объект `String` , и новая ячейка памяти будет выделена в `Heap` памяти [(нажмите здесь, чтобы узнать больше)](https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/geninfo/diagnos/garbage_collect.html) . строка литералы и постоянные выражения String кэшируются во время компиляции. Компилятор помещает их в пул строк String для предотвращения дублирования и улучшить потребление памяти. Распределение объектов дорогое, и этот трюк увеличивает производительность при создании строк. Если вы используете тот же самый буквальный, JVM использует тот же объект. Использование такого конструктора, как и выше, почти всегда является худшим выбором.
+
+В этом фрагменте кода сколько объектов String создано?
+
+```java
+String str = "This is a string"; 
+ String str2 = "This is a string"; 
+ String str3 = new String("This is a string"); 
+```
+
+Ответ: 2 Создаются объекты String. `str` и `str2` оба относятся к одному и тому же объекту. `str3` имеет тот же контент, но с использованием `new` принудительных создание нового, отличного объекта.
+
+Когда вы создаете строковый литерал, JVM внутренне проверяет, что называется `String pool` , чтобы увидеть, может ли он найти аналогичный (контентный) Строковый объект. Если он найдет его, он вернет ту же ссылку. В противном случае он просто продолжит работу и создаст новый объект String в пуле, чтобы такая же проверка может быть выполнена в будущем.
+
+Вы можете проверить это, используя ласточку, быстрое сравнение объектов `==` и реализованное `equals()` .
+
+```java
+System.out.println(str == str2); // This prints 'true' 
+ System.out.println(str == str3); // This prints 'false' 
+ System.out.println(str.equals(str3)); // This prints 'true' 
+```
+
+Вот еще один пример того, как создать строку в Java с помощью разных методов:
+
+```java
+public class StringExample{ 
+ 
+   public static void main(String args[]) { 
+      String s1 = "java";  // creating string by Java string literal 
+      char ch[] = {'s','t','r','i','n','g','s'}; 
+      String s2 = new String(ch);  // converting char array to string 
+      String s3 = new String("example");  // creating Java string by new keyword 
+      System.out.println(s1); 
+      System.out.println(s2); 
+      System.out.println(s3); 
+   } 
+ } 
+```
+
+#### Сравнение строк
+
+Если вы хотите сравнить значение двух переменных String, вы не можете использовать ==. Это связано с тем, что это будет сравнивать ссылки переменных а не значения, которые связаны с ними. Чтобы сравнить сохраненные значения строк, вы используете метод равно.
+
+```java
+boolean equals(Object obj) 
+```
+
+Он возвращает true, если два объекта равны и false в противном случае.
+
+```java
+String str = "Hello world"; 
+ String str2 = "Hello world"; 
+ 
+ System.out.println(str == str2); // This prints false 
+ System.out.println(str.equals(str2); // This prints true 
+```
+
+Первое сравнение ложно, потому что «==» рассматривает ссылки, и они не совпадают.
+
+Второе сравнение верно, потому что переменные сохраняют одни и те же значения. В этом случае «Hello world».
+
+У нас есть несколько встроенных методов в String. Ниже приведен пример метода String Length ().
+
+```java
+public class StringDemo { 
+ 
+   public static void main(String args[]) { 
+      String palindrome = "Dot saw I was Tod"; 
+      int len = palindrome.length(); 
+      System.out.println( "String Length is : " + len ); 
+   } 
+ } 
+```
+
+Это приведет к: - `String Length is : 17`
+
+**Ответ: 2** Создаются объекты String. **Заметки**
+
+1.  В методах String используются индексы с нулевым значением, за исключением второго аргумента `substring()` .
+2.  Класс String является окончательным - его методы нельзя переопределить.
+3.  Когда литерал String найден JVM, он добавляется в пул строковых литералов.
+4.  Класс String имеет имя метода `length()` , а массивы имеют длину имени атрибута.
+5.  В java строковые объекты неизменяемы. Неизменяемый просто означает неизменяемость или неизменяемость. После создания строкового объекта его данные или состояние не могут быть изменены, но создается новый строковый объект.
+
+Длина строки
+
+«Длина» строки - это просто количество символов в ней. Итак, «hi» - длина 2, а «Hello» - длина 5. Метод length () в строке возвращает свою длину, например:
+
+```java
+String a = "Hello"; 
+ int len = a.length();  // len is 5 
+```
+
+#### Другие методы сравнения, которые также могут использоваться в String:
+
+1.  equalsIgnoreCase (): - сравнивает строку без учета чувствительности к регистру.
+
+```java
+String a = "HELLO"; 
+ String b = "hello"; 
+ System.out.println(a.equalsIgnoreCase(b));   // It will print true 
+```
+
+2.  compareTo: - сравнивает значение лексикографически и возвращает целое число.
+
+```java
+String a = "Sam"; 
+ String b = "Sam"; 
+ String c = "Ram"; 
+ System.out.println(a.compareTo(b));       // 0 
+ System.out.prinltn(a.compareTo(c));       // 1 since (a>b) 
+ System.out.println(c.compareTo(a));       // -1 since (c<a) 
+
+```

guide/russian/java/swing/index.md

@@ -0,0 +1,36 @@
+---
+title: Java Swing
+localeTitle: Java Swing
+---
+## Java Swing
+
+Давайте рассмотрим учебник Java swing. Прежде чем сделать наши руки грязными с Swing, рекомендуется пройти через набор [абстрактных окон (AWT).](https://www.studytonight.com/java/java-awt.php) Ранее Swing был добавлен как часть [Java Foundation Classes (JFC).](https://en.wikipedia.org/wiki/Java_Foundation_Classes) Однако он полностью слился с Java из Java 1.2 и далее.
+
+### Устойчивые функции
+
+1.  Легкие компоненты. Поскольку компоненты Swing полностью записаны в JAVA, они не используют ресурсы платформы, как это делают компоненты AWT.
+    
+2.  Pluggable Look and Feel (PLAF) - внешний вид и чувство компонента полностью определяется самим Swing. Это облегчает различение внешнего вида и логики компонента.
+    
+
+Swing GUI состоит из двух основных столпов: -компонентов и контейнеров. В следующей части подробно обсуждается их оба.
+
+### Компоненты
+
+Компонент - это просто независимый визуальный контроль. Компоненты, связанные с компонентами, основаны на классе JComponent. Далее JComponent наследует все свои характеристики от контейнеров и компонентов AWT. Для получения дополнительной информации перейдите по иерархии класса [JComponent](https://docs.oracle.com/javase/tutorial/uiswing/components/jcomponent.html) .
+
+### Контейнеры
+
+Все контейнеры также являются компонентами. Контейнеры могут состоять из одного или нескольких компонентов. Swing определяет два типа контейнеров
+
+*   наследует от JComponent - например, JFrame, JWindow, JApplet, JDialog
+*   не наследуется от JComponent - например, JPanel
+
+### пакеты
+
+Swing состоит из большого количества пакетов. Пожалуйста, ознакомьтесь с [официальной документацией](https://docs.oracle.com/javase/7/docs/api/javax/swing/package-use.html) для получения дополнительной информации.
+
+#### Дополнительная информация:
+
+*   [Документация Oracle](https://docs.oracle.com/javase/7/docs/api/javax/swing/package-use.html)
+*   [Википедия](https://en.wikipedia.org/wiki/Swing_(Java)

guide/russian/java/the-java-virtual-machine-jvm/index.md

@@ -0,0 +1,13 @@
+---
+title: Java Virtual Machine
+localeTitle: Виртуальная машина Java
+---
+# Виртуальная машина Java (JVM)
+
+Java принадлежит к семейству языков, называемых [**Compiled Languages**](https://en.wikipedia.org/wiki/Compiled_language) . Любой код, написанный на таком языке, должен быть преобразован (скомпилирован) в промежуточную форму, которая затем может быть понята платформой хоста (ОС / платформа, на которой выполняется код).
+
+Для Java эта промежуточная форма называется **Bytecode,** которая затем интерпретируется средой выполнения, называемой виртуальной машиной Java (JVM). Подумайте о [**JVM**](https://docs.oracle.com/javase/specs/jvms/se7/html/) как о программном обеспечении, которое усложняет работу вашего Java-кода. Он заботится о распределении памяти, управлении потоками, сборке мусора и многом другом. Помимо Java, он также поддерживает (читает: может работать) код, написанный на таких языках, как Groovy, Scala и т. Д.
+
+В Java код записывается и сохраняется как `.java` файлы. Компилятор (javac) работает с java-файлами и генерирует эквивалентные `.class` Bytecode ( `.class` ). Теперь команда `java` сможет выполнить Bytecode, сохраненный в файлах `.class` . Подробнее об этом позже.
+
+В следующих разделах описываются некоторые основные строительные блоки кодирования на Java.

guide/russian/java/throw-keyword/index.md

@@ -0,0 +1,17 @@
+---
+title: Throw
+localeTitle: бросать
+---
+## бросать
+
+Ключевое слово Java throw используется для явного исключения исключения. Вы можете использовать исключенное или исключенное исключение в java по ключевому слову throw. Ключевое слово throw используется в основном для создания настраиваемого исключения.
+
+**_Пример:_**
+
+```java
+throw new ArithmeticException("/ by zero not permitted"); 
+```
+
+##### Больше ресурсов
+
+[Вундеркинды для вундеркиндов](https://www.geeksforgeeks.org/throw-throws-java/)

guide/russian/java/throws-keyword/index.md

@@ -0,0 +1,32 @@
+---
+title: Throws
+localeTitle: Броски
+---
+## бросает
+
+Ключевое слово Java throw используется для объявления исключения. Он дает информацию программисту о том, что может возникнуть исключение, поэтому программисту лучше предоставить код обработки исключений, чтобы можно было поддерживать нормальный поток.
+
+**_Пример:_**
+
+```java
+import java.io.IOException; 
+ class Testthrows1{ 
+  void m()throws IOException{ 
+    throw new IOException("device error");//checked exception 
+  } 
+  void n()throws IOException{ 
+    m(); 
+  } 
+  void p(){ 
+   try{ 
+    n(); 
+   }catch(Exception e){System.out.println("exception handled");} 
+  } 
+  public static void main(String args[]){ 
+   Testthrows1 obj=new Testthrows1(); 
+   obj.p(); 
+   System.out.println("normal flow..."); 
+  } 
+ } 
+
+```

guide/russian/java/tokens/index.md

@@ -0,0 +1,66 @@
+---
+title: tokens
+localeTitle: жетоны
+---
+# Токены в Java
+
+Это фундаментальные строительные блоки программы или наименьшая единица программы. Java поддерживает пять типов токенов:
+
+## 1\. Ключевые слова
+
+Это слова, которые имеют предопределенные определения в компиляторе и не могут использоваться как имена идентификаторов. В Java есть 51 ключевое слово и 2 зарезервированных слова.
+
+## 2\. Идентификаторы
+
+Это различные имена, данные различным компонентам программы. Они включают имена переменных, методов, классов и т. Д. Они не должны начинаться с цифры, но могут содержать цифры, буквы, символы подчеркивания, символы валюты.
+
+## 3\. Литералы
+
+Они обеспечивают способ выражения конкретных значений в программе. Они относятся к следующим типам:
+
+### Числовые литералы
+
+В Java они три типа.
+
+*   \#### Целочисленные литеры
+*   \#### Литералы с плавающей точкой
+*   \#### Литералы символов
+
+### Булевы литералы
+
+Они двух типов
+
+*   \#### правда
+*   \#### ложный
+
+### Строковые литералы
+
+## 4\. Операторы
+
+Это специальные типы символов, используемых для выполнения определенных операций. Например, +, -, \*, /,%
+
+## 5\. Сепараторы
+
+К ним относятся вкладка, ввод, пробел.
+
+##### Теперь рассмотрим программу
+
+```java
+       //Printing Hello World 
+ 
+ public class Hello 
+ 
+ { 
+ 
+ public static void main(String args[]) 
+ 
+ { 
+ 
+ System.out.println(“Hello World”); 
+ 
+ } 
+ 
+ } 
+```
+
+Исходный код содержит токены, такие как _public_ , _class_ , _Hello_ , {, _public_ , _static_ , _void_ , _main_ , (, _String_ , \[\], _args_ , {, _System_ , _out_ , _println_ , (, _Hello World_ ),} Получаемые токены · скомпилированы в байт-коды Java, которые могут запускаться из интерпретируемой среды java. Токен полезен для компилятора для обнаружения ошибок. Когда токены не расположены в определенной последовательности, компилятор генерирует сообщение об ошибке.

guide/russian/java/typecasting/index.md

@@ -0,0 +1,25 @@
+---
+title: Typecasting
+localeTitle: Приведение типов
+---
+## Приведение типов
+
+Преобразование одного типа данных в другой тип данных известно как литье типов. поскольку Java является объектно-ориентированным языком программирования и поддерживает как **наследование, так** и **полиморфизм** . Легко, что эталонная переменная суперкласса указывает на объект subClass.
+
+Когда мы присваиваем значение одного типа данных другому, эти два типа могут быть несовместимы друг с другом. Если типы данных совместимы, то JVM будет выполнять преобразование, автоматически известное как автоматическое преобразование типа, и если нет, то они должны быть явно введены или преобразованы.
+
+### Типы Typecasting
+
+Java, литье типов классифицируется на два типа.
+
+**_1\. Неявная Typecasting_** Здесь автоматическое литье типов происходит, когда эти два типа совместимы тип цели больше, чем тип источника. например. \`\` \`java int i = 100; long l = i; // нет необходимости в явном типе float f = l; // нет необходимости в явном типе
+```
+***2.  Explicit Typecasting*** 
+ When we assign a larger type value to a variable of smaller type, then we need to perform explicit type casting. 
+ eg. 
+```
+
+Ява двойной d = 100,04; long l = (long) d; // Требуется явное задание типа int i = (int) l; // Требуется явное задание типа \`\` \`
+
+#### Дополнительная информация:
+

guide/russian/java/variables/index.md

@@ -0,0 +1,55 @@
+---
+title: Variables
+localeTitle: переменные
+---
+# переменные
+
+Значения переменных хранятся. Они являются самой основной сущностью, используемой для хранения данных, таких как текст, цифры и т. Д. В программе.
+
+В [Java](https://github.com/FreeCodeCamp/FreeCodeCamp/wiki/Java) переменные [_строго типизированы_](https://en.wikipedia.org/wiki/Strong_and_weak_typing#Definitions_of_.22strong.22_or_.22weak.22) , что означает, что вы должны определять тип для каждой переменной всякий раз, когда вы ее объявляете. В противном случае компилятор будет вызывать ошибку во [время компиляции](https://en.wikipedia.org/wiki/Compile_time) . Поэтому каждая переменная имеет связанный « [тип данных](https://guide.freecodecamp.org/java/data-types) » одного из следующих:
+
+*   Примитивный тип: `int` , `short` , `char` , `long` , `boolean` , `byte` , `float` , `double`
+*   Тип обертки: `Integer` , `Short` , `Char` , `Long` , `Boolean` , `Byte` , `Float` , `Double`
+*   Тип ссылки: `String` , `StringBuilder` , `Calendar` , `ArrayList` и т. Д.
+
+Возможно, вы заметили, что **тип Wrapper** состоит из типов, записанных точно так же, как и **Primitive Type** , за исключением заглавных букв в начале (например, **Reference Type** ). Это связано с тем, что типы Wrapper фактически являются частью более общих ссылочных типов, но _тесно связаны_ с их примитивными аналогами посредством [автобоксинга и распаковки](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html) . На данный момент вам просто нужно знать, что такой «тип Wrapper» существует.
+
+Как правило, вы можете _объявлять_ (т. Е. Создавать) переменные в соответствии с следующим синтаксисом: < _data-type_ > < _variableName_ >;
+
+```java
+// Primitive Data Type 
+ int i; 
+ 
+ // Reference Data Type 
+ Float myFloat; 
+```
+
+Вы можете _присвоить_ значение переменной либо одновременно, когда вы объявляете ее (которая называется _инициализацией_ ), либо где-либо в коде после того, как вы ее объявили. Символ **\=** используется для одного и того же.
+
+```java
+// Initialise the variable of Primitive Data Type 'int' to store the value 10 
+ int i = 10; 
+ double amount = 10.0; 
+ boolean isOpen = false; 
+ char c = 'a'; // Note the single quotes 
+ 
+ //Variables can also be declared in one statement, and assigned values later. 
+ int j; 
+ j = 10; 
+ 
+ // initiates an Float object with value 1.0 
+ // variable myFloat now points to the object 
+ Float myFloat = new Float(1.0); 
+ 
+ //Bytes are one of types in Java and can be 
+ //represented with this code 
+ int byteValue = 0B101; 
+ byte anotherByte = (byte)0b00100001; 
+```
+
+Как видно из приведенного выше примера, переменные типа Primitive ведут себя несколько иначе, чем переменные типа Reference (& Wrapper), тогда как примитивные переменные _сохраняют_ фактическое значение, ссылочные переменные _относятся к_ «объекту», содержащему фактическое значение. Вы можете узнать больше в разделах, приведенных ниже.
+
+# Другие источники
+
+*   [Типы данных](https://guide.freecodecamp.org/java/data-types)
+*   [Классы и объекты](https://guide.freecodecamp.org/java/classes-and-objects)