diff --git a/task01/src/com/example/task01/Level.java b/task01/src/com/example/task01/Level.java new file mode 100644 index 00000000..ca6f18ba --- /dev/null +++ b/task01/src/com/example/task01/Level.java @@ -0,0 +1,8 @@ +package com.example.task01; + +public enum Level { + DEBUG, + INFO, + WARNING, + ERROR +} diff --git a/task01/src/com/example/task01/Logger.java b/task01/src/com/example/task01/Logger.java new file mode 100644 index 00000000..3036b0a8 --- /dev/null +++ b/task01/src/com/example/task01/Logger.java @@ -0,0 +1,81 @@ +package com.example.task01; + +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.HashMap; + +public class Logger { + private static HashMap loggers = new HashMap(); + private final String name; + private Level currentLevel = Level.DEBUG; + private final SimpleDateFormat formatter = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss"); + + public String getName() { + return name; + } + + public Level getLevel() { + return currentLevel; + } + + public void setLevel(Level level) { + currentLevel = level; + } + + public Logger(String name) { + this.name = name; + loggers.put(name, this); + } + + public static Logger getLogger(String name) { + if (loggers.get(name) == null) + new Logger(name); + return loggers.get(name); + } + + public void log(Level level, String message) { + if (level.ordinal() < currentLevel.ordinal()) + return; + Date date = new Date(); + String formattedMessage = String.format("[%s] %s %s - %s", level, formatter.format(date), name, message); + System.out.println(formattedMessage); + } + + public void log(Level level, String pattern, Object... args) { + if (args.length == 0) + throw new IllegalArgumentException("Количество аргументов не может равняться нулю!"); + log(level, String.format(pattern, args)); + } + + public void debug(String message) { + log(Level.DEBUG, message); + } + + public void debug(String pattern, Object... args) { + log(Level.DEBUG, pattern, args); + } + + public void info(String message) { + log(Level.INFO, message); + } + + public void info(String pattern, Object... args) { + log(Level.INFO, pattern, args); + } + + public void warning(String message) { + log(Level.WARNING, message); + } + + public void warning(String pattern, Object... args) { + log(Level.WARNING, pattern, args); + } + + public void error(String message) { + log(Level.ERROR, message); + } + + public void error(String pattern, Object... args) { + log(Level.ERROR, pattern, args); + } +} diff --git a/task01/src/com/example/task01/Task01Main.java b/task01/src/com/example/task01/Task01Main.java index 9973557d..7e73be05 100644 --- a/task01/src/com/example/task01/Task01Main.java +++ b/task01/src/com/example/task01/Task01Main.java @@ -2,6 +2,7 @@ public class Task01Main { public static void main(String[] args) { - + Logger logger1 = new Logger("test1"); + Logger logger2 = new Logger("test2"); } } diff --git a/task02/src/com/example/task02/DiscountBill.java b/task02/src/com/example/task02/DiscountBill.java new file mode 100644 index 00000000..2e729f70 --- /dev/null +++ b/task02/src/com/example/task02/DiscountBill.java @@ -0,0 +1,23 @@ +package com.example.task02; + +public class DiscountBill extends Bill { + private final int discountPercent; + + public DiscountBill(int discountPercent) { + if (discountPercent < 0 || discountPercent > 100) + throw new IllegalArgumentException("Скидка должна быть от 0% до 100%!"); + this.discountPercent = discountPercent; + } + public int getDiscountPercent() { + return discountPercent; + } + + public long getAbsoluteDiscount() { + return super.getPrice() * discountPercent / 100; + } + + @Override + public long getPrice() { + return super.getPrice() - getAbsoluteDiscount(); + } +} diff --git a/task02/src/com/example/task02/Task02Main.java b/task02/src/com/example/task02/Task02Main.java index e589f2d3..6d8bea1c 100644 --- a/task02/src/com/example/task02/Task02Main.java +++ b/task02/src/com/example/task02/Task02Main.java @@ -17,5 +17,12 @@ public static void main(String[] args) { System.out.println(bill); bill.add(ITEM3, 3); System.out.println(bill); + + Bill discountBill = new DiscountBill(10); + discountBill.add(ITEM1, 10); + discountBill.add(ITEM3, 3); + discountBill.add(ITEM6, 1); + discountBill.add(ITEM3, 3); + System.out.println(discountBill); } } diff --git a/task03/src/com/example/task03/Hours.java b/task03/src/com/example/task03/Hours.java new file mode 100644 index 00000000..0676e035 --- /dev/null +++ b/task03/src/com/example/task03/Hours.java @@ -0,0 +1,30 @@ +package com.example.task03; + +public class Hours implements TimeUnit { + + private final long amount; + + public Hours(long amount) { + this.amount = amount; + } + + @Override + public long toMillis() { + return amount * 60 * 60 * 1000; + } + + @Override + public long toSeconds() { + return amount * 60 * 60; + } + + @Override + public long toMinutes() { + return amount * 60; + } + + @Override + public long toHours() { + return amount; + } +} diff --git a/task03/src/com/example/task03/Milliseconds.java b/task03/src/com/example/task03/Milliseconds.java index 5115bc7d..799e7e7a 100644 --- a/task03/src/com/example/task03/Milliseconds.java +++ b/task03/src/com/example/task03/Milliseconds.java @@ -18,11 +18,16 @@ public long toMillis() { @Override public long toSeconds() { - return amount / 1000; + return Math.round((double) amount / 1000); } @Override public long toMinutes() { - return amount / 1000 * 60; + return Math.round((double) amount / 1000 / 60); + } + + @Override + public long toHours() { + return Math.round((double)amount / 1000 / 60 / 60); } } diff --git a/task03/src/com/example/task03/Minutes.java b/task03/src/com/example/task03/Minutes.java index d6fa0594..cc7340cc 100644 --- a/task03/src/com/example/task03/Minutes.java +++ b/task03/src/com/example/task03/Minutes.java @@ -2,26 +2,29 @@ public class Minutes implements TimeUnit { + private final long amount; + public Minutes(long amount) { - // TODO: реализовать - throw new UnsupportedOperationException(); + this.amount = amount; } @Override public long toMillis() { - // TODO: реализовать - throw new UnsupportedOperationException(); + return amount * 60 * 1000; } @Override public long toSeconds() { - // TODO: реализовать - throw new UnsupportedOperationException(); + return amount * 60; } @Override public long toMinutes() { - // TODO: реализовать - throw new UnsupportedOperationException(); + return amount; + } + + @Override + public long toHours() { + return Math.round((double)amount / 60); } } diff --git a/task03/src/com/example/task03/Seconds.java b/task03/src/com/example/task03/Seconds.java index ce6bc213..57af7ac5 100644 --- a/task03/src/com/example/task03/Seconds.java +++ b/task03/src/com/example/task03/Seconds.java @@ -23,6 +23,11 @@ public long toSeconds() { @Override public long toMinutes() { - return Math.round(amount / 60); + return Math.round((double)amount / 60); + } + + @Override + public long toHours() { + return Math.round((double)amount / 60 / 60); } } diff --git a/task03/src/com/example/task03/Task03Main.java b/task03/src/com/example/task03/Task03Main.java index ff0f14b0..93cd74ef 100644 --- a/task03/src/com/example/task03/Task03Main.java +++ b/task03/src/com/example/task03/Task03Main.java @@ -2,7 +2,7 @@ public class Task03Main { public static void main(String[] args) { - TimeUnit unit1 = new Seconds(1000); + TimeUnit unit1 = new Milliseconds(1000); printTimeUnit(unit1); } @@ -10,5 +10,6 @@ private static void printTimeUnit(TimeUnit unit) { System.out.println(String.format("Milliseconds: %d", unit.toMillis())); System.out.println(String.format("Seconds: %d", unit.toSeconds())); System.out.println(String.format("Minutes: %d", unit.toMinutes())); + System.out.println(String.format("Hours: %d", unit.toHours())); } } diff --git a/task03/src/com/example/task03/TimeUnit.java b/task03/src/com/example/task03/TimeUnit.java index 3b123fb8..bf03dcd8 100644 --- a/task03/src/com/example/task03/TimeUnit.java +++ b/task03/src/com/example/task03/TimeUnit.java @@ -28,4 +28,11 @@ public interface TimeUnit { */ long toMinutes(); + /** + * Возвращает продолжительность текущего интервала, пересчитанного в часах. + * При необходимости округлять по обычным правилам округления (число, меньшее 0.5 переходит в 0, большее или равное - в 1) + * + * @return количество часов в текущем интервале + */ + long toHours(); } diff --git a/task03/src/com/example/task03/TimeUnitUtils.java b/task03/src/com/example/task03/TimeUnitUtils.java index 790f8850..0276b6f9 100644 --- a/task03/src/com/example/task03/TimeUnitUtils.java +++ b/task03/src/com/example/task03/TimeUnitUtils.java @@ -6,7 +6,37 @@ public class TimeUnitUtils { /** - * Конвертирует интервал в секундах в интервал в миллисекундах + * Конвертирует интервал в миллисекундах в интервал в секундах. + * + * @param millis интервал в миллисекундах + * @return интервал в секундах + */ + public static Seconds toSeconds(Milliseconds millis) { + return new Seconds(millis.toSeconds()); + } + + /** + * Конвертирует интервал в миллисекундах в интервал в минутах. + * + * @param millis интервал в миллисекундах + * @return интервал в минутах + */ + public static Minutes toMinutes(Milliseconds millis) { + return new Minutes(millis.toMinutes()); + } + + /** + * Конвертирует интервал в миллисекундах в интервал в часах. + * + * @param millis интервал в миллисекундах + * @return интервал в часах + */ + public static Hours toHours(Milliseconds millis) { + return new Hours(millis.toHours()); + } + + /** + * Конвертирует интервал в секундах в интервал в миллисекундах. * * @param seconds интервал в секундах * @return интервал в миллисекундах @@ -16,12 +46,82 @@ public static Milliseconds toMillis(Seconds seconds) { } /** - * Конвертирует интервал в миллисекундах в интервал в секундах + * Конвертирует интервал в секундах в интервал в минутах. * - * @param millis интервал в миллисекундах + * @param seconds интервал в секундах + * @return интервал в минутах + */ + public static Minutes toMinutes(Seconds seconds) { + return new Minutes(seconds.toMinutes()); + } + + /** + * Конвертирует интервал в секундах в интервал в часах. + * + * @param seconds интервал в секундах + * @return интервал в часах + */ + public static Hours toHours(Seconds seconds) { + return new Hours(seconds.toHours()); + } + + /** + * Конвертирует интервал в минутах в интервал в миллисекундах. + * + * @param minutes интервал в минутах + * @return интервал в миллисекундах + */ + public static Milliseconds toMillis(Minutes minutes) { + return new Milliseconds(minutes.toMillis()); + } + + /** + * Конвертирует интервал в минутах в интервал в секундах. + * + * @param minutes интервал в минутах * @return интервал в секундах */ - public static Seconds toSeconds(Milliseconds millis) { - return new Seconds(millis.toSeconds()); + public static Seconds toSeconds(Minutes minutes) { + return new Seconds(minutes.toSeconds()); + } + + /** + * Конвертирует интервал в минутах в интервал в часах. + * + * @param minutes интервал в минутах + * @return интервал в часах + */ + public static Hours toHours(Minutes minutes) { + return new Hours(minutes.toHours()); + } + + /** + * Конвертирует интервал в часах в интервал в миллисекундах. + * + * @param hours интервал в часах + * @return интервал в миллисекундах + */ + public static Milliseconds toMillis(Hours hours) { + return new Milliseconds(hours.toMillis()); + } + + /** + * Конвертирует интервал в часах в интервал в секундах. + * + * @param hours интервал в часах + * @return интервал в секундах + */ + public static Seconds toSeconds(Hours hours) { + return new Seconds(hours.toSeconds()); + } + + /** + * Конвертирует интервал в часах в интервал в минутах. + * + * @param hours интервал в часах + * @return интервал в минутах + */ + public static Minutes toMinutes(Hours hours) { + return new Minutes(hours.toMinutes()); } } diff --git a/task04/src/com/example/task04/ConsoleHandler.java b/task04/src/com/example/task04/ConsoleHandler.java new file mode 100644 index 00000000..d543bc2e --- /dev/null +++ b/task04/src/com/example/task04/ConsoleHandler.java @@ -0,0 +1,8 @@ +package com.example.task04; + +public class ConsoleHandler implements MessageHandler{ + @Override + public void handle(String message) { + System.out.println(message); + } +} diff --git a/task04/src/com/example/task04/FileHandler.java b/task04/src/com/example/task04/FileHandler.java new file mode 100644 index 00000000..d04b92b7 --- /dev/null +++ b/task04/src/com/example/task04/FileHandler.java @@ -0,0 +1,41 @@ +package com.example.task04; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; + +public class FileHandler implements MessageHandler { + private String name = "log.txt"; + private String directory = new java.io.File(".").getAbsolutePath(); + private File file; + + public void setName(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + public void setDirectory(String directory) { + this.directory = directory; + } + + public String getDirectory() { + return directory; + } + + private File getFile() { + return new File(directory, name); + } + + @Override + public void handle(String message) { + try (FileWriter writer = new FileWriter(getFile(), true)) { + writer.write(message + "\n"); + System.out.println("Сообщение успешно записано в файл!"); + } catch (IOException e) { + System.out.println(e.getMessage()); + } + } +} diff --git a/task04/src/com/example/task04/Level.java b/task04/src/com/example/task04/Level.java new file mode 100644 index 00000000..277816f3 --- /dev/null +++ b/task04/src/com/example/task04/Level.java @@ -0,0 +1,8 @@ +package com.example.task04; + +public enum Level { + DEBUG, + INFO, + WARNING, + ERROR +} diff --git a/task04/src/com/example/task04/Logger.java b/task04/src/com/example/task04/Logger.java new file mode 100644 index 00000000..fea4dc54 --- /dev/null +++ b/task04/src/com/example/task04/Logger.java @@ -0,0 +1,126 @@ +package com.example.task04; + +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.HashMap; + +public class Logger { + private final String name; + private Level currentLevel = Level.DEBUG; + private static final HashMap loggers = new HashMap(); + private final ArrayList handlers = new ArrayList(); + private final SimpleDateFormat formatter = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss"); + + public String getName() { + return name; + } + + public Level getLevel() { + return currentLevel; + } + + public void setLevel(Level level) { + currentLevel = level; + } + + public void addHandler(MessageHandler handler) { + for (MessageHandler h : handlers) { + if (h.getClass().equals(handler.getClass())) + throw new IllegalArgumentException(String.format("Обработчик %s уже существует!", handler.getClass().getSimpleName())); + } + + handlers.add(handler); + } + + public void addHandler(MessageHandler... handlers) { + if (handlers.length == 0) + throw new NullPointerException("Количество аргументов не должно равняться нулю!"); + + for (MessageHandler handler : handlers) { + addHandler(handler); + } + } + + public void removeHandler(MessageHandler handler) { + if (handlers.isEmpty()) + throw new NullPointerException("Список обработчиков пуст!"); + + boolean removed = handlers.removeIf(h -> h.getClass().equals(handler.getClass())); + + if (!removed) + throw new IllegalArgumentException("Такого обработчика нет в списке!"); + } + + public void getHandlers() { + if (handlers.isEmpty()) + System.out.println("Список обработчиков пуст"); + + for (MessageHandler handler : handlers) { + System.out.println(handler.getClass().getSimpleName()); + } + } + + public Logger(String name) { + this.name = name; + loggers.put(name, this); + } + + public static Logger getLogger(String name) { + if (loggers.get(name) == null) + new Logger(name); + return loggers.get(name); + } + + public void log(Level level, String message) { + if (handlers.isEmpty()) + throw new NullPointerException("Список обработчиков пуст!"); + if (level.ordinal() < currentLevel.ordinal()) + return; + + Date date = new Date(); + String formattedMessage = String.format("[%s] %s %s - %s", level, formatter.format(date), name, message); + + for (MessageHandler handler : handlers) { + handler.handle(formattedMessage); + } + } + + public void log(Level level, String pattern, Object... args) { + if (args.length == 0) + throw new IllegalArgumentException("Количество аргументов не может равняться нулю!"); + log(level, String.format(pattern, args)); + } + + public void debug(String message) { + log(Level.DEBUG, message); + } + + public void debug(String pattern, Object... args) { + log(Level.DEBUG, pattern, args); + } + + public void info(String message) { + log(Level.INFO, message); + } + + public void info(String pattern, Object... args) { + log(Level.INFO, pattern, args); + } + + public void warning(String message) { + log(Level.WARNING, message); + } + + public void warning(String pattern, Object... args) { + log(Level.WARNING, pattern, args); + } + + public void error(String message) { + log(Level.ERROR, message); + } + + public void error(String pattern, Object... args) { + log(Level.ERROR, pattern, args); + } +} diff --git a/task04/src/com/example/task04/MemoryHandler.java b/task04/src/com/example/task04/MemoryHandler.java new file mode 100644 index 00000000..dece3d79 --- /dev/null +++ b/task04/src/com/example/task04/MemoryHandler.java @@ -0,0 +1,54 @@ +package com.example.task04; + +import java.util.ArrayList; + +public class MemoryHandler implements MessageHandler{ + private ArrayList buffer = new ArrayList(); + private int sizeMaxLimit = Integer.MAX_VALUE; + private MessageHandler handler; + + public MemoryHandler(MessageHandler handler) { + if (handler.getClass().equals(this.getClass())) + throw new IllegalArgumentException("Обработчик не может вызывать сам себя!"); + + this.handler = handler; + } + + public void setHandler(MessageHandler handler) { + this.handler = handler; + } + + public void setSizeMaxLimit(int sizeMaxLimit) { + this.sizeMaxLimit = sizeMaxLimit; + + if (sizeMaxLimit <= buffer.size()) { + getLogs(sizeMaxLimit); + } + } + + public void getLogs() { + for (String message : buffer) { + handler.handle(message); + } + buffer.clear(); + } + + private void getLogs(int limit) { + for (int i = 0; i < limit; i++) { + handler.handle(buffer.get(i)); + } + + buffer = new ArrayList<>(buffer.subList(limit, buffer.size())); + } + + @Override + public void handle(String message) { + buffer.add(message); + if (buffer.size() >= sizeMaxLimit) { + for (String m : buffer) { + handler.handle(m); + } + buffer.clear(); + } + } +} diff --git a/task04/src/com/example/task04/MessageHandler.java b/task04/src/com/example/task04/MessageHandler.java new file mode 100644 index 00000000..76727e35 --- /dev/null +++ b/task04/src/com/example/task04/MessageHandler.java @@ -0,0 +1,7 @@ +package com.example.task04; + +import java.util.logging.Handler; + +public interface MessageHandler { + public void handle(String message); +} diff --git a/task04/src/com/example/task04/RotationFileHandler.java b/task04/src/com/example/task04/RotationFileHandler.java new file mode 100644 index 00000000..963f7707 --- /dev/null +++ b/task04/src/com/example/task04/RotationFileHandler.java @@ -0,0 +1,59 @@ +package com.example.task04; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; + +public class RotationFileHandler implements MessageHandler { + private String name; + private String directory; + private final ChronoUnit rotationUnit; + private LocalDateTime lastRotationTime; + private File currentFile; + private final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH-mm-ss"); + + public RotationFileHandler(String name, ChronoUnit rotationUnit) { + this(new java.io.File(".").getAbsolutePath(), name, rotationUnit); + } + public RotationFileHandler(String directory, String name, ChronoUnit rotationUnit) { + this.directory = directory; + this.name = name; + this.rotationUnit = rotationUnit; + this.lastRotationTime = LocalDateTime.now(); + createNewFile(); + } + + private void createNewFile() { + String timestamp = lastRotationTime.format(formatter); + currentFile = new File(directory, name + "-" + timestamp + ".log"); + try { + currentFile.getParentFile().mkdirs(); + currentFile.createNewFile(); + } catch (IOException e) { + System.out.println(e.getMessage()); + } + } + + private void checkRotation() { + LocalDateTime now = LocalDateTime.now(); + long elapsed = rotationUnit.between(lastRotationTime, now); + if (elapsed >= 1) { + lastRotationTime = now; + createNewFile(); + } + } + + @Override + public void handle(String message) { + checkRotation(); + try (FileWriter writer = new FileWriter(currentFile, true)) { + writer.write(message + "\n"); + System.out.println("Сообщение успешно записано в файл!"); + } catch (IOException e) { + System.out.println(e.getMessage()); + } + } +} \ No newline at end of file diff --git a/task04/src/com/example/task04/Task04Main.java b/task04/src/com/example/task04/Task04Main.java index 55917a30..7a4e9899 100644 --- a/task04/src/com/example/task04/Task04Main.java +++ b/task04/src/com/example/task04/Task04Main.java @@ -1,7 +1,32 @@ package com.example.task04; +import java.time.temporal.ChronoUnit; + public class Task04Main { public static void main(String[] args) { + Logger logger = new Logger("test1"); + + RotationFileHandler rfh = new RotationFileHandler(logger.getName(), ChronoUnit.MINUTES); + + logger.addHandler(rfh); + + logger.log(Level.INFO, "Мой первый лог"); + sleep(1000); + logger.log(Level.INFO, "Мой второй лог"); + sleep(1000); + logger.log(Level.INFO, "Мой третий лог"); + logger.log(Level.INFO, "Мой четвертый лог"); + logger.log(Level.INFO, "Мой пятый лог"); + sleep(1000); + logger.log(Level.INFO, "Мой шестой лог"); + logger.log(Level.INFO, "Мой седьмой лог"); + logger.log(Level.INFO, "Мой восьмой лог"); + logger.log(Level.INFO, "Мой девятый лог"); + } + private static void sleep(long millis) { + try { + Thread.sleep(millis); + } catch (InterruptedException ignored) {} } }