Java - это объектно-ориентированный язык программирования общего назначения, основанный на классах и поддерживающий параллельное программирование. Подробнее читайте здесь.
1// Однострочные комментарии начинаются с //.
2/*
3Многострочные комментарии
4выглядят так.
5*/
6/**
7JavaDoc-комментарии выглядят так. Они используются для описания класса
8и его членов.
9*/
10
11// Импорт класса ArrayList из пакета java.util.
12import java.util.ArrayList;
13// Импорт всех классов из пакета java.security.
14import java.security.*;
15
16// Каждый .java файл содержит один публичный класс, имя которого совпадает с
17// именем файла.
18public class LearnJavaRu {
19
20 // Программа должна содержать метод main, который является точкой входа.
21 public static void main (String[] args) {
22
23 // System.out.println используется для печати строк.
24 System.out.println("Hello World!");
25 System.out.println(
26 "Integer: " + 10 +
27 " Double: " + 3.14 +
28 " Boolean: " + true);
29
30 // Чтобы печатать что-либо, не заканчивая переводом строки,
31 // используйте System.out.print.
32 System.out.print("Hello ");
33 System.out.print("World");
34
35 // Используйте System.out.printf() для печати с форматированием
36 System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
37
38 ///////////////////////////////////////
39 // Переменные
40 ///////////////////////////////////////
41
42 /*
43 * Объявление переменных
44 */
45 // Переменные объявляются с использованием <тип> <имя>
46 int fooInt;
47 // Одновременное объявление нескольких переменных одного типа
48 // <type> <name1>, <name2>, <name3>
49 int fooInt1, fooInt2, fooInt3;
50
51 /*
52 * Инициализация переменных
53 */
54
55 // объявление и инициализация переменной <type> <name> = <val>
56 int fooInt = 1;
57 int fooInt1, fooInt2, fooInt3;
58 // инициализация нескольких переменных одного типа
59 // <type> <name1>, <name2>, <name3> = <val>
60 fooInt1 = fooInt2 = fooInt3 = 1;
61
62 /*
63 * Типы переменных
64 */
65 // Byte - 8-битное целое число.
66 // (-128 <= byte <= 127)
67 byte fooByte = 100;
68
69 // Short - 16-битное целое число.
70 // (-32,768 <= short <= 32,767)
71 short fooShort = 10000;
72
73 // Integer - 32-битное целое число.
74 // (-2,147,483,648 <= int <= 2,147,483,647)
75 int fooInt = 1;
76
77 // Long - 64-битное целое число.
78 // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
79 long fooLong = 100000L;
80 // L используется для указания на то, что переменная имеет тип long;
81 // По умолчанию, числа без L являются integer.
82
83 // Замечание: в Java нет беззнаковых типов.
84
85 // Float - 32-битное IEEE 754 число с плавающей запятой с одинарной степенью точности.
86 float fooFloat = 234.5f;
87 // f используется для указания на то, что переменная имеет тип float;
88 // иначе, число являлось бы double.
89
90 // Double - 64-битное IEEE 754 число с плавающей запятой с двойной степенью точности.
91 double fooDouble = 123.4;
92
93 // Boolean - true или false
94 boolean fooBoolean = true;
95 boolean barBoolean = false;
96
97 // Char - Простой 16-битный символ Unicode.
98 char fooChar = 'A';
99
100 // Переменным final не может быть присвоен другой объект.
101 final int HOURS_I_WORK_PER_WEEK = 9001;
102
103 // Строки.
104 String fooString = "My String Is Here!";
105
106 // \n - это экранированный символ, который означает начало новой строки.
107 String barString = "Printing on a new line?\nNo Problem!";
108 // \t - это экранированный символ, который добавляет символ табуляции.
109 String bazString = "Do you want to add a tab?\tNo Problem!";
110 System.out.println(fooString);
111 System.out.println(barString);
112 System.out.println(bazString);
113
114 // Массивы
115 // Размер массива должен быть указан при объявлении.
116 // Объявлять массив можно в следующих форматах:
117 //<тип данных> [] <имя> = new <тип данных>[<размер массива>];
118 //<тип данных> <имя>[] = new <тип данных>[<размер массива>];
119 int [] intArray = new int[10];
120 String [] stringArray = new String[1];
121 boolean boolArray [] = new boolean[100];
122
123 // Другой способ объявления и инициализации массива:
124 int [] y = {9000, 1000, 1337};
125 String names [] = {"Bob", "John", "Fred", "Juan Pedro"};
126 boolean bools[] = new boolean[] {true, false, false};
127
128 // Индексация массива - доступ к элементу.
129 System.out.println("intArray @ 0: " + intArray[0]);
130
131 // Массивы изменяемы и индекс в них начинается с 0.
132 intArray[1] = 1;
133 System.out.println("intArray @ 1: " + intArray[1]); // => 1
134
135 // Дополнительно.
136 // ArrayLists - похож на массив, но предлагает больше возможностей,
137 // его размер изменяемый.
138 // LinkedLists - реализация двусвязного списка. Все операции
139 // выполняются так, как ожидается от двусвязного
140 // списка.
141 // Maps - набор объектов, в которых присутствует связь
142 // ключ-значение. В Map ключ не может дублироваться.
143 // Каждый ключ связан только с одним значением.
144 // HashMaps - этот класс использует хэш-таблицу для реализации
145 // интерфейса Map. Это позволяет сохранить постоянной
146 // скорость выполнения базовых операций, таких как
147 // добавление и удаление элементов, вне зависимости
148 // от размера множества.
149
150 ///////////////////////////////////////
151 // Операторы
152 ///////////////////////////////////////
153 System.out.println("\n->Операторы");
154
155 int i1 = 1, i2 = 2; // Сокращение для множественного объявления.
156
157 // Арифметика в Java проста.
158 System.out.println("1+2 = " + (i1 + i2)); // => 3
159 System.out.println("2-1 = " + (i2 - i1)); // => 1
160 System.out.println("2*1 = " + (i2 * i1)); // => 2
161 System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 округлено)
162
163 // Остаток от деления
164 System.out.println("11%3 = "+(11 % 3)); // => 2
165
166 // Операторы сравнения.
167 System.out.println("3 == 2? " + (3 == 2)); // => false
168 System.out.println("3 != 2? " + (3 != 2)); // => true
169 System.out.println("3 > 2? " + (3 > 2)); // => true
170 System.out.println("3 < 2? " + (3 < 2)); // => false
171 System.out.println("2 <= 2? " + (2 <= 2)); // => true
172 System.out.println("2 >= 2? " + (2 >= 2)); // => true
173
174 // Побитовые операторы!
175 /*
176 ~ Унарное побитовое дополнение.
177 << Знаковый сдвиг влево.
178 >> Знаковый сдвиг вправо.
179 >>> Беззнаковый сдвиг вправо.
180 & Побитовое И.
181 ^ Побитовое исключающее ИЛИ.
182 | Побитовое ИЛИ.
183 */
184
185 // Операторы инкремента.
186 int i = 0;
187 System.out.println("\n->Inc/Dec-rementation");
188 // Операторы ++ и -- увеличивают и уменьшают значение на 1 соответственно.
189 // Если они находятся перед переменной, сначала происходит
190 // увеличение/уменьшение, затем операция, если после,
191 // то сначала выполняется операция, затем увеличение/уменьшение.
192 System.out.println(i++); //i = 1, напечатает 0 (пост-инкремент)
193 System.out.println(++i); //i = 2, напечатает 2 (пре-инкремент)
194 System.out.println(i--); //i = 1, напечатает 2 (пост-декремент)
195 System.out.println(--i); //i = 0, напечатает 0 (пре-декремент)
196
197 ///////////////////////////////////////
198 // Контролирующие операторы.
199 ///////////////////////////////////////
200 System.out.println("\n->Контролирующие операторы");
201
202 // Оператор if такой же, как и в С.
203 int j = 10;
204 if (j == 10){
205 System.out.println("Я напечатаюсь!");
206 } else if (j > 10) {
207 System.out.println("Я нет.");
208 } else {
209 System.out.println("И я тоже нет.");
210 }
211
212 // Цикл while.
213 int fooWhile = 0;
214 while(fooWhile < 100)
215 {
216 // System.out.println(fooWhile);
217 // Увеличить счетчик.
218 // Будет пройдено 100 итераций, fooWhile 0,1,2...99
219 fooWhile++;
220 }
221 System.out.println("Значение fooWhile: " + fooWhile);
222
223 // Цикл Do While.
224 int fooDoWhile = 0;
225 do
226 {
227 // System.out.println(fooDoWhile);
228 // Увеличить счетчик.
229 // Будет пройдено 100 итераций, fooDoWhile 0->99
230 fooDoWhile++;
231 } while(fooDoWhile < 100);
232 System.out.println("Значение fooDoWhile: " + fooDoWhile);
233
234 // Цикл for.
235 int fooFor;
236 // Структура цикла for => for(<начальное_состояние>; <условие>; <шаг>)
237 for(fooFor=0; fooFor<10; fooFor++){
238 // System.out.println(fooFor);
239 // Пройдет 10 итераций., fooFor 0->9
240 }
241 System.out.println("Значение fooFor: " + fooFor);
242
243 // Цикл For Each
244 // Автоматический проход через массив или список объектов.
245 int[] fooList = {1,2,3,4,5,6,7,8,9};
246 // Структура цикла for each => for(<объект> : <объект_массив>)
247 // читается как: для каждого объекта в массиве
248 // заметка: тип объекта должен совпадать с типом массива.
249
250 for( int bar : fooList ){
251 System.out.println(bar);
252 //Пройдет 9 итераций и напечатает 1-9 на новых строках.
253 }
254
255 // Switch Case
256 // switch работает с типами byte, short, char и int.
257 // Также он работает с перечислениями,
258 // классом String (с Java 7) и с некоторыми классами-обертками над
259 // примитивными типами: Character, Byte, Short и Integer.
260 int month = 3;
261 String monthString;
262 switch (month){
263 case 1:
264 monthString = "Январь";
265 break;
266 case 2:
267 monthString = "Февраль";
268 break;
269 case 3:
270 monthString = "Март";
271 break;
272 default:
273 monthString = "Другой месяц";
274 break;
275 }
276 System.out.println("Результат Switch Case: " + monthString);
277
278 // Сокращенный синтаксис условного оператора.
279 // Вы можете использовать этот синтаксис для быстрого присвоения
280 // или логических переходов.
281 // Читается так: "Если (условие) истинно, использовать <значение 1>,
282 // в ином случае, использовать <значение 2>"
283 int foo = 5;
284 String bar = (foo < 10) ? "A" : "B";
285 System.out.println(bar); // Напечатает А, потому что условие истинно
286
287
288 ///////////////////////////////////////
289 // Преобразование и приведение типов данных.
290 ///////////////////////////////////////
291
292 // Преобразование данных.
293
294 // Преобразование строки в число.
295 Integer.parseInt("123"); // Вернет числовое представление "123".
296
297 // Преобразование числа в строку
298 Integer.toString(123); // Вернет строковое представление 123.
299
300 // Для других преобразований смотрите следующие классы:
301 // Double
302 // Long
303 // String
304
305 // Приведение типов
306 // Вы так же можете приводить типы в Java.
307 // Подробнее об этом можно узнать по ссылке:
308 // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
309
310
311 ///////////////////////////////////////
312 // Классы и Функции
313 ///////////////////////////////////////
314
315 System.out.println("\n->Классы и Функции");
316
317 // (Класс Bicycle определен ниже)
318
319 // Для создания экземпляра класса используется new.
320 Bicycle trek = new Bicycle();
321
322 // Вызов методов объекта.
323 trek.speedUp(3); // Вы должны всегда использовать сеттеры и геттеры.
324 trek.setCadence(100);
325
326 // toString возвращает строковое представление объекта.
327 System.out.println("trek info: " + trek.toString());
328
329 } // Конец метода main.
330} // Конец класса LearnJavaRu.
331
332
333// Вы можете включать другие, не публичные классы в .java файл.
334
335
336// Синтаксис объявления класса:
337// <public/private/protected> class <имя класса>{
338// // Поля с данными, конструкторы, функции, все внутри.
339// // Функции называют методами в Java.
340// }
341
342class Bicycle {
343
344 // Поля/Переменные класса Bicycle.
345 public int cadence;// Публичные(public): Доступны из любого места.
346 private int speed; // Приватные(private): Доступны только внутри класса.
347 protected int gear;// Защищенные(protected): Доступ из класса и наследников.
348 String name; // по умолчанию: Доступны только внутри пакета.
349
350 // Конструкторы - способ создания класса.
351 // Это конструктор:
352 public Bicycle() {
353 gear = 1;
354 cadence = 50;
355 speed = 5;
356 name = "Bontrager";
357 }
358
359 // Это конструктор, который принимает аргументы:
360 public Bicycle(int startCadence, int startSpeed, int startGear, String name) {
361 this.gear = startGear;
362 this.cadence = startCadence;
363 this.speed = startSpeed;
364 this.name = name;
365 }
366
367 // Синтаксис функций:
368 // <public/private/protected> <тип возвращаемого значения> <имя>(<аргументы>)
369
370 // Классы в Java часто реализуют сеттеры и геттеры для своих полей.
371
372 // Синтаксис определения метода:
373 // <модификатор доступа> <тип возвращаемого значения> <имя метода>(<аргументы>)
374 public int getCadence() {
375 return cadence;
376 }
377
378 // void-методы не возвращают значений.
379 public void setCadence(int newValue) {
380 cadence = newValue;
381 }
382
383 public void setGear(int newValue) {
384 gear = newValue;
385 }
386
387 public void speedUp(int increment) {
388 speed += increment;
389 }
390
391 public void slowDown(int decrement) {
392 speed -= decrement;
393 }
394
395 public void setName(String newName) {
396 name = newName;
397 }
398
399 public String getName() {
400 return name;
401 }
402
403 //Метод для отображения значений атрибутов объекта.
404 @Override
405 public String toString() {
406 return "gear: " + gear +
407 " cadence: " + cadence +
408 " speed: " + speed +
409 " name: " + name;
410 }
411} // конец класса Bicycle.
412
413// PennyFarthing - это класс, наследованный от Bicycle
414class PennyFarthing extends Bicycle {
415 // (Penny Farthings - это такие велосипеды с большим передним колесом,
416 // у них нет передач.)
417
418 public PennyFarthing(int startCadence, int startSpeed){
419 // Вызов конструктора родительского класса.
420 super(startCadence, startSpeed, 0, "PennyFarthing");
421 }
422
423 // Вы должны пометить метод, который переопределяете, при помощи @аннотации
424 // Чтобы узнать о том, что такое аннотации и зачем они нужны, почитайте:
425 // http://docs.oracle.com/javase/tutorial/java/annotations/
426 @Override
427 public void setGear(int gear) {
428 gear = 0;
429 }
430
431}
432
433// Интерфейсы
434// Синтаксис определения интерфейса:
435// <модификатор доступа> interface <имя интерфейса> extends <базовый интерфейс> {
436// // Константы
437// // Определение методов
438// }
439
440// Пример - Еда:
441public interface Edible {
442 // Любой класс, реализующий этот интерфейс, должен реализовать этот метод.
443 public void eat();
444}
445
446public interface Digestible {
447 public void digest();
448}
449
450
451// Сейчас мы можем создать класс, реализующий оба эти интерфейса.
452public class Fruit implements Edible, Digestible {
453 public void eat() {
454 //...
455 }
456
457 public void digest() {
458 //...
459 }
460}
461
462// В Java Вы можете наследовать только один класс, однако можете реализовывать
463// несколько интерфейсов. Например:
464public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo {
465 public void InterfaceOneMethod() {
466
467 }
468
469 public void InterfaceTwoMethod() {
470
471 }
472}
Почитать еще ¶
Здесь приведены ссылки только для того, чтобы получить общее представление о Java. Гуглите, чтобы найти какие-либо конкретные примеры.
Официальные руководства Oracle:
Уроки онлайн
Книги: