learnxinyminutes-docs/ru-ru/java-ru.html.markdown
2017-08-25 14:06:36 +05:45

532 lines
23 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
language: java
filename: LearnJava-ru.java
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
- ["Madison Dickson", "http://github.com/mix3d"]
translators:
- ["Sergey Gaykov", "https://github.com/gaykov"]
lang: ru-ru
---
Java - это объектно-ориентированный язык программирования общего назначения,
основанный на классах и поддерживающий параллельное программирование.
[Подробнее читайте здесь.](http://docs.oracle.com/javase/tutorial/java/index.html)
```java
// Однострочные комментарии начинаются с //.
/*
Многострочные комментарии
выглядят так.
*/
/**
JavaDoc-комментарии выглядят так. Они используются для описания класса
и его членов.
*/
// Импорт класса ArrayList из пакета java.util.
import java.util.ArrayList;
// Импорт всех классов из пакета java.security.
import java.security.*;
// Каждый .java файл содержит один публичный класс, имя которого совпадает с
// именем файла.
public class LearnJavaRu {
// Программа должна содержать метод main, который является точкой входа.
public static void main (String[] args) {
// System.out.println используется для печати строк.
System.out.println("Hello World!");
System.out.println(
"Integer: " + 10 +
" Double: " + 3.14 +
" Boolean: " + true);
// Чтобы печатать что-либо, не заканчивая переводом строки,
// используйте System.out.print.
System.out.print("Hello ");
System.out.print("World");
// Используйте System.out.printf() для печати с форматированием
System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
///////////////////////////////////////
// Переменные
///////////////////////////////////////
/*
* Объявление переменных
*/
// Переменные объявляются с использованием <тип> <имя>
int fooInt;
// Одновременное объявление нескольких переменных одного типа
// <type> <name1>, <name2>, <name3>
int fooInt1, fooInt2, fooInt3;
/*
* Инициализация переменных
*/
// объявление и инициализация переменной <type> <name> = <val>
int fooInt = 1;
int fooInt1, fooInt2, fooInt3;
// инициализация нескольких переменных одного типа
// <type> <name1>, <name2>, <name3> = <val>
fooInt1 = fooInt2 = fooInt3 = 1;
/*
* Типы переменных
*/
// Byte - 8-битное целое число.
// (-128 <= byte <= 127)
byte fooByte = 100;
// Short - 16-битное целое число.
// (-32,768 <= short <= 32,767)
short fooShort = 10000;
// Integer - 32-битное целое число.
// (-2,147,483,648 <= int <= 2,147,483,647)
int fooInt = 1;
// Long - 64-битное целое число.
// (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
long fooLong = 100000L;
// L используется для указания на то, что переменная имеет тип long;
// По умолчанию, числа без L являются integer.
// Замечание: в Java нет беззнаковых типов.
// Float - 32-битное IEEE 754 число с плавающей запятой с одинарной степенью точности.
float fooFloat = 234.5f;
// f используется для указания на то, что переменная имеет тип float;
// иначе, число являлось бы double.
// Double - 64-битное IEEE 754 число с плавающей запятой с двойной степенью точности.
double fooDouble = 123.4;
// Boolean - true или false
boolean fooBoolean = true;
boolean barBoolean = false;
// Char - Простой 16-битный символ Unicode.
char fooChar = 'A';
// Переменным final не может быть присвоен другой объект.
final int HOURS_I_WORK_PER_WEEK = 9001;
// Строки.
String fooString = "My String Is Here!";
// \n - это экранированный символ, который означает начало новой строки.
String barString = "Printing on a new line?\nNo Problem!";
// \t - это экранированный символ, который добавляет символ табуляции.
String bazString = "Do you want to add a tab?\tNo Problem!";
System.out.println(fooString);
System.out.println(barString);
System.out.println(bazString);
// Массивы
// Размер массива должен быть указан при объявлении.
// Объявлять массив можно в следующих форматах:
//<тип данных> [] <имя> = new <тип данных>[<размер массива>];
//<тип данных> <имя>[] = new <тип данных>[<размер массива>];
int [] intArray = new int[10];
String [] stringArray = new String[1];
boolean boolArray [] = new boolean[100];
// Другой способ объявления и инициализации массива:
int [] y = {9000, 1000, 1337};
String names [] = {"Bob", "John", "Fred", "Juan Pedro"};
boolean bools[] = new boolean[] {true, false, false};
// Индексация массива - доступ к элементу.
System.out.println("intArray @ 0: " + intArray[0]);
// Массивы изменяемы и индекс в них начинается с 0.
intArray[1] = 1;
System.out.println("intArray @ 1: " + intArray[1]); // => 1
// Дополнительно.
// ArrayLists - похож на массив, но предлагает больше возможностей,
// его размер изменяемый.
// LinkedLists - реализация двусвязного списка. Все операции
// выполняются так, как ожидается от двусвязного
// списка.
// Maps - набор объектов, в которых присутствует связь
// ключ-значение. В Map ключ не может дублироваться.
// Каждый ключ связан только с одним значением.
// HashMaps - этот класс использует хэш-таблицу для реализации
// интерфейса Map. Это позволяет сохранить постоянной
// скорость выполнения базовых операций, таких как
// добавление и удаление элементов, вне зависимости
// от размера множества.
///////////////////////////////////////
// Операторы
///////////////////////////////////////
System.out.println("\n->Операторы");
int i1 = 1, i2 = 2; // Сокращение для множественного объявления.
// Арифметика в Java проста.
System.out.println("1+2 = " + (i1 + i2)); // => 3
System.out.println("2-1 = " + (i2 - i1)); // => 1
System.out.println("2*1 = " + (i2 * i1)); // => 2
System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 округлено)
// Остаток от деления
System.out.println("11%3 = "+(11 % 3)); // => 2
// Операторы сравнения.
System.out.println("3 == 2? " + (3 == 2)); // => false
System.out.println("3 != 2? " + (3 != 2)); // => true
System.out.println("3 > 2? " + (3 > 2)); // => true
System.out.println("3 < 2? " + (3 < 2)); // => false
System.out.println("2 <= 2? " + (2 <= 2)); // => true
System.out.println("2 >= 2? " + (2 >= 2)); // => true
// Побитовые операторы!
/*
~ Унарное побитовое дополнение.
<< Знаковый сдвиг влево.
>> Знаковый сдвиг вправо.
>>> Беззнаковый сдвиг вправо.
& Побитовое И.
^ Побитовое исключающее ИЛИ.
| Побитовое ИЛИ.
*/
// Операторы инкремента.
int i = 0;
System.out.println("\n->Inc/Dec-rementation");
// Операторы ++ и -- увеличивают и уменьшают значение на 1 соответственно.
// Если они находятся перед переменной, сначала происходит
// увеличение/уменьшение, затем операция, если после,
// то сначала выполняется операция, затем увеличение/уменьшение.
System.out.println(i++); //i = 1, напечатает 0 (пост-инкремент)
System.out.println(++i); //i = 2, напечатает 2 (пре-инкремент)
System.out.println(i--); //i = 1, напечатает 2 (пост-декремент)
System.out.println(--i); //i = 0, напечатает 0 (пре-декремент)
///////////////////////////////////////
// Контролирующие операторы.
///////////////////////////////////////
System.out.println("\n->Контролирующие операторы");
// Оператор if такой же, как и в С.
int j = 10;
if (j == 10){
System.out.println("Я напечатаюсь!");
} else if (j > 10) {
System.out.println("Я нет.");
} else {
System.out.println("И я тоже нет.");
}
// Цикл while.
int fooWhile = 0;
while(fooWhile < 100)
{
// System.out.println(fooWhile);
// Увеличить счетчик.
// Будет пройдено 100 итераций, fooWhile 0,1,2...99
fooWhile++;
}
System.out.println("Значение fooWhile: " + fooWhile);
// Цикл Do While.
int fooDoWhile = 0;
do
{
// System.out.println(fooDoWhile);
// Увеличить счетчик.
// Будет пройдено 100 итераций, fooDoWhile 0->99
fooDoWhile++;
} while(fooDoWhile < 100);
System.out.println("Значение fooDoWhile: " + fooDoWhile);
// Цикл for.
int fooFor;
// Структура цикла for => for(<начальное_состояние>; <условие>; <шаг>)
for(fooFor=0; fooFor<10; fooFor++){
// System.out.println(fooFor);
// Пройдет 10 итераций., fooFor 0->9
}
System.out.println("Значение fooFor: " + fooFor);
// Цикл For Each
// Автоматический проход через массив или список объектов.
int[] fooList = {1,2,3,4,5,6,7,8,9};
// Структура цикла for each => for(<объект> : <объект_массив>)
// читается как: для каждого объекта в массиве
// заметка: тип объекта должен совпадать с типом массива.
for( int bar : fooList ){
System.out.println(bar);
//Пройдет 9 итераций и напечатает 1-9 на новых строках.
}
// Switch Case
// switch работает с типами byte, short, char и int.
// Также он работает с перечислениями,
// классом String (с Java 7) и с некоторыми классами-обертками над
// примитивными типами: Character, Byte, Short и Integer.
int month = 3;
String monthString;
switch (month){
case 1:
monthString = "Январь";
break;
case 2:
monthString = "Февраль";
break;
case 3:
monthString = "Март";
break;
default:
monthString = "Другой месяц";
break;
}
System.out.println("Результат Switch Case: " + monthString);
// Сокращенный синтаксис условного оператора.
// Вы можете использовать этот синтаксис для быстрого присвоения
// или логических переходов.
// Читается так: "Если (условие) истинно, использовать <значение 1>,
// в ином случае, использовать <значение 2>"
int foo = 5;
String bar = (foo < 10) ? "A" : "B";
System.out.println(bar); // Напечатает А, потому что условие истинно
///////////////////////////////////////
// Преобразование и приведение типов данных.
///////////////////////////////////////
// Преобразование данных.
// Преобразование строки в число.
Integer.parseInt("123"); // Вернет числовое представление "123".
// Преобразование числа в строку
Integer.toString(123); // Вернет строковое представление 123.
// Для других преобразований смотрите следующие классы:
// Double
// Long
// String
// Приведение типов
// Вы так же можете приводить типы в Java.
// Подробнее об этом можно узнать по ссылке:
// http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
///////////////////////////////////////
// Классы и Функции
///////////////////////////////////////
System.out.println("\n->Классы и Функции");
// (Класс Bicycle определен ниже)
// Для создания экземпляра класса используется new.
Bicycle trek = new Bicycle();
// Вызов методов объекта.
trek.speedUp(3); // Вы должны всегда использовать сеттеры и геттеры.
trek.setCadence(100);
// toString возвращает строковое представление объекта.
System.out.println("trek info: " + trek.toString());
} // Конец метода main.
} // Конец класса LearnJavaRu.
// Вы можете включать другие, не публичные классы в .java файл.
// Синтаксис объявления класса:
// <public/private/protected> class <имя класса>{
// // Поля с данными, конструкторы, функции, все внутри.
// // Функции называют методами в Java.
// }
class Bicycle {
// Поля/Переменные класса Bicycle.
public int cadence;// Публичные(public): Доступны из любого места.
private int speed; // Приватные(private): Доступны только внутри класса.
protected int gear;// Защищенные(protected): Доступ из класса и наследников.
String name; // по умолчанию: Доступны только внутри пакета.
// Конструкторы - способ создания класса.
// Это конструктор:
public Bicycle() {
gear = 1;
cadence = 50;
speed = 5;
name = "Bontrager";
}
// Это конструктор, который принимает аргументы:
public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
this.gear = startGear;
this.cadence = startCadence;
this.speed = startSpeed;
this.name = name;
}
// Синтаксис функций:
// <public/private/protected> <тип возвращаемого значения> <имя>(<аргументы>)
// Классы в Java часто реализуют сеттеры и геттеры для своих полей.
// Синтаксис определения метода:
// <модификатор доступа> <тип возвращаемого значения> <имя метода>(<аргументы>)
public int getCadence() {
return cadence;
}
// void-методы не возвращают значений.
public void setCadence(int newValue) {
cadence = newValue;
}
public void setGear(int newValue) {
gear = newValue;
}
public void speedUp(int increment) {
speed += increment;
}
public void slowDown(int decrement) {
speed -= decrement;
}
public void setName(String newName) {
name = newName;
}
public String getName() {
return name;
}
//Метод для отображения значений атрибутов объекта.
@Override
public String toString() {
return "gear: " + gear +
" cadence: " + cadence +
" speed: " + speed +
" name: " + name;
}
} // конец класса Bicycle.
// PennyFarthing - это класс, наследованный от Bicycle
class PennyFarthing extends Bicycle {
// (Penny Farthings - это такие велосипеды с большим передним колесом,
// у них нет передач.)
public PennyFarthing(int startCadence, int startSpeed){
// Вызов конструктора родительского класса.
super(startCadence, startSpeed, 0, "PennyFarthing");
}
// Вы должны пометить метод, который переопределяете, при помощи @аннотации
// Чтобы узнать о том, что такое аннотации и зачем они нужны, почитайте:
// http://docs.oracle.com/javase/tutorial/java/annotations/
@Override
public void setGear(int gear) {
gear = 0;
}
}
// Интерфейсы
// Синтаксис определения интерфейса:
// <модификатор доступа> interface <имя интерфейса> extends <базовый интерфейс> {
// // Константы
// // Определение методов
// }
// Пример - Еда:
public interface Edible {
// Любой класс, реализующий этот интерфейс, должен реализовать этот метод.
public void eat();
}
public interface Digestible {
public void digest();
}
// Сейчас мы можем создать класс, реализующий оба эти интерфейса.
public class Fruit implements Edible, Digestible {
public void eat() {
//...
}
public void digest() {
//...
}
}
// В Java Вы можете наследовать только один класс, однако можете реализовывать
// несколько интерфейсов. Например:
public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
public void InterfaceOneMethod() {
}
public void InterfaceTwoMethod() {
}
}
```
## Почитать еще
Здесь приведены ссылки только для того, чтобы получить общее представление о Java. Гуглите, чтобы найти какие-либо конкретные примеры.
**Официальные руководства Oracle**:
* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
* [Модификаторы доступа в Java](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
* [Концепции объектно-ориентированного программирования](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
* [Наследование](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
* [Полиморфизм](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
* [Абстракция](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
* [Исключения](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
* [Интерфейсы](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
**Уроки онлайн**
* [Learneroo.com - Изучение Java](http://www.learneroo.com)
* [Codingbat.com](http://codingbat.com/java)
**Книги**:
* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)