Многострочные комментарии в java

10 главных конструкций языка Java

Java — важный язык разработки во многих больших корпорациях. Мы уже рассказывали про то, как и где применяется Java, теперь настало время для практики.

Так как авторы языка Java при создании вдохновлялись языками C и C++, то в Java тоже появилось много похожих конструкций и команд. Если вы знаете C или C++, то освоить Java вам будет гораздо проще.

👉 В Java после каждой команды ставится точка с запятой.

Комментарии

Комментарии в Java точно такие же, как в C-подобных языках — есть однострочные, которые работают только для одной строки, и многострочные.

// Это однострочный комментарий
// Для каждой строки нужно добавлять его отдельно
/* А это — многострочный
его можно сделать любой длины,
если в начале и в конце поставить нужные символы */

Переменные и типы данных

Как и в C, в Java есть несколько типов данных с разным объёмом выделяемой памяти. Предполагается, что программист сам решит, какой тип использовать лучше всего в каждой ситуации и сам будет следить за тем, чтобы в переменную поместилось всё что нужно.

// целое, 1 байт byte b; // целое, 2 байта short s; // целое, 4 байта int x = 420; // целое, 8 байт long l; // дробное, 4 байта float fl = 4.3; // дробное, 8 байт double d,q; // логический тип, true или false boolean bol;

Присваивание и сравнение

// это присваивание
x = 10;
// а это — сравнение x и 10
// результат сравнения отправляется в переменную b
boolean bol;
b = (x == 10);

Ещё есть метод сравнения .equal — он работает более гибко и предсказуемо, чем ==, потому что двойное равно может сравнивать только числа и строки.

Структура программы

Разработчикам Java понравилось, что в C вся программа состоит из функций, среди которых есть одна обязательная — main, поэтому сделали точно так же. В классах эта функция называется методом.

Но есть одно важное отличие: каждая java-программа — это как бы один большой класс со своими разделами, которые должны быть у каждого класса. Благодаря этому большие программы легко собираются из маленьких java-кирпичиков и работают друг с другом как с классами, используя все их возможности.

// программа — тоже класс public class Program < // публичная часть класса, доступная всем // в ней сразу делают основную функцию программы main public static void main(String[] args) < // объявляем переменные String name = "Код"; // выводим строку на экран System.out.printf("Привет, это журнал %s \n", name); // конец основной функции >// конец описания класса >

Ввод и вывод

Для ввода и вывода используют системный класс System и два его объекта — in и out. Но на практике чаще всего вместо in используют объект Scanner, чтобы можно было более гибко управлять вводом данных.

// подключаем класс Scanner import java.util.Scanner; // класс с программой public class Program < // основная функция public static void main(String[] args) < // создаём новый объект ввода, через который будем дальше работать Scanner in = new Scanner(System.in); // выводим строку System.out.print("Введите имя: "); // создаём переменную name и помещаем в неё то, что пользователь введёт с клавиатуры String name = in.nextLine(); // выводим ещё одну строку System.out.print("Возраст: "); // так же запоминаем возраст в другую переменную int age = in.nextInt(); // просим ввести рост System.out.print("Введите рост: "); // запоминаем введённое значение float height = in.nextFloat(); // выводим строку с результатом System.out.printf("Имя: %s Возраст: %d Рост: %.2f \n", name, age, height); // закрываем наш объект ввода, потому что пока он больше не нужен in.close(); >>

Условные операторы if и switch

Работают так же, как в C и в любых современных языках высокого уровня. Главное здесь — следить за фигурными скобками и не перепутать, что к чему относится. Проще всего это регулировать отступами:

// числа для сравнения int num1 = 6; int num2 = 8; // если первое больше второго if(num1>num2) < // выводим результат System.out.println("Первое число больше второго"); >// если первое условие не выполнилось — можем проверить второе else if(num1 // если и это условие не выполнилось else< // выводим финальное сообщение System.out.println("Числа равны"); >

У оператора множественного выбора есть особенность: ему не нужны фигурные скобки для действий в каждом случае. Компьютер по синтаксису понимает, что к чему относится, и выбирает нужный вариант.

// число для сравнения int num = 8; // сравниваем значение этого числа с нашими вариантами switch(num)< // если число = 1 case 1: // выводим сообщение System.out.println("число равно 1"); // выходим из дальнейших проверок break; // если число = 8 case 8: System.out.println("число равно 8"); // увеличиваем число на 1 num++; break; // если число = 9 case 9: System.out.println("число равно 9"); break; // если ни один из вариантов не подошёл default: System.out.println("число не равно 1, 8, 9"); >

Циклы

В Java есть три основных вида циклов:

• for — с известным числом повторений и счётчиком;
• do — с проверкой условия до цикла;
• while — условие проверяется после первого выполнения цикла.

Ещё есть два полезных оператора:

• break — прерывает цикл в любой момент;
• continue — сразу переходит к следующему витку цикла без выполнения остальных команд.

// цикл со счётчиком // задаётся начальное значение, условие и шаг цикла for (int i = 1; i < 9; i++)< // тело цикла System.out.printf("Квадрат числа %d равен %d \n", i, i * i); >// то же самое с циклом do int j = 1; // начинаем цикл do < // выводим результат System.out.printf("Квадрат числа %d равен %d \n", i, i * i); // увеличиваем переменную цикла j++; >// проверяем условие цикла while (j < 9); // и то же самое с циклом while int k = 1; // начинаем цикл и сразу проверяем условие while (k < 10)< // выводим результат System.out.printf("Квадрат числа %d равен %d \n", k, k * k); // увеличиваем переменную цикла k++; >

Функции (они же методы)

Так как каждая программа — это описание какого-то класса, то функции в Java — это и есть методы этого класса. Функций (или методов) может быть сколько угодно, главное — соблюдать правила описания классов. Покажем на примере:

// программа — класс public class Program < // публичная часть, доступная всем // основная функция-метод main public static void main (String args[])< // вызваем методы (функции) в любое время hello(); welcome(); >// метод hellо(), который не передаёт и не принимает никаких аргументов void hello() < System.out.println("Привет!"); >// метод welcome() void welcome() < System.out.println("Это журнал Код."); >>

Классы

В Java всё построено на классах, от самой программы до реализаций различных функций. Конечно, можно не использовать классы и работать в чисто процедурном стиле, но в Java так не принято. Это ООП-язык с родной поддержкой классов на всех уровнях.

Сами классы объявляются и используются так же, как и в любом другом ООП-языке:

// объявляем новый класс с информацией о заказанном товаре class Order < // переменные класса String name; // название int cost; // стоимость // метод класса void displayInfo()< // выводим информацию о заказе System.out.printf("Заказ: %s \tСтоимость: %d\n", name, cost); >>

Объекты

Объекты в Java работают по тому же принципу, что и все объекты в ООП: можно создавать сколько угодно объектов на основе классов и делать их любой сложности.

Обычно используют классы, прописанные в том же файле, что и программа. Если нужно использовать класс из другой программы, её подключают отдельно. Вот самый простой способ сделать объект на основе предыдущего класса с заказом:

// программа — тоже класс public class Program < // основная функция-метод main public static void main (String args[])< // создаём новый объект на основе класса ниже Order new_order; // заполняем данные new_order.name = "Айфон"; new_order.cost = 9999; // вызываем метод класса new_order.displayInfo(); >> // объявляем новый класс с информацией о заказанном товаре class Order < // переменные класса String name; // название int cost; // стоимость // метод класса void displayInfo()< // выводим информацию о заказе System.out.printf("Заказ: %s \tСтоимость: %d\n", name, cost); >>

Источник

Многострочные комментарии в java

The information on this page is for Archive Purposes Only

5 — Comments

Java programs can have two kinds of comments: implementation comments and documentation comments. Implementation comments are those found in C++, which are delimited by /*. */, and //. Documentation comments (known as «doc comments») are Java-only, and are delimited by /**. */. Doc comments can be extracted to HTML files using the javadoc tool.

Implementation comments are meant for commenting out code or for comments about the particular implementation. Doc comments are meant to describe the specification of the code, from an implementation-free perspective. to be read by developers who might not necessarily have the source code at hand.

Comments should be used to give overviews of code and provide additional information that is not readily available in the code itself. Comments should contain only information that is relevant to reading and understanding the program. For example, information about how the corresponding package is built or in what directory it resides should not be included as a comment.

Discussion of nontrivial or nonobvious design decisions is appropriate, but avoid duplicating information that is present in (and clear from) the code. It is too easy for redundant comments to get out of date. In general, avoid any comments that are likely to get out of date as the code evolves.

Note:The frequency of comments sometimes reflects poor quality of code. When you feel compelled to add a comment, consider rewriting the code to make it clearer.

Comments should not be enclosed in large boxes drawn with asterisks or other characters.
Comments should never include special characters such as form-feed and backspace.

5.1 Implementation Comment Formats

Programs can have four styles of implementation comments: block, single-line, trailing, and end-of-line.

5.1.1 Block Comments

Block comments are used to provide descriptions of files, methods, data structures and algorithms. Block comments may be used at the beginning of each file and before each method. They can also be used in other places, such as within methods. Block comments inside a function or method should be indented to the same level as the code they describe.

A block comment should be preceded by a blank line to set it apart from the rest of the code.

/*-* Here is a block comment with some very special * formatting that I want indent(1) to ignore. * * one * two * three */ 

5.1.2 Single-Line Comments

Short comments can appear on a single line indented to the level of the code that follows. If a comment can’t be written in a single line, it should follow the block comment format (see section 5.1.1). A single-line comment should be preceded by a blank line. Here’s an example of a single-line comment in Java code (also see «Documentation Comments» on page 9):

5.1.3 Trailing Comments

Very short comments can appear on the same line as the code they describe, but should be shifted far enough to separate them from the statements. If more than one short comment appears in a chunk of code, they should all be indented to the same tab setting.

Here’s an example of a trailing comment in Java code:

5.1.4 End-Of-Line Comments

The // comment delimiter can comment out a complete line or only a partial line. It shouldn’t be used on consecutive multiple lines for text comments; however, it can be used in consecutive multiple lines for commenting out sections of code. Examples of all three styles follow:

if (foo > 1) else < return false; // Explain why here. >//if (bar > 1) < // // // Do a triple-flip. // . //>//else < // return false; //>

5.2 Documentation Comments

Note: See «Java Source File Example» on page 19 for examples of the comment formats described here.

For further details, see «How to Write Doc Comments for Javadoc» which includes information on the doc comment tags (@return, @param, @see): link

Doc comments describe Java classes, interfaces, constructors, methods, and fields. Each doc comment is set inside the comment delimiters /**. */ , with one comment per class, interface, or member. This comment should appear just before the declaration:

/** * The Example class provides . */ public class Example < . 

Notice that top-level classes and interfaces are not indented, while their members are. The first line of doc comment (/**) for classes and interfaces is not indented; subsequent doc comment lines each have 1 space of indentation (to vertically align the asterisks). Members, including constructors, have 4 spaces for the first doc comment line and 5 spaces thereafter.

If you need to give information about a class, interface, variable, or method that isn't appropriate for documentation, use an implementation block comment (see section 5.1.1) or single-line (see section 5.1.2) comment immediately after the declaration. For example, details about the implementation of a class should go in in such an implementation block comment following the class statement, not in the class doc comment.

Doc comments should not be positioned inside a method or constructor definition block, because Java associates documentation comments with the first declaration after the comment.

Источник