Комментарии в Java: не всё так просто
Комментарии — казалось бы, что может быть проще, и чего тут целую статью писать. Но тут не всё так просто. Как говорил мой начальник, код писать может каждый, а вот хороший комментарий написать сложно. Большинство курсов по изучению языка начинаются с традиционного Hello World. Даже в Oracle Tutorials в разделе «Getting Started» мы начинаем с The «Hello World!» Application. И с самых первых строк кода мы видим их — Java комментарии. Их важность также подчёркивается тем, что в таком важном документе, как «Java Code Convention» комментариям отводится отдельный раздел: Comments. Как гласит документация, комментарии в Java делятся на два типа:
- комментарий реализации (или комментарий кода);
- документирующий комментарий.
Комментарии кода используются для описания отдельных строк/блоков, а комментарии для документирования используются, чтобы описать спецификацию кода (его интерфейс), не зависящую от его реализации. Java комментарии игнорируются компилятором, т.к. они несут смысл для разработчика, а не для пользователя. Поэтому можно уменьшить размер компилируемых классов.
Комментарии Java кода
- Строчные (т.е. описываются в одну строку)
// Строчный комментарий System.out.println("Hello, World!");
/* * Блочный комментарий */ System.out.println("Hello");
Каждый раз, когда вы пишите комментарий, поморщитесь и ощутите свою неудачу»
Понятно, что нет абсолютной истины, и иногда комментарии необходимы. Но всегда есть варианты, и с излишними комментариями нужно бороться. В этой же главе упоминаются необычные комментарии, TODO:
// TODO: Добавить World System.out.println("Hello, ");
Смысл в них в том, что они могут особым образом обрабатываться в IDE. Например, в IDEA они собираются на отдельной вкладке, где их можно посмотреть:
И небольшой puzzler с комментарием: Строка «http://google.com» является корректной строчкой внутри метода, т.к. http здесь — это на самом деле метка, а дальше — комментарий. Зачастую многие комментарии могут стать из комментариев кода комментарием для документирования, о которых поговорим далее.
Комментарии для документирования
Комментарии для документации описывают общедоступный API. API — это програмный интерфейс приложения, то есть те классы и методы, которые доступны другим разработчикам для выполнения каких-либо действий. Если кратко, то данные комментарии должны пояснять, зачем создан тот или иной класс и пакет и что делает тот или иной метод. Так же можно при необходимости описывать поля класса. Именно то, что оформлено в качестве JavaDoc мы и видим в подсказках наших IDE. Например:
Если мы перейдём в этот метод, мы увидим, откуда взялся этот текст:
То, как правильно оформлять JavaDoc опять же смотрим в Java Code Convention: Code Convention. Они чем-то похожи на блочные комментарии, но вместо одного астериска (не Астерикса)) используется два. Пример JavaDoc был приведён выше. Описывать все возможности нет смысла, так как об этом уже написано в официальной документации Oracle. Поэтому всё необходимое смотрим в официальной документации по JavaDoc, раздел «Tag Descriptions». У Oracle есть даже отдельный tutorial на эту тему: How to Write Doc Comments for the Javadoc Tool. Подсказки в IDE — хорошо, но на самом деле они не просто так doc. На основе этих JavaDoc комментариев генерируется документация. Для этого есть специальная утилита javadoc. Как мы видим, в том Tutorial об этом и говорится. Описание того, как ей пользоваться, есть на официальном сайте Oracle для JavaDoc. Чтобы увидеть воочию, как это выглядит, можно создать в каталоге подкаталог с названием пакета, например: test. В нём создать простенький класс с комментариями. Например:
package test; /** * This is a JavaDoc class comment */ public class JavaDocTest < /** * This is a JavaDoc public field comment */ public static final String HELLO_MESSAGE = "Hello, World!"; public static void main(String. args) < JavaDocTest.greetings(); >/** * This is a JavaDoc public method comment */ public static void greetings() < System.out.println(HELLO_MESSAGE); >>
После этого можно выполнить следующую команду из каталога, который содержит наш каталог с пакетом: javadoc -d ./test test После этого мы увидим процесс генерации документации.
И после можем открыть index.html, чтобы увидеть сгенерированный документ. Вы часто сможете увидеть, когда выставляют документацию по API. Например, Spring Framework API.
Заключение
Как мы видим, казалось бы, такая простая штука как комментарии на деле оказывается куда сложнее. Поэтому, если комментариям выделить некоторое время и за ними следить, ваш код будет лучше и вы как программист будете ценнее. #Viacheslav
Что полезно знать Java-разработчику про вывод типов
В Java 8 кардинально переработали процедуру вывода типов выражений. В спецификации появилась целая новая глава на эту тему. Это весьма сложная штука, изложенная скорее на языке алгебры, чем на языке нормальных людей. Не каждый программист готов в этом разобраться. Я, разработчик IDE, которому приходилось ковыряться в соответствующем коде, к своему стыду тоже довольно плохо разбираюсь в этой теме и понимаю процесс только по верхам. Причём сложно не только мне, но и авторам компилятора Java. После выхода Java 8 обнаружились десятки багов, когда поведение компилятора не соответствовало спецификации, либо текст спецификации был неоднозначен. В средах разработки для Java ситуация обстояла не лучше: там тоже были баги, причём другие, поэтому код мог отображаться ошибочным в вашей IDE, но успешно компилироваться. Или наоборот. С годами ситуация улучшилась, многие баги исправили, хотя всё ещё в спецификации остались тёмные углы.
Если вы просто пишете на Java, вам в целом необязательно знать в деталях, как это всё работает. В большинстве случаев либо результат вывода типов соответствует вашей интуиции, либо вывод типов не работает вообще, и надо ему помочь. Например, указав типы-аргументы в при вызове метода, либо указав явно типы параметров лямбды. Тем не менее есть некоторый начальный уровень этого тайного знания, и его несложно освоить. Овладев им, вы будете лучше понимать, почему компилятор не всегда может вывести то, что вы хотите. В частности, вы сможете ответить на вопрос, который мне часто задавали в той или иной форме: какие из следующих строчек не компилируются и почему?
Comparator c1 = Comparator.comparing(String::length).reversed(); Comparator c2 = Comparator.comparing(s -> s.length()).reversed(); Comparator c3 = Collections.reverseOrder(Comparator.comparing(s -> s.length()));Первое важное знание: в Java есть два типа выражений (JLS §15.2). Первый тип — «автономные выражения» (standalone expression), а второй — «поли-выражения» (poly expression). Тип автономных выражений вычисляется, глядя исключительно на само выражение. Если выражение автономное, совершенно неважно, в каком оно встретилось контексте, то есть что вокруг этого выражения. Для поли-выражений контекст важен и может влиять на их тип. Если поли-выражение вложено в другое поли-выражение, то фактически выбирается самое внешнее из них, и для него запускается процесс вывода типов. По всем вложенным поли-выражениям собираются ограничения (constraints). Иногда к ним добавляется целевой тип. Например, если поли-выражение — это инициализатор переменной, то тип этой переменной является целевым и тоже включается в ограничения. После этого выполняется редукция ограничений и определяются типы для всех поли-выражений сразу. Скажем, простой пример:
Comparator c2 = Comparator.comparing(s -> s.length());Здесь лямбда является поли-выражением. Вообще лямбды и ссылки на методы всегда являются поли-выражениями, потому что их нужно отобразить на какой-то функциональный интерфейс, а по содержимому лямбды вы никогда не поймёте, на какой. Вызов метода Comparator.comparing тоже является поли-выражением (ниже мы поймём, почему). У лямбды надо определить точный функциональный тип, а у Comparator.comparing — значения типовых параметров T и U . В процессе вывода устанавливается, что
- T = String
- U = Integer
- Тип лямбды = Function
- Тип параметра s = String
Только некоторые выражения в Java могут быть поли-выражениями. Вот их полный список (на момент Java 17):
- Выражения в скобках
- Создание нового объекта (new)
- Вызов метода
- Условные выражения (?:)
- switch-выражения (те что в Java 14 появились)
- Ссылки на методы
- Лямбды
Но «могут» не значит «должны». Могут быть, а могут и не быть. Проще всего со скобками: они наследуют «полистость» выражения, которое в скобках. В остальных случаях важен контекст.
Контексты определяются в пятой главе спецификации. Нам будут интересны только три из них:
- Контекст присваивания (assignment context) — это контекст, при котором автоматически выполняется преобразование присваивания. Включает в себя инициализацию переменной (кроме переменной с неявным типом var ), оператор присваивания, а также возврат значения из метода или лямбды (как с использованием return , так и без).
- Контекст вызова (invocation context) — аргумент вызова метода или конструктора.
- Контекст приведения (cast context) — аргумент оператора приведения типа.
Для определения контекста можно подниматься через скобки, условные операторы и switch-выражения. Поли-выражения могут быть только в контексте присваивания и контексте вызова. Для лямбд и ссылок на методы дополнительно разрешён контекст приведения. В любых других контекстах использование лямбд и ссылок на методы недопустимо вообще. Это правило, кстати, приводит к интересным последствиям:
Runnable r1 = () -> <>; // можно Runnable r2 = true ? () -> <> : () -> <>; // можно Object r3 = (Runnable)() -> <>; // можно Object r4 = (Runnable)(true ? () -> <> : () -> <>); // нельзя! Object r5 = true ? (Runnable)() -> <> : (Runnable)() -> <>; // можноУсловный оператор во второй строке является поли-выражением, потому что он в контексте присваивания. Поэтому он может посмотреть наружу и увидеть, что результат должен быть типа Runnable , а значить использовать эту информацию для вывода типов веток и в итоге присвоить обеим лямбдам тип Runnable . Однако четвёртая строчка в таком виде не работает, несмотря на большое сходство. Здесь условный оператор true ? () -> <> : () -> <> находится в контексте приведения, что по спецификации делает его автономным выражением. Поэтому мы не можем выглянуть за его пределы и увидеть тип Runnable , а значит мы не знаем, какой тип назначить лямбдам — возникает ошибка компиляции. В этом случае придётся переносить приведение типов в каждую ветку условного оператора (или не писать такой код вообще).
Не только контекст, но и вид выражения может влиять на полистость. Например, выражение new может быть поли-выражением (в соответствующем контексте), только если используется оператор «ромб» ( new X<>() , JLS §15.9). В противном случае тип результата всё равно однозначен и нет смысла усложнять компиляцию. Аналогичная мысль применяется к выражениям вызова метода, только это приводит к более сложным условиям (JLS §15.12):
- Мы вызываем generic-метод
- Этот generic-метод упоминает хотя бы один из своих типовых параметров в возвращаемом типе
- Типы-аргументы не заданы явно при вызове в
Если хоть одно из этих условий не выполнено, тип результата метода устанавливается однозначно и разумно считать выражение автономным. Тут ещё дополнительная сложность в том, что мы можем не сразу знать, какой конкретно метод вызываем, если имеется несколько перегруженных методов. Но тут может открыться портал в ад, поэтому не будем копать эту тему.
Интересная история с условным оператором (JLS §15.25). Сначала в зависимости от типов выражений в ветках выясняется разновидность оператора: это может быть булев условный оператор, числовой условный оператор или ссылочный условный оператор. Только ссылочный условный оператор может быть поли-выражением, а булев и числовой всегда автономные. С этим связано много странностей. Вот например:
static Double get() < return null; >public static void main(String[] args)
Здесь типы веток условного оператора — конкретно Double и конкретно double . Это означает, что условный оператор числовой (numeric conditional expression, JLS §15.25.2), то есть автономный. Соответственно, мы не смотрим наружу, нас не волнует, что мы присваиваем результат в объектный Double . Мы определяем тип только по самому оператору, и этот тип — примитивный double . Соответственно, для балансировки типов добавляется unboxing левой ветки, а потом для присваивания добавляется снова boxing:
Double x = Double.valueOf(true ? get().doubleValue() : 1.0);Здесь мы разворачиваем результат метода get() , а потом заново сворачиваем. Разумеется, этот код падает с NullPointerException , хотя казалось бы мог бы и не падать.
Ситуация в корне меняется, если мы объявим метод get() по-другому:
static T get()
Теперь в одной из веток не числовой тип Double , а неизвестный ссылочный тип T . Весь условный оператор становится ссылочным (reference conditional expression, JLS §15.25.3), соответственно становится поли-выражением и может посмотреть наружу, на целевой тип Double и использовать именно его как целевой тип веток. В итоге обе ветки успешно приводятся к типу Double , для чего добавляется boxing в правой ветке:
Double x = true ? get() : Double.valueOf(1.0);Теперь программа успешно печатает null и завершается. Такие нестыковки обусловлены историческими причинами и необходимостью совместимости. В первых версиях Java никаких поли-выражений не было, все были автономными, поэтому надо было выкручиваться, и выкручивались не всегда идеально. К счастью, это не распространяются на более новые switch-выражения. Для них нет дополнительных условий на полистость кроме контекста, поэтому такой код вполне ожидаемо печатает null вместо падения с исключением:
static Double get() < return null; >public static void main(String[] args) < Double x = switch (0) < case 0 ->get(); default -> 1.0; >; System.out.println(x); >Вернёмся к нашему примеру с компараторами. Я раскрою карты: второй вариант не компилируется.
Comparator c1 = Comparator.comparing(String::length).reversed(); // можно Comparator c2 = Comparator.comparing(s -> s.length()).reversed(); // нельзя Comparator c3 = Collections.reverseOrder(Comparator.comparing(s -> s.length())); // можноВот главное, что следует запомнить:
Квалификатор никогда не находится в контексте присваивания или контексте вызова, поэтому не может быть поли-выражением.
В первых двух строчках у нас есть квалификаторы: Comparator.comparing(String::length) и Comparator.comparing(s -> s.length()) . При определении типа квалификатора мы не можем смотреть на то что происходит вокруг, нам остаётся пользоваться только самим содержимым квалификатора.
Comparator.comparing возвращает Comparator , принимая функцию Function , и нам необходимо определить значения T и U . В случае со ссылкой на метод у нас есть дополнительная информация: ссылка однозначно указывает на метод length() в классе String . соответственно, выводу типов хватает этого, чтобы понять, что T = String и U = Integer . Однако в случае с лямбдой у нас нет никаких указаний на то что s — это строка. Соответственно, у нас нет ограничений на T , а значит в соответствии с правилами редукции выбирается максимально общий тип: T = Object . Далее запускается анализ тела лямбды и мы обнаруживаем, что у класса Object нет метода length() , из-за чего компиляция останавливается. Вот такое, кстати, бы сработало, потому что hashCode() в объекте есть:
Comparator cmp = Comparator.comparing(s -> s.hashCode()).reversed();Понятно и почему работает строчка c3 . Так как Comparator.comparing здесь в контексте вызова, мы можем подняться наверх и добраться до контекста присваивания, а значит, использовать целевой тип Comparator . Тут вывод сложнее, потому что есть ещё переменная типа в методе reverseOrder . Тем не менее компилятор справляется и успешно всё выводит.
Как починить c2 , если всё-таки хочется использовать квалификатор? Мы уже знаем достаточно, чтобы понять, что вот это не сработает:
Comparator c2 = ((Comparator)Comparator.comparing(s -> s.length())).reversed();Приведение типа не чинит результат вызова метода, так как контекст приведения не действует на вызовы. Зато приведение типа срабатывает с лямбдой, хотя и выглядит ужасно:
Comparator c2 = Comparator.comparing((Function) s -> s.length()).reversed();Вариант проще: сделать вызов метода автономным. Для этого надо добавить типы-аргументы. В итоге тип вызова comparing устанавливается однозначно, и из него уже выводится тип лямбды:
Comparator c2 = Comparator.comparing(s -> s.length()).reversed();Ещё проще в данном случае — явно указать тип параметра лямбды. Тут у нас вызов comparing по-прежнему является поли-выражением, но появляется ограничение на тип s , и его хватает, чтобы вывести всё остальное правильно:
Comparator c2 = Comparator.comparing((String s) -> s.length()).reversed();Можно ли было распространить вывод типов на квалификаторы, чтобы c2 работало без дополнительных подсказок компилятору? Возможно. Но, как я уже говорил, процедура вывода типов и так невообразимо сложная. В ней и так до сих пор есть тёмные места, а даже когда она правильно работает, она может работать ужасно долго. К примеру, возможно написать относительно несложный код, который создаст сотню ограничений и поставит на колени и IDE, и компилятор javac, потому что реализация вывода типов может быть полиномом довольно высокой степени от количества ограничений. Если мы в этот замес добавим квалификаторы, всё станет сложнее на порядок, ведь они будут интерферировать со всем остальным. Также возникнут проблемы из-за того, что мы можем вообще толком не знать, какой метод какого класса мы пытаемся вызвать. Например:
T fn(UnaryOperator op) < return op.apply((T) " hello "); // грязно, но имеем право! >String s = fn(t -> t).trim();Если мы выводим тип квалификатора fn(t -> t) вместе с типом всего выражения, то мы даже не знаем, у какого класса вызывается метод trim() . Нам подходит любой метод trim() в любом классе, который не принимает аргументов и возвращает строку. Например, метод String.trim() подойдёт. Или ещё какой-нибудь. У этого уравнения может быть много решений. Придётся как-то отдельно обговаривать в спецификации такие случаи. Так или иначе, я не был бы счастлив заниматься поддержкой данной возможности в IDE.
Объявляем переменные,
вычисляем выражения
Операторы +=, -=, *=,/=, ++, —
Каждая программа что-нибудь вычисляет. Это может быть все что угодно — координаты персонажа в игре, сумма расходов, количество букв в тексте и т.д. Для всех вычислений используются переменные и числовые выражения.
Пусть вам нужно что-то рассчитать. Например, вы хотите примерно оценить сумму своих расходов за год по разным категориям — на продукты, одежду и транспорт. Причем вы знаете, что одежду вы покупаете в год 5 раз, продукты два раза в неделю, а транспортом пользуетесь каждый день, и знаете среднюю стоимость разовой покупки.
Это можно закодить так:
// Объявим по одной переменной для каждого вида расходов // Слева от равно пишем double - значит у нас будет дробное число // transp - имя переменной, мы его выбрали сами // Справа от равно - начальное значение double transp = 100; // на транспорт за один день тратим порядка 100 рублей double food = 500; // на еду за один заход в магазин в среднем 500 рублей double dress = 2000; // на одежду - 2000 //Начальное значение переменной result вычислим по выражению: double result = transp*365 + food*2*4*12 + dress*5; // То есть 365 раз за год потратились на транспорт, // еду покупали 2 раза в неделю, а недель 4 в месяце, а месяцев 12, // одежду купили 5 раз в год. // Теперь переменная result хранит сумму затрат за год - можно ее распечатать, // сравнить с другими переменными или использовать в дальнейших расчетах. // Удобно, что теперь мы можем менять значения исходных данных, // и смотреть, как это отразится на итоговом результате.
Определение. Переменная – это имя, которое обозначает некоторое число. Переменные могут получать начальное значение и потом менять его. У переменных есть тип – либо это целые числа ( int ), либо дробные ( double и float), либо символы ( char ). Переменные участвуют в любых выражениях наравне с обычными числами.
Объявить переменную — значит дать ей имя, указать, какого она типа, и указать начальное значение справа от знака равно. В коде это делается так:
int x = 10;
Это значит завести переменную с именем x , у которой тип – int , сокращенно от integer (по-английски «целое число»). Справа от знака равно ставится начальное значение переменной. Оно может быть просто равно заданному числу, например, 10, а может вычисляться через любое выражение.
В общем случае объявление переменной выглядит так:
тип имя = числовое выражение ;
Типы данных бывают такие – целое число int , дробное число double , символ char . Переменная — это имя, обозначающее заданное число. Вы можете это число по ходу программы менять. Как только вы объявили переменную, под неё выделяется место в оперативной памяти компьютера — ячейка. В ней записаны цифры данного числа в двоичной системе исчисления, где вместо привычных цифр 0, 1, 2, …, 9 есть только цифры 0 и 1.
Давайте поменяем значение переменной x вот так:
int x = 10; x = 200; //изменить значение икс - забыть 10, и запомнить 200 //слева int не указан, значит мы используем уже объявленную переменную
Разберем популярную ошибку — объявление одной и той же переменной дважды:
int x = 100; int x = 300; // ошибка - указав int, мы говорим "объявить новую x", но переменная x уже объявлена // Создадим другую переменную с именем y int y = 100; // Объявим ее еще раз с другим типом double y = 200.5; // ошибка - переменная y уже была раньше объявлена. // Теперь, когда мы указали новый тип, компилятор просто не может определиться, // что же имелось в виду, y - целое, или y - дробное. Вы можете получить ошибку // ambiguous name, то есть многозначное имя.
Посмотрим новый пример с несколькими переменными. Кстати я пишу, что делает очередная строчка в комментарии к ней. Комментарии не исполняются в программе, в них можно просто пояснять код. Комментарии на одну строчку в Java обозначаются // , а также внутри блока /* Можно писать всё что угодно */ — это комментарий на много строчек. Вы легко опознаете комментарии, когда увидите их в этом коде:
package javaapplication1; public class JavaApplication1 < public static void main(String[] args) < //вызовем функцию println System.out.println ("Щас будем вычислять!"); // Объявим переменную x целого типа, равную 10 int x = 10; // Объявим переменную y целого типа, равную 30 int y = 30; // Объявим переменную z, равную выражению: int z = x + y /2; // Распечатаем значение z – это будет 25 System.out.println (z); // Изменим z снова, пусть оно будет теперь x/2 z = x / 2; // Выведем на экран новое значение z – это будет 5 System.out.println (z); // Можно объявить несколько переменных в одной строчке int a = 10, b = 20; /* В принципе можно объявить переменную без начального значения, но Java ударит вас по рукам, если вы позже не присвоите ей значение. Лучше так не делать, потому что от переменных без начального значения пользы никакой, а навредить они могут сильно – если вдруг Java не заметит, что вы её используете, то вы получите непредсказуемое поведение программы, каждый раз разное – эту ошибку очень сложно отловить, иногда на её поиск уходят недели. */ int w; // Лучше не надо, поверьте.. w = 5; // Объявим переменную дробного типа double double some = 0.5; // Изменим значение переменной some на новое some = 1.5; // Сделаем some равной y some = y; // Объявим символ с равным коду буквы b char c = ‘b’; /* Здесь можно писать только одну букву или цифру в одинарных кавычках. Символы нельзя складывать, зато из них можно делать строки и тексты – мы займемся этим на следующих уроках*/ // Объявим дробное d, равное 2.5 double d = 2.5; /* Используем саму переменную, чтобы например, увеличить ее на 5: */ d = d + 5; // теперь d равно 7.5, старое значение забыто >/* В конце переменные, объявленные в main, удаляются - так происходит всегда по достижении конца блока фигурных скобок, внутри которого они были объявлены */ > /* По сути переменная – это число, записанное в ячейке памяти компьютера. Объявить переменную – значит назвать эту ячейку именем. Имя может быть одной буквой, а может быть и словом. Вы можете поменять число, сидящее в ячейке, или использовать его для вычисления других чисел. Это очень удобно, иначе вам пришлось бы указывать «вон то число», а потом «вот это число», чтобы сделать любые вычисления. Так писали программы в 80ых годах прошлого века – это было настолько неудобно, что элементарный калькулятор приходилось писать месяцами. Теперь, заводя переменные, мы пишем его за несколько минут. */
Привычные нам знаки арифметических действий +, — , * , / называются операторами, они служат для простых вычислений. Знак = тоже оператор и означает приравнять , то есть изменить старое значение переменной на новое. Но есть еще операторы +=, -= , *= , /= . Они читаются увеличить (уменьшить, умножить, поделить) переменную на значение справа. Рассмотрим пример ниже:
int x = 10; // Увеличим x на 10 x = x + 10; // Ту же фразу можно записать короче с оператором += x += 10;
То есть оператор += является просто сокращением и означает увеличить переменную на значение, стоящее справа. Аналогично, операторы -=, *=, /= вычитают, умножают, делят переменную на значение, стоящее справа, например:
double y = 12; double z = 3; // Поделим y на 3 и запишем новое значение в y y /= z; // Умножим на 4, затем на (z-2) y *= 4; y *= z-2; /* Все это допустимые операции, их удобно делать с операторами +=, -=, *=, /= */
Ещё операцию x += 1 тоже можно записать короче с помощью оператора инкремента ++ . То есть ++ означает «увеличить переменную на один». Аналогично — значит «уменьшить на 1». Посмотрим в коде:
int x = 10; x ++; // теперь x равен 11 x ++; // теперь x равен 12 x --; // теперь x снова 11
Можно писать x++ (постфиксный инкремент), а можно ++x (префиксный инкремент). Аналогично и с декрементом. Если эти операции стоят в коде отдельно от прочих, то оба варианта записи эквивалентны, они увеличивают x на 1. Если же x++ используется прямо в выражении, то разница есть . Поясним в коде:
int a = 10; // зададим a и b равным 10 int b = 10; // a++ означает в выражении использовать старое значение a, но в потом a увеличить int y = 5 + a++; // итого будет 5+10 // ++b означает уже в выражении увеличить b int z = 5 + ++b; // итого будет 5 + 11 System.out.println (a); System.out.println (b); System.out.println (y); System.out.println (z); /* Вывод программы: 11 11 15 16 */
Ещё поясняющий пример:
// вариант с использованием x ++ // постфиксная запись, как бы "увеличить x после" выражения int x = 10; int y = 5 + x++; // будет эквивалентно следующему: int x = 10; int y = 5 + x; // в выражении старое значение x += 1; // уже после выражения мы увеличим x // а теперь то же самое с использование x-- // префиксная запись, как бы "увеличить перед" выражением int x = 10; int y = 5 + ++x; // будет эквивалентно следующему: int x = 10; x += 1; // перед выражением мы увеличим x int y = 5 + x; // в выражении новое увеличенное значение // Начинающим обучение можно лишний раз не думать об разнице x++, ++x // Просто не пишите их прямо в выражения, и считайте, что это просто "увеличить на 1" // Но если где-то встретите, то будете готовы :)
Более сложные выражения с участием скобок (. )
Скобки позволяют указать программе, что нужно в выражении вычислить раньше, а что потом. Выражения в скобках имеют абсолютный приоритет — сначала вычисляется то что в скобках, потом умножение и деление, потом уже сложение и вычитание. Разберёмся в приоритетах на примере:
double x = 10 + 5 * 2 - 3; // будет конечно 10+10-3, то есть 17 double y = (10 + 5) * 2 - 3; // теперь есть скобки , поэтому 15*2 - 3, то есть 27 double z = 100 / 4 * 2 + 5; // при равнозначном приоритете компилятор читает слева направо: // получится 100/4 - это 25, умножить на 2 - это 50, и добавить 5 - в итоге z=55 // Очень советую поэкспериментировать в коде с такими выражениями. // Усложняйте их постепенно, используйте старые значения переменной в новом выражении. // Несколько полезных примеров: z = z*z; // получается, возвести z в квадрат, // поскольку мы взяли старое значение, умножили его само на себя и записали в z. // Аналогично можно возвести в куб и вообще в любую степень: x = x*x*x ; // возвели x в куб. // Также можно получить обратную к исходной величину: x = 1 / x; // но помните, что если бы x был int, а не double, // то тут часто получался бы чистый ноль, // т.к. при делении целых дробные части отбрасываются. // Теперь пример на несколько скобок x = 10; x = (x + 10) / 2 - 5 * (x-2); // будет 20 / 2 - 5 * 8, то есть -30. // А также вложенные скобки: x = 10; x = (x + 5*(x-1) ) * 2 + 1; // будет (10 + 5 * 9) * 2 + 1 = 55 * 2 + 1 = 111.
Самое главное мы уже освоили. Теперь время решать задачи. Ответьте на несколько вопросов, чтобы лучше усвоился новый материал:
Java | Вопросы с ответами
2. Дан код:
public class Quest4 public static void main(String[] args) byte b[] = new byte[80];
for (int i=0; i System.out.print(“Ok”);
>
>
Результатом компиляции запуска будет?
>> ошибка компиляции, так как метод read() может порождать исключительную ситуацию типа IOException.
3. Программы Java категория Приложение (application)?
>> аналог “обычной” прикладной программы.
4. Программы Java категория Апплет (applet)?
>> специализированная программа с ограниченными возможностями, работающая в окне WWW-документа под управлением браузера.
5. Программы Java категория Сервлет (servlet)?
>> специализированная программа с ограниченными возможностями, работающая в WWW на стороне сервера. Используется преимущественно в рамках технологии JSP для программирования WWW-документов со стороны сервера.
6. Программы Java категория Серверное приложение (Enterprise application)?
>> предназначено для многократного использования на стороне сервера.
7. Программы Java категория Библиотека (Java Class Library)?
>> библиотека классов, либо NetBeansModule – модуль платформы NetBeans) – предназначена для многократного использования программами Java.
8. Какие из следующих строк скомпилируются без ошибки?
>> int i = 32565;
— float f = 7.0;
— char c = «z»;
— byte b = 255;
— boolean n = null;
9. Какие из следующих строк скомпилируются без ошибки?
>> int j = ’ъ’;
— float f = 7.0;
— char c = «z»;
— byte b = 255;
— boolean n = null;
10. Какие варианты записи оператора условного перехода корректны?
>> if (i
— if (i
— if [i — if then System.out.print(«-6-«);
12. Какие из следующих идентификаторов являются корректными?
>> _int;
— 2int;
— int_#;
— #int
— _#int
13. Назначение утилиты javac?
>> Компилятор в режиме командной строки для программ, написанных на языке Java.
14. Назначение утилиты java?
>> Утилита для запуска в режиме командной строки откомпилированных программ-приложений.
15. Назначение утилиты appletviewer?
>> Утилита для запуска на исполнение и отладку апплетов без браузера. При этом не гарантируется работоспособность отлаженного апплета в браузере.
16. Назначение утилиты jdb?
>> Отладчик программ, написанных на языке Java.
17. Назначение утилиты javadoc?
>> Генератор документации по классом на основе комментариев, начинающихся с /**.
18. Назначение утилиты jar?
>> Создание и управление Java-архивами jar.
19. Назначение утилиты javah?
>> Генератор заголовочных файлов C/C++ для подключения к программам Java внешних библиотек C/C++ на основе интерфейса JNI.
20. Назначение утилиты javap?
>> Дизассемблер классов.
21. Назначение утилиты extcheck?
>> Утилита для обнаружения конфликтов между файлами архивов jar.
22. Назначение утилиты native2ascii?
>> Утилита для конвертации в режиме командной строки параметра, передаваемого в виде текста на национальном алфавите, в последовательность символов UNICODE.
23. Управляющая последовательность: \a ?
>> звонок.
24. Управляющая последовательность: \b ?
>> возврат на один символ назад.
25. Управляющая последовательность: \f ?
>> перевод на новую страницу.
26. Управляющая последовательность: \n ?
>> перевод на новую строку.
27. Управляющая последовательность: \r ?
>> возврат к началу строки.
28. Управляющая последовательность: \t ?
>> горизонтальная табуляция.
29. Управляющая последовательность: \v ?
>> вертикальная табуляция.
30. Управляющая последовательность: \’ ?
>> кавычка.
31. Управляющая последовательность: \” ?
>> двойные кавычки.
32. Управляющая последовательность: \\ ?
>> обратная косая черта.
33. Управляющая последовательность: \u ?
>> начало кодировки символа Unicode.
34. Оператор ~ ?
>> Оператор побитового дополнения (побитовое “не”).
35. Оператор ^ ?
>> Оператор “исключающее или” (XOR).
36. Оператор & ?
>> Оператор “побитовое и” (AND).
37. Оператор | ?
>> Оператор “побитовое или” (OR).
38. Оператор ! ?
>> Оператор “НЕ”.
39. Оператор && ?
>> Оператор “логическое И” (AND).
40. Оператор || ?
>> Оператор “ логическое ИЛИ” (OR).
41. Оператор >> Оператор левого побитового сдвига.
42. Оператор >>> ?
>> Оператор беззнакового правого побитового сдвига.
43. Оператор >> ?
>> Оператор правого побитового сдвига с сохранением знака отрицательного числа.
44. Для чего предназначен пакет java.applet?
>> Классы, необходимые для создания аплетов.
45. Для чего предназначен пакет java.awt?
>> Графический пользовательский интерфейс на базе AbstractWindowsToolkit.
46. Для чего предназначен пакет java.awt.color?
>> Пространства цветов для AWT.
47. Для чего предназначен пакет java.awt.datatransfer?
>> Передача данных внутри программы и между программами.
48. Для чего предназначен пакет java.awt.dnd?
>> Поддержка технологии drag-and-drop.
49. Для чего предназначен пакет java.awt.event?
>> Обработка событий AWT.
50. Для чего предназначен пакет java.awt.im?
>> Поддержка нестандартных методов ввода текста.
51. Для чего предназначен пакет java.awt.im.spi?
>> Интерфейсы для создания нестандартных методов ввода текста.
52. Для чего предназначен пакет java.lang?
>> Базовые классы языка Java.
53. Для чего предназначен пакет java.lang.ref?
>> Управление ссылками на объекты.
54. В папке build проекта NetBeans находятся?
>> хранятся скомпилированные файлы классов, имеющие расширение .class.
55. В папке dist проекта NetBeans находятся?
>> файлы, предназначенные для распространения как результат компиляции (модуль JAR приложения или библиотеки, а также документация к нему).
56. В папке nbproject проекта NetBeans находятся?
>> находится служебная информация по проекту.
57. В папке src проекта NetBeans находятся?
>> исходные коды классов. Кроме того, там же хранится информация об экранных формах (которые будут видны на экране в виде окон с кнопками, текстом и т.п.). Она содержится в XML-файлах, имеющих расширение .form.
58. В папке test проекта NetBeans находятся?
>> сопроводительные тесты, предназначенные для проверки правильности работы классов проекта.
59. Команды документации (символы метаданных) @see?
>> применяется для создания в документе гиперссылок на другие комментарии. Можно использовать для любых конструкций (классов, методов и т.д. ).
60. Команды документации (символы метаданных) @since?
>> Информация о версии JDK, начиная с которой введён или работоспособен класс или интерфейс.
61. Команды документации (символы метаданных) @throws?
>> Информация об исключительных ситуациях, которые могут возбуждаться методом.
62. Команды документации (символы метаданных) @param?
>> информация о параметре метода.
63. Команды документации (символы метаданных) @deprecated?
>> информация о том, что данный метод устарел и в последующих версиях будет ликвидирован. При попытке использования таких методов компилятор выдаёт программисту предупреждение (warning) о том, что метод устарел, хотя и компилирует проект.
64. Целые типы, тип byte?
>> Однобайтовое целое число (8-битное целое со знаком).
65. Целые типы, тип short?
>> Короткое целое число (16- битное целое со знаком).
66. Целые типы, тип char?
>> Символьный тип (беззнаковое 16- битное целое).
67. Целые типы, тип int?
>> Целое число (32- битное целое со знаком).
68. Целые типы, тип long?
>> Длинное целое число (64- битное целое со знаком).
69. Выберите правильный вариант a,b,c,d чтобы результат выражения a&&b || c^ d являлся истиной?
>> все ответы верны
— a=true, b=true, c=false, d=true
— a=false, b=false, c=false, d=true
— a=false, b=false, c=true, d=false
— a=true, b=true, c=true, d=true
70. Выберите правильный вариант a,b,c,d чтобы результат выражения a&&(b || c)^ d являлся ложью?
>> все ответы верны
— a=false, b=true, c=false, d=true
— a=true, b=true, c=false, d=true
— a=false, b=false, c=false, d=true
— a=false, b=false, c=false, d=false
71. Вещественные типы, размер типа float?
>> 4 байта
72. Вещественные типы, размер типа double?
>> 8 байт
73. Float f1 = new Float(Float.NaN);
Float f2 = new Float(Float.NaN);
System.out.println( «»+ (f1 == f2)+» «+f1.equals(f2)+ » «+(Float.NaN == Float.NaN) );
Что будет выведено в результате выполнения данного куска кода?
>> false true false
74. int i = 0;
i++;
System.out.print(i);
i = i++;
System.out.println(i); Что выведет данный код?
>> 11
75. int i = 0, j = 5;
tp: for (;;) < i++;
for (;;) < if (i >—j) breaktp; > >
System.out.println(«i =» + i + «, j = » + j);> Что произойдет во время компиляции и выполнения данного фрагмента кода?
>> Ошибка компиляции.
76. int i = 1; //1
i = -+(10 + 2 + i); //2
++i—; //3
System.out.println(i); В какой строке(-ах) кода содержится ошибка?
>> 3.
77. Integer i = newInteger(«10»);
if (i.toString().intern() == i.toString().intern()) System.out.println(«Равный»);
> else System.out.println(«Не равный»); >> Результат выполнения программы?
>> Выведется “Равный”.
78. public class Main public static void main(String[] args) Boolean b1 = new Boolean(«true»); System.out.print(b1 +» «);
b1 =new Boolean(«tRuE»); System.out.print(b1 +» «);
b1 =new Boolean(«test»); System.out.print(b1 +» «);
b1 =new Boolean(true); System.out.print(b1 +» «);
b1 = true; System.out.println(b1); >> каким будет результат компиляции и выполнения кода?
>> true true false true true
79. public class Test static < System.out.print("Bo-Bo ");>
public static void main(String[] args) System.out.print(«Hello, World! «); >
static < System.out.println("Go-Go "); System.exit(0); >> что выведет код?
>> Bo-Bo Go-Go
80. int i = 1; //1
i = -+(10 + 2 + 1); //2
++i—; //3
System.out.println(i); В какой строке(-ах) кода содержится ошибка?
>> 3
81. Integer a = 128; Integer b = 128;
Integer c = -128; Integer d = -128;
System.out.print((a == b)+» «);
System.out.println(c == d); Что будет выведено на экран?
>> false true
82. Boolean b = new Boolean(«Hello»);
System.out.println(b); Какой результат выполнения данного кода?
>> false
83. public class Test static < i =5; >
static int i = 6;
public static void main(String[] args) System.out.println(i); >> Выберите правильный ответ?
>> 6
84. public class MathTest public static void main(String[] args) System.out.print(((-7 % 5)>(7 % -5))+» «);
System.out.println(Math.abs(Math.ceil(-2.5))
Что будет напечатано в результате выполнения данного кода?
>> false true
85. int i = 0;
System.out.print(i++);
System.out.println(i); Результат кода?
>> 01
86. int j = 0;
System.out.print(++j);
System.out.println(j); Результат кода?
>> 11
87. public class TestClass
int i = getInt();
int k = 20;
public int getInt()
public static void main(String[] args)
TestClass t = new TestClass ();
System.out.println(t.i+» «+t.k); >>
Что выведет этот код?
>> Будет выведено на печать 1 20
88. int x = 0;
int y = 10;
do< y--;
++x;> while(x<5);
System.out.print(x+»,»+y); >
Что напечатает этот код?
>> напечатает 5 5
89. Дана строка:
String s=»true,false»;
Каким способом можно сформировать новую строку, равную “test”?
>> String n = s.substring(0,1) + s.substring(9,10) + s.substring(8,9) + s.substring(0,1)
90. int result = 12+2*5%3-15/4;
String x=12-6+»Hello»+7+5;
System.out.println(result+»-«+x);
Что будет выведено на консоль?
>> 10-6Hello75
91. String s1=»Строка типа String»;
String s2=»Строка«;
s2+=» типа String»;
if(s1==s2) System.out.println(«s1 равно s2″);
else System.out.println(«s1 не равно s2″);
Что выведет этот код?
>> s1 не равно s2
92. String s1=»Строка типа String»;
String s2=»Строка«;
s2+=» типа String»;
if(s1.equals(s2)) System.out.println(«s1 равно s2″);
else System.out.println(«s1 не равно s2″);
Что выведет этот код?
>> s1 равно s2
93. String s1=»Строка»;
String s2=»Строка»;
if(s1==s2) System.out.println(«s1 равно s2″);
else System.out.println(«s1 не равно s2″);
Что выведет этот код?
>> s1 равно s2
94. String s=»»;
s+= 1+2+3;
System.out.println(s);
Что выведет этот код?
>> 6
95. String s=»Сумма =»+1+2+3;
System.out.println(s);
Что выведет этот код?
>> Сумма=123
96. String s=1+2+» не равно «+1+2;
System.out.println(s);
Что выведет этот код?
>> 3 не равно 12
97. Работа с графикой. Функция clearRect(x,y,w,h)?
>> Очистка прямоугольника (заполнение текущим цветом).
98. Работа с графикой.Функция fill3DRect(x,y,w,h, isRaised)?
>> Вывод «объемного» прямоугольника, заполненного текущим цветом.
99. Работа с графикой.Функция fillPolygon(Polygon p)?
>> Вывод многоугольника, заполненного текущим цветом.
100. Работа с графикой. Функция copyArea(x,y,w,h,dx,dy)?
>> Копирование области на новое место.
101. Переменные класса File. String pathSeparator?
>> Содержит строку с символом разделителя пути в операционной системе. Это «/» в Unix-подобных системах и «\» в Windows.
102. Переменные класса File.char pathSeparatorChar?
>> Содержит символ разделителя пути в операционной системе. Это «/» в Unix-подобных системах и «\» в Windows.
103. Переменные класса File.String separator?
>> Содержит строку с символом разделителя между именами файлов и файловых масок в операционной системе.
104. Переменные класса File. char separatorChar?
>> Содержит символ разделителя между именами файлов и файловых масок в операционной системе.
105. Методы класса File.canRead() ?
>> Возвращает true в случае, когда файл (или папка) с заданным в конструкторе именем существует и доступен по чтению. Иначе false.
106. Методы класса File.setReadOnly() ?
>> Возвращает true в случае, когда файл (или папка) с заданным в конструкторе именем существует, и ему удалось установить статус «доступен только по чтению». Иначе false.
107. Методы класса File. isDirectory() ?
>> Возвращает true в случае, когда файл или папка с заданным в конструкторе именем существует и является папкой. Иначе false.
108. Методы класса File. isFile() ?
>> Возвращает true в случае, когда файл или папка с заданным в конструкторе именем существует и является файлом. Иначе false.
109. Методы класса File.isHidden() ?
>> Возвращает true в случае, когда файл или папка с заданным в конструкторе именем существует и является скрытым. Иначе false.
110. Методы класса File. lastModified() ?
>> Возвращает время последней модификации файла, если он существует и доступен по чтению. Иначе 0L.
111. Методы класса File. setLastModified(long time) ?
>> Устанавливает время последней модификации файла. Возвращает true, если он существует и доступен по записи. Иначе false.
112. Методы класса File.getName() ?
>> Возвращает короткое имя файла или папки.
113. Методы класса File.getAbsolutePath() ?
>> Возвращает абсолютный путь к файлу или папке, включая имя файла. При этом, если в имени файла в конструкторе была задана относительная адресация, соответствующая часть пути сохраняется в возвращаемой строке.
114. Методы класса File. getCanonicalPath() ?
>> Возвращает абсолютный путь к файлу или папке, включая имя файла. При этом, если в имени файла в конструкторе была задана относительная адресация, соответствующая часть пути заменяется в возвращаемой строке на канонический вариант адресации – без элементов относительной адресации.
115. Методы класса File.compareTo(File f) ?
>> Сравнение имён файлов (папок), сопоставляемых текущему файловому объекту и объекту f. Возвращает 0 в случае, когда абсолютные имена файлов (папок) совпадают. Иначе возвращает число, зависящее от разницы в длинах имён и кодов, составляющих их символов.
116. Методы класса File.isAbsolute() ?
>> Возвращает true в случае, когда адресация к имени файла (папки) текущего файлового объекта является абсолютной. Хотя может содержать элементы относительной адресации, то есть не быть канонической.
117. Методы класса File.equals(Object obj) ?
>> Возвращает true тогда и только тогда, когда текущий объект и параметр obj соответствует одному и тому же файлу (папке).
118. Методы класса File.createTempFile(String prefix, String suffix) ?
>> Обеспечивает создание пустого файла (или папки), задаваемого коротким именем prefix+suffix в папке операционной системы, предназначенной для временных файлов. Возвращает ссылку на объект. Префикс должен быть не менее 3 символов.
119. Методы класса File.mkdir() ?
>> Попытка создания папки по имени, которое было задано в конструкторе объекта. Возвращает true в случае успешного создания и false в других случаях.
120. Методы класса File.renameTo(File dest) ?
>> Попытка переименования файла или папки с имени, которое было задано в конструкторе объекта, на новое, задаваемое параметром dest. Возвращает true в случае успешного переименования и false в других случаях.
121. Методы класса File.getAbsoluteFile() ?
>> Создание нового файлового объекта по абсолютному пути, соответствующему текущему файловому объекту.
122. Методы класса File.list() ?
>> Возвращает массив строк (список) коротких имён, находящихся в папке файлов и папок. Имена элементов, находящихся во вложенных папках, не показываются. Если файловый объект не соответствует существующей папке, возвращает null.
123. Конструкторы?
>> это методы, используемые для инициализации объектов в процессе их реализации.
124. Как объекты обмениваются информацией?
>> Объекты общаются друг с другом посредством посылки сообщений.
125. Что такое this?
>> ссылка, с помощью которой объект обращается к самому себе.
126. Класс ?
>> Класс – это структурный тип данных, который включает описание полей данных, а также процедур и функций, работающих с этими полями данных.
127. Процедуры и функции, работающие с полями данных класса?
>> Называются методами.
128. Объединение полей данных и процедур и функций, работающих с этими данными, в единый пакет, при наличии специальных правил доступа к элементам пакета?
>> Инкапсуляция.
129. Основные средства разработки классов. Наследование?
>> Конструирование новых более сложных классов из уже имеющихся посредством добавления полей и определения новых методов (принцип иерархичности).
130. Основные средства разработки классов. Полиморфизм?
>> обеспечивает возможность задания различных реализаций некоторого единого по названию метода для классов различных уровней иерархии.
131. Полиморфными объектами или полиморфными переменными называются?
>> переменные, которым в процессе выполнения программы может быть присвоено значение, тип которого отличается от типа переменной.
132. К изменению свойств объекта возможен только через принадлежащие ему?
>> методы.
133. В момент времени объект характеризуется:?
>> Свойствами
134. Программа в объектно-ориентированном программировании состоит из:?
>> событийных процедур.
135. Инкапсулированные в классе процедуры и функции называются?
>> Методы
136. Процесс, при котором различный код и данные различных модулей соединяются друг с другом в процессе исполнения, называют компоновкой?
>> Динамической
137. Область исходного кода программы, из которой допустим нормальный доступ к связанному с идентификатором объекту, называется?
>> Видимостью
138. Конструктором по умолчанию называется такой конструктор, который?
>> не принимает никаких аргументов.
139. Класс-наследник называется . от базового класса?
>> Производным.
140. Что следует ожидать на экране?
System.out.print(«A»+»B»+»C»);
System.out.println(‘A’+’B’+’C’);
>> ABC198
141. int j = 0;
for (int i = 0; i< 10; i++)
j = j++;
System.out.println(j);
Что выведется в результате?
>> 0
142. int x, y;
int i;
x = 1;
for (i = 0; i< 10; i++)
Что выведется в результате?
>> 3 5 7 9 11 13 15 17 19 21
143. int x, y;
int i;
x = 1;
for (i = 0; i< 10; i++)
Что выведется в результате?
>> 2 4 6 8 10 12 14 16 18 20
144. int x=0;
for(int count=10; count < 5; count++)
x += count ;>
Чему равна х?
>> 0
145. for(inti=-10; i
System.out.print(i + » «) ;>,
Что выведется в результате?
>> -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0
147. Каков будет результат следующего примера?
Point p = new Point(1,2);
int a =p.x;
p = new Point(3,4);
System.out.println(a);
>> 1
148. Каков будет результат следующего примера?
Point p1 = new Point(3,4);
Point p2 = p1;
p1.x = 5;
p1 = new Point(4,4);
System.out.println(p2.x-p1.x);
>> 1
149. Каков будет результат следующих действий?
Point p1 = new Point(2,3);
Point p2 = new Point(2,3);
System.out.print(p1==p2);
p2=p1;
p1.x = 3;
System.out.print(» «);
System.out.println(p1==p2);
>> false true
150. Каков будет результат следующего примера?
public class testClass
public static void process (int x)
public static void main(String[] args)
int x=3; process(x);
System.out.println(x); >>
>> 3
151. Что будет напечатано в консоли в результате выполнения следующего кода:
System.out.println((byte)383+» «+(byte)384+» «+(byte)-384); ?
>> 127 -128 -128
152. Каков будет результат следующего примера?
char c = 65;
System.out.print(c);
System.out.print(+c);
System.out.print(«=»+c);
>> A65=A
153. Каков будет результат следующего примера?
class Parent
class Child extends Parent
public class testClass
public static void main(String[] args)
Child c = new Child(); System.out.print(c.a);
Parent p=c; System.out.print(p.a); >>
>> 32
154. Каков будет результат следующего примера?
class Parent
public void printX()>
class Child extends Parent
public class testClass
public static void main(String[] args)
new Child().printX(); >>
>> 0
155. Каков будет результат следующего примера?
class Parent
class Child extends Parent
public class testClass
public static void main(String[] args)
Child.a=10; Parent.a=5; System.out.println(Child.a); >>
>> 5
156. Каков будет результат следующего примера?
int i,j;
lab:for(i=0;i<6;i++)
for(j=3;j>1;j—)
if(i==j) > >
>> 2
157. Каков будет результат следующей программы?
public class testClass public static void main(String[] args) inti =5;
while(i=5) <
System.out.println(i++); >>>
>> Ошибка компиляции.
158. Каков будет результат следующего примера?
int b=5;
System.out.print(b+(b=3));
System.out.print((b=3)+3);b=5;
System.out.print(b+=(b=3));
>> 868
159. Дан код:
class Quest3
public static void main(String s[ ])
String args;
System.out.print(args + s);
>>
Результатом компиляции кода будет?
>> ошибка компиляции: переменная args используется до инициализации.
160. Дан код:
public class Quest5
public static void main()
System.out.print(«А«); >
public static void main(String args)
System.out.print(«Б«); >
public static void main(String[] args)
System.out.print(«В»);>>
Что будет выведено в результате компиляции и запуска?
>> B
161. Какие из следующихутверждений истинные?
a-nonstatic-метод не может быть вызван из статического метода;
b-static-метод не может быть вызван из нестатического метода;
c-private-метод не может быть вызван из другого метода этого класса;
d-final-метод не может быть статическим.
>> a
162. Дан код:
public class Quest5
static
Quest5()
public static void main(String[] args)
System.out.print(«4»); >>
В результате при компиляции и запуске будет выведено?
>> 24
163. Какие из объявлений корректны, если
classOwner
classInner
>>?
>> new Owner().new Inner();
164. Дан код:
public class Quest1
public static void main(String[] args)
String str = new String(«java»);
int i=1;
char j=3;
System.out.println(str.substring(i,j));>>
В результате при компиляции запуске будет выведено?
>>
165. Экземпляром какого класса является поле System.in?
>> java.io.InputStream;
166. Какой абстрактный класс является суперклассом для всех классов, используемых для чтения байтов?
>> InputStream
167. Какой интерфейс наиболее пригоден для создания класса, содержащего несортированные уникальные объекты?
>> Set
168. Дан код:
Какой код читает параметр count в переменную i?
>> int i = new Integer(getParameter(»count»)).intValue()