533 lines
19 KiB
Java
533 lines
19 KiB
Java
import java.math.BigInteger;
|
||
import java.util.Arrays;
|
||
|
||
// page: 165
|
||
|
||
public class Main {
|
||
public static void main(String[] args) {
|
||
task36();
|
||
}
|
||
|
||
static void task36() {
|
||
/*
|
||
Включите в класс с именем Tank (емкость), который можно наполнить и опустошить. Условие «готовности» требует, чтобы он был пуст перед очисткой. Напишите метод finalize(), проверяющий это условие. В методе main() протестируйте возможные случаи использования вашего класса.
|
||
*/
|
||
Tank tank = new Tank(true);
|
||
tank.fillOut();
|
||
|
||
new Tank(true);
|
||
System.gc();
|
||
}
|
||
|
||
static class Tank {
|
||
boolean full = false;
|
||
|
||
Tank(boolean fill) {
|
||
full = fill;
|
||
}
|
||
|
||
void fillOut() {
|
||
full = false;
|
||
}
|
||
|
||
public void finalize() {
|
||
if (full)
|
||
System.out.println("Ошибка: full");
|
||
}
|
||
}
|
||
|
||
|
||
static void task35() {
|
||
/*
|
||
Измените предыдущее упражнение так, чтобы метод finalize() обязательно был исполнен.
|
||
*/
|
||
|
||
Task34 task = new Task34();
|
||
System.gc();
|
||
}
|
||
|
||
static void task34() {
|
||
/*
|
||
Создайте класс с методом fin alize(), который выводит сообщение. В методе main() создайте объект вашего класса. Объясните поведение программы.
|
||
*/
|
||
Task34 task = new Task34();
|
||
}
|
||
|
||
static class Task34 {
|
||
Task34() {
|
||
System.out.println("Task34 obj created");
|
||
}
|
||
|
||
public void finalize() {
|
||
System.out.println("memory cleared. inside finalize");
|
||
}
|
||
}
|
||
|
||
static class Task33 {
|
||
Task33(int x, String s) {
|
||
System.out.println("this is a string constructor: '" + s + "'");
|
||
}
|
||
|
||
Task33(int x) {
|
||
this(x, "default");
|
||
System.out.println("this is an integer constructor: '" + x + "'");
|
||
}
|
||
}
|
||
|
||
static void task33() {
|
||
/*
|
||
Подготовьте класс с двумя (перегруженными) конструкторами. Используя ключевое слово this, вызовите второй конструктор из первого.
|
||
*/
|
||
|
||
Task33 task1 = new Task33(1);
|
||
Task33 task2 = new Task33(2, "hello");
|
||
}
|
||
|
||
static class Task32 {
|
||
void method1() {
|
||
method2("without 'this' kw");
|
||
this.method2("with 'this' kw");
|
||
}
|
||
void method2(String s) {
|
||
System.out.println("from method 2: " + s);
|
||
}
|
||
}
|
||
|
||
static void task32() {
|
||
/*
|
||
Создайте класс с двумя методами. В первом методе дважды вызовите второй метод: один раз без ключевого слова this, а во второй с this - просто для того, чтобы убедиться в работоспособности этого синтаксиса; не используйте этот способ вызова на практике.
|
||
*/
|
||
Task32 task = new Task32();
|
||
task.method1();
|
||
}
|
||
|
||
static void task31() {
|
||
/*
|
||
Создайте класс без конструктора. Создайте объект этого класса в методе main(), чтобы удостовериться, что конструктор по умолчанию синтезируется автоматически.
|
||
*/
|
||
Task31 task = new Task31();
|
||
}
|
||
|
||
static class Task31 {}
|
||
|
||
static void task30() {
|
||
/*
|
||
Измените предыдущее упражнение так, чтобы два перегруженных метода принимали два аргумента (разных типов) и отличались только порядком их следования в списке аргументов. Проверьте, работает ли это.
|
||
*/
|
||
Dog dog = new Dog();
|
||
dog.bark("hello", 1);
|
||
dog.bark(2, "world");
|
||
}
|
||
|
||
static class Dog {
|
||
void bark() {
|
||
System.out.println("собака лает");
|
||
}
|
||
|
||
void bark(int times) {
|
||
System.out.println("cобака лает " + times + " раз");
|
||
}
|
||
|
||
void bark(double volume) {
|
||
System.out.println("cобака воет с громкостью " + volume);
|
||
}
|
||
|
||
void bark(char mood) {
|
||
System.out.println("собака поскуливает");
|
||
}
|
||
|
||
void bark(boolean angry) {
|
||
System.out.println("собака рычит");
|
||
}
|
||
|
||
void bark(String s, int x) {
|
||
System.out.println("string '" + s + "' first, number '" + x + "' next");
|
||
}
|
||
|
||
void bark(int x, String s) {
|
||
System.out.println("number '" + x + "' first, string '" + s + "' next");
|
||
}
|
||
}
|
||
|
||
static void task29() {
|
||
/*
|
||
Создайте класс Dog (собака) с перегруженным методом bark() (лай). Метод должен быть перегружен для разных примитивных типов данных с целью вывода сообщения о лае, завывании, поскуливании и т. п. в зависимости от версии перегруженного метода. Напишите метод main(), вызывающий все версии.
|
||
*/
|
||
Dog dog = new Dog();
|
||
|
||
dog.bark();
|
||
dog.bark(3);
|
||
dog.bark(2.5);
|
||
dog.bark('s');
|
||
dog.bark(true);
|
||
|
||
}
|
||
|
||
static class Task28 {
|
||
|
||
Task28() {
|
||
System.out.println("task28 object was created");
|
||
}
|
||
|
||
Task28(String s) {
|
||
System.out.println(s + " world");
|
||
}
|
||
}
|
||
|
||
static void task28() {
|
||
/*
|
||
Добавьте к классу из упражнения 3 перегруженный конструктор, принимающий в качестве параметра строку (String) и распечатывающий ее вместе с сообщением.
|
||
*/
|
||
Task28 task1 = new Task28();
|
||
Task28 task2 = new Task28("hello");
|
||
}
|
||
|
||
static class Task27 {
|
||
Task27() {
|
||
System.out.println("Task27 object was created successfully!");
|
||
}
|
||
}
|
||
|
||
static void task27() {
|
||
/*
|
||
Создайте класс с конструктором по умолчанию (без параметров), который выводит на экран сообщение. Создайте объект этого класса.
|
||
*/
|
||
Task27 task = new Task27();
|
||
}
|
||
|
||
static class Task26 {
|
||
String s1 = "hello";
|
||
String s2;
|
||
|
||
Task26 (String s2) {
|
||
this.s2 = s2;
|
||
}
|
||
}
|
||
|
||
|
||
static void task26() {
|
||
/*
|
||
Создайте класс с полем String, инициализируемым в точке определения, и другим полем, инициализируемым конструктором. Чем отличаются эти два подхода?
|
||
*/
|
||
|
||
Task26 task = new Task26("world");
|
||
System.out.println(task.s1);
|
||
System.out.println(task.s2);
|
||
|
||
}
|
||
|
||
static class Task25 {
|
||
String string;
|
||
}
|
||
|
||
|
||
static void task25() {
|
||
/*
|
||
Создайте класс с неинициализированной ссылкой на String. Покажите, что Java инициализирует ссылку значением null.
|
||
*/
|
||
Task25 task = new Task25();
|
||
System.out.println(task.string);
|
||
}
|
||
|
||
static void task24(String[] args) {
|
||
/*
|
||
Вампирами называются числа, состоящие из четного количества цифр и полученные перемножением пары чисел, каждое из которых содержит половину цифр результата. Цифры берутся из исходного числа в произвольном порядке, завершающие нули недопустимы. Примеры:
|
||
1) 1260 = 21 * 60;
|
||
2) 1827 = 21 * 87;
|
||
3) 2187 = 27 * 81.
|
||
Напишите программу, которая находит всех «вампиров», состоящих из 4 цифр. (Задача предложена Дэном Форханом.)
|
||
*/
|
||
|
||
for (int x = 10; x < 100; x++) {
|
||
for (int y = 10; y < 100; y++) {
|
||
if ((x < y) && (Integer.toString(x * y).length() == 4)) {
|
||
char[] claws_array = (Integer.toString(x) + Integer.toString(y)).toCharArray();
|
||
Arrays.sort(claws_array);
|
||
String claws = new String(claws_array);
|
||
|
||
char[] vampire_array = Integer.toString(x * y).toCharArray();
|
||
Arrays.sort(vampire_array);
|
||
String vampire = new String(vampire_array);
|
||
|
||
if (claws.equals(vampire)) {
|
||
System.out.println(x + " * " + y + " = " + x * y);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
static void task23(String[] args) {
|
||
/*
|
||
(4) Числами Фибоначчи называется числовая последовательность 1, 1, 2, 3, 5, 8, 13, 21, 34 и т. д., в которой каждое число, начиная с третьего, является суммой двух предыдущих. Напишите метод, который получает целочисленный аргумент и выводит указанное количество чисел Фибоначчи. Например, при запуске командой java Fibonacci 5 (где Fibonacci — имя класса) должна выводиться последовательность 1, 1, 2, 3, 5.
|
||
*/
|
||
|
||
int n = Integer.parseInt(args[0]);
|
||
// System.out.println(n);
|
||
|
||
BigInteger A = BigInteger.valueOf(1), B = BigInteger.valueOf(1), C;
|
||
|
||
if (n == 0) {
|
||
System.out.println("");
|
||
} else if (n == 1) {
|
||
System.out.println("1");
|
||
} else if (n == 2) {
|
||
System.out.println("1 1");
|
||
} else {
|
||
System.out.print("1 1 ");
|
||
for (int i = 0; i < n - 2; i++) {
|
||
C = A.add(B);
|
||
A = B;
|
||
B = C;
|
||
System.out.print(B.toString() + " ");
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
static void task22() {
|
||
/*
|
||
Создайте команду switch, которая выводит сообщение в каждой секции case. Разместите ее в цикле for, проверяющем все допустимые значения case. Каждая секция case должна завершаться командой break. Затем удалите команды break и посмотрите, что произойдет.
|
||
*/
|
||
|
||
for (int i = 1; i <= 5; i++) {
|
||
switch (i) {
|
||
case 1:
|
||
case 2:
|
||
|
||
System.out.println("<3");
|
||
break;
|
||
|
||
case 4:
|
||
case 5:
|
||
|
||
System.out.println("no love :(");
|
||
break;
|
||
|
||
default:
|
||
System.out.println(i);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
static int test(int testval, int begin, int end) {
|
||
/*
|
||
1 - testval принадлежит [begin, end]
|
||
0 - иначе
|
||
*/
|
||
if (begin <= testval && testval <= end) {
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
static void task20() {
|
||
/*
|
||
Измените метод test() так, чтобы он получал два дополнительных аргумента begin и end, а значение testval проверялось на принадлежность к диапазону [begin, end] (с включением границ).
|
||
*/
|
||
|
||
System.out.println(
|
||
test(2, 1, 5) // 2 in [1, 5] (1)
|
||
);
|
||
|
||
System.out.println(
|
||
test(1, 1, 5) // 1 in [1, 5] (1)
|
||
);
|
||
|
||
System.out.println(
|
||
test(-1, 1, 5) // -1 not in [1, 5] (0)
|
||
);
|
||
|
||
}
|
||
|
||
static void task18() {
|
||
/*
|
||
Напишите программу, использующую два вложенных цикла for и оператор остатка (%) для поиска и вывода простых чисел (то есть целых чисел, не делящихся нацело ни на какое другое число, кроме себя и 1).
|
||
*/
|
||
|
||
|
||
for (int i = 2; i < 100000; i++) {
|
||
boolean prime = true;
|
||
for (int j = 2; j < i; j++) {
|
||
if (i % j == 0) {
|
||
// System.out.println("число " + i + " не простое");
|
||
prime = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (prime) {
|
||
System.out.println("число " + i + " простое");
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
static void task17() {
|
||
/*
|
||
Измените упражнение 2 так, чтобы код выполнялся в «бесконечном» цикле while. Программа должна работать до тех пор, пока ее выполнение не будет прервано с клавиатуры (как правило, нажатием клавиш Ctrl+C).
|
||
*/
|
||
|
||
while (true) {
|
||
task16();
|
||
}
|
||
}
|
||
|
||
static void task16() {
|
||
/*
|
||
Напишите программу, которая генерирует 25 случайных значений типа int. Для каждого значения команда if - e ls e сообщает, в каком отношении оно находится с другим случайно сгенерированным числом (больше, меньше, равно).
|
||
*/
|
||
for (int i = 0; i < 25; i++) {
|
||
int num1 = (int)(Math.random() * 100);
|
||
int num2 = (int)(Math.random() * 100);
|
||
|
||
// System.out.println("num1: " + num1);
|
||
// System.out.println("num2: " + num2);
|
||
|
||
if (num1 > num2) {
|
||
System.out.println(num1 + " > " + num2);
|
||
} else if (num1 < num2) {
|
||
System.out.println(num1 + " < " + num2);
|
||
} else {
|
||
System.out.println(num1 + " = " + num2);
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
|
||
static void task15() {
|
||
/*
|
||
Напишите программу, которая выводит числа от 1 до 100.
|
||
*/
|
||
for (int i = 1; i <= 100; i++) {
|
||
System.out.println(i);
|
||
}
|
||
}
|
||
|
||
static void allStringOps(String s1, String s2) {
|
||
System.out.println("s1 < s2: " + (s1.compareTo(s2) < 0));
|
||
System.out.println("s1 > s2: " + (s1.compareTo(s2) > 0));
|
||
System.out.println("s1 <= s2: " + (s1.compareTo(s2) <= 0));
|
||
System.out.println("s1 >= s2: " + (s1.compareTo(s2) >= 0));
|
||
|
||
System.out.println("s1 == s2: " + (s1 == s2));
|
||
System.out.println("s1 != s2: " + (s1 != s2));
|
||
|
||
System.out.println("s1.equals(s2): " + s1.equals(s2));
|
||
System.out.println("s2.equals(s1): " + s2.equals(s1));
|
||
System.out.println();
|
||
}
|
||
|
||
|
||
static void task14() {
|
||
/*
|
||
Напишите метод, который получает два аргумента String, выполняет с ними все операции логических сравнений и выводит результаты. Для операций == и != также выполните проверку equals(). Вызовите свой метод из main() для нескольких разных объектов String.
|
||
*/
|
||
|
||
allStringOps("hello", "world");
|
||
allStringOps("hello", "hello");
|
||
allStringOps(new String("hello"), new String("hello"));
|
||
}
|
||
|
||
static void charToBin(char ch) {
|
||
String bin = Integer.toBinaryString(ch);
|
||
|
||
System.out.println(
|
||
String.format("%16s", bin).replace(' ', '0')
|
||
);
|
||
}
|
||
|
||
static void task13() {
|
||
/*
|
||
Напишите метод для вывода char в двоичном представлении. Продемонстрируйте его работу на нескольких разных символах.
|
||
*/
|
||
|
||
char a = 'a', b = 'b', x = 'x', z = 'z';
|
||
charToBin(a);
|
||
charToBin(b);
|
||
charToBin(x);
|
||
charToBin(z);
|
||
}
|
||
|
||
static void task12() {
|
||
/*
|
||
Начните с числа, состоящего из двоичных единиц. Сдвиньте его влево, а затем используйте беззнаковый оператор сдвига вправо по всем двоичным позициям, с выводом всех промежуточных результатов методом lnteger.toBinaryString().
|
||
*/
|
||
|
||
int value = 0xFFFFFFFF;
|
||
System.out.println(Integer.toBinaryString(value));
|
||
|
||
value <<= 1;
|
||
System.out.println(Integer.toBinaryString(value));
|
||
|
||
for (int i = 0; i < 32; i++) {
|
||
value >>>= 1;
|
||
System.out.println(Integer.toBinaryString(value));
|
||
}
|
||
}
|
||
|
||
static void task11() {
|
||
/*
|
||
Начните с числа, содержащего двоичную 1 в старшем бите (подсказка: воспользуйтесь шестнадцатеричной константой). Используйте знаковый оператор сдвига вправо, сдвигайте знак до крайней правой позиции, с выводом всех промежуточных результатов методом Integer.toBinaryString().
|
||
*/
|
||
int value = 0x80000000;
|
||
|
||
for (int i = 0; i < 32; i++) {
|
||
System.out.println(Integer.toBinaryString(value));
|
||
value >>= 1;
|
||
}
|
||
}
|
||
|
||
static void task10() {
|
||
/*
|
||
Напишите программу с двумя константами: обе константы состоят из чередующихся нулей и единиц, но у одной нулю равен младший бит, а у другой старший (подсказка: константы проще всего определить в шестнадцатеричном виде). Объедините эти две константы всеми возможными поразрядными операторами. Для вывода результатов используйте метод Integer.toBinaryString().
|
||
*/
|
||
|
||
int const1 = 0xAAAAAAAA;
|
||
int const2 = 0x55555555;
|
||
|
||
int bitwise_and = const1 & const2;
|
||
int bitwise_or = const1 | const2;
|
||
int bitwise_xor = const1 ^ const2;
|
||
int bitwise_not = ~const1;
|
||
|
||
System.out.println("AND(&): " + Integer.toBinaryString(bitwise_and));
|
||
System.out.println("OR(|): " + Integer.toBinaryString(bitwise_or));
|
||
System.out.println("XOR(^): " + Integer.toBinaryString(bitwise_xor));
|
||
System.out.println("NOT(~):" + Integer.toBinaryString(bitwise_not));
|
||
}
|
||
|
||
static void task9() {
|
||
/*
|
||
Выведите наибольшее и наименьшее число в экспоненциальной записи для типов float и double.
|
||
*/
|
||
|
||
float max_float = Float.MAX_VALUE;
|
||
double max_double = Double.MAX_VALUE;
|
||
|
||
float min_float = Float.MIN_VALUE;
|
||
double min_double = Double.MIN_VALUE;
|
||
|
||
System.out.println("Max float value: " + max_float);
|
||
System.out.println("Max double value: " + max_double);
|
||
|
||
System.out.println("Min float value: " + min_float);
|
||
System.out.println("Min double value: " + min_double);
|
||
}
|
||
|
||
static void task8() {
|
||
/*
|
||
Покажите, что шестнадцатеричная и восьмеричная записи могут использоваться с типом long. Для вывода результатов используйте метод Long.toBinaryString().
|
||
*/
|
||
|
||
long hex = 0x123L;
|
||
long oct = 0123;
|
||
|
||
System.out.println(Long.toBinaryString(hex));
|
||
System.out.println(Long.toBinaryString(oct));
|
||
}
|
||
}
|