From e1d9cfc97fac1972b3680d05c710d6c55a9f48bb Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 20:47:13 +0200 Subject: [PATCH 1/9] 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) From b71d01fd8aba1a9da6305dc1f52fb748ee824adf Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 20:52:42 +0200 Subject: [PATCH 2/9] Changed the name of Ukrainian translation uk-ua is more correctly --- {ua-ua => uk-ua}/java-ua.html.markdown | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename {ua-ua => uk-ua}/java-ua.html.markdown (100%) diff --git a/ua-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown similarity index 100% rename from ua-ua/java-ua.html.markdown rename to uk-ua/java-ua.html.markdown From 6d60e96a1296637e8f1c425c179af241b80838ed Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 21:25:21 +0200 Subject: [PATCH 3/9] 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) From ce3a57d4a08b858e2f5006922bf70b65cbce1d68 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 21:35:19 +0200 Subject: [PATCH 4/9] 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/) From 5668de06465df72933b0d5c5c33ad1ccf7f4a806 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 21:40:26 +0200 Subject: [PATCH 5/9] 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 --- From dee2ed5f7c46f5ddaf2a85871f9f97ca819e940d Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 23:12:56 +0200 Subject: [PATCH 6/9] 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. From 6a76bb326c246e3f78db6dbe35e879daafab7ed3 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 31 Oct 2015 23:20:04 +0200 Subject: [PATCH 7/9] 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 --- From 3df055f2f71d7fe27186a9d61c1d8af66d2295d9 Mon Sep 17 00:00:00 2001 From: Oleksandr Tatarchuk Date: Sat, 14 Nov 2015 20:13:56 +0200 Subject: [PATCH 8/9] 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 --- 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: [PATCH 9/9] [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)