diff --git a/.idea/misc.xml b/.idea/misc.xml index 049adb9..e0844bc 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -1,7 +1,6 @@ - + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Animals.java b/Animals.java new file mode 100644 index 0000000..4a32b95 --- /dev/null +++ b/Animals.java @@ -0,0 +1,35 @@ +public class Animals { + protected String name; + protected int runLimit = 0; + protected float jumpLimit = 0f; + protected int swimLimit = 0; + + public Animals(String name) { + this.name = name; + } + + public void info() { + System.out.println("name: " + name ); + } + public void run(int i){ + boolean a= false; + if(i answer) { + System.out.println("Ваш ответ был слишком большим"); + } + if (userAnswer < answer) { + System.out.println("Ваш ответ был слишком маленьким"); + } + } + System.out.println("Повторить игру еще раз? 1 – да / 0 – нет"); + keepPlaying = in.nextInt(); + } + } + + public static void GuessTheWord() { + String[] words = {"apple", "orange", "lemon", "banana", "apricot", "avocado", "broccoli", "carrot", "cherry", "garlic", "grape", "melon", "leak", "kiwi", "mango", "mushroom", "nut", "olive", "pea", "peanut", "pear", "pepper", "pineapple", "pumpkin", "potato"}; + + Random rnd = new Random(); + String answer; + answer = words[rnd.nextInt(words.length)]; + System.out.println("Загадано слово, попробуйте отгадать"); + Scanner in = new Scanner(System.in); + while (true) { + String userAnswer = in.nextLine(); + if (userAnswer.equalsIgnoreCase(answer)) { + System.out.println("Поздравляю, вы угадали"); + break; + } else { + String wrongGuess = ""; + for (int i = 0; i < 9; i++) { + if (i < userAnswer.length() && i < answer.length()) { + if (userAnswer.charAt(i) == answer.charAt(i)) { + wrongGuess += userAnswer.charAt(i); + } else { + wrongGuess += "#"; + } + } + else{ + wrongGuess +="#"; + } + + } + System.out.println(wrongGuess); + } + } + } + + public static void main(String[] args) { + GuessTheWord(); + GuessGame(); + } +} diff --git a/src/lesson3/homework/WordsGame.java b/src/lesson3/homework/WordsGame.java new file mode 100644 index 0000000..62c7a23 --- /dev/null +++ b/src/lesson3/homework/WordsGame.java @@ -0,0 +1,84 @@ +package lesson3.homework; + +import java.io.File; +import java.io.FileNotFoundException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Random; +import java.util.Scanner; + +public class WordsGame { + + private static String[] words = {"apple", "orange", "lemon", "banana", + "apricot", "avocado", "broccoli", "carrot", "cherry", "garlic", "grape", + "melon", "leak", "kiwi", "mango", "mushroom", "nut", + "olive", "pea", "peanut", "pear", "pepper", "pineapple", + "pumpkin", "potato"}; + private final Random rnd = new Random(); + + public void game() { + System.out.println("Вам предстоит угадать слово"); + System.out.println("Как вы думаете какое слово я загадал? " + + "Я буду открывать верные буквы!"); + String word = words[rnd.nextInt(words.length)]; + String random = word; + word = word + "#".repeat(15 - word.length()); + //System.out.println(random); + //System.out.println(word); + char [] sym = word.toCharArray(); + Arrays.fill(sym, '#'); + Scanner in = new Scanner(System.in); + boolean inGame = true; + while (inGame) { + System.out.println("Введите ваше предположение"); + String predict = in.next(); + if (predict.equals(random)) { + System.out.println("Вы угадали! Я загадал слово: " + predict); + return; + } + + for (int i = 0; i < word.length(); i++) { + if (i < predict.length() && predict.charAt(i) == word.charAt(i)) { + if (sym[i] == '#') { + sym[i] = word.charAt(i); + } + } + } + for(char ch : sym) System.out.print(ch); + System.out.println(); + } + } + + public static void main(String[] args) throws FileNotFoundException { + if (args != null && args.length == 1) { + if (args[0].equals("-h") || args[0].equals("-help")) { + System.out.println("use path to file or use list of param or don't use param"); + return; + } + File file = new File(args[0]); + if (file.exists()) { + Scanner in = new Scanner(file); + ArrayList list = new ArrayList<>(); + while (in.hasNext()) { + list.add(in.next()); + } + in.close(); + //System.out.println(list); + String [] tmp = new String[list.size()]; + for (int i = 0; i < list.size(); i++) { + tmp[i] = list.get(i); + } + words = tmp; + System.out.println(Arrays.toString(words)); + new WordsGame().game(); + } + } else { + if (args == null || args.length == 0) { + new WordsGame().game(); + } else { + words = args; + new WordsGame().game(); + } + } + } +} diff --git a/src/lesson4/GameXO.java b/src/lesson4/GameXO.java new file mode 100644 index 0000000..569c6c3 --- /dev/null +++ b/src/lesson4/GameXO.java @@ -0,0 +1,336 @@ +package lesson4; + +import org.w3c.dom.ls.LSOutput; + +import java.util.Arrays; +import java.util.InputMismatchException; +import java.util.Scanner; + +public class GameXO { + + private final static char EMPTY = '_'; + private final static char DOT_X = 'X'; + private final static char DOT_O = 'O'; + //private static int fieldSize = 3; + //|_|_|_| + //|_|_|_| + //|_|_|_| + + private void printTab(char[][] tab) { + int counter = 1; + System.out.print(" "); + for (int i = 0; i < tab.length; i++) { + System.out.print((i + 1) + " "); + } + System.out.println(); + for (char[] chars : tab) { + System.out.print(counter + " "); + counter++; + for (char sym : chars) { + System.out.print("|" + sym); + } + System.out.println("|"); + } + } + + private void fillTab(char[][] tab) { + for (char[] chars : tab) { + Arrays.fill(chars, EMPTY); + } + } + + private boolean IsDraw(char[][] tab) { + boolean draw = true; + for (int l = 0; l < tab.length; l++) { + for (int j = 0; j < tab.length; j++) { + if (tab[l][j] == EMPTY) + draw = false; + } + } + return draw; + + } + + public void startGame(int fieldSize) { + // TODO: 23.03.2020 *** fieldSize > 3, 4(WIN) + char[][] tab = new char[fieldSize][fieldSize]; + fillTab(tab); + System.out.println("Игра крестики нолики. Вы играете за Х"); + printTab(tab); + System.out.println("Для того, чтобы совершить" + + "" + + " ход введите номер строки" + + "и номер столбца таблицы"); + boolean inGame = true; + Scanner in = new Scanner(System.in); + while (inGame) { + System.out.println("Ваш ход:"); + int x, y; + try { + x = in.nextInt(); + y = in.nextInt(); + x--; + y--; + if (isValid(x, y, tab)) { + tab[x][y] = DOT_X; + printTab(tab); + if (isVictory(tab, DOT_X)) { + System.out.println("Вы победили"); + break; + } + System.out.print("Компьютер совершает ход"); + for (int i = 0; i < 5; i++) { + Thread.sleep(300); + System.out.print("."); + } + System.out.println(); + movePC(tab); + if (isVictory(tab, DOT_O)) { + System.out.println("Вы проиграли"); + break; + } + // TODO: 23.03.2020 Ничья ??? + if (IsDraw(tab)) { + System.out.println("Ничья"); + break; + } + + } else { + System.out.println("Данный ход невозможен! Введите новые значения"); + } + } catch (InputMismatchException exception) { + System.out.println("Вы ввели не цифры! Введите цифры"); + in.next(); + continue; + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + //..... game ..... + } + + private boolean isVictory(char[][] tab, char player /*X, O*/) { + // TODO: 23.03.2020 + int winningLength = tab.length - 1; + if (winningLength > 4) + winningLength = 4; + for (int x = 0; x < tab[0].length; x++) + for (int y = 0; y < tab.length; y++) + if (tab[y][x] == player) { + int winStreak; + for (int i = 1; i <= winningLength; i++) { + if (x - winningLength < 0 || x + winningLength >= tab.length) + break; + if (player != tab[y][x + i]) + break; + if (i == winningLength) + return true; + } + for (int i = 1; i <= winningLength; i++) { + if (x - winningLength < 0 || x - winningLength >= tab.length) + break; + if (player != tab[y][x - i]) + break; + if (i == winningLength) + return true; + } + + for (int i = 1; i <= winningLength; i++) { + if (y - winningLength < 0 || y - winningLength >= tab.length) + break; + if (player != tab[y - i][x]) + break; + if (i == winningLength) + return true; + } + for (int i = 0; i <= winningLength; i++) { + if (y + winningLength < 0 || y + winningLength >= tab.length) + break; + if (player != tab[y + i][x]) + break; + if (i == winningLength) + return true; + } + + for (int i = 1; i <= winningLength; i++) { + if (y + winningLength < 0 || y + winningLength >= tab.length || x + winningLength < 0 || x + winningLength >= tab.length) + break; + if (player != tab[y + i][x + i]) + break; + if (i == winningLength) + return true; + } + for (int i = 1; i <= winningLength; i++) { + if (y - winningLength < 0 || y - i >= tab.length || x + i < 0 || x + i >= tab.length) + break; + if (player != tab[y - i][x + i]) + break; + if (i == winningLength) + return true; + } + for (int i = 1; i <= winningLength; i++) { + if (y + winningLength < 0 || y + winningLength >= tab.length || x - winningLength < 0 || x - winningLength >= tab.length) + break; + if (player != tab[y + i][x - i]) + break; + if (i == winningLength) + return true; + } + for (int i = 1; i <= winningLength; i++) { + if (y - winningLength < 0 || y - winningLength >= tab.length || x - winningLength < 0 || x - winningLength >= tab.length) + break; + if (player != tab[y - i][x - i]) + break; + if (i == winningLength) + return true; + } + } + return false; + } + + private int[] Danger(char[][] tab, char player /*X, O*/) { + // TODO: 23.03.2020 + int winningLength = tab.length - 1; + if (winningLength > 4) + winningLength = 4; + int[] arr = {-1, -1}; + for (int x = 0; x < tab[0].length; x++) + for (int y = 0; y < tab.length; y++) + if (tab[y][x] == player) { + int winStreak; + for (int i = 1; i <= winningLength - 1; i++) { + if (x - winningLength < 0 || x + winningLength >= tab.length) + break; + if (player != tab[y][x + i]) + break; + if (i == winningLength - 1) { + arr[0] = y; + arr[1] = x + winningLength; + return arr; + } + } + for (int i = 1; i <= winningLength - 1; i++) { + if (x - winningLength < 0 || x - winningLength >= tab.length) + break; + if (player != tab[y][x - i]) + break; + if (i == winningLength - 1) { + arr[0] = y; + arr[1] = x - winningLength; + return arr; + } + } + + for (int i = 1; i <= winningLength-1; i++) { + if (y - winningLength < 0 || y - winningLength >= tab.length) + break; + if (player != tab[y - i][x]) + break; + if (i == winningLength-1) { + arr[0] = y - winningLength; + arr[1] = x; + return arr; + } + } + for (int i = 0; i <= winningLength-1; i++) { + if (y + winningLength < 0 || y + winningLength >= tab.length) + break; + if (player != tab[y + i][x]) + break; + if (i == winningLength-1) { + arr[0] = y + winningLength; + arr[1] = x; + return arr; + } + } + + for (int i = 1; i <= winningLength-1; i++) { + if (y + winningLength < 0 || y + winningLength >= tab.length || x + winningLength < 0 || x + winningLength >= tab.length) + break; + if (player != tab[y + i][x + i]) + break; + if (i == winningLength-1) { + arr[0] = y + winningLength; + arr[1] = x + winningLength; + return arr; + } + } + for (int i = 1; i <= winningLength-1; i++) { + if (y - winningLength < 0 || y - i >= tab.length || x + i < 0 || x + i >= tab.length) + break; + if (player != tab[y - i][x + i]) + break; + if (i == winningLength-1) { + arr[0] = y - winningLength; + arr[1] = x + winningLength; + return arr; + } + } + for (int i = 1; i <= winningLength-1; i++) { + if (y + winningLength < 0 || y + winningLength >= tab.length || x - winningLength < 0 || x - winningLength >= tab.length) + break; + if (player != tab[y + i][x - i]) + break; + if (i == winningLength-1) { + arr[0] = y + winningLength; + arr[1] = x - winningLength; + return arr; + } + } + for (int i = 1; i <= winningLength-1; i++) { + if (y - winningLength < 0 || y - winningLength >= tab.length || x - winningLength < 0 || x - winningLength >= tab.length) + break; + if (player != tab[y - i][x - i]) + break; + if (i == winningLength-1) { + arr[0] = y - winningLength; + arr[1] = x - winningLength; + return arr; + } + } + } + return arr; + } + + private void movePC(char[][] tab) { + // TODO: 23.03.2020 smart strategy + int len = tab.length; + int[] dan = Danger(tab,DOT_X); + int[] arr = {-1,-1}; + if(dan[0]==arr[0]&&dan[1]==arr[1]|| tab[dan[0]][dan[1]] == DOT_O ) { + for (int i = 0; i < len; i++) { + for (int j = 0; j < len; j++) { + if (tab[i][j] == EMPTY) { + tab[i][j] = DOT_O; + printTab(tab); + return; + } + } + } + } + else{ + tab[dan[0]][dan[1]] = DOT_O; + printTab(tab); + return; + } + } + + private boolean isValid(int x, int y, char[][] tab) { + int len = tab.length; + if (x >= 0 && x < len && y >= 0 && y < len) { + if (tab[x][y] == EMPTY) { + return true; + } + } + return false; + } + + public static void main(String[] args) { + if (args != null && args.length == 1) { + new GameXO().startGame(Integer.parseInt(args[0])); + } else { + new GameXO().startGame(3); + } + + } +} diff --git a/src/lesson4/Task1.java b/src/lesson4/Task1.java new file mode 100644 index 0000000..becc434 --- /dev/null +++ b/src/lesson4/Task1.java @@ -0,0 +1,7 @@ +package lesson4; + +public class Task1 { + public static void main(String[] args) { + System.out.println("Hello world"); + } +} diff --git a/src/lesson5/animals/Cat.java b/src/lesson5/animals/Cat.java new file mode 100644 index 0000000..667a375 --- /dev/null +++ b/src/lesson5/animals/Cat.java @@ -0,0 +1,36 @@ +package lesson5.animals; + +import java.util.Random; + +public class Cat { + + public static final String SPEACH = "MEOW"; + private static Random rnd = new Random(); + private String name; + private CatColor color; + private int age; + + public Cat(String name) { + age = 0; + this.name = name; + color = CatColor.values()[rnd.nextInt(CatColor.values().length)]; + } + + // Method + public void run() { + System.out.println("I'm is running"); + } + + public void say() { + System.out.println(SPEACH); + } + + @Override + public String toString() { + return "Cat{" + + "name='" + name + '\'' + + ", color=" + color + + ", age=" + age + + '}'; + } +} diff --git a/src/lesson5/animals/CatColor.java b/src/lesson5/animals/CatColor.java new file mode 100644 index 0000000..2219deb --- /dev/null +++ b/src/lesson5/animals/CatColor.java @@ -0,0 +1,9 @@ +package lesson5.animals; + +public enum CatColor { + WHITE, + BLACK, + GRAY, + BROUN, + PINK +} diff --git a/src/lesson5/animals/Test.java b/src/lesson5/animals/Test.java new file mode 100644 index 0000000..d19b04e --- /dev/null +++ b/src/lesson5/animals/Test.java @@ -0,0 +1,10 @@ +package lesson5.animals; + +public class Test { + public static void main(String[] args) { + Cat cat = new Cat("Vaska"); + cat.run(); + cat.say(); + System.out.println(cat); + } +} diff --git a/src/lesson5/geometry/Main.java b/src/lesson5/geometry/Main.java new file mode 100644 index 0000000..5d15675 --- /dev/null +++ b/src/lesson5/geometry/Main.java @@ -0,0 +1,13 @@ +package lesson5.geometry; + +public class Main { + + + public static void main(String[] args) { + System.out.println(new Vector(new Point(1, 1), new Point(3, 5))); + for (int i = 0; i < 5; i++) { + System.out.println(new Vector()); + } + System.out.println(Vector.vectorCounter); + } +} diff --git a/src/lesson5/geometry/Point.java b/src/lesson5/geometry/Point.java new file mode 100644 index 0000000..e3d8e80 --- /dev/null +++ b/src/lesson5/geometry/Point.java @@ -0,0 +1,19 @@ +package lesson5.geometry; + +// SOLID +// single response +public class Point { + + double x, y; + + Point(int x, int y) { + // x - переменная функции + this.x = x; + this.y = y; + } + + @Override + public String toString() { + return String.format("(%f; %f)", x, y); + } +} diff --git a/src/lesson5/geometry/Vector.java b/src/lesson5/geometry/Vector.java new file mode 100644 index 0000000..f83ec2f --- /dev/null +++ b/src/lesson5/geometry/Vector.java @@ -0,0 +1,36 @@ +package lesson5.geometry; + +public class Vector { + + static int vectorCounter = 0; + Point a, b; // Fields (Свойства, поля) + double x, y; + int id; + // классовые перемнные + + // constructor + Vector(Point x, Point y) { + a = x; b = y; + vectorCounter++; + id = vectorCounter; + this.x = y.x - x.x; + this.y = y.y - x.y; + } + + Vector() { + vectorCounter++; + id = vectorCounter; + } + + Vector add(Vector other) { + return null; + } + + @Override + public String toString() { + return "v" + id + "{" + + "a=" + a + + ", b=" + b + + '}'; + } +} diff --git a/src/lesson5/hometask/AbstractValue.java b/src/lesson5/hometask/AbstractValue.java new file mode 100644 index 0000000..88394a6 --- /dev/null +++ b/src/lesson5/hometask/AbstractValue.java @@ -0,0 +1,18 @@ +package lesson5.hometask; + +public class AbstractValue { + + T value; + + public AbstractValue(T value) { + this.value = value; + } + + public T getValue() { + return value; + } + + public void setValue(T value) { + this.value = value; + } +} diff --git a/src/lesson5/hometask/Cat.java b/src/lesson5/hometask/Cat.java new file mode 100644 index 0000000..33d3143 --- /dev/null +++ b/src/lesson5/hometask/Cat.java @@ -0,0 +1,61 @@ +package lesson5.hometask; + +import java.util.ArrayList; + +public class Cat { + + enum Sex { + MAN, + WOMAN + } + + private String name; + private Sex sex; + // for Adam and Eva mother = null, father = null + private Cat mother, father; + private ArrayList children; + + public String getName() { + return name; + } + + public Cat getMother() { + return mother; + } + + public Cat getFather() { + return father; + } + + public Sex getSex() { + return sex; + } + + public Cat(String name, Sex sex) { + this.name = name; + this.sex = sex; + children = new ArrayList<>(); + } + + public Cat(Sex sex) { + this.sex = sex; + children = new ArrayList<>(); + } + + public ArrayList getChildren() { + return children; + } + + public void makeChild(Cat otherCat) { + // TODO: 3/26/2020 + /* No man-man, woman-woman + * */ + // if man trying make child with man kill him ))) + } + + @Override + public String toString() { + // TODO: 3/26/2020 + return "Cat{}"; + } +} diff --git a/src/lesson5/hometask/Population.java b/src/lesson5/hometask/Population.java new file mode 100644 index 0000000..61525e2 --- /dev/null +++ b/src/lesson5/hometask/Population.java @@ -0,0 +1,54 @@ +package lesson5.hometask; + +public class Population { + + private Cat adam = new Cat("Adam", Cat.Sex.MAN); + private Cat eva = new Cat("Eva", Cat.Sex.WOMAN); + + public Population() { + for (int i = 0; i < 10; i++) { + adam.makeChild(eva); + } + for (Cat cat : adam.getChildren()) { + for (Cat cat1 : adam.getChildren()) { + if (!cat.getSex().equals(cat1.getSex())) { + deepPopulationIncrease(cat1, cat, 5); + } + } + } + } + + public void deepPopulationIncrease(Cat cat1, Cat cat2, int depth) { + if (depth <= 0) { + return; + } + if (!cat1.getSex().equals(cat2.getSex())) { + cat1.makeChild(cat2); + cat1.makeChild(cat2); + Cat firstChild = cat1.getChildren().get(0); + Cat secondChild = cat1.getChildren().get(1); + deepPopulationIncrease(firstChild, secondChild, depth - 1); + } + } + + public void printPopulationTree() { + // TODO: 3/26/2020 +// Adam : { +// children : { +// Cat1 : { +// children : { +// Cat3, +// Cat4, +// Cat5 +// } +// }, +// Cat6 : { +// children : { +// Cat7, +// Cat8 +// } +// } +// } +// } + } +} diff --git a/src/lesson5/hometask/RefValue.java b/src/lesson5/hometask/RefValue.java new file mode 100644 index 0000000..436790f --- /dev/null +++ b/src/lesson5/hometask/RefValue.java @@ -0,0 +1,18 @@ +package lesson5.hometask; + +import java.math.BigInteger; +import java.util.List; + +public class RefValue extends Value { + + List value; + + public RefValue(List value) { + this.value = value; + } + + @Override + List getValue() { + return value; + } +} diff --git a/src/lesson5/hometask/TextValue.java b/src/lesson5/hometask/TextValue.java new file mode 100644 index 0000000..0a90375 --- /dev/null +++ b/src/lesson5/hometask/TextValue.java @@ -0,0 +1,13 @@ +package lesson5.hometask; + +public class TextValue extends Value{ + String value; + + public TextValue(String value) { + this.value = value; + } + + public String getValue() { + return value; + } +} diff --git a/src/lesson5/hometask/Value.java b/src/lesson5/hometask/Value.java new file mode 100644 index 0000000..cb6f271 --- /dev/null +++ b/src/lesson5/hometask/Value.java @@ -0,0 +1,5 @@ +package lesson5.hometask; + +public abstract class Value { + abstract Object getValue(); +} diff --git a/src/lesson5/hometask/Wrapper.java b/src/lesson5/hometask/Wrapper.java new file mode 100644 index 0000000..c887c51 --- /dev/null +++ b/src/lesson5/hometask/Wrapper.java @@ -0,0 +1,15 @@ +package lesson5.hometask; + +import java.math.BigInteger; +import java.util.Collections; + +public class Wrapper { + static T getValue(T object) { + return (T) object; + } + + public static void main(String[] args) { + AbstractValue txt = new AbstractValue<>(new TextValue("123")); + System.out.println(txt.getValue().getValue()); + } +} diff --git a/src/lesson5/homework/Test.java b/src/lesson5/homework/Test.java new file mode 100644 index 0000000..358243c --- /dev/null +++ b/src/lesson5/homework/Test.java @@ -0,0 +1,17 @@ +package lesson5.homework; + +public class Test { + public static void main(String[] args) { + Worker[] w = new Worker[5]; + w[0] = new Worker("Ivanov Ivan", "Engineer", "ivivan@mailbox.com", "892312312", 30000, 30); + w[1] = new Worker("Ivahov Ivan", "Engineer", "ivhvan@mailbox.com", "892312312", 10000, 10); + w[2] = new Worker("Ivapov Ivan", "Engineer", "ivpvan@mailbox.com", "892312312", 50000, 20); + w[3] = new Worker("Ivamov Ivan", "Engineer", "ivmvan@mailbox.com", "892312312", 20000, 70); + w[4] = new Worker("Ivabov Ivan", "Engineer", "ivbvan@mailbox.com", "892312312", 80000, 60); + for (int i = 0; i < 5; i++) { + if(w[i].age>40){ + w[i].Info(); + } + } + } +} diff --git a/src/lesson5/homework/Worker.java b/src/lesson5/homework/Worker.java new file mode 100644 index 0000000..73d2f7e --- /dev/null +++ b/src/lesson5/homework/Worker.java @@ -0,0 +1,33 @@ +package lesson5.homework; + +import lesson5.persons.Group; + +import java.util.ArrayList; + +public class Worker { +//ФИО, должность, email, телефон, зарплата, возраст; + String fio; + String position; + String email; + String phone; + int paycheck; + int age; + + public Worker(String fio, String position, String email,String phone, int paycheck, int age) { + this.fio = fio; + this.position = position; + this.email = email; + this.phone = phone; + this.paycheck = paycheck; + this.age = age; + } + public void Info(){ + System.out.println("ФИО сотрудника - " + fio); + System.out.println("Должность сотрудника - " + position); + System.out.println("Email- " + email); + System.out.println("Tелефон - " + phone); + System.out.println("Зарплата - " + paycheck); + System.out.println("Возраст - "+ age); + } + +} diff --git a/src/lesson5/persons/Group.java b/src/lesson5/persons/Group.java new file mode 100644 index 0000000..a6495b2 --- /dev/null +++ b/src/lesson5/persons/Group.java @@ -0,0 +1,56 @@ +package lesson5.persons; + +import java.util.ArrayList; + +public class Group { + + private static int counter = 0; + private int id; + + @Override + public String toString() { + return "Group{" + + "id=" + id + + '}'; + } + + public Group() { + counter++; + id = counter; + students = new ArrayList<>(); + teachers = new ArrayList<>(); + } + + public void addStudent(Student student) { + students.add(student); + student.setGroup(this); + } + + public void addTeacher(Teacher teacher) { + teachers.add(teacher); + // TODO: 3/26/2020 set group on teacher + if (!teacher.getGroups().contains(this)) { + teacher.selectGroup(this); + } + } + + public Group(ArrayList students, ArrayList teachers) { + this.students = students; + this.teachers = teachers; + } + + public Group(ArrayList students) { + this.students = students; + } + + private ArrayList students; + private ArrayList teachers; + + public ArrayList getStudents() { + return students; + } + + public ArrayList getTeachers() { + return teachers; + } +} diff --git a/src/lesson5/persons/Student.java b/src/lesson5/persons/Student.java new file mode 100644 index 0000000..ede701d --- /dev/null +++ b/src/lesson5/persons/Student.java @@ -0,0 +1,38 @@ +package lesson5.persons; + +import java.util.ArrayList; + +public class Student { + + class Type { + int state; + } + + private String fio; + private Group group; + + public Student(String fio) { + this.fio = fio; + } + + public void showListOfMates() { + ArrayList mates = new ArrayList<>(group.getStudents()); + mates.remove(this); + System.out.println(mates); + } + + @Override + public String toString() { + return "Student{" + + "fio='" + fio + '\'' + + '}'; + } + + public void showListOfTeachers() { + System.out.println(group.getTeachers()); + } + + public void setGroup(Group group) { + this.group = group; + } +} diff --git a/src/lesson5/persons/Teacher.java b/src/lesson5/persons/Teacher.java new file mode 100644 index 0000000..d85817a --- /dev/null +++ b/src/lesson5/persons/Teacher.java @@ -0,0 +1,46 @@ +package lesson5.persons; + +import java.util.ArrayList; + +public class Teacher { + + private String fio; + private ArrayList groups; + + public Teacher(String fio) { + this.fio = fio; + groups = new ArrayList<>(); + } + + public void showGroupList() { + System.out.println(groups); + } + + public void showStudentListByGroup(Group group) { + if (groups.contains(group)) { + int groupPosition = groups.indexOf(group); + // a[pos] + System.out.println(group + " " + groups.get(groupPosition).getStudents()); + } + } + + @Override + public String toString() { + return "Teacher{" + + "fio='" + fio + '\'' + + '}'; + } + + public ArrayList getGroups() { + return groups; + } + + public void selectGroup(Group group) { + groups.add(group); + // TODO: 3/26/2020 add teacher to group + if (!group.getTeachers().contains(this)) { + group.addTeacher(this); + } + } + +} diff --git a/src/lesson5/persons/Test.java b/src/lesson5/persons/Test.java new file mode 100644 index 0000000..88ae371 --- /dev/null +++ b/src/lesson5/persons/Test.java @@ -0,0 +1,28 @@ +package lesson5.persons; + +public class Test { + public static void main(String[] args) { + Group g1 = new Group(); + Group g2 = new Group(); + Teacher t1 = new Teacher("Oleg Ivanovich"); + Teacher t2 = new Teacher("Aleksei Anatolievich"); + Student s1 = new Student("S1"); + Student s2 = new Student("S2"); + Student s3 = new Student("S3"); + Student s4 = new Student("S4"); + g1.addTeacher(t1); + g1.addTeacher(t2); + g1.addStudent(s1); + g1.addStudent(s2); + g2.addStudent(s3); + g2.addStudent(s4); + t1.selectGroup(g2); + t1.showGroupList(); + t1.showStudentListByGroup(g1); + t1.showStudentListByGroup(g2); + s2.showListOfMates(); + s2.showListOfTeachers(); + s4.showListOfMates(); + s4.showListOfTeachers(); + } +} diff --git a/src/lesson6/animals/Animal.java b/src/lesson6/animals/Animal.java new file mode 100644 index 0000000..e511344 --- /dev/null +++ b/src/lesson6/animals/Animal.java @@ -0,0 +1,61 @@ +package lesson6.animals; + +public abstract class Animal { + + private String color; + private String name; + private int age, stamina; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + + public int getStamina() { + return stamina; + } + + public void setStamina(int stamina) { + this.stamina = stamina; + } + + public void setColor(String color) { + this.color = color; + } + + public String getColor() { + return color; + } + + public Animal(String name) { + // this -> Cat + this.name = name; + age = 0; + stamina = 100; + } + + public void eat() { + stamina += 20; + } + + public void sleep() { + stamina = 100; + } + + public abstract void say(); + + public void jump() { + stamina--; + } +} diff --git a/src/lesson6/animals/Bengal.java b/src/lesson6/animals/Bengal.java new file mode 100644 index 0000000..09b06cc --- /dev/null +++ b/src/lesson6/animals/Bengal.java @@ -0,0 +1,15 @@ +package lesson6.animals; + +public class Bengal extends Cat { + + public Bengal(String name) { + super(name); + //cat this = bengal this + setColor("Orange"); + } + + @Override + public void eat() { + setStamina(getStamina() + 10); + } +} diff --git a/src/lesson6/animals/Bird.java b/src/lesson6/animals/Bird.java new file mode 100644 index 0000000..5f4344b --- /dev/null +++ b/src/lesson6/animals/Bird.java @@ -0,0 +1,14 @@ +package lesson6.animals; + +public class Bird extends Animal { + + public Bird(String name) { + super(name); + } + + @Override + public void say() { + System.out.println("CHIK CHIRIK"); + } + +} diff --git a/src/lesson6/animals/Cat.java b/src/lesson6/animals/Cat.java new file mode 100644 index 0000000..75e0a04 --- /dev/null +++ b/src/lesson6/animals/Cat.java @@ -0,0 +1,15 @@ +package lesson6.animals; + +public class Cat extends Animal { + + public Cat(String name) { + super(name); + // this -> Bengal + } + + //ctrl + O + @Override + public void say() { + System.out.println("MEOW"); + } +} diff --git a/src/lesson6/animals/Dog.java b/src/lesson6/animals/Dog.java new file mode 100644 index 0000000..880bcb0 --- /dev/null +++ b/src/lesson6/animals/Dog.java @@ -0,0 +1,14 @@ +package lesson6.animals; + +public class Dog extends Animal { + + public Dog(String name) { + super(name); + } + + @Override + public void say() { + System.out.println("WOW"); + } + +} diff --git a/src/lesson6/animals/Main.java b/src/lesson6/animals/Main.java new file mode 100644 index 0000000..e0f6563 --- /dev/null +++ b/src/lesson6/animals/Main.java @@ -0,0 +1,17 @@ +package lesson6.animals; + +import lesson6.ext.A; +import lesson6.ext.C; + +public class Main { + public static void main(String[] args) { + Cat cat = new Cat("Name"); + Animal cat1 = new Cat("Name1"); + Animal bengal = new Bengal("Sfinx"); + System.out.println(cat.getColor()); + System.out.println(bengal.getColor()); + A a = new C(1,2,3); + // cat.getName() = "3"; + // Cat cat2 = new Animal("Oleg"); + } +} diff --git a/src/lesson6/ext/A.java b/src/lesson6/ext/A.java new file mode 100644 index 0000000..980373b --- /dev/null +++ b/src/lesson6/ext/A.java @@ -0,0 +1,18 @@ +package lesson6.ext; + +public class A { + + int a; + + public A(int a) { + this.a = a; + System.out.println("A " + this); + } + + @Override + public String toString() { + return "A{" + + "a=" + a + + '}'; + } +} diff --git a/src/lesson6/ext/B.java b/src/lesson6/ext/B.java new file mode 100644 index 0000000..11b53c2 --- /dev/null +++ b/src/lesson6/ext/B.java @@ -0,0 +1,20 @@ +package lesson6.ext; + +public class B extends A { + + int b; + + public B(int a, int b) { + super(a); + this.b = b; + System.out.println("B" + this); + } + + @Override + public String toString() { + return "B{" + + "b=" + b + + ", a=" + a + + '}'; + } +} diff --git a/src/lesson6/ext/C.java b/src/lesson6/ext/C.java new file mode 100644 index 0000000..a17951e --- /dev/null +++ b/src/lesson6/ext/C.java @@ -0,0 +1,20 @@ +package lesson6.ext; + +public class C extends B { + + int c; + public C(int a, int b, int c) { + super(a, b); + this.c = c; + System.out.println("C" + this); + } + + @Override + public String toString() { + return "C{" + + "c=" + c + + ", b=" + b + + ", a=" + a + + '}'; + } +} diff --git a/src/lesson6/ext/Test.java b/src/lesson6/ext/Test.java new file mode 100644 index 0000000..01a1480 --- /dev/null +++ b/src/lesson6/ext/Test.java @@ -0,0 +1,17 @@ +package lesson6.ext; + +public class Test { + public static void main(String[] args) { + A a = new C(1,2,3); + Class c = a.getClass(); + while (true) { + System.out.println(c.getSimpleName()); + if (c.equals(Object.class)) { + System.out.println(c.getSuperclass()); + break; + } + c = c.getSuperclass(); + } + System.out.println(a); + } +} diff --git a/src/lesson6/interfaces/ConsoleLogger.java b/src/lesson6/interfaces/ConsoleLogger.java new file mode 100644 index 0000000..a02ba5b --- /dev/null +++ b/src/lesson6/interfaces/ConsoleLogger.java @@ -0,0 +1,9 @@ +package lesson6.interfaces; + +public class ConsoleLogger implements Logger { + + @Override + public void log(String tag, String message) { + System.out.println(tag + ": " + message); + } +} diff --git a/src/lesson6/interfaces/FileLogger.java b/src/lesson6/interfaces/FileLogger.java new file mode 100644 index 0000000..740fd69 --- /dev/null +++ b/src/lesson6/interfaces/FileLogger.java @@ -0,0 +1,55 @@ +package lesson6.interfaces; + +import java.io.*; + +public class FileLogger implements Logger { + + private String path; + private File out; + private PrintWriter printer; + + public FileLogger() { + path = "log.txt"; + out = new File(path); + if (!out.exists()) { + try { + out.createNewFile(); + printer = new PrintWriter(new FileOutputStream(out, true)); + } catch (IOException e) { + e.printStackTrace(); + } + } else { + try { + printer = new PrintWriter(new FileOutputStream(out, true)); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + } + + } + + public FileLogger(String path) { + this.path = path; + out = new File(path); + if (!out.exists()) { + try { + out.createNewFile(); + printer = new PrintWriter(new FileOutputStream(out, true)); + } catch (IOException e) { + e.printStackTrace(); + } + } else { + try { + printer = new PrintWriter(new FileOutputStream(out, true)); + } catch (FileNotFoundException e) { + e.printStackTrace(); + } + } + } + + @Override + public void log(String tag, String message) { + printer.println(tag + ": " + message); + printer.flush(); + } +} diff --git a/src/lesson6/interfaces/Logger.java b/src/lesson6/interfaces/Logger.java new file mode 100644 index 0000000..38838ed --- /dev/null +++ b/src/lesson6/interfaces/Logger.java @@ -0,0 +1,5 @@ +package lesson6.interfaces; + +public interface Logger { + void log(String tag, String message); +} diff --git a/src/lesson6/interfaces/Main.java b/src/lesson6/interfaces/Main.java new file mode 100644 index 0000000..324efaf --- /dev/null +++ b/src/lesson6/interfaces/Main.java @@ -0,0 +1,8 @@ +package lesson6.interfaces; + +public class Main { + public static void main(String[] args) { + Logger log = new FileLogger(); + log.log("test", "message1"); + } +} diff --git a/src/lesson6/interfaces/ReadWriter.java b/src/lesson6/interfaces/ReadWriter.java new file mode 100644 index 0000000..733fb89 --- /dev/null +++ b/src/lesson6/interfaces/ReadWriter.java @@ -0,0 +1,23 @@ +package lesson6.interfaces; + +// SoLid +// Liskov substitution FAIL +// Single response +// Bad example +public class ReadWriter implements Reader, Writer { + + @Override + public int read() { + return 0; + } + + @Override + public void write(int value) { + + } + + public static void main(String[] args) { + Writer writer = new ReadWriter(); + Reader reader = new ReadWriter(); + } +} diff --git a/src/lesson6/interfaces/Reader.java b/src/lesson6/interfaces/Reader.java new file mode 100644 index 0000000..13faf77 --- /dev/null +++ b/src/lesson6/interfaces/Reader.java @@ -0,0 +1,5 @@ +package lesson6.interfaces; + +public interface Reader { + int read(); +} diff --git a/src/lesson6/interfaces/Writer.java b/src/lesson6/interfaces/Writer.java new file mode 100644 index 0000000..78ba99a --- /dev/null +++ b/src/lesson6/interfaces/Writer.java @@ -0,0 +1,5 @@ +package lesson6.interfaces; + +public interface Writer { + void write(int value); +} diff --git a/src/lesson6/values/AbstractParameter.java b/src/lesson6/values/AbstractParameter.java new file mode 100644 index 0000000..3f0ed9f --- /dev/null +++ b/src/lesson6/values/AbstractParameter.java @@ -0,0 +1,14 @@ +package lesson6.values; + +public class AbstractParameter { + + private T value; + + public T getValue() { + return value; + } + + public void setValue(T value) { + this.value = value; + } +} diff --git a/src/lesson6/values/Main.java b/src/lesson6/values/Main.java new file mode 100644 index 0000000..693bd74 --- /dev/null +++ b/src/lesson6/values/Main.java @@ -0,0 +1,46 @@ +package lesson6.values; + +import java.util.ArrayList; +import java.util.List; + +public class Main { + + List parameterList = new ArrayList<>(); + + public void addToParamList(AbstractParameter parameter) { + parameterList.add(parameter); + } + + public void setParamValue(AbstractParameter param, Object value) { + parameterList.get(parameterList.indexOf(param)).setValue(value); + } + + public void showAllParamValues() { + for(AbstractParameter parameter : parameterList) { + System.out.println(parameter.getValue()); + } + } + + public static T funcName(T param) { + return param; + } + + public static void main(String[] args) { + funcName("new ArrayList<>()"); + List list = new ArrayList<>(); + list.add("123"); list.add("124"); + AbstractParameter parameter = new MultipleTextParameter(list); + System.out.println(parameter.getValue().getClass()); + parameter.setValue(list); + System.out.println(parameter.getValue()); + parameter.setValue(1); + AbstractParameter parameter1 = new SingleTextParameter("123"); + System.out.println(parameter1.getValue()); + Main main = new Main(); + main.addToParamList(parameter); + main.addToParamList(parameter1); + main.setParamValue(parameter1, "New String"); + main.showAllParamValues(); + //System.out.println(); + } +} diff --git a/src/lesson6/values/MultipleTextParameter.java b/src/lesson6/values/MultipleTextParameter.java new file mode 100644 index 0000000..7047c3a --- /dev/null +++ b/src/lesson6/values/MultipleTextParameter.java @@ -0,0 +1,10 @@ +package lesson6.values; + +import java.util.List; + +public class MultipleTextParameter extends AbstractParameter{ + + public MultipleTextParameter(List values) { + setValue(values); + } +} diff --git a/src/lesson6/values/SingleTextParameter.java b/src/lesson6/values/SingleTextParameter.java new file mode 100644 index 0000000..e9de80d --- /dev/null +++ b/src/lesson6/values/SingleTextParameter.java @@ -0,0 +1,9 @@ +package lesson6.values; + +public class SingleTextParameter extends AbstractParameter { + + public SingleTextParameter(String value) { + setValue(value); + } + +} diff --git a/src/lesson7/Cat.java b/src/lesson7/Cat.java new file mode 100644 index 0000000..abe14bc --- /dev/null +++ b/src/lesson7/Cat.java @@ -0,0 +1,27 @@ +package lesson7; + +public class Cat { + + private String name; + private boolean hunger = false; + private int appetite; + public Cat(String name, int appetite) { + this.name = name; + this.appetite = appetite; + } + public void eat(Plate p) { + if(appetite< p.food) { + p.decreaseFood(appetite); + hunger = true; + } + } + public void HungerInfo(){ + if(hunger){ + System.out.println("Котик сыт"); + } + else { + System.out.println("Котик голоден"); + } + } + +} diff --git a/src/lesson7/Example1.java b/src/lesson7/Example1.java new file mode 100644 index 0000000..3e3c759 --- /dev/null +++ b/src/lesson7/Example1.java @@ -0,0 +1,29 @@ +package lesson7; + +public class Example1 { + + public static void main(String[] args) { + + class A { + int a; + } + + class B extends A{ + + } + + A a = new B(); + System.out.println(a.getClass()); + // a.a; a принадлежит В!!! + foo(1L); + // OOP!!! + // Stream_API + // + lambda + // SQL, NoSQL (Mongo, Firebase) + // concurrent + } + + static void foo(Object object) { + System.out.println(object.getClass()); + } +} diff --git a/src/lesson7/InnerClassFabric.java b/src/lesson7/InnerClassFabric.java new file mode 100644 index 0000000..4ea6985 --- /dev/null +++ b/src/lesson7/InnerClassFabric.java @@ -0,0 +1,43 @@ +package lesson7; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +public class InnerClassFabric { + + private int a; + + static public InnerClass1 getInnerClass1Instance(int a) { + return new InnerClass1(a); + } + + static public InnerClass2 getInnerClass2Instance(int a) { + return new InnerClass2(a); + } + + private static class InnerClass1 { + int b; + + private InnerClass1(int b) { + // a = 3; + this.b = b; + } + } + + private static class InnerClass2 { + int b; + + private InnerClass2(int b) { + // a = 3; + this.b = b; + } + } + + public static void main(String[] args) { + // InnerClassFabric outerClass = new InnerClassFabric(1); + // InnerClassFabric.InnerClass innerClass = outerClass.new InnerClass(2); + InnerClass1 instance = InnerClassFabric.getInnerClass1Instance(5); + + } + +} diff --git a/src/lesson7/MainClass.java b/src/lesson7/MainClass.java new file mode 100644 index 0000000..c77de4e --- /dev/null +++ b/src/lesson7/MainClass.java @@ -0,0 +1,15 @@ +package lesson7; +public class MainClass { + + public static void main(String[] args) { + Plate plate = new Plate(100); + Cat[] cat = new Cat[28]; + for (int i = 0; i < 28; i++) { + cat[i] = new Cat("Barsik", (int)(Math.random()*10)); + cat[i].eat(plate); + System.out.print(i+")"); + cat[i].HungerInfo(); + } + } + +} diff --git a/src/lesson7/PerformanceTest.java b/src/lesson7/PerformanceTest.java new file mode 100644 index 0000000..7ba356f --- /dev/null +++ b/src/lesson7/PerformanceTest.java @@ -0,0 +1,31 @@ +package lesson7; + +public class PerformanceTest { + + public static void stringPerformance() { + String s = ""; + for (int i = 0; i < 100000; i++) { + s += 'a'; + } + } + + public static void stringBuilderPerformance() { + StringBuilder s = new StringBuilder(); + s.insert(4, "asfasg"); + s.append("sagasg"); + for (int i = 0; i < 100000; i++) { + s.append('a'); + } + } + + public static void main(String[] args) { + long start = System.currentTimeMillis(); + stringPerformance(); + long end = System.currentTimeMillis(); + System.out.println(end - start + "ms."); + start = System.currentTimeMillis(); + stringBuilderPerformance(); + end = System.currentTimeMillis(); + System.out.println(end - start + "ms."); + } +} diff --git a/src/lesson7/Plate.java b/src/lesson7/Plate.java new file mode 100644 index 0000000..8308d3d --- /dev/null +++ b/src/lesson7/Plate.java @@ -0,0 +1,18 @@ +package lesson7; + +public class Plate { + public int food; + public Plate(int food) { + this.food = food; + } + public void decreaseFood(int n) { + food -= n; + } + public void increaseFood(int n){ + food +=n; + } + public void info() { + System.out.println("plate: " + food); + } + +} diff --git a/src/lesson7/StringCompressor.java b/src/lesson7/StringCompressor.java new file mode 100644 index 0000000..2c210a8 --- /dev/null +++ b/src/lesson7/StringCompressor.java @@ -0,0 +1,100 @@ +package lesson7; + +public class StringCompressor { + + private String data, compressedData; + + public StringCompressor(String data) { + this.data = data; + compressedData = data; + } + + public String decompress(String compressedString) { + // a135(f)4(r) если цифр более 1 то число надо собрать + // 1) d = ""; d = "5" + d; 135 если не цифра, то число собрано + // + char[] c = compressedString.toCharArray(); + StringBuilder value = new StringBuilder(); + StringBuilder result = new StringBuilder(); + for (int i = 0; i < c.length; i++) { + if (Character.isDigit(c[i])) { + value.append(c[i]); + } else { + if (c[i] == '(') { + //123(sym) + int len = Integer.parseInt(value.toString()); + char sym = c[i + 1]; + for (int j = 0; j < len; j++) { + result.append(sym); + } + i += 2; + value = new StringBuilder(); + } else { + result.append(c[i]); + } + } + } + return result.toString(); + } + + public String compress() { + // abc -> 1(a)2(b)3(c), abbc -> a2(b)c + // посчитаем подряд идущие одинаковые буквы + char[] chars = data.toCharArray(); + int cnt = 1; + char sym = ' '; + StringBuilder cD = new StringBuilder(); + for (int i = 0; i < chars.length - 1; i++) { + if (chars[i] == chars[i + 1]) { // ArrayIndexOut + sym = chars[i]; + cnt++; + if (i == chars.length - 2) { + cD.append(cnt) + .append('(') + .append(sym) + .append(')'); + } + } else { + if (cnt > 1) { + // cnt(sym) + cD.append(cnt) + .append('(') + .append(sym) + .append(')'); + cnt = 1; + } else { + // chars[i] + cD.append(chars[i]); + cnt = 1; + } + } + } + if (chars.length <= 1) { + return data; + } else if (chars[chars.length - 1] != chars[chars.length - 2]) { + cD.append(chars[chars.length - 1]); + } + return cD.toString(); + } + + public boolean isGood() { + return compressedData.length() < data.length(); + } + + public static void main(String[] args) { + System.out.println( + new StringCompressor("aaaaaaacccdfffff") + .compress()); + System.out.println( + new StringCompressor("aabbcc") + .compress()); + System.out.println( + new StringCompressor("abcdeeefffffggrgrgrggr") + .compress()); + StringCompressor compressor = new StringCompressor("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); + System.out.println(compressor.compress()); + System.out.println(compressor.isGood()); + System.out.println(compressor.decompress("15(e)6(f)x")); + } + +} diff --git a/src/lesson7/StringExamples.java b/src/lesson7/StringExamples.java new file mode 100644 index 0000000..f812d2c --- /dev/null +++ b/src/lesson7/StringExamples.java @@ -0,0 +1,22 @@ +package lesson7; + +import java.util.Arrays; + +public class StringExamples { + public static void main(String[] args) { + String s = "mama mil;a ramU!!!!"; + // [mama, mila, ramu] + s = s.toLowerCase() + .replaceAll("[^a-z ]", ""); + System.out.println(s); + String [] words = s.split(" +"); + System.out.println(Arrays.toString(words)); + System.out.println(Arrays.toString("abc, cde, efg".split(", +"))); + System.out.println("aaaabcdbcd".indexOf("bcd")); + System.out.println("aaaabcdbcd".lastIndexOf("bcd")); + System.out.println("aaaabcdbcd".indexOf("bcde")); + System.out.println("123@gmail.com".matches("[a-zA-Z0-9]+@{1}[a-zA-Z0-9]+\\.[a-zA-Z0-9]+")); + + + } +} diff --git a/src/lesson8/ListenerTest.java b/src/lesson8/ListenerTest.java new file mode 100644 index 0000000..4bcbf16 --- /dev/null +++ b/src/lesson8/ListenerTest.java @@ -0,0 +1,52 @@ +package lesson8; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.*; + +public class ListenerTest extends JFrame { + public ListenerTest() throws HeadlessException { + setDefaultCloseOperation(EXIT_ON_CLOSE); + setLocation(500, 400); + setSize(300, 300); + setResizable(false); + JPanel panel = new JPanel(new GridLayout(3, 3)); + JTextArea txt = new JTextArea(); + JButton btn = new JButton(); + JCheckBox chk = new JCheckBox("in upper case"); + JLabel lbl = new JLabel(); + addMouseListener(new MouseAdapter() { + @Override + public void mousePressed(MouseEvent e) { + System.out.println(e); + } + }); + txt.addKeyListener(new KeyAdapter() { + @Override + public void keyPressed(KeyEvent e) { + int symbolCount = txt.getText().length(); + lbl.setText(String.valueOf(symbolCount)); + } + }); + chk.addActionListener(actionEvent -> { + lbl.setText(""); + System.out.println(chk.isSelected()); + System.out.println(actionEvent.paramString()); + }); + btn.addActionListener(action -> { + if (chk.isSelected()) { + lbl.setText(txt.getText().toUpperCase()); + } else { + lbl.setText(txt.getText()); + } + }); + panel.add(txt); panel.add(btn); + panel.add(chk); panel.add(lbl); + add(panel); + setVisible(true); + } + + public static void main(String[] args) { + new ListenerTest(); + } +} diff --git a/src/lesson8/Window.java b/src/lesson8/Window.java new file mode 100644 index 0000000..0db6b7c --- /dev/null +++ b/src/lesson8/Window.java @@ -0,0 +1,110 @@ +package lesson8; + +import javax.swing.*; +import java.awt.*; + +public class Window extends JFrame { + + private JPanel getPanelWithBorderLayout() { + JPanel panel = new JPanel(new BorderLayout()); + panel.add(new JButton("OK"), BorderLayout.WEST); + panel.add(new JTextArea(), BorderLayout.CENTER); + panel.add(new JButton("OK"), BorderLayout.EAST); + panel.add(new JButton("OK"), BorderLayout.NORTH); + panel.add(new JButton("OK"), BorderLayout.SOUTH); + return panel; + } + + public JPanel getPanelWithFlowLayout() { + JPanel panel = new JPanel(new FlowLayout()); + panel.add(new JButton("OK")); + panel.add(new JTextArea("asfasgasgasg")); + panel.add(new JButton("OK")); + panel.add(new JButton("OK")); + panel.add(new JButton("OK")); + return panel; + } + + public JPanel getPanelWithGridLayout(int row, int col) { + JPanel panel = new JPanel(new GridLayout(row, col)); + panel.add(new JButton("OK")); + panel.add(new JTextArea("asfasgasgasg")); + panel.add(new JButton("OK")); + panel.add(new JButton("OK")); + panel.add(new JButton("OK")); + return panel; + } + + private final ImageIcon imageX = new ImageIcon("src/lesson8/x.jpg"); + private final ImageIcon imageO = new ImageIcon("src/lesson8/o.jpg"); + private final ImageIcon imageEmpty = new ImageIcon("src/lesson8/empty.jpg"); + private int cnt = 0; + + public Window() throws HeadlessException { + setDefaultCloseOperation(EXIT_ON_CLOSE); + setLocation(500, 400); + setSize(300, 300); + setResizable(false); + JPanel panel = new JPanel(new GridLayout(3, 3)); + JButton[][] buttons = new JButton[3][3]; + System.out.println(imageX); + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + buttons[i][j] = new JButton(); + buttons[i][j].setIcon(imageEmpty); + JButton copy = buttons[i][j]; + copy.addActionListener(action -> { + copy.setIcon(imageX); + copy.setEnabled(false); + cnt++; + copy.setDisabledIcon(imageX); + movePC(buttons); + if (cnt == 9) { + JFrame alert = new JFrame("кто то победил или ничья"); + alert.setLocation(500, 400); + alert.setSize(300, 100); + JPanel alertPanel = new JPanel(new FlowLayout()); + JButton newGame = new JButton("new game"); + newGame.addActionListener(a -> { + this.dispose(); + new Window(); + alert.dispose(); + }); + JButton close = new JButton("close"); + close.addActionListener(a -> { + dispose(); + alert.dispose(); + }); + alertPanel.add(newGame); + alertPanel.add(close); + alert.add(alertPanel); + alert.setResizable(false); + alert.setVisible(true); + } + }); + panel.add(buttons[i][j]); + } + } + add(panel); + setVisible(true); + } + + private void movePC(JButton[][] buttons) { + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 3; j++) { + if (buttons[i][j].isEnabled()) { + buttons[i][j].setIcon(imageO); + buttons[i][j].setEnabled(false); + buttons[i][j].setDisabledIcon(imageO); + cnt++; + return; + } + } + } + } + + public static void main(String[] args) { + /* Window win = */ + new Window(); + } +} diff --git a/src/lesson8/empty.jpg b/src/lesson8/empty.jpg new file mode 100644 index 0000000..ac3826d Binary files /dev/null and b/src/lesson8/empty.jpg differ diff --git a/src/lesson8/o.jpg b/src/lesson8/o.jpg new file mode 100644 index 0000000..09b5af7 Binary files /dev/null and b/src/lesson8/o.jpg differ diff --git a/src/lesson8/x.jpg b/src/lesson8/x.jpg new file mode 100644 index 0000000..01a89c8 Binary files /dev/null and b/src/lesson8/x.jpg differ diff --git a/test.java b/test.java new file mode 100644 index 0000000..8303cf7 --- /dev/null +++ b/test.java @@ -0,0 +1,6 @@ +public class test { + public static void main(String[] args) { + Cat cat = new Cat("Vaska"); + cat.jump(1); + } +}