From e1d9cfc97fac1972b3680d05c710d6c55a9f48bb Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 20:47:13 +0200 Subject: Added Ukrainian translation for Java Translated from beginning to arrays (including). Translation in progress --- ua-ua/java-ua.html.markdown | 803 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 803 insertions(+) create mode 100644 ua-ua/java-ua.html.markdown diff --git a/ua-ua/java-ua.html.markdown b/ua-ua/java-ua.html.markdown new file mode 100644 index 00000000..1a0bb670 --- /dev/null +++ b/ua-ua/java-ua.html.markdown @@ -0,0 +1,803 @@ +--- +language: java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Jakukyo Friel", "http://weakish.github.io"] + - ["Madison Dickson", "http://github.com/mix3d"] + - ["Simon Morgan", "http://sjm.io/"] + - ["Zachary Ferguson", "http://github.com/zfergus2"] + - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"] + - ["Rachel Stiyer", "https://github.com/rstiyer"] +translators: + - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"] +filename: LearnJava.java +lang: uk-ua +--- + +Java є об'єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах. +[Read more here.](http://docs.oracle.com/javase/tutorial/java/) + +```java +// Однорядковий коментар починається з // +/* +Багаторядковий коментар виглядає так. +*/ +/** +JavaDoc коментар виглядає так. Використовується для опису класу та членів класу. +*/ + +// Імпорт класу ArrayList з пакету java.util +import java.util.ArrayList; +// Імпорт усіх класів з пакету java.security +import java.security.*; + +// Кожний .java файл містить один зовнішній публічний клас, ім'я якого співпадає +// з і менем файлу. +public class LearnJava { + + // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу 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; + // Оголошення декількох змінних одного типу <тип> <ім'я1>, <ім'я2>, <ім'я3> + int fooInt1, fooInt2, fooInt3; + + /* + * Ініціалізація змінних + */ + + // Ініціалізація змінної з використанням формату <тип> <ім'я> = <значення> + int fooInt = 1; + // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім'я1>, <ім'я2>, <ім'я3> = <значення> + int fooInt1, fooInt2, fooInt3; + fooInt1 = fooInt2 = fooInt3 = 1; + + /* + * Типи змінних + */ + // Байт - 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; + // інакше число буде трактуватись як integer. + + // Примітка: Java не має беззнакових типів. + + // Float - 32-бітне число з плаваючою комою одиничної точності за стандартом IEEE 754 + // 2^-149 <= float <= (2-2^-23) * 2^127 + float fooFloat = 234.5f; + // f or F використовується для позначення того, що змінна має тип float; + // інакше трактується як double. + + // Double - 64-бітне число з плаваючою комою подвійної точності за стандартом IEEE 754 + // 2^-1074 <= x <= (2-2^-52) * 2^1023 + 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; + // але вони можуть мати відкладену ініціалізацію. + final double E; + E = 2.71828; + + + // BigInteger -Незмінні знакові цілі числа довільної точності + // + // BigInteger є типом даних, який дає можливість розробнику виконувати операції з + // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві + // байтів, операції над ними виконуються функціями, які має клас BigInteger + // + // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок. + + BigInteger fooBigInteger = new BigInteger(fooByteArray); + + + // BigDecimal - Незмінні знакові дробові числа довільної точності + // + // BigDecimal складається з двох частин: цілого числа довільної точності + // з немасштабованим значенням та 32-бітного масштабованого цілого числа + // + // BigDecimal дозволяє розробника контролювати десяткове округлення. + // Рекомндовано використовувати BigDecimal зі значеннями валют + // і там, де необхідна точність дробових обчислень. + // + // BigDecimal може бути ініціалізований типами даних int, long, double or String + // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int). + + BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt); + + // Для дотримання заданої точності рекомендується використовувати + // конструктор, який приймає String + + BigDecimal tenCents = new BigDecimal("0.1"); + + + // Рядки + String fooString = "Це мій рядок!"; + + // \n символ переходу на новий рядок + String barString = "Друк з нового рялка?\nНема питань!"; + // \t символ табуляції + String bazString = "Хочете додати табуляцію?\tТримайте!"; + 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]); + + // Масиви є змінними та мають нульовий елемент. + intArray[1] = 1; + System.out.println("intArray @ 1: " + intArray[1]); // => 1 + + // Додатково + // ArrayLists - Схожі на масив, але мають більший функціонал та змінний розмір. + // LinkedLists - Реалізація двозв'язного списку. Всі операції + // виконуються так, як очікується від + // двозв'язного списку. + // Maps - Множина об'єктів, які пов'язують ключ зі значенням. Map є + // інтерфейсом, тому не може бути успадкований. + // Типи ключів і значень, які зберігаються в Map мають + // вказуватись у класі, який його реалізує. + // Ключ не може повторюватись і пов'язаний лише з одним значенням + // HashMaps - Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map. + // Це дозволяє виконувати певні операції, + // такі як отримання та вставка елемента, + // за сталий час для будь-якої кількості значень. + + /////////////////////////////////////// + // Operators + /////////////////////////////////////// + System.out.println("\n->Operators"); + + int i1 = 1, i2 = 2; // Shorthand for multiple declarations + + // Arithmetic is straightforward + 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 (int/int returns an int) + System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5 + + // Modulo + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Comparison operators + 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 + + // Boolean operators + System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false + System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true + System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true + + // Bitwise operators! + /* + ~ Unary bitwise complement + << Signed left shift + >> Signed/Arithmetic right shift + >>> Unsigned/Logical right shift + & Bitwise AND + ^ Bitwise exclusive OR + | Bitwise inclusive OR + */ + + // Incrementations + int i = 0; + System.out.println("\n->Inc/Dec-rementation"); + // The ++ and -- operators increment and decrement by 1 respectively. + // If they are placed before the variable, they increment then return; + // after the variable they return then increment. + System.out.println(i++); // i = 1, prints 0 (post-increment) + System.out.println(++i); // i = 2, prints 2 (pre-increment) + System.out.println(i--); // i = 1, prints 2 (post-decrement) + System.out.println(--i); // i = 0, prints 0 (pre-decrement) + + /////////////////////////////////////// + // Control Structures + /////////////////////////////////////// + System.out.println("\n->Control Structures"); + + // If statements are c-like + int j = 10; + if (j == 10) { + System.out.println("I get printed"); + } else if (j > 10) { + System.out.println("I don't"); + } else { + System.out.println("I also don't"); + } + + // While loop + int fooWhile = 0; + while(fooWhile < 100) { + System.out.println(fooWhile); + // Increment the counter + // Iterated 100 times, fooWhile 0,1,2...99 + fooWhile++; + } + System.out.println("fooWhile Value: " + fooWhile); + + // Do While Loop + int fooDoWhile = 0; + do { + System.out.println(fooDoWhile); + // Increment the counter + // Iterated 99 times, fooDoWhile 0->99 + fooDoWhile++; + } while(fooDoWhile < 100); + System.out.println("fooDoWhile Value: " + fooDoWhile); + + // For Loop + // for loop structure => for(; ; ) + for (int fooFor = 0; fooFor < 10; fooFor++) { + System.out.println(fooFor); + // Iterated 10 times, fooFor 0->9 + } + System.out.println("fooFor Value: " + fooFor); + + // Nested For Loop Exit with Label + outer: + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + if (i == 5 && j ==5) { + break outer; + // breaks out of outer loop instead of only the inner one + } + } + } + + // For Each Loop + // The for loop is also able to iterate over arrays as well as objects + // that implement the Iterable interface. + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + // for each loop structure => for ( : ) + // reads as: for each element in the iterable + // note: the object type must match the element type of the iterable. + + for (int bar : fooList) { + System.out.println(bar); + //Iterates 9 times and prints 1-9 on new lines + } + + // Switch Case + // A switch works with the byte, short, char, and int data types. + // It also works with enumerated types (discussed in Enum Types), the + // String class, and a few special classes that wrap primitive types: + // Character, Byte, Short, and Integer. + int month = 3; + String monthString; + switch (month) { + case 1: monthString = "January"; + break; + case 2: monthString = "February"; + break; + case 3: monthString = "March"; + break; + default: monthString = "Some other month"; + break; + } + System.out.println("Switch Case Result: " + monthString); + + // Starting in Java 7 and above, switching Strings works like this: + String myAnswer = "maybe"; + switch(myAnswer) { + case "yes": + System.out.println("You answered yes."); + break; + case "no": + System.out.println("You answered no."); + break; + case "maybe": + System.out.println("You answered maybe."); + break; + default: + System.out.println("You answered " + myAnswer); + break; + } + + // Conditional Shorthand + // You can use the '?' operator for quick assignments or logic forks. + // Reads as "If (statement) is true, use , otherwise, use + // " + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Prints A, because the statement is true + + + //////////////////////////////////////// + // Converting Data Types And Typecasting + //////////////////////////////////////// + + // Converting data + + // Convert String To Integer + Integer.parseInt("123");//returns an integer version of "123" + + // Convert Integer To String + Integer.toString(123);//returns a string version of 123 + + // For other conversions check out the following classes: + // Double + // Long + // String + + // Typecasting + // You can also cast Java objects, there's a lot of details and deals + // with some more intermediate concepts. Feel free to check it out here: + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Classes And Functions + /////////////////////////////////////// + + System.out.println("\n->Classes & Functions"); + + // (definition of the Bicycle class follows) + + // Use new to instantiate a class + Bicycle trek = new Bicycle(); + + // Call object methods + trek.speedUp(3); // You should always use setter and getter methods + trek.setCadence(100); + + // toString returns this Object's string representation. + System.out.println("trek info: " + trek.toString()); + + // Double Brace Initialization + // The Java Language has no syntax for how to create static Collections + // in an easy way. Usually you end up in the following way: + + private static final Set COUNTRIES = new HashSet(); + static { + validCodes.add("DENMARK"); + validCodes.add("SWEDEN"); + validCodes.add("FINLAND"); + } + + // But there's a nifty way to achieve the same thing in an + // easier way, by using something that is called Double Brace + // Initialization. + + private static final Set COUNTRIES = new HashSet() {{ + add("DENMARK"); + add("SWEDEN"); + add("FINLAND"); + }} + + // The first brace is creating a new AnonymousInnerClass and the + // second one declares an instance initializer block. This block + // is called when the anonymous inner class is created. + // This does not only work for Collections, it works for all + // non-final classes. + + } // End main method +} // End LearnJava class + + +// You can include other, non-public outer-level classes in a .java file, +// but it is good practice. Instead split classes into separate files. + + +// Class Declaration Syntax: +// class { +// // data fields, constructors, functions all inside. +// // functions are called as methods in Java. +// } + +class Bicycle { + + // Bicycle's Fields/Variables + public int cadence; // Public: Can be accessed from anywhere + private int speed; // Private: Only accessible from within the class + protected int gear; // Protected: Accessible from the class and subclasses + String name; // default: Only accessible from within this package + + static String className; // Static class variable + + // Static block + // Java has no implementation of static constructors, but + // has a static block that can be used to initialize class variables + // (static variables). + // This block will be called when the class is loaded. + static { + className = "Bicycle"; + } + + // Constructors are a way of creating classes + // This is a constructor + public Bicycle() { + // You can also call another constructor: + // this(1, 50, 5, "Bontrager"); + gear = 1; + cadence = 50; + speed = 5; + name = "Bontrager"; + } + + // This is a constructor that takes arguments + public Bicycle(int startCadence, int startSpeed, int startGear, + String name) { + this.gear = startGear; + this.cadence = startCadence; + this.speed = startSpeed; + this.name = name; + } + + // Method Syntax: + // () + + // Java classes often implement getters and setters for their fields + + // Method declaration syntax: + // () + public int getCadence() { + return cadence; + } + + // void methods require no return statement + 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; + } + + //Method to display the attribute values of this Object. + @Override // Inherited from the Object class. + public String toString() { + return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + + " name: " + name; + } +} // end class Bicycle + +// PennyFarthing is a subclass of Bicycle +class PennyFarthing extends Bicycle { + // (Penny Farthings are those bicycles with the big front wheel. + // They have no gears.) + + public PennyFarthing(int startCadence, int startSpeed){ + // Call the parent constructor with super + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // You should mark a method you're overriding with an @annotation. + // To learn more about what annotations are and their purpose check this + // out: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setGear(int gear) { + gear = 0; + } +} + +// Interfaces +// Interface declaration syntax +// interface extends { +// // Constants +// // Method declarations +// } + +// Example - Food: +public interface Edible { + public void eat(); // Any class that implements this interface, must + // implement this method. +} + +public interface Digestible { + public void digest(); +} + + +// We can now create a class that implements both of these interfaces. +public class Fruit implements Edible, Digestible { + + @Override + public void eat() { + // ... + } + + @Override + public void digest() { + // ... + } +} + +// In Java, you can extend only one class, but you can implement many +// interfaces. For example: +public class ExampleClass extends ExampleClassParent implements InterfaceOne, + InterfaceTwo { + + @Override + public void InterfaceOneMethod() { + } + + @Override + public void InterfaceTwoMethod() { + } + +} + +// Abstract Classes + +// Abstract Class declaration syntax +// abstract extends { +// // Constants and variables +// // Method declarations +// } + +// Marking a class as abstract means that it contains abstract methods that must +// be defined in a child class. Similar to interfaces, abstract classes cannot +// be instantiated, but instead must be extended and the abstract methods +// defined. Different from interfaces, abstract classes can contain a mixture of +// concrete and abstract methods. Methods in an interface cannot have a body, +// unless the method is static, and variables are final by default, unlike an +// abstract class. Also abstract classes CAN have the "main" method. + +public abstract class Animal +{ + public abstract void makeSound(); + + // Method can have a body + public void eat() + { + System.out.println("I am an animal and I am Eating."); + // Note: We can access private variable here. + age = 30; + } + + // No need to initialize, however in an interface + // a variable is implicitly final and hence has + // to be initialized. + protected int age; + + public void printAge() + { + System.out.println(age); + } + + // Abstract classes can have main function. + public static void main(String[] args) + { + System.out.println("I am abstract"); + } +} + +class Dog extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. + @Override + public void makeSound() + { + System.out.println("Bark"); + // age = 30; ==> ERROR! age is private to Animal + } + + // NOTE: You will get an error if you used the + // @Override annotation here, since java doesn't allow + // overriding of static methods. + // What is happening here is called METHOD HIDING. + // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/ + public static void main(String[] args) + { + Dog pluto = new Dog(); + pluto.makeSound(); + pluto.eat(); + pluto.printAge(); + } +} + +// Final Classes + +// Final Class declaration syntax +// final { +// // Constants and variables +// // Method declarations +// } + +// Final classes are classes that cannot be inherited from and are therefore a +// final child. In a way, final classes are the opposite of abstract classes +// because abstract classes must be extended, but final classes cannot be +// extended. +public final class SaberToothedCat extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. + @Override + public void makeSound() + { + System.out.println("Roar"); + } +} + +// Final Methods +public abstract class Mammal() +{ + // Final Method Syntax: + // final () + + // Final methods, like, final classes cannot be overridden by a child class, + // and are therefore the final implementation of the method. + public final boolean isWarmBlooded() + { + return true; + } +} + + +// Enum Type +// +// An enum type is a special data type that enables for a variable to be a set +// of predefined constants. The variable must be equal to one of the values that +// have been predefined for it. Because they are constants, the names of an enum +// type's fields are in uppercase letters. In the Java programming language, you +// define an enum type by using the enum keyword. For example, you would specify +// a days-of-the-week enum type as: + +public enum Day { + SUNDAY, MONDAY, TUESDAY, WEDNESDAY, + THURSDAY, FRIDAY, SATURDAY +} + +// We can use our enum Day like that: + +public class EnumTest { + + // Variable Enum + Day day; + + public EnumTest(Day day) { + this.day = day; + } + + public void tellItLikeItIs() { + switch (day) { + case MONDAY: + System.out.println("Mondays are bad."); + break; + + case FRIDAY: + System.out.println("Fridays are better."); + break; + + case SATURDAY: + case SUNDAY: + System.out.println("Weekends are best."); + break; + + default: + System.out.println("Midweek days are so-so."); + break; + } + } + + public static void main(String[] args) { + EnumTest firstDay = new EnumTest(Day.MONDAY); + firstDay.tellItLikeItIs(); // => Mondays are bad. + EnumTest thirdDay = new EnumTest(Day.WEDNESDAY); + thirdDay.tellItLikeItIs(); // => Midweek days are so-so. + } +} + +// Enum types are much more powerful than we show above. +// The enum body can include methods and other fields. +// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html + +``` + +## Further Reading + +The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. + +**Official Oracle Guides**: + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](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/codeconvtoc-136057.html) + +**Online Practice and Tutorials** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Books**: + +* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) + +* [Thinking in Java](http://www.mindview.net/Books/TIJ/) + +* [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) -- cgit v1.2.3 From b71d01fd8aba1a9da6305dc1f52fb748ee824adf Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 20:52:42 +0200 Subject: Changed the name of Ukrainian translation uk-ua is more correctly --- ua-ua/java-ua.html.markdown | 803 -------------------------------------------- uk-ua/java-ua.html.markdown | 803 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 803 insertions(+), 803 deletions(-) delete mode 100644 ua-ua/java-ua.html.markdown create mode 100644 uk-ua/java-ua.html.markdown diff --git a/ua-ua/java-ua.html.markdown b/ua-ua/java-ua.html.markdown deleted file mode 100644 index 1a0bb670..00000000 --- a/ua-ua/java-ua.html.markdown +++ /dev/null @@ -1,803 +0,0 @@ ---- -language: java -contributors: - - ["Jake Prather", "http://github.com/JakeHP"] - - ["Jakukyo Friel", "http://weakish.github.io"] - - ["Madison Dickson", "http://github.com/mix3d"] - - ["Simon Morgan", "http://sjm.io/"] - - ["Zachary Ferguson", "http://github.com/zfergus2"] - - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"] - - ["Rachel Stiyer", "https://github.com/rstiyer"] -translators: - - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"] -filename: LearnJava.java -lang: uk-ua ---- - -Java є об'єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах. -[Read more here.](http://docs.oracle.com/javase/tutorial/java/) - -```java -// Однорядковий коментар починається з // -/* -Багаторядковий коментар виглядає так. -*/ -/** -JavaDoc коментар виглядає так. Використовується для опису класу та членів класу. -*/ - -// Імпорт класу ArrayList з пакету java.util -import java.util.ArrayList; -// Імпорт усіх класів з пакету java.security -import java.security.*; - -// Кожний .java файл містить один зовнішній публічний клас, ім'я якого співпадає -// з і менем файлу. -public class LearnJava { - - // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу 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; - // Оголошення декількох змінних одного типу <тип> <ім'я1>, <ім'я2>, <ім'я3> - int fooInt1, fooInt2, fooInt3; - - /* - * Ініціалізація змінних - */ - - // Ініціалізація змінної з використанням формату <тип> <ім'я> = <значення> - int fooInt = 1; - // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім'я1>, <ім'я2>, <ім'я3> = <значення> - int fooInt1, fooInt2, fooInt3; - fooInt1 = fooInt2 = fooInt3 = 1; - - /* - * Типи змінних - */ - // Байт - 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; - // інакше число буде трактуватись як integer. - - // Примітка: Java не має беззнакових типів. - - // Float - 32-бітне число з плаваючою комою одиничної точності за стандартом IEEE 754 - // 2^-149 <= float <= (2-2^-23) * 2^127 - float fooFloat = 234.5f; - // f or F використовується для позначення того, що змінна має тип float; - // інакше трактується як double. - - // Double - 64-бітне число з плаваючою комою подвійної точності за стандартом IEEE 754 - // 2^-1074 <= x <= (2-2^-52) * 2^1023 - 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; - // але вони можуть мати відкладену ініціалізацію. - final double E; - E = 2.71828; - - - // BigInteger -Незмінні знакові цілі числа довільної точності - // - // BigInteger є типом даних, який дає можливість розробнику виконувати операції з - // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві - // байтів, операції над ними виконуються функціями, які має клас BigInteger - // - // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок. - - BigInteger fooBigInteger = new BigInteger(fooByteArray); - - - // BigDecimal - Незмінні знакові дробові числа довільної точності - // - // BigDecimal складається з двох частин: цілого числа довільної точності - // з немасштабованим значенням та 32-бітного масштабованого цілого числа - // - // BigDecimal дозволяє розробника контролювати десяткове округлення. - // Рекомндовано використовувати BigDecimal зі значеннями валют - // і там, де необхідна точність дробових обчислень. - // - // BigDecimal може бути ініціалізований типами даних int, long, double or String - // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int). - - BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt); - - // Для дотримання заданої точності рекомендується використовувати - // конструктор, який приймає String - - BigDecimal tenCents = new BigDecimal("0.1"); - - - // Рядки - String fooString = "Це мій рядок!"; - - // \n символ переходу на новий рядок - String barString = "Друк з нового рялка?\nНема питань!"; - // \t символ табуляції - String bazString = "Хочете додати табуляцію?\tТримайте!"; - 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]); - - // Масиви є змінними та мають нульовий елемент. - intArray[1] = 1; - System.out.println("intArray @ 1: " + intArray[1]); // => 1 - - // Додатково - // ArrayLists - Схожі на масив, але мають більший функціонал та змінний розмір. - // LinkedLists - Реалізація двозв'язного списку. Всі операції - // виконуються так, як очікується від - // двозв'язного списку. - // Maps - Множина об'єктів, які пов'язують ключ зі значенням. Map є - // інтерфейсом, тому не може бути успадкований. - // Типи ключів і значень, які зберігаються в Map мають - // вказуватись у класі, який його реалізує. - // Ключ не може повторюватись і пов'язаний лише з одним значенням - // HashMaps - Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map. - // Це дозволяє виконувати певні операції, - // такі як отримання та вставка елемента, - // за сталий час для будь-якої кількості значень. - - /////////////////////////////////////// - // Operators - /////////////////////////////////////// - System.out.println("\n->Operators"); - - int i1 = 1, i2 = 2; // Shorthand for multiple declarations - - // Arithmetic is straightforward - 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 (int/int returns an int) - System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5 - - // Modulo - System.out.println("11%3 = "+(11 % 3)); // => 2 - - // Comparison operators - 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 - - // Boolean operators - System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false - System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true - System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true - - // Bitwise operators! - /* - ~ Unary bitwise complement - << Signed left shift - >> Signed/Arithmetic right shift - >>> Unsigned/Logical right shift - & Bitwise AND - ^ Bitwise exclusive OR - | Bitwise inclusive OR - */ - - // Incrementations - int i = 0; - System.out.println("\n->Inc/Dec-rementation"); - // The ++ and -- operators increment and decrement by 1 respectively. - // If they are placed before the variable, they increment then return; - // after the variable they return then increment. - System.out.println(i++); // i = 1, prints 0 (post-increment) - System.out.println(++i); // i = 2, prints 2 (pre-increment) - System.out.println(i--); // i = 1, prints 2 (post-decrement) - System.out.println(--i); // i = 0, prints 0 (pre-decrement) - - /////////////////////////////////////// - // Control Structures - /////////////////////////////////////// - System.out.println("\n->Control Structures"); - - // If statements are c-like - int j = 10; - if (j == 10) { - System.out.println("I get printed"); - } else if (j > 10) { - System.out.println("I don't"); - } else { - System.out.println("I also don't"); - } - - // While loop - int fooWhile = 0; - while(fooWhile < 100) { - System.out.println(fooWhile); - // Increment the counter - // Iterated 100 times, fooWhile 0,1,2...99 - fooWhile++; - } - System.out.println("fooWhile Value: " + fooWhile); - - // Do While Loop - int fooDoWhile = 0; - do { - System.out.println(fooDoWhile); - // Increment the counter - // Iterated 99 times, fooDoWhile 0->99 - fooDoWhile++; - } while(fooDoWhile < 100); - System.out.println("fooDoWhile Value: " + fooDoWhile); - - // For Loop - // for loop structure => for(; ; ) - for (int fooFor = 0; fooFor < 10; fooFor++) { - System.out.println(fooFor); - // Iterated 10 times, fooFor 0->9 - } - System.out.println("fooFor Value: " + fooFor); - - // Nested For Loop Exit with Label - outer: - for (int i = 0; i < 10; i++) { - for (int j = 0; j < 10; j++) { - if (i == 5 && j ==5) { - break outer; - // breaks out of outer loop instead of only the inner one - } - } - } - - // For Each Loop - // The for loop is also able to iterate over arrays as well as objects - // that implement the Iterable interface. - int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - // for each loop structure => for ( : ) - // reads as: for each element in the iterable - // note: the object type must match the element type of the iterable. - - for (int bar : fooList) { - System.out.println(bar); - //Iterates 9 times and prints 1-9 on new lines - } - - // Switch Case - // A switch works with the byte, short, char, and int data types. - // It also works with enumerated types (discussed in Enum Types), the - // String class, and a few special classes that wrap primitive types: - // Character, Byte, Short, and Integer. - int month = 3; - String monthString; - switch (month) { - case 1: monthString = "January"; - break; - case 2: monthString = "February"; - break; - case 3: monthString = "March"; - break; - default: monthString = "Some other month"; - break; - } - System.out.println("Switch Case Result: " + monthString); - - // Starting in Java 7 and above, switching Strings works like this: - String myAnswer = "maybe"; - switch(myAnswer) { - case "yes": - System.out.println("You answered yes."); - break; - case "no": - System.out.println("You answered no."); - break; - case "maybe": - System.out.println("You answered maybe."); - break; - default: - System.out.println("You answered " + myAnswer); - break; - } - - // Conditional Shorthand - // You can use the '?' operator for quick assignments or logic forks. - // Reads as "If (statement) is true, use , otherwise, use - // " - int foo = 5; - String bar = (foo < 10) ? "A" : "B"; - System.out.println(bar); // Prints A, because the statement is true - - - //////////////////////////////////////// - // Converting Data Types And Typecasting - //////////////////////////////////////// - - // Converting data - - // Convert String To Integer - Integer.parseInt("123");//returns an integer version of "123" - - // Convert Integer To String - Integer.toString(123);//returns a string version of 123 - - // For other conversions check out the following classes: - // Double - // Long - // String - - // Typecasting - // You can also cast Java objects, there's a lot of details and deals - // with some more intermediate concepts. Feel free to check it out here: - // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html - - - /////////////////////////////////////// - // Classes And Functions - /////////////////////////////////////// - - System.out.println("\n->Classes & Functions"); - - // (definition of the Bicycle class follows) - - // Use new to instantiate a class - Bicycle trek = new Bicycle(); - - // Call object methods - trek.speedUp(3); // You should always use setter and getter methods - trek.setCadence(100); - - // toString returns this Object's string representation. - System.out.println("trek info: " + trek.toString()); - - // Double Brace Initialization - // The Java Language has no syntax for how to create static Collections - // in an easy way. Usually you end up in the following way: - - private static final Set COUNTRIES = new HashSet(); - static { - validCodes.add("DENMARK"); - validCodes.add("SWEDEN"); - validCodes.add("FINLAND"); - } - - // But there's a nifty way to achieve the same thing in an - // easier way, by using something that is called Double Brace - // Initialization. - - private static final Set COUNTRIES = new HashSet() {{ - add("DENMARK"); - add("SWEDEN"); - add("FINLAND"); - }} - - // The first brace is creating a new AnonymousInnerClass and the - // second one declares an instance initializer block. This block - // is called when the anonymous inner class is created. - // This does not only work for Collections, it works for all - // non-final classes. - - } // End main method -} // End LearnJava class - - -// You can include other, non-public outer-level classes in a .java file, -// but it is good practice. Instead split classes into separate files. - - -// Class Declaration Syntax: -// class { -// // data fields, constructors, functions all inside. -// // functions are called as methods in Java. -// } - -class Bicycle { - - // Bicycle's Fields/Variables - public int cadence; // Public: Can be accessed from anywhere - private int speed; // Private: Only accessible from within the class - protected int gear; // Protected: Accessible from the class and subclasses - String name; // default: Only accessible from within this package - - static String className; // Static class variable - - // Static block - // Java has no implementation of static constructors, but - // has a static block that can be used to initialize class variables - // (static variables). - // This block will be called when the class is loaded. - static { - className = "Bicycle"; - } - - // Constructors are a way of creating classes - // This is a constructor - public Bicycle() { - // You can also call another constructor: - // this(1, 50, 5, "Bontrager"); - gear = 1; - cadence = 50; - speed = 5; - name = "Bontrager"; - } - - // This is a constructor that takes arguments - public Bicycle(int startCadence, int startSpeed, int startGear, - String name) { - this.gear = startGear; - this.cadence = startCadence; - this.speed = startSpeed; - this.name = name; - } - - // Method Syntax: - // () - - // Java classes often implement getters and setters for their fields - - // Method declaration syntax: - // () - public int getCadence() { - return cadence; - } - - // void methods require no return statement - 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; - } - - //Method to display the attribute values of this Object. - @Override // Inherited from the Object class. - public String toString() { - return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + - " name: " + name; - } -} // end class Bicycle - -// PennyFarthing is a subclass of Bicycle -class PennyFarthing extends Bicycle { - // (Penny Farthings are those bicycles with the big front wheel. - // They have no gears.) - - public PennyFarthing(int startCadence, int startSpeed){ - // Call the parent constructor with super - super(startCadence, startSpeed, 0, "PennyFarthing"); - } - - // You should mark a method you're overriding with an @annotation. - // To learn more about what annotations are and their purpose check this - // out: http://docs.oracle.com/javase/tutorial/java/annotations/ - @Override - public void setGear(int gear) { - gear = 0; - } -} - -// Interfaces -// Interface declaration syntax -// interface extends { -// // Constants -// // Method declarations -// } - -// Example - Food: -public interface Edible { - public void eat(); // Any class that implements this interface, must - // implement this method. -} - -public interface Digestible { - public void digest(); -} - - -// We can now create a class that implements both of these interfaces. -public class Fruit implements Edible, Digestible { - - @Override - public void eat() { - // ... - } - - @Override - public void digest() { - // ... - } -} - -// In Java, you can extend only one class, but you can implement many -// interfaces. For example: -public class ExampleClass extends ExampleClassParent implements InterfaceOne, - InterfaceTwo { - - @Override - public void InterfaceOneMethod() { - } - - @Override - public void InterfaceTwoMethod() { - } - -} - -// Abstract Classes - -// Abstract Class declaration syntax -// abstract extends { -// // Constants and variables -// // Method declarations -// } - -// Marking a class as abstract means that it contains abstract methods that must -// be defined in a child class. Similar to interfaces, abstract classes cannot -// be instantiated, but instead must be extended and the abstract methods -// defined. Different from interfaces, abstract classes can contain a mixture of -// concrete and abstract methods. Methods in an interface cannot have a body, -// unless the method is static, and variables are final by default, unlike an -// abstract class. Also abstract classes CAN have the "main" method. - -public abstract class Animal -{ - public abstract void makeSound(); - - // Method can have a body - public void eat() - { - System.out.println("I am an animal and I am Eating."); - // Note: We can access private variable here. - age = 30; - } - - // No need to initialize, however in an interface - // a variable is implicitly final and hence has - // to be initialized. - protected int age; - - public void printAge() - { - System.out.println(age); - } - - // Abstract classes can have main function. - public static void main(String[] args) - { - System.out.println("I am abstract"); - } -} - -class Dog extends Animal -{ - // Note still have to override the abstract methods in the - // abstract class. - @Override - public void makeSound() - { - System.out.println("Bark"); - // age = 30; ==> ERROR! age is private to Animal - } - - // NOTE: You will get an error if you used the - // @Override annotation here, since java doesn't allow - // overriding of static methods. - // What is happening here is called METHOD HIDING. - // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/ - public static void main(String[] args) - { - Dog pluto = new Dog(); - pluto.makeSound(); - pluto.eat(); - pluto.printAge(); - } -} - -// Final Classes - -// Final Class declaration syntax -// final { -// // Constants and variables -// // Method declarations -// } - -// Final classes are classes that cannot be inherited from and are therefore a -// final child. In a way, final classes are the opposite of abstract classes -// because abstract classes must be extended, but final classes cannot be -// extended. -public final class SaberToothedCat extends Animal -{ - // Note still have to override the abstract methods in the - // abstract class. - @Override - public void makeSound() - { - System.out.println("Roar"); - } -} - -// Final Methods -public abstract class Mammal() -{ - // Final Method Syntax: - // final () - - // Final methods, like, final classes cannot be overridden by a child class, - // and are therefore the final implementation of the method. - public final boolean isWarmBlooded() - { - return true; - } -} - - -// Enum Type -// -// An enum type is a special data type that enables for a variable to be a set -// of predefined constants. The variable must be equal to one of the values that -// have been predefined for it. Because they are constants, the names of an enum -// type's fields are in uppercase letters. In the Java programming language, you -// define an enum type by using the enum keyword. For example, you would specify -// a days-of-the-week enum type as: - -public enum Day { - SUNDAY, MONDAY, TUESDAY, WEDNESDAY, - THURSDAY, FRIDAY, SATURDAY -} - -// We can use our enum Day like that: - -public class EnumTest { - - // Variable Enum - Day day; - - public EnumTest(Day day) { - this.day = day; - } - - public void tellItLikeItIs() { - switch (day) { - case MONDAY: - System.out.println("Mondays are bad."); - break; - - case FRIDAY: - System.out.println("Fridays are better."); - break; - - case SATURDAY: - case SUNDAY: - System.out.println("Weekends are best."); - break; - - default: - System.out.println("Midweek days are so-so."); - break; - } - } - - public static void main(String[] args) { - EnumTest firstDay = new EnumTest(Day.MONDAY); - firstDay.tellItLikeItIs(); // => Mondays are bad. - EnumTest thirdDay = new EnumTest(Day.WEDNESDAY); - thirdDay.tellItLikeItIs(); // => Midweek days are so-so. - } -} - -// Enum types are much more powerful than we show above. -// The enum body can include methods and other fields. -// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html - -``` - -## Further Reading - -The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. - -**Official Oracle Guides**: - -* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) - -* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) - -* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): - * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) - * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) - * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) - -* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) - -* [Interfaces](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/codeconvtoc-136057.html) - -**Online Practice and Tutorials** - -* [Learneroo.com - Learn Java](http://www.learneroo.com) - -* [Codingbat.com](http://codingbat.com/java) - - -**Books**: - -* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) - -* [Thinking in Java](http://www.mindview.net/Books/TIJ/) - -* [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) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown new file mode 100644 index 00000000..1a0bb670 --- /dev/null +++ b/uk-ua/java-ua.html.markdown @@ -0,0 +1,803 @@ +--- +language: java +contributors: + - ["Jake Prather", "http://github.com/JakeHP"] + - ["Jakukyo Friel", "http://weakish.github.io"] + - ["Madison Dickson", "http://github.com/mix3d"] + - ["Simon Morgan", "http://sjm.io/"] + - ["Zachary Ferguson", "http://github.com/zfergus2"] + - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"] + - ["Rachel Stiyer", "https://github.com/rstiyer"] +translators: + - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"] +filename: LearnJava.java +lang: uk-ua +--- + +Java є об'єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах. +[Read more here.](http://docs.oracle.com/javase/tutorial/java/) + +```java +// Однорядковий коментар починається з // +/* +Багаторядковий коментар виглядає так. +*/ +/** +JavaDoc коментар виглядає так. Використовується для опису класу та членів класу. +*/ + +// Імпорт класу ArrayList з пакету java.util +import java.util.ArrayList; +// Імпорт усіх класів з пакету java.security +import java.security.*; + +// Кожний .java файл містить один зовнішній публічний клас, ім'я якого співпадає +// з і менем файлу. +public class LearnJava { + + // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу 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; + // Оголошення декількох змінних одного типу <тип> <ім'я1>, <ім'я2>, <ім'я3> + int fooInt1, fooInt2, fooInt3; + + /* + * Ініціалізація змінних + */ + + // Ініціалізація змінної з використанням формату <тип> <ім'я> = <значення> + int fooInt = 1; + // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім'я1>, <ім'я2>, <ім'я3> = <значення> + int fooInt1, fooInt2, fooInt3; + fooInt1 = fooInt2 = fooInt3 = 1; + + /* + * Типи змінних + */ + // Байт - 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; + // інакше число буде трактуватись як integer. + + // Примітка: Java не має беззнакових типів. + + // Float - 32-бітне число з плаваючою комою одиничної точності за стандартом IEEE 754 + // 2^-149 <= float <= (2-2^-23) * 2^127 + float fooFloat = 234.5f; + // f or F використовується для позначення того, що змінна має тип float; + // інакше трактується як double. + + // Double - 64-бітне число з плаваючою комою подвійної точності за стандартом IEEE 754 + // 2^-1074 <= x <= (2-2^-52) * 2^1023 + 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; + // але вони можуть мати відкладену ініціалізацію. + final double E; + E = 2.71828; + + + // BigInteger -Незмінні знакові цілі числа довільної точності + // + // BigInteger є типом даних, який дає можливість розробнику виконувати операції з + // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві + // байтів, операції над ними виконуються функціями, які має клас BigInteger + // + // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок. + + BigInteger fooBigInteger = new BigInteger(fooByteArray); + + + // BigDecimal - Незмінні знакові дробові числа довільної точності + // + // BigDecimal складається з двох частин: цілого числа довільної точності + // з немасштабованим значенням та 32-бітного масштабованого цілого числа + // + // BigDecimal дозволяє розробника контролювати десяткове округлення. + // Рекомндовано використовувати BigDecimal зі значеннями валют + // і там, де необхідна точність дробових обчислень. + // + // BigDecimal може бути ініціалізований типами даних int, long, double or String + // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int). + + BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt); + + // Для дотримання заданої точності рекомендується використовувати + // конструктор, який приймає String + + BigDecimal tenCents = new BigDecimal("0.1"); + + + // Рядки + String fooString = "Це мій рядок!"; + + // \n символ переходу на новий рядок + String barString = "Друк з нового рялка?\nНема питань!"; + // \t символ табуляції + String bazString = "Хочете додати табуляцію?\tТримайте!"; + 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]); + + // Масиви є змінними та мають нульовий елемент. + intArray[1] = 1; + System.out.println("intArray @ 1: " + intArray[1]); // => 1 + + // Додатково + // ArrayLists - Схожі на масив, але мають більший функціонал та змінний розмір. + // LinkedLists - Реалізація двозв'язного списку. Всі операції + // виконуються так, як очікується від + // двозв'язного списку. + // Maps - Множина об'єктів, які пов'язують ключ зі значенням. Map є + // інтерфейсом, тому не може бути успадкований. + // Типи ключів і значень, які зберігаються в Map мають + // вказуватись у класі, який його реалізує. + // Ключ не може повторюватись і пов'язаний лише з одним значенням + // HashMaps - Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map. + // Це дозволяє виконувати певні операції, + // такі як отримання та вставка елемента, + // за сталий час для будь-якої кількості значень. + + /////////////////////////////////////// + // Operators + /////////////////////////////////////// + System.out.println("\n->Operators"); + + int i1 = 1, i2 = 2; // Shorthand for multiple declarations + + // Arithmetic is straightforward + 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 (int/int returns an int) + System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5 + + // Modulo + System.out.println("11%3 = "+(11 % 3)); // => 2 + + // Comparison operators + 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 + + // Boolean operators + System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false + System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true + System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true + + // Bitwise operators! + /* + ~ Unary bitwise complement + << Signed left shift + >> Signed/Arithmetic right shift + >>> Unsigned/Logical right shift + & Bitwise AND + ^ Bitwise exclusive OR + | Bitwise inclusive OR + */ + + // Incrementations + int i = 0; + System.out.println("\n->Inc/Dec-rementation"); + // The ++ and -- operators increment and decrement by 1 respectively. + // If they are placed before the variable, they increment then return; + // after the variable they return then increment. + System.out.println(i++); // i = 1, prints 0 (post-increment) + System.out.println(++i); // i = 2, prints 2 (pre-increment) + System.out.println(i--); // i = 1, prints 2 (post-decrement) + System.out.println(--i); // i = 0, prints 0 (pre-decrement) + + /////////////////////////////////////// + // Control Structures + /////////////////////////////////////// + System.out.println("\n->Control Structures"); + + // If statements are c-like + int j = 10; + if (j == 10) { + System.out.println("I get printed"); + } else if (j > 10) { + System.out.println("I don't"); + } else { + System.out.println("I also don't"); + } + + // While loop + int fooWhile = 0; + while(fooWhile < 100) { + System.out.println(fooWhile); + // Increment the counter + // Iterated 100 times, fooWhile 0,1,2...99 + fooWhile++; + } + System.out.println("fooWhile Value: " + fooWhile); + + // Do While Loop + int fooDoWhile = 0; + do { + System.out.println(fooDoWhile); + // Increment the counter + // Iterated 99 times, fooDoWhile 0->99 + fooDoWhile++; + } while(fooDoWhile < 100); + System.out.println("fooDoWhile Value: " + fooDoWhile); + + // For Loop + // for loop structure => for(; ; ) + for (int fooFor = 0; fooFor < 10; fooFor++) { + System.out.println(fooFor); + // Iterated 10 times, fooFor 0->9 + } + System.out.println("fooFor Value: " + fooFor); + + // Nested For Loop Exit with Label + outer: + for (int i = 0; i < 10; i++) { + for (int j = 0; j < 10; j++) { + if (i == 5 && j ==5) { + break outer; + // breaks out of outer loop instead of only the inner one + } + } + } + + // For Each Loop + // The for loop is also able to iterate over arrays as well as objects + // that implement the Iterable interface. + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + // for each loop structure => for ( : ) + // reads as: for each element in the iterable + // note: the object type must match the element type of the iterable. + + for (int bar : fooList) { + System.out.println(bar); + //Iterates 9 times and prints 1-9 on new lines + } + + // Switch Case + // A switch works with the byte, short, char, and int data types. + // It also works with enumerated types (discussed in Enum Types), the + // String class, and a few special classes that wrap primitive types: + // Character, Byte, Short, and Integer. + int month = 3; + String monthString; + switch (month) { + case 1: monthString = "January"; + break; + case 2: monthString = "February"; + break; + case 3: monthString = "March"; + break; + default: monthString = "Some other month"; + break; + } + System.out.println("Switch Case Result: " + monthString); + + // Starting in Java 7 and above, switching Strings works like this: + String myAnswer = "maybe"; + switch(myAnswer) { + case "yes": + System.out.println("You answered yes."); + break; + case "no": + System.out.println("You answered no."); + break; + case "maybe": + System.out.println("You answered maybe."); + break; + default: + System.out.println("You answered " + myAnswer); + break; + } + + // Conditional Shorthand + // You can use the '?' operator for quick assignments or logic forks. + // Reads as "If (statement) is true, use , otherwise, use + // " + int foo = 5; + String bar = (foo < 10) ? "A" : "B"; + System.out.println(bar); // Prints A, because the statement is true + + + //////////////////////////////////////// + // Converting Data Types And Typecasting + //////////////////////////////////////// + + // Converting data + + // Convert String To Integer + Integer.parseInt("123");//returns an integer version of "123" + + // Convert Integer To String + Integer.toString(123);//returns a string version of 123 + + // For other conversions check out the following classes: + // Double + // Long + // String + + // Typecasting + // You can also cast Java objects, there's a lot of details and deals + // with some more intermediate concepts. Feel free to check it out here: + // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html + + + /////////////////////////////////////// + // Classes And Functions + /////////////////////////////////////// + + System.out.println("\n->Classes & Functions"); + + // (definition of the Bicycle class follows) + + // Use new to instantiate a class + Bicycle trek = new Bicycle(); + + // Call object methods + trek.speedUp(3); // You should always use setter and getter methods + trek.setCadence(100); + + // toString returns this Object's string representation. + System.out.println("trek info: " + trek.toString()); + + // Double Brace Initialization + // The Java Language has no syntax for how to create static Collections + // in an easy way. Usually you end up in the following way: + + private static final Set COUNTRIES = new HashSet(); + static { + validCodes.add("DENMARK"); + validCodes.add("SWEDEN"); + validCodes.add("FINLAND"); + } + + // But there's a nifty way to achieve the same thing in an + // easier way, by using something that is called Double Brace + // Initialization. + + private static final Set COUNTRIES = new HashSet() {{ + add("DENMARK"); + add("SWEDEN"); + add("FINLAND"); + }} + + // The first brace is creating a new AnonymousInnerClass and the + // second one declares an instance initializer block. This block + // is called when the anonymous inner class is created. + // This does not only work for Collections, it works for all + // non-final classes. + + } // End main method +} // End LearnJava class + + +// You can include other, non-public outer-level classes in a .java file, +// but it is good practice. Instead split classes into separate files. + + +// Class Declaration Syntax: +// class { +// // data fields, constructors, functions all inside. +// // functions are called as methods in Java. +// } + +class Bicycle { + + // Bicycle's Fields/Variables + public int cadence; // Public: Can be accessed from anywhere + private int speed; // Private: Only accessible from within the class + protected int gear; // Protected: Accessible from the class and subclasses + String name; // default: Only accessible from within this package + + static String className; // Static class variable + + // Static block + // Java has no implementation of static constructors, but + // has a static block that can be used to initialize class variables + // (static variables). + // This block will be called when the class is loaded. + static { + className = "Bicycle"; + } + + // Constructors are a way of creating classes + // This is a constructor + public Bicycle() { + // You can also call another constructor: + // this(1, 50, 5, "Bontrager"); + gear = 1; + cadence = 50; + speed = 5; + name = "Bontrager"; + } + + // This is a constructor that takes arguments + public Bicycle(int startCadence, int startSpeed, int startGear, + String name) { + this.gear = startGear; + this.cadence = startCadence; + this.speed = startSpeed; + this.name = name; + } + + // Method Syntax: + // () + + // Java classes often implement getters and setters for their fields + + // Method declaration syntax: + // () + public int getCadence() { + return cadence; + } + + // void methods require no return statement + 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; + } + + //Method to display the attribute values of this Object. + @Override // Inherited from the Object class. + public String toString() { + return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + + " name: " + name; + } +} // end class Bicycle + +// PennyFarthing is a subclass of Bicycle +class PennyFarthing extends Bicycle { + // (Penny Farthings are those bicycles with the big front wheel. + // They have no gears.) + + public PennyFarthing(int startCadence, int startSpeed){ + // Call the parent constructor with super + super(startCadence, startSpeed, 0, "PennyFarthing"); + } + + // You should mark a method you're overriding with an @annotation. + // To learn more about what annotations are and their purpose check this + // out: http://docs.oracle.com/javase/tutorial/java/annotations/ + @Override + public void setGear(int gear) { + gear = 0; + } +} + +// Interfaces +// Interface declaration syntax +// interface extends { +// // Constants +// // Method declarations +// } + +// Example - Food: +public interface Edible { + public void eat(); // Any class that implements this interface, must + // implement this method. +} + +public interface Digestible { + public void digest(); +} + + +// We can now create a class that implements both of these interfaces. +public class Fruit implements Edible, Digestible { + + @Override + public void eat() { + // ... + } + + @Override + public void digest() { + // ... + } +} + +// In Java, you can extend only one class, but you can implement many +// interfaces. For example: +public class ExampleClass extends ExampleClassParent implements InterfaceOne, + InterfaceTwo { + + @Override + public void InterfaceOneMethod() { + } + + @Override + public void InterfaceTwoMethod() { + } + +} + +// Abstract Classes + +// Abstract Class declaration syntax +// abstract extends { +// // Constants and variables +// // Method declarations +// } + +// Marking a class as abstract means that it contains abstract methods that must +// be defined in a child class. Similar to interfaces, abstract classes cannot +// be instantiated, but instead must be extended and the abstract methods +// defined. Different from interfaces, abstract classes can contain a mixture of +// concrete and abstract methods. Methods in an interface cannot have a body, +// unless the method is static, and variables are final by default, unlike an +// abstract class. Also abstract classes CAN have the "main" method. + +public abstract class Animal +{ + public abstract void makeSound(); + + // Method can have a body + public void eat() + { + System.out.println("I am an animal and I am Eating."); + // Note: We can access private variable here. + age = 30; + } + + // No need to initialize, however in an interface + // a variable is implicitly final and hence has + // to be initialized. + protected int age; + + public void printAge() + { + System.out.println(age); + } + + // Abstract classes can have main function. + public static void main(String[] args) + { + System.out.println("I am abstract"); + } +} + +class Dog extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. + @Override + public void makeSound() + { + System.out.println("Bark"); + // age = 30; ==> ERROR! age is private to Animal + } + + // NOTE: You will get an error if you used the + // @Override annotation here, since java doesn't allow + // overriding of static methods. + // What is happening here is called METHOD HIDING. + // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/ + public static void main(String[] args) + { + Dog pluto = new Dog(); + pluto.makeSound(); + pluto.eat(); + pluto.printAge(); + } +} + +// Final Classes + +// Final Class declaration syntax +// final { +// // Constants and variables +// // Method declarations +// } + +// Final classes are classes that cannot be inherited from and are therefore a +// final child. In a way, final classes are the opposite of abstract classes +// because abstract classes must be extended, but final classes cannot be +// extended. +public final class SaberToothedCat extends Animal +{ + // Note still have to override the abstract methods in the + // abstract class. + @Override + public void makeSound() + { + System.out.println("Roar"); + } +} + +// Final Methods +public abstract class Mammal() +{ + // Final Method Syntax: + // final () + + // Final methods, like, final classes cannot be overridden by a child class, + // and are therefore the final implementation of the method. + public final boolean isWarmBlooded() + { + return true; + } +} + + +// Enum Type +// +// An enum type is a special data type that enables for a variable to be a set +// of predefined constants. The variable must be equal to one of the values that +// have been predefined for it. Because they are constants, the names of an enum +// type's fields are in uppercase letters. In the Java programming language, you +// define an enum type by using the enum keyword. For example, you would specify +// a days-of-the-week enum type as: + +public enum Day { + SUNDAY, MONDAY, TUESDAY, WEDNESDAY, + THURSDAY, FRIDAY, SATURDAY +} + +// We can use our enum Day like that: + +public class EnumTest { + + // Variable Enum + Day day; + + public EnumTest(Day day) { + this.day = day; + } + + public void tellItLikeItIs() { + switch (day) { + case MONDAY: + System.out.println("Mondays are bad."); + break; + + case FRIDAY: + System.out.println("Fridays are better."); + break; + + case SATURDAY: + case SUNDAY: + System.out.println("Weekends are best."); + break; + + default: + System.out.println("Midweek days are so-so."); + break; + } + } + + public static void main(String[] args) { + EnumTest firstDay = new EnumTest(Day.MONDAY); + firstDay.tellItLikeItIs(); // => Mondays are bad. + EnumTest thirdDay = new EnumTest(Day.WEDNESDAY); + thirdDay.tellItLikeItIs(); // => Midweek days are so-so. + } +} + +// Enum types are much more powerful than we show above. +// The enum body can include methods and other fields. +// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html + +``` + +## Further Reading + +The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. + +**Official Oracle Guides**: + +* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) + +* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) + +* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): + * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) + * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) + * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) + +* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) + +* [Interfaces](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/codeconvtoc-136057.html) + +**Online Practice and Tutorials** + +* [Learneroo.com - Learn Java](http://www.learneroo.com) + +* [Codingbat.com](http://codingbat.com/java) + + +**Books**: + +* [Head First Java](http://www.headfirstlabs.com/books/hfjava/) + +* [Thinking in Java](http://www.mindview.net/Books/TIJ/) + +* [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) -- cgit v1.2.3 From 6d60e96a1296637e8f1c425c179af241b80838ed Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 21:25:21 +0200 Subject: improving java Ukrainian translation added operators --- uk-ua/java-ua.html.markdown | 40 ++++++++++++++++++++-------------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index 1a0bb670..cd3dae56 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -200,23 +200,23 @@ public class LearnJava { // за сталий час для будь-якої кількості значень. /////////////////////////////////////// - // Operators + // Оператори /////////////////////////////////////// System.out.println("\n->Operators"); - int i1 = 1, i2 = 2; // Shorthand for multiple declarations + int i1 = 1, i2 = 2; // Коротка форма присвоєння - // Arithmetic is straightforward + // Арифметичні операції виконуються 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 (int/int returns an int) + System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int повертається як int) System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5 - // Modulo + // Ділення з остачею System.out.println("11%3 = "+(11 % 3)); // => 2 - // Comparison operators + // Оператори порівняння System.out.println("3 == 2? " + (3 == 2)); // => false System.out.println("3 != 2? " + (3 != 2)); // => true System.out.println("3 > 2? " + (3 > 2)); // => true @@ -224,28 +224,28 @@ public class LearnJava { System.out.println("2 <= 2? " + (2 <= 2)); // => true System.out.println("2 >= 2? " + (2 >= 2)); // => true - // Boolean operators + // Логічні оператори System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true - // Bitwise operators! + // Бітові оператори! /* - ~ Unary bitwise complement - << Signed left shift - >> Signed/Arithmetic right shift - >>> Unsigned/Logical right shift - & Bitwise AND - ^ Bitwise exclusive OR - | Bitwise inclusive OR + ~ Унарне бітове доповнення + << Знаковий зсув уліво + >> Знаковий/Арифметичний зсув управо + >>> Беззнаковий/Логічний зсув управо + & Бітове І + ^ Бітови виключне АБО + | Бітове АБО */ - // Incrementations + // Інкремнт int i = 0; - System.out.println("\n->Inc/Dec-rementation"); - // The ++ and -- operators increment and decrement by 1 respectively. - // If they are placed before the variable, they increment then return; - // after the variable they return then increment. + System.out.println("\n->Інкремент/Декремент"); + // Оператори ++ і -- здійснюють інкремент та декремент ретроспективно. + // Якщо вони розташовані перед змінною, операція виконається перед поверненням; + // після - повернеться інкремент або декремент. System.out.println(i++); // i = 1, prints 0 (post-increment) System.out.println(++i); // i = 2, prints 2 (pre-increment) System.out.println(i--); // i = 1, prints 2 (post-decrement) -- cgit v1.2.3 From ce3a57d4a08b858e2f5006922bf70b65cbce1d68 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 21:35:19 +0200 Subject: translated further reading --- uk-ua/java-ua.html.markdown | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index cd3dae56..a142680f 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -762,37 +762,37 @@ public class EnumTest { ``` -## Further Reading +## Додатково для прочитання The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. -**Official Oracle Guides**: +**Офіційні посібники Oracle**: * [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) -* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) +* [Java модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) -* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): +* [ООП концепції](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html) -* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) +* [Виключення](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html) -* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) +* [Інтерфейси](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html) -* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html) +* [параметризація](http://docs.oracle.com/javase/tutorial/java/generics/index.html) * [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html) -**Online Practice and Tutorials** +**Online практика та посібники** * [Learneroo.com - Learn Java](http://www.learneroo.com) * [Codingbat.com](http://codingbat.com/java) -**Books**: +**Книжки**: * [Head First Java](http://www.headfirstlabs.com/books/hfjava/) -- cgit v1.2.3 From 5668de06465df72933b0d5c5c33ad1ccf7f4a806 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 21:40:26 +0200 Subject: tech upgrade --- uk-ua/java-ua.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index a142680f..3582f73d 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -9,7 +9,7 @@ contributors: - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"] - ["Rachel Stiyer", "https://github.com/rstiyer"] translators: - - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"] + - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"] filename: LearnJava.java lang: uk-ua --- -- cgit v1.2.3 From dee2ed5f7c46f5ddaf2a85871f9f97ca819e940d Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 23:12:56 +0200 Subject: final Java translation can be used --- uk-ua/java-ua.html.markdown | 321 +++++++++++++++++++++----------------------- 1 file changed, 150 insertions(+), 171 deletions(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index 3582f73d..63472b3f 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -9,8 +9,8 @@ contributors: - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"] - ["Rachel Stiyer", "https://github.com/rstiyer"] translators: - - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"] -filename: LearnJava.java + - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"] +filename: LearnJavaUa.java lang: uk-ua --- @@ -252,92 +252,88 @@ public class LearnJava { System.out.println(--i); // i = 0, prints 0 (pre-decrement) /////////////////////////////////////// - // Control Structures + // Управляючі конструкції /////////////////////////////////////// System.out.println("\n->Control Structures"); - // If statements are c-like + // Оператор if використовується так само, як у мові С int j = 10; if (j == 10) { - System.out.println("I get printed"); + System.out.println("Це надрукується"); } else if (j > 10) { - System.out.println("I don't"); + System.out.println("А це - ні"); } else { - System.out.println("I also don't"); + System.out.println("Це - також ні"); } - // While loop + // Цикл з передумовою While int fooWhile = 0; while(fooWhile < 100) { System.out.println(fooWhile); - // Increment the counter - // Iterated 100 times, fooWhile 0,1,2...99 + // Інкремент лічильника + // Виконається 100 разів, fooWhile 0,1,2...99 fooWhile++; } System.out.println("fooWhile Value: " + fooWhile); - // Do While Loop + // Цикл з післяумовою Do While int fooDoWhile = 0; do { System.out.println(fooDoWhile); - // Increment the counter - // Iterated 99 times, fooDoWhile 0->99 + // Інкремент лічильника + // Виконається 99 разів, fooDoWhile 0->99 fooDoWhile++; } while(fooDoWhile < 100); System.out.println("fooDoWhile Value: " + fooDoWhile); - // For Loop - // for loop structure => for(; ; ) + // Цикл з параметром For + // структура циклу => for(<початковий стан>; <умова завершення>; <крок>) for (int fooFor = 0; fooFor < 10; fooFor++) { System.out.println(fooFor); - // Iterated 10 times, fooFor 0->9 + // Виконається 10 разів, fooFor 0->9 } System.out.println("fooFor Value: " + fooFor); - // Nested For Loop Exit with Label + // Вихід з вкладеного циклу через Label outer: for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { if (i == 5 && j ==5) { break outer; - // breaks out of outer loop instead of only the inner one + // вихід із зовнішнього циклу, а не лише внутрішнього } } } - // For Each Loop - // The for loop is also able to iterate over arrays as well as objects - // that implement the Iterable interface. - int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; - // for each loop structure => for ( : ) - // reads as: for each element in the iterable - // note: the object type must match the element type of the iterable. + // Цикл For Each + // Призначений для перебору масивів та колекцій + int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9}; for (int bar : fooList) { System.out.println(bar); //Iterates 9 times and prints 1-9 on new lines } - // Switch Case - // A switch works with the byte, short, char, and int data types. - // It also works with enumerated types (discussed in Enum Types), the - // String class, and a few special classes that wrap primitive types: - // Character, Byte, Short, and Integer. + // Оператор вибору Switch Case + // Оператор вибору працює з типами даних byte, short, char, int. + // Також працює з переліками Enum, + // класом String та класами-обгортками примітивних типів: + // Character, Byte, Short та Integer. int month = 3; String monthString; switch (month) { - case 1: monthString = "January"; + case 1: monthString = "Січень"; break; - case 2: monthString = "February"; + case 2: monthString = "Лютий"; break; - case 3: monthString = "March"; + case 3: monthString = "Березень"; break; - default: monthString = "Some other month"; + default: monthString = "Інший місяць"; break; } - System.out.println("Switch Case Result: " + monthString); + System.out.println("Switch Case результат: " + monthString); - // Starting in Java 7 and above, switching Strings works like this: + // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так: String myAnswer = "maybe"; switch(myAnswer) { case "yes": @@ -354,59 +350,55 @@ public class LearnJava { break; } - // Conditional Shorthand - // You can use the '?' operator for quick assignments or logic forks. - // Reads as "If (statement) is true, use , otherwise, use - // " + // Тернарний оператор вибору + // Можна використовувати '?' оператор для визначення умови. + // Читається так "Якщо (умова) вірна, то <перше значення>, інакше + // <друге значення" int foo = 5; String bar = (foo < 10) ? "A" : "B"; - System.out.println(bar); // Prints A, because the statement is true + System.out.println(bar); // Надрукується А, бо умова вірна //////////////////////////////////////// - // Converting Data Types And Typecasting + // Перетворення типів //////////////////////////////////////// - // Converting data + // Перетворення String на Integer + Integer.parseInt("123");//поверне числову версію рядка "123" - // Convert String To Integer - Integer.parseInt("123");//returns an integer version of "123" + // Перетворення Integer на String + Integer.toString(123);//повертає рядкову версію 123 - // Convert Integer To String - Integer.toString(123);//returns a string version of 123 - - // For other conversions check out the following classes: + // Для інших перетворень є наступні класи: // Double // Long // String - // Typecasting - // You can also cast Java objects, there's a lot of details and deals - // with some more intermediate concepts. Feel free to check it out here: + // Приведення типів + // Тут можна прочитати про приведення об'єктів: // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html /////////////////////////////////////// - // Classes And Functions + // Класи та функції /////////////////////////////////////// System.out.println("\n->Classes & Functions"); - // (definition of the Bicycle class follows) + // (Клас Bicycle наведений нижче) - // Use new to instantiate a class + // Новий об'єкт класу Bicycle trek = new Bicycle(); - // Call object methods - trek.speedUp(3); // You should always use setter and getter methods + // Виклик методу об'єкта + trek.speedUp(3); // Постійно використовуються методи з назвами set і get trek.setCadence(100); - // toString returns this Object's string representation. + // toString повертає рядкове представленя об'єкту. System.out.println("trek info: " + trek.toString()); - - // Double Brace Initialization - // The Java Language has no syntax for how to create static Collections - // in an easy way. Usually you end up in the following way: + + // У Java немає синтаксису для явного створення статичних колекцій. + // Це можна зробити так: private static final Set COUNTRIES = new HashSet(); static { @@ -415,9 +407,7 @@ public class LearnJava { validCodes.add("FINLAND"); } - // But there's a nifty way to achieve the same thing in an - // easier way, by using something that is called Double Brace - // Initialization. + // Але є інший спосіб - Double Brace Initialization. private static final Set COUNTRIES = new HashSet() {{ add("DENMARK"); @@ -425,49 +415,44 @@ public class LearnJava { add("FINLAND"); }} - // The first brace is creating a new AnonymousInnerClass and the - // second one declares an instance initializer block. This block - // is called when the anonymous inner class is created. - // This does not only work for Collections, it works for all - // non-final classes. + // Використовується анонімний внутрішній клас - } // End main method -} // End LearnJava class + } // Кінець методу main +} // Кінець класу LearnJava -// You can include other, non-public outer-level classes in a .java file, -// but it is good practice. Instead split classes into separate files. +// Можна додавати інші, не public класи зовнішнього рівня у .java файл, +// але це не є хорошою практикою. Розміщуйте класи в окремих файлах. -// Class Declaration Syntax: +// Синтаксис оголошення класу: // class { -// // data fields, constructors, functions all inside. -// // functions are called as methods in Java. +// // поля, конструктори, функції та ін. +// // у Java функції називаються методами. // } class Bicycle { - // Bicycle's Fields/Variables - public int cadence; // Public: Can be accessed from anywhere - private int speed; // Private: Only accessible from within the class - protected int gear; // Protected: Accessible from the class and subclasses - String name; // default: Only accessible from within this package + // Поля (змінні) класу Bicycle + public int cadence; // Public: доступно звідусіль + private int speed; // Private: доступно лише у межах класу + protected int gear; // Protected: доступно лише класу та нащадкам + String name; // default: доступно у даному пакеті - static String className; // Static class variable + static String className; // статична змінна класу - // Static block - // Java has no implementation of static constructors, but - // has a static block that can be used to initialize class variables - // (static variables). - // This block will be called when the class is loaded. + // статичний блок + // Java не має статичних конструкторів, але + // має статичний блок ініціалізації змінних класу + // Цей блок виконується при завантаженні класу. static { className = "Bicycle"; } - // Constructors are a way of creating classes - // This is a constructor + // Конструктори є способом створення класу + // Це - конструктор public Bicycle() { - // You can also call another constructor: + // Можна викликати інший конструктор: // this(1, 50, 5, "Bontrager"); gear = 1; cadence = 50; @@ -475,7 +460,7 @@ class Bicycle { name = "Bontrager"; } - // This is a constructor that takes arguments + // Цей конструктор приймає аргументи public Bicycle(int startCadence, int startSpeed, int startGear, String name) { this.gear = startGear; @@ -484,18 +469,18 @@ class Bicycle { this.name = name; } - // Method Syntax: - // () + // Синтаксис методу: + // <тип повернутого значення> <ім'я методу>(<аргументи>) - // Java classes often implement getters and setters for their fields + // Java класи часто мають методи для отримання та встановлення змінних - // Method declaration syntax: - // () + // Синтаксис оголошення методу: + // <модифікатор доступу> <тип повернутого значення> <ім'я методу>(<аргументи>) public int getCadence() { return cadence; } - // void methods require no return statement + // void методи не повертають значень public void setCadence(int newValue) { cadence = newValue; } @@ -520,26 +505,26 @@ class Bicycle { return name; } - //Method to display the attribute values of this Object. + //Метод показує значення змінних об'єкту. @Override // Inherited from the Object class. public String toString() { return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + " name: " + name; } -} // end class Bicycle +} // кінець класу Bicycle -// PennyFarthing is a subclass of Bicycle +// PennyFarthing є розширенням (нащадком) класу Bicycle class PennyFarthing extends Bicycle { - // (Penny Farthings are those bicycles with the big front wheel. - // They have no gears.) + // (Penny Farthings мають велике переднє колесо. + // Вони не мають передач.) public PennyFarthing(int startCadence, int startSpeed){ - // Call the parent constructor with super + // Виклик батьківського конструктора через super super(startCadence, startSpeed, 0, "PennyFarthing"); } - // You should mark a method you're overriding with an @annotation. - // To learn more about what annotations are and their purpose check this + // Перевизначений метод має відти відмічений аннотацією @annotation. + // Для ознайомлення з аннотаціями перейдіть за посиланням // out: http://docs.oracle.com/javase/tutorial/java/annotations/ @Override public void setGear(int gear) { @@ -547,17 +532,17 @@ class PennyFarthing extends Bicycle { } } -// Interfaces -// Interface declaration syntax -// interface extends { -// // Constants -// // Method declarations +// Інтерфейси +// Синтаксис оголошення інтерфейсів +// <рівень доступу> interface <ім'я інтерфейсу> extends <супер-інтерфейс> { +// // Констатнти +// // Оголошення методів // } -// Example - Food: +//Приклад - Food: public interface Edible { - public void eat(); // Any class that implements this interface, must - // implement this method. + public void eat(); // Будь-які класи, що реалізують цей інтерфейс + // повинні реалізувати цей метод. } public interface Digestible { @@ -565,7 +550,7 @@ public interface Digestible { } -// We can now create a class that implements both of these interfaces. +// Можна створити клас, що реалізує обидва інтерфейси. public class Fruit implements Edible, Digestible { @Override @@ -579,8 +564,8 @@ public class Fruit implements Edible, Digestible { } } -// In Java, you can extend only one class, but you can implement many -// interfaces. For example: +// В Java можна успадковувати лише один клас, але реалізовувати багато +// інтерфейсів. Наприклад: public class ExampleClass extends ExampleClassParent implements InterfaceOne, InterfaceTwo { @@ -594,37 +579,35 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, } -// Abstract Classes +// Абстрактні класи -// Abstract Class declaration syntax -// abstract extends { -// // Constants and variables -// // Method declarations +// Синтаксис оголошення абстрактних класів: +// <ріаень доступу> abstract <ім1я класу> extends <супер-абстрактний клас> { +// // Константи і змінні +// // Оголошення методів // } -// Marking a class as abstract means that it contains abstract methods that must -// be defined in a child class. Similar to interfaces, abstract classes cannot -// be instantiated, but instead must be extended and the abstract methods -// defined. Different from interfaces, abstract classes can contain a mixture of -// concrete and abstract methods. Methods in an interface cannot have a body, -// unless the method is static, and variables are final by default, unlike an -// abstract class. Also abstract classes CAN have the "main" method. +// Позначення класу як абстрактного означає, що оголошені у ньому методи мають +// бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри +// абстракних класів, але їх можна успадковувати. Нащадок зобов'язаний реалізувати всі абстрактні +// методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені, +// так і абстрактні методи. Методи в інтерфейсах не мають тіла, +// за вийнятком статичних методів, а змінні неявно мають модифікатор final, на відміну від +// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод "main". public abstract class Animal { public abstract void makeSound(); - // Method can have a body + // Метод може мати тіло public void eat() { System.out.println("I am an animal and I am Eating."); - // Note: We can access private variable here. + // Зауваження: є доступ до privat змінних. age = 30; } - // No need to initialize, however in an interface - // a variable is implicitly final and hence has - // to be initialized. + // Ініціалізація не потрібна protected int age; public void printAge() @@ -632,7 +615,7 @@ public abstract class Animal System.out.println(age); } - // Abstract classes can have main function. + // Абстрактні класи МОЖУТЬ мати метод "main". public static void main(String[] args) { System.out.println("I am abstract"); @@ -641,20 +624,19 @@ public abstract class Animal class Dog extends Animal { - // Note still have to override the abstract methods in the - // abstract class. + // Слід помічати перевизначення абстрактних методів @Override public void makeSound() { System.out.println("Bark"); - // age = 30; ==> ERROR! age is private to Animal + // age = 30; ==> ПОМИЛКА! age є private для Animal } - // NOTE: You will get an error if you used the - // @Override annotation here, since java doesn't allow - // overriding of static methods. - // What is happening here is called METHOD HIDING. - // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/ + // NOTE: Буде помилка, якщо використати аннотацію + // @Override тут, так як у java не можна + // перевизначати статичні методи. + // Те, що тут відбувається, називається METHOD HIDING. + // Більш детально: http://stackoverflow.com/questions/16313649/ public static void main(String[] args) { Dog pluto = new Dog(); @@ -664,22 +646,20 @@ class Dog extends Animal } } -// Final Classes +// Final класи -// Final Class declaration syntax -// final { -// // Constants and variables -// // Method declarations +// Синтаксис оголошення Final класів +// <рівень доступу> final <ім'я класу> { +// // Константи і змінні +// // Оголошення методів // } -// Final classes are classes that cannot be inherited from and are therefore a -// final child. In a way, final classes are the opposite of abstract classes -// because abstract classes must be extended, but final classes cannot be -// extended. +// Final не можуть мати нащадків, також самі вони є останніми нащадками. +// Final класи є протилежністю абстрактних у цьому плані. + public final class SaberToothedCat extends Animal { - // Note still have to override the abstract methods in the - // abstract class. + // Перевизначення методу @Override public void makeSound() { @@ -687,14 +667,14 @@ public final class SaberToothedCat extends Animal } } -// Final Methods +// Final методи public abstract class Mammal() { - // Final Method Syntax: - // final () + // Синтаксис Final методів: + // <модифікаор доступу> final <тип повернутого значення> <ім'я функції>(<аргументи>) - // Final methods, like, final classes cannot be overridden by a child class, - // and are therefore the final implementation of the method. + // Final методи не можуть бути перевизначені класом-нащадком, + // вони є остаточною реалізацією методу. public final boolean isWarmBlooded() { return true; @@ -702,21 +682,20 @@ public abstract class Mammal() } -// Enum Type +// Тип Enum (перелік) // -// An enum type is a special data type that enables for a variable to be a set -// of predefined constants. The variable must be equal to one of the values that -// have been predefined for it. Because they are constants, the names of an enum -// type's fields are in uppercase letters. In the Java programming language, you -// define an enum type by using the enum keyword. For example, you would specify -// a days-of-the-week enum type as: +// Enum є спеціальним типом даних, який дозволяє змінним бути певною множиною +// визначених констант. Змінна має відповідати одному зі значень, що +// заздалегідь визначені для неї. Так як це константи, імена типів полів у enum +// задаються у верхньому регістрі. У Java задається тип переліку за допомогою +// ключового слова. Наприклад, перелік днів тижня можна задати так: public enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY } -// We can use our enum Day like that: +// Можна використовувати перелік Day так: public class EnumTest { @@ -756,13 +735,13 @@ public class EnumTest { } } -// Enum types are much more powerful than we show above. -// The enum body can include methods and other fields. -// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html +// Переліки набагато потужніші, ніж тут показано. +// Тіло переліків може містити методи та інші змінні. +// Дивіться більше тут: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html ``` -## Додатково для прочитання +## Додатково для читання The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. -- cgit v1.2.3 From 6a76bb326c246e3f78db6dbe35e879daafab7ed3 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 23:20:04 +0200 Subject: some bug fixing --- uk-ua/java-ua.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index 63472b3f..3127f7f5 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -10,7 +10,7 @@ contributors: - ["Rachel Stiyer", "https://github.com/rstiyer"] translators: - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"] -filename: LearnJavaUa.java +filename: LearnJava.java lang: uk-ua --- -- cgit v1.2.3 From 3df055f2f71d7fe27186a9d61c1d8af66d2295d9 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 14 Nov 2015 20:13:56 +0200 Subject: Added -ua to the filename In order to Java Code Conventions, LearnJavaUa.java --- uk-ua/java-ua.html.markdown | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index 3127f7f5..63472b3f 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -10,7 +10,7 @@ contributors: - ["Rachel Stiyer", "https://github.com/rstiyer"] translators: - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"] -filename: LearnJava.java +filename: LearnJavaUa.java lang: uk-ua --- -- cgit v1.2.3 From 4c814b4df9bb73f200b2ab08e5660b6c74c5397f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andre=20Polykanine=20A=2EK=2EA=2E=20Menelion=20Elens=C3=BA?= =?UTF-8?q?l=C3=AB?= Date: Sat, 27 Feb 2016 18:24:20 +0200 Subject: [java/uk] Applied comments to #1969 --- uk-ua/java-ua.html.markdown | 293 ++++++++++++++++++++++---------------------- 1 file changed, 147 insertions(+), 146 deletions(-) diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown index 63472b3f..1ea30f3d 100644 --- a/uk-ua/java-ua.html.markdown +++ b/uk-ua/java-ua.html.markdown @@ -10,12 +10,13 @@ contributors: - ["Rachel Stiyer", "https://github.com/rstiyer"] translators: - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"] + - ["Andre Polykanine", "https://github.com/Oire"] filename: LearnJavaUa.java lang: uk-ua --- -Java є об'єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах. -[Read more here.](http://docs.oracle.com/javase/tutorial/java/) +Java є об’єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах. +[Детальніше читайте тут, англ.](http://docs.oracle.com/javase/tutorial/java/) ```java // Однорядковий коментар починається з // @@ -23,31 +24,31 @@ Java є об'єктно-орієнтованою мовою програмува Багаторядковий коментар виглядає так. */ /** -JavaDoc коментар виглядає так. Використовується для опису класу та членів класу. +JavaDoc-коментар виглядає так. Використовується для опису класу та членів класу. */ -// Імпорт класу ArrayList з пакету java.util +// Імпорт класу ArrayList з пакета java.util import java.util.ArrayList; -// Імпорт усіх класів з пакету java.security +// Імпорт усіх класів з пакета java.security import java.security.*; -// Кожний .java файл містить один зовнішній публічний клас, ім'я якого співпадає -// з і менем файлу. +// Кожний .java файл містить один зовнішній публічний клас, ім’я якого співпадає +// з іменем файлу. public class LearnJava { // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу main. public static void main (String[] args) { // Використання System.out.println() для виводу на друк рядків. - System.out.println("Hello World!"); + System.out.println("Привіт, світе!"); System.out.println( - "Integer: " + 10 + - " Double: " + 3.14 + - " Boolean: " + true); + " Ціле число: " + 10 + + " Число з рухомою комою подвійної точности: " + 3.14 + + " Булеве значення: " + true); - // Для друку з нового рядкка використовується System.out.print(). - System.out.print("Hello "); - System.out.print("World"); + // Для друку без переходу на новий рядок використовується System.out.print(). + System.out.print("Привіт, "); + System.out.print("світе"); // Використання System.out.printf() для простого форматованого виводу на друк. System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159 @@ -61,60 +62,60 @@ public class LearnJava { */ // Для оголошення змінних використовується формат <тип> <змінна> int fooInt; - // Оголошення декількох змінних одного типу <тип> <ім'я1>, <ім'я2>, <ім'я3> + // Оголошення декількох змінних одного типу <тип> <ім’я1>, <ім’я2>, <ім’я3> int fooInt1, fooInt2, fooInt3; /* * Ініціалізація змінних */ - // Ініціалізація змінної з використанням формату <тип> <ім'я> = <значення> + // Ініціалізація змінної з використанням формату <тип> <ім’я> = <значення> int fooInt = 1; - // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім'я1>, <ім'я2>, <ім'я3> = <значення> + // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім’я1>, <ім’я2>, <ім’я3> = <значення> int fooInt1, fooInt2, fooInt3; fooInt1 = fooInt2 = fooInt3 = 1; /* * Типи змінних */ - // Байт - 8-бітне ціле число зі знаком + // Байт — 8-бітне ціле число зі знаком // (-128 <= byte <= 127) byte fooByte = 100; - // Short - 16-бітне ціле число зі знаком - // (-32,768 <= short <= 32,767) + // Short — 16-бітне ціле число зі знаком + // (-32 768 <= short <= 32 767) short fooShort = 10000; - // Integer - 32-бітне ціле число зі знаком - // (-2,147,483,648 <= int <= 2,147,483,647) + // 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 — 64-бітне ціле число зі знаком + // (-9 223 372 036 854 775 808 <= long <= 9 223 372 036 854 775 807) long fooLong = 100000L; // L використовується для позначення того, що число має тип Long; // інакше число буде трактуватись як integer. // Примітка: Java не має беззнакових типів. - // Float - 32-бітне число з плаваючою комою одиничної точності за стандартом IEEE 754 + // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754 // 2^-149 <= float <= (2-2^-23) * 2^127 float fooFloat = 234.5f; - // f or F використовується для позначення того, що змінна має тип float; + // f або F використовується для позначення того, що змінна має тип float; // інакше трактується як double. - // Double - 64-бітне число з плаваючою комою подвійної точності за стандартом IEEE 754 + // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754 // 2^-1074 <= x <= (2-2^-52) * 2^1023 double fooDouble = 123.4; - // Boolean - true & false (істина чи неправда) + // Boolean — true & false (істина чи хиба) boolean fooBoolean = true; boolean barBoolean = false; - // Char - 16-бітний символ Unicode + // Char — 16-бітний символ Unicode char fooChar = 'A'; - // final - посилання на такі змінні не можуть бути присвоєні іншим об'єктам, + // final - посилання на такі змінні не можуть бути присвоєні іншим об’єктам, final int HOURS_I_WORK_PER_WEEK = 9001; // але вони можуть мати відкладену ініціалізацію. final double E; @@ -123,25 +124,25 @@ public class LearnJava { // BigInteger -Незмінні знакові цілі числа довільної точності // - // BigInteger є типом даних, який дає можливість розробнику виконувати операції з + // BigInteger є типом даних, який дає можливість розробнику виконувати операції // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві - // байтів, операції над ними виконуються функціями, які має клас BigInteger + // байтів, операції над ними виконуються функціями, які мають клас BigInteger // // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок. BigInteger fooBigInteger = new BigInteger(fooByteArray); - // BigDecimal - Незмінні знакові дробові числа довільної точності + // BigDecimal — Незмінні знакові дробові числа довільної точності // // BigDecimal складається з двох частин: цілого числа довільної точності // з немасштабованим значенням та 32-бітного масштабованого цілого числа // - // BigDecimal дозволяє розробника контролювати десяткове округлення. - // Рекомндовано використовувати BigDecimal зі значеннями валют + // BigDecimal дозволяє розробникам контролювати десяткове округлення. + // Рекомендовано використовувати BigDecimal зі значеннями валют // і там, де необхідна точність дробових обчислень. // - // BigDecimal може бути ініціалізований типами даних int, long, double or String + // BigDecimal може бути ініціалізований типами даних int, long, double або String // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int). BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt); @@ -155,9 +156,9 @@ public class LearnJava { // Рядки String fooString = "Це мій рядок!"; - // \n символ переходу на новий рядок - String barString = "Друк з нового рялка?\nНема питань!"; - // \t символ табуляції + // \n є символом переходу на новий рядок + String barString = "Друк з нового рядка?\nНема питань!"; + // \t — це символ табуляції String bazString = "Хочете додати табуляцію?\tТримайте!"; System.out.println(fooString); System.out.println(barString); @@ -166,8 +167,8 @@ public class LearnJava { // Масиви // Розмір масиву має бути визначений перед ініціалізацією // Наведений формат ілюструє ініціалізацію масивів - // <тип даних>[] <ім'я змінної> = new <тип даних>[<розмір масиву>]; - // <тип даних> <ім'я змінної>[] = new <тип даних>[<розмір масиву>]; + // <тип даних>[] <ім’я змінної> = new <тип даних>[<розмір масиву>]; + // <тип даних> <ім’я змінної>[] = new <тип даних>[<розмір масиву>]; int[] intArray = new int[10]; String[] stringArray = new String[1]; boolean boolArray[] = new boolean[100]; @@ -177,7 +178,7 @@ public class LearnJava { String names[] = {"Bob", "John", "Fred", "Juan Pedro"}; boolean bools[] = new boolean[] {true, false, false}; - // Індексація масиву - доступ за елементами + // Індексація масиву — доступ за елементами System.out.println("intArray @ 0: " + intArray[0]); // Масиви є змінними та мають нульовий елемент. @@ -185,28 +186,28 @@ public class LearnJava { System.out.println("intArray @ 1: " + intArray[1]); // => 1 // Додатково - // ArrayLists - Схожі на масив, але мають більший функціонал та змінний розмір. - // LinkedLists - Реалізація двозв'язного списку. Всі операції + // ArrayLists — Схожі на масив, але мають більший функціонал та змінний розмір. + // LinkedLists — Реалізація двозв’язного списку. Всі операції // виконуються так, як очікується від - // двозв'язного списку. - // Maps - Множина об'єктів, які пов'язують ключ зі значенням. Map є + // двозв’язного списку. + // Maps — Множина об’єктів, які пов’язують ключ зі значенням. Map є // інтерфейсом, тому не може бути успадкований. - // Типи ключів і значень, які зберігаються в Map мають + // Типи ключів і значень, які зберігаються в Map, мають // вказуватись у класі, який його реалізує. - // Ключ не може повторюватись і пов'язаний лише з одним значенням - // HashMaps - Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map. + // Ключ не може повторюватись і пов’язаний лише з одним значенням + // HashMaps — Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map. // Це дозволяє виконувати певні операції, - // такі як отримання та вставка елемента, - // за сталий час для будь-якої кількості значень. + // такі, як отримання та вставка елемента, + // залишаючись постійними навіть для великої кількості елементів. /////////////////////////////////////// // Оператори /////////////////////////////////////// - System.out.println("\n->Operators"); + System.out.println("\n->Оператори"); int i1 = 1, i2 = 2; // Коротка форма присвоєння - // Арифметичні операції виконуються + // Арифметичні операції виконуються очевидним способом System.out.println("1+2 = " + (i1 + i2)); // => 3 System.out.println("2-1 = " + (i2 - i1)); // => 1 System.out.println("2*1 = " + (i2 * i1)); // => 2 @@ -240,30 +241,30 @@ public class LearnJava { | Бітове АБО */ - // Інкремнт + // Інкремент int i = 0; System.out.println("\n->Інкремент/Декремент"); // Оператори ++ і -- здійснюють інкремент та декремент ретроспективно. // Якщо вони розташовані перед змінною, операція виконається перед поверненням; - // після - повернеться інкремент або декремент. - System.out.println(i++); // i = 1, prints 0 (post-increment) - System.out.println(++i); // i = 2, prints 2 (pre-increment) - System.out.println(i--); // i = 1, prints 2 (post-decrement) - System.out.println(--i); // i = 0, prints 0 (pre-decrement) + // якщо після неї — повернеться інкремент або декремент. + 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->Control Structures"); + System.out.println("\n->Керуючі конструкції"); - // Оператор if використовується так само, як у мові С + // Оператор if використовується так само, як у мові C int j = 10; if (j == 10) { System.out.println("Це надрукується"); } else if (j > 10) { - System.out.println("А це - ні"); + System.out.println("А це — ні"); } else { - System.out.println("Це - також ні"); + System.out.println("Це — також ні"); } // Цикл з передумовою While @@ -284,7 +285,7 @@ public class LearnJava { // Виконається 99 разів, fooDoWhile 0->99 fooDoWhile++; } while(fooDoWhile < 100); - System.out.println("fooDoWhile Value: " + fooDoWhile); + System.out.println("Значення fooDoWhile: " + fooDoWhile); // Цикл з параметром For // структура циклу => for(<початковий стан>; <умова завершення>; <крок>) @@ -292,9 +293,9 @@ public class LearnJava { System.out.println(fooFor); // Виконається 10 разів, fooFor 0->9 } - System.out.println("fooFor Value: " + fooFor); + System.out.println("Значення fooFor: " + fooFor); - // Вихід з вкладеного циклу через Label + // Вихід із вкладеного циклу через мітку outer: for (int i = 0; i < 10; i++) { for (int j = 0; j < 10; j++) { @@ -311,7 +312,7 @@ public class LearnJava { for (int bar : fooList) { System.out.println(bar); - //Iterates 9 times and prints 1-9 on new lines + // Повторюється 9 разів та друкує числа від 1 до 9 на нових рядках } // Оператор вибору Switch Case @@ -331,29 +332,29 @@ public class LearnJava { default: monthString = "Інший місяць"; break; } - System.out.println("Switch Case результат: " + monthString); + System.out.println("Результат Switch Case: " + monthString); // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так: - String myAnswer = "maybe"; + String myAnswer = "можливо"; switch(myAnswer) { - case "yes": - System.out.println("You answered yes."); + case "так": + System.out.println("Ви відповіли «Так»."); break; - case "no": - System.out.println("You answered no."); + case "ні": + System.out.println("Ви відповіли «ні»."); break; - case "maybe": - System.out.println("You answered maybe."); + case "можливо": + System.out.println("Ви відповіли «Можливо»."); break; default: - System.out.println("You answered " + myAnswer); + System.out.println("Ви відповіли «" + myAnswer + "»"); break; } // Тернарний оператор вибору - // Можна використовувати '?' оператор для визначення умови. - // Читається так "Якщо (умова) вірна, то <перше значення>, інакше - // <друге значення" + // Можна використовувати оператор «?» (знак питання) для визначення умови. + // Читається так: «Якщо (умова) вірна, то <перше значення>, інакше + // <друге значення>» int foo = 5; String bar = (foo < 10) ? "A" : "B"; System.out.println(bar); // Надрукується А, бо умова вірна @@ -375,7 +376,7 @@ public class LearnJava { // String // Приведення типів - // Тут можна прочитати про приведення об'єктів: + // Тут можна прочитати про приведення об’єктів (англ.): // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html @@ -383,19 +384,19 @@ public class LearnJava { // Класи та функції /////////////////////////////////////// - System.out.println("\n->Classes & Functions"); + System.out.println("\n->Класи та функції"); // (Клас Bicycle наведений нижче) - // Новий об'єкт класу + // Новий об’єкт класу Bicycle trek = new Bicycle(); - // Виклик методу об'єкта + // Виклик методу об’єкта trek.speedUp(3); // Постійно використовуються методи з назвами set і get trek.setCadence(100); - // toString повертає рядкове представленя об'єкту. - System.out.println("trek info: " + trek.toString()); + // toString повертає рядкове представлення об’єкту. + System.out.println("Інформація про об’єкт trek: " + trek.toString()); // У Java немає синтаксису для явного створення статичних колекцій. // Це можна зробити так: @@ -407,7 +408,7 @@ public class LearnJava { validCodes.add("FINLAND"); } - // Але є інший спосіб - Double Brace Initialization. + // Але є інший спосіб — ініціалізація з подвійними фігурними дужками. private static final Set COUNTRIES = new HashSet() {{ add("DENMARK"); @@ -421,12 +422,12 @@ public class LearnJava { } // Кінець класу LearnJava -// Можна додавати інші, не public класи зовнішнього рівня у .java файл, +// У .java-файл можна додавати інші, не public класи зовнішнього рівня, // але це не є хорошою практикою. Розміщуйте класи в окремих файлах. // Синтаксис оголошення класу: -// class { +// class <ім’я класу> { // // поля, конструктори, функції та ін. // // у Java функції називаються методами. // } @@ -436,8 +437,8 @@ class Bicycle { // Поля (змінні) класу Bicycle public int cadence; // Public: доступно звідусіль private int speed; // Private: доступно лише у межах класу - protected int gear; // Protected: доступно лише класу та нащадкам - String name; // default: доступно у даному пакеті + protected int gear; // Protected: доступно лише класові та його нащадкам + String name; // за замовчанням: доступно у даному пакеті static String className; // статична змінна класу @@ -450,7 +451,7 @@ class Bicycle { } // Конструктори є способом створення класу - // Це - конструктор + // Оце — конструктор public Bicycle() { // Можна викликати інший конструктор: // this(1, 50, 5, "Bontrager"); @@ -470,17 +471,17 @@ class Bicycle { } // Синтаксис методу: - // <тип повернутого значення> <ім'я методу>(<аргументи>) + // <тип повернутого значення> <ім’я методу>(<аргументи>) - // Java класи часто мають методи для отримання та встановлення змінних + // Java-класи часто мають методи для отримання та встановлення змінних // Синтаксис оголошення методу: - // <модифікатор доступу> <тип повернутого значення> <ім'я методу>(<аргументи>) + // <модифікатор доступу> <тип повернутого значення> <ім’я методу>(<аргументи>) public int getCadence() { return cadence; } - // void методи не повертають значень + // void-методи не повертають значень public void setCadence(int newValue) { cadence = newValue; } @@ -505,8 +506,8 @@ class Bicycle { return name; } - //Метод показує значення змінних об'єкту. - @Override // Inherited from the Object class. + //Метод показує значення змінних об’єкту. + @Override // Успадковано від класу Object. public String toString() { return "gear: " + gear + " cadence: " + cadence + " speed: " + speed + " name: " + name; @@ -523,9 +524,9 @@ class PennyFarthing extends Bicycle { super(startCadence, startSpeed, 0, "PennyFarthing"); } - // Перевизначений метод має відти відмічений аннотацією @annotation. + // Перевизначений метод має бути відмічений аннотацією, яка починається зі знака @. // Для ознайомлення з аннотаціями перейдіть за посиланням - // out: http://docs.oracle.com/javase/tutorial/java/annotations/ + // http://docs.oracle.com/javase/tutorial/java/annotations/ @Override public void setGear(int gear) { gear = 0; @@ -534,14 +535,14 @@ class PennyFarthing extends Bicycle { // Інтерфейси // Синтаксис оголошення інтерфейсів -// <рівень доступу> interface <ім'я інтерфейсу> extends <супер-інтерфейс> { -// // Констатнти +// <рівень доступу> interface <ім’я інтерфейсу> extends <батьківський інтерфейс> { +// // Константи // // Оголошення методів // } -//Приклад - Food: +//Приклад — їжа (Food): public interface Edible { - public void eat(); // Будь-які класи, що реалізують цей інтерфейс + public void eat(); // Будь-які класи, що реалізують цей інтерфейс, // повинні реалізувати цей метод. } @@ -582,18 +583,18 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne, // Абстрактні класи // Синтаксис оголошення абстрактних класів: -// <ріаень доступу> abstract <ім1я класу> extends <супер-абстрактний клас> { +// <рівень доступу> abstract <ім’я класу> extends <батьківський абстрактний клас> { // // Константи і змінні // // Оголошення методів // } // Позначення класу як абстрактного означає, що оголошені у ньому методи мають // бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри -// абстракних класів, але їх можна успадковувати. Нащадок зобов'язаний реалізувати всі абстрактні +// абстракних класів, але їх можна успадковувати. Нащадок зобов’язаний реалізувати всі абстрактні // методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені, // так і абстрактні методи. Методи в інтерфейсах не мають тіла, -// за вийнятком статичних методів, а змінні неявно мають модифікатор final, на відміну від -// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод "main". +// за винятком статичних методів, а змінні неявно мають модифікатор final, на відміну від +// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод «main». public abstract class Animal { @@ -602,8 +603,8 @@ public abstract class Animal // Метод може мати тіло public void eat() { - System.out.println("I am an animal and I am Eating."); - // Зауваження: є доступ до privat змінних. + System.out.println("Я тварина, і я їм."); + // Зауваження: є доступ до приватних змінних. age = 30; } @@ -615,10 +616,10 @@ public abstract class Animal System.out.println(age); } - // Абстрактні класи МОЖУТЬ мати метод "main". + // Абстрактні класи МОЖУТЬ мати метод «main». public static void main(String[] args) { - System.out.println("I am abstract"); + System.out.println("Я абстрактний"); } } @@ -628,14 +629,14 @@ class Dog extends Animal @Override public void makeSound() { - System.out.println("Bark"); + System.out.println("Гав!"); // age = 30; ==> ПОМИЛКА! age є private для Animal } - // NOTE: Буде помилка, якщо використати аннотацію + // Зауваження: Буде помилка, якщо використати аннотацію // @Override тут, так як у java не можна // перевизначати статичні методи. - // Те, що тут відбувається, називається METHOD HIDING. + // Те, що тут відбувається, називається приховування методів. // Більш детально: http://stackoverflow.com/questions/16313649/ public static void main(String[] args) { @@ -646,16 +647,16 @@ class Dog extends Animal } } -// Final класи +// Фінальні класи -// Синтаксис оголошення Final класів -// <рівень доступу> final <ім'я класу> { +// Синтаксис оголошення фінальних класів +// <рівень доступу> final <ім’я класу> { // // Константи і змінні // // Оголошення методів // } -// Final не можуть мати нащадків, також самі вони є останніми нащадками. -// Final класи є протилежністю абстрактних у цьому плані. +// Фінальні класи не можуть мати нащадків, також самі вони є останніми нащадками. +// Фінальні класи є протилежністю абстрактних у цьому плані. public final class SaberToothedCat extends Animal { @@ -663,17 +664,17 @@ public final class SaberToothedCat extends Animal @Override public void makeSound() { - System.out.println("Roar"); + System.out.println("Гррр!"); } } -// Final методи +// Фінальні методи public abstract class Mammal() { - // Синтаксис Final методів: - // <модифікаор доступу> final <тип повернутого значення> <ім'я функції>(<аргументи>) + // Синтаксис фінальних методів: + // <модифікатор доступу> final <тип повернутого значення> <ім’я функції>(<аргументи>) - // Final методи не можуть бути перевизначені класом-нащадком, + // Фінальні методи не можуть бути перевизначені класом-нащадком, // вони є остаточною реалізацією методу. public final boolean isWarmBlooded() { @@ -686,20 +687,20 @@ public abstract class Mammal() // // Enum є спеціальним типом даних, який дозволяє змінним бути певною множиною // визначених констант. Змінна має відповідати одному зі значень, що -// заздалегідь визначені для неї. Так як це константи, імена типів полів у enum -// задаються у верхньому регістрі. У Java задається тип переліку за допомогою -// ключового слова. Наприклад, перелік днів тижня можна задати так: +// заздалегідь визначені для неї. Оскільки це константи, імена типів полів у enum +// задаються у верхньому регістрі. Тип «перелік» у Java задається за допомогою +// ключового слова enum. Наприклад, перелік днів тижня можна задати так: public enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY } -// Можна використовувати перелік Day так: +// Перелік Day можна використовувати так: public class EnumTest { - // Variable Enum + // Змінна того же типу, що й перелік Day day; public EnumTest(Day day) { @@ -709,29 +710,29 @@ public class EnumTest { public void tellItLikeItIs() { switch (day) { case MONDAY: - System.out.println("Mondays are bad."); + System.out.println("Понеділкі важкі."); break; case FRIDAY: - System.out.println("Fridays are better."); + System.out.println("П’ятниці краще."); break; case SATURDAY: case SUNDAY: - System.out.println("Weekends are best."); + System.out.println("Вихідні найліпші."); break; default: - System.out.println("Midweek days are so-so."); + System.out.println("Середина тижня так собі."); break; } } public static void main(String[] args) { EnumTest firstDay = new EnumTest(Day.MONDAY); - firstDay.tellItLikeItIs(); // => Mondays are bad. + firstDay.tellItLikeItIs(); // => Понеділки важкі. EnumTest thirdDay = new EnumTest(Day.WEDNESDAY); - thirdDay.tellItLikeItIs(); // => Midweek days are so-so. + thirdDay.tellItLikeItIs(); // => Середина тижня так собі. } } @@ -743,18 +744,18 @@ public class EnumTest { ## Додатково для читання -The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples. +Посилання, наведені нижче, дозволяють тільки зрозуміти тему. Щоб знайти конкретні приклади, використовуйте Ґуґл. **Офіційні посібники Oracle**: -* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) +* [Посібник Java від Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html) -* [Java модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) +* [Java — модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html) -* [ООП концепції](http://docs.oracle.com/javase/tutorial/java/concepts/index.html): - * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html) - * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html) - * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.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) @@ -762,11 +763,11 @@ The links provided here below are just to get an understanding of the topic, fee * [параметризація](http://docs.oracle.com/javase/tutorial/java/generics/index.html) -* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html) +* [Стиль коду у Java](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html) -**Online практика та посібники** +**Online-практика та посібники** -* [Learneroo.com - Learn Java](http://www.learneroo.com) +* [Learneroo.com — Вивчаємо Java](http://www.learneroo.com) * [Codingbat.com](http://codingbat.com/java) -- cgit v1.2.3