Как сгенерировать ошибку java

To define a checked exception you create a subclass (or hierarchy of subclasses) of java.lang.Exception. For example:

public class FooException extends Exception {
  public FooException() { super(); }
  public FooException(String message) { super(message); }
  public FooException(String message, Throwable cause) { super(message, cause); }
  public FooException(Throwable cause) { super(cause); }
}

Methods that can potentially throw or propagate this exception must declare it:

public void calculate(int i) throws FooException, IOException;

… and code calling this method must either handle or propagate this exception (or both):

try {
  int i = 5;
  myObject.calculate(5);
} catch(FooException ex) {
  // Print error and terminate application.
  ex.printStackTrace();
  System.exit(1);
} catch(IOException ex) {
  // Rethrow as FooException.
  throw new FooException(ex);
}

You’ll notice in the above example that IOException is caught and rethrown as FooException. This is a common technique used to encapsulate exceptions (typically when implementing an API).

Sometimes there will be situations where you don’t want to force every method to declare your exception implementation in its throws clause. In this case you can create an unchecked exception. An unchecked exception is any exception that extends java.lang.RuntimeException (which itself is a subclass of java.lang.Exception):

public class FooRuntimeException extends RuntimeException {
  ...
}

Methods can throw or propagate FooRuntimeException exception without declaring it; e.g.

public void calculate(int i) {
  if (i < 0) {
    throw new FooRuntimeException("i < 0: " + i);
  }
}

Unchecked exceptions are typically used to denote a programmer error, for example passing an invalid argument to a method or attempting to breach an array index bounds.

The java.lang.Throwable class is the root of all errors and exceptions that can be thrown within Java. java.lang.Exception and java.lang.Error are both subclasses of Throwable. Anything that subclasses Throwable may be thrown or caught. However, it is typically bad practice to catch or throw Error as this is used to denote errors internal to the JVM that cannot usually be «handled» by the programmer (e.g. OutOfMemoryError). Likewise you should avoid catching Throwable, which could result in you catching Errors in addition to Exceptions.

Уровень сложности
Простой

Время на прочтение
7 мин

Количество просмотров 3.9K

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

Статья может быть полезна для новичков или тем, кто не так давно в мире Java. В ней мы не касаемся типов исключений, а рассматриваем создание собственных.

Зачем нужны собственные исключения?

Этот вопрос может возникнуть у тех кто только входит в ИТ, и вопрос даже вполне корректный, ведь имеется масса своих исключений, но собственные исключения позволяют разработчикам более гибко управлять ошибками и обрабатывать их в соответствии с требованиями конкретного приложения. Вот несколько причин, по которым собственные исключения в Java могут быть полезны:

1. Отражение специфических ситуаций: Собственные исключения могут быть созданы для отображения конкретных ошибок или ситуаций, которые могут возникнуть в приложении. Например, вы можете создать исключение InvalidInputException, чтобы указать, что получен недопустимый ввод от пользователя.

2. Локализация и обработка ошибок: Собственные исключения позволяют локализовать и обрабатывать ошибки на определенном уровне в коде. Каждое исключение может быть обработано отдельно, что упрощает отладку и обработку ошибок.

3. Гибкая обработка и восстановление: При использовании собственных исключений вы можете предоставить гибкую обработку ошибок, включая восстановление после ошибки или выполнение альтернативных действий. Например, вы можете перехватить исключение FileNotFoundException и попробовать открыть альтернативный файл.

4. Инкапсуляция ошибок: Собственные исключения позволяют инкапсулировать информацию об ошибке и передавать ее на более высокий уровень в коде. Это помогает упростить код и улучшить его читаемость, так как обработка ошибок может быть сосредоточена в одном месте.

5. Расширение стандартных исключений: Собственные исключения могут расширять стандартные исключения Java, такие как Exception или RuntimeException, чтобы добавить дополнительную информацию или функциональность при обработке ошибок. Например, вы можете создать исключение DatabaseException, которое расширяет Exception и содержит дополнительные методы для работы с базой данных.

Примеры создания собственных исключений

Пример 1

Для создания собственного исключения в Java необходимо создать класс, который расширяет стандартный класс исключений или другое собственное исключение.

public class InvalidInputException extends Exception {
    public InvalidInputException(String message) {
        super(message);
    }
}

В этом примере класс InvalidInputException расширяет класс Exception и имеет конструктор, который принимает сообщение об ошибке в качестве параметра. В конструкторе вызывается конструктор суперкласса Exception, передавая ему сообщение.

Теперь, когда у вас есть собственное исключение, вы можете использовать его в своем коде для обработки конкретных ошибок.

public class Example {
    public static void main(String[] args) {
        try {
            validateInput("abc");
        } catch (InvalidInputException e) {
            System.out.println("Invalid input: " + e.getMessage());
        }
    }

    public static void validateInput(String input) throws InvalidInputException {
        if (input == null || input.isEmpty()) {
            throw new InvalidInputException("Input cannot be null or empty");
        }
    }
}

В этом примере метод validateInput() проверяет, является ли входная строка пустой или равной null. Если это так, то метод выбрасывает исключение InvalidInputException с сообщением. В методе main() мы вызываем validateInput() с недопустимым вводом и перехватываем исключение с помощью блока catch, где выводим сообщение об ошибке.

Пример 2

// Создаем собственное исключение
class CustomException extends Exception {
    public CustomException(String message) {
        super(message);
    }
}

// Класс, который использует собственное исключение
class Example {
    // Метод, который может выбросить собственное исключение
    public static void doSomething(int value) throws CustomException {
        if (value < 0) {
            throw new CustomException("Значение должно быть больше или равно нулю");
        }
    }

    public static void main(String[] args) {
        try {
            // Вызываем метод, который может выбросить исключение
            doSomething(-5);
        } catch (CustomException e) {
            // Обрабатываем исключение
            System.out.println("Ошибка: " + e.getMessage());
        }
    }
}

В этом примере у нас есть метод doSomething, который может выбросить собственное исключение CustomException, если значение аргумента меньше нуля. В методе main мы вызываем этот метод с отрицательным значением и перехватываем исключение с помощью блока catch. Затем мы выводим сообщение об ошибке.

Этот пример показывает, как правильно объявлять методы, которые могут выбрасывать собственные исключения, и как перехватывать их при вызове этих методов

Пример 3

// Создаем собственное исключение
class InvalidEmailException extends Exception {
    public InvalidEmailException(String message) {
        super(message);
    }
}

// Класс, который использует собственное исключение
class EmailValidator {
    // Метод, который может выбросить собственное исключение
    public static void validateEmail(String email) throws InvalidEmailException {
        if (!email.contains("@")) {
            throw new InvalidEmailException("Некорректный адрес электронной почты");
        }
    }

    public static void main(String[] args) {
        try {
            // Вызываем метод, который может выбросить исключение
            validateEmail("example.com");
        } catch (InvalidEmailException e) {
            // Обрабатываем исключение
            System.out.println("Ошибка: " + e.getMessage());
        }
    }
}

В этом примере у нас есть метод validateEmail, который может выбросить собственное исключение InvalidEmailException, если переданный адрес электронной почты не содержит символа «@». В конструкторе исключения мы передаем сообщение об ошибке. В методе main мы вызываем этот метод с некорректным адресом электронной почты и перехватываем исключение с помощью блока catch. Затем мы выводим сообщение об ошибке.

Вот вроде бы и все, достаточно легко и просто, как всегда, есть одно большое но! можно создать исключения, которые только усложнят жизнь разработку

Пример 4 (некорректное создание исключений)

// Некорректное создание собственного исключения
class MyException extends Exception {
    public MyException() {
        super();
    }
}

В этом примере мы создаем собственное исключение MyException, но не передаем ему сообщение об ошибке через конструктор. Это может привести к непонятным или неинформативным сообщениям об ошибках при перехвате исключения.

Корректным подходом будет передача сообщения об ошибке через конструктор, как показано в предыдущем примере:

class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

Таким образом, при выбрасывании и перехвате исключения MyException будет доступно информативное сообщение об ошибке.

Пример 5 (некорректное использование)

Примером неправильного использования собственного исключения может быть его применение без реальной необходимости или создание избыточных иерархий исключений.

public class MyCustomException extends Exception {
    // ...
}

public class Example {
    public static void main(String[] args) {
        try {
            throw new MyCustomException();
        } catch (MyCustomException e) {
            System.out.println("Caught MyCustomException");
        } catch (Exception e) {
            System.out.println("Caught Exception");
        }
    }
}

В этом примере мы создаем собственное исключение MyCustomException, но в блоке catch обрабатываем его так же, как и любое другое исключение Exception. Такое использование собственного исключения делает его бессмысленным, поскольку нет никакой разницы между обработкой MyCustomException и обработкой любого другого исключения.

Инструмент создания собственных исключений может иметь как плюсы, так и минусы, поэтому подход к его использованию должен быть обоснован архитектурой кода.

Плюсы создания собственных исключений:

1. Отражение специфических ситуаций: Собственные исключения позволяют точно отражать конкретные ошибки или ситуации, которые могут возникнуть в вашем приложении. Это упрощает понимание и обработку ошибок другими разработчиками, которые работают с вашим кодом.

2. Гибкая обработка и восстановление: Использование собственных исключений позволяет предоставить гибкую обработку ошибок, включая восстановление после ошибки или выполнение альтернативных действий. Это помогает повысить надежность и стабильность вашего приложения.

3. Инкапсуляция информации об ошибке: Собственные исключения позволяют инкапсулировать информацию об ошибке, включая дополнительные детали или контекст ошибки. Это помогает упростить код и улучшить его читаемость, так как обработка ошибок может быть сосредоточена в одном месте.

4. Расширение стандартных исключений: Вы можете расширять стандартные исключения Java, такие как Exception или RuntimeException, с добавлением дополнительной функциональности или информации для обработки ошибок. Это позволяет вам более точно определить тип ошибки и предоставить дополнительные методы для работы с ней.

Минусы создания собственных исключений:

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

2. Переусиление иерархии исключений: Если неправильно спроектировать иерархию собственных исключений, это может привести к избыточности или неправильной обработке ошибок. Следует тщательно продумать, какие исключения создавать и как они связаны между собой.

3. Неоднозначность исключений: Если вы создаете собственные исключения, которые перекрывают или имеют схожие имена с существующими стандартными исключениями, это может вызывать путаницу при обработке ошибок. Разработчики могут испытывать трудности в определении, какое исключение выбрать для обработки конкретной ситуации.

4. Проблемы совместимости: Если вы используете собственные исключения в библиотеке или API, это может создать проблемы совместимости, если другие разработчики не знакомы с вашими исключениями или не знают, как с ними работать.

Заключение

Собственные исключения в Java предоставляют разработчикам возможность более гибко управлять ошибками и исключительными ситуациями в своих приложениях или библиотеках. Они позволяют отразить специфические ситуации, локализовать и обработать ошибки, предоставить гибкую обработку и восстановление, инкапсулировать ошибки и расширить стандартные исключения.

Java. Исключения. Операторы throw, throws. Примеры

Изучение данной темы базируется на использовании следующих тем:

• Понятие об исключении. Конструкция try…catch…finally
• Классы Java для обработки исключительных ситуаций.

Содержание

• 1. Какое назначение ключевого слова throw? Общая форма
• 2. Пример генерирования исключения с помощью оператора throw в блоке try. Создание класса, который решает квадратное уравнение
• 3. Какие типы запрещено использовать для генерирования исключений оператором throw?
• 4. Каким образом создать собственный класс исключения? Пример
• 5. Какое назначение ключевого слова throws? Общая форма
• 6. Пример использования оператора throws для метода, который генерирует исключение
• Связанные темы

Поиск на других ресурсах:

1. Какое назначение ключевого слова throw? Общая форма

Исключение может генерировать:

• исполняющая среда Java;
• прикладная программа. В этом случае программа должна использовать оператор throw.

Общая форма оператора throw имеет следующий вид

throw instance;

здесь instance – объект класса Throwable или производного от него подкласса. Более подробно о классе Throwable можно просмотреть здесь.

Если оператор throw используется в блоке try…catch, то в общем вид блока следующий

...
try {
    // ...
    throw new ThrowableClass(parameters); // если исключительная ситуация, то сгенерировать исключение
    // ...
}
catch (ThrowableClass e) {
    // обработать исключение
    // ...
}
...

здесь

• ThrowableClass – класс, производный от класса Throwable или RunTimeException;
• e – экземпляр класса, который соответствует перехватываемому исключению;
• parameters – параметры конструктора класса ThrowableClass. Как правило, конструкторы классов производных от Throwable или RunTimeException имеют два варианта реализации: без параметров или с одним строчным параметром, который описывает исключительную ситуацию.

В строке

throw new ThrowableClass(parameters);

создается исключение с помощью оператора new, который выделяет память и вызывает конструктор. Для всех стандартных исключений существует два конструктора:

• конструктор по умолчанию. Этот конструктор не содержит параметров;
• конструктор с одним параметром, который представляет собой строку. В строке указывается информация об исключении. Например, строка «деление на ноль».

  ⇑

2. Пример генерирования исключения с помощью оператора throw в блоке try. Создание класса, который решает квадратное уравнение

Генерирование исключения осуществляется с помощью ключевого слова throw, которое может встречаться в блоке try (генерирование исключения вручную). Например, приведенный ниже код демонстрирует пример генерирования исключения вручную с помощью средства throw.

Объявляется класс QuadraticEquation который решает квадратное уравнение.

В классе объявляются следующие элементы:

• внутренние переменные a, b, c которые есть коэффициентами уравнения;
• внутренние переменные x1, x2 которые есть решениями уравнения (в случае, если уравнение имеет решение);
• конструктор класса;
• метод Solution(). В этом методе используется обработка возможных исключительных ситуаций: деление на 0 и корень из отрицательного числа.

Текст класса следующий:

// генерирование исключения оператором throw
// решение квадратного уравнения
class QuadraticEquation {
    double a,b,c,x1,x2;

    // конструктор
    QuadraticEquation(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    // метод, который решает квадратное уравнение
    void Solution() {
        double d; // дискриминант

        try {
            d = b*b - 4*a*c;

            // учесть деление на 0
            if (a==0)
                throw new ArithmeticException("Деление на 0."); // создать исключение

            // учесть корень из отрицательного числа
            if (d<0)
                throw new ArithmeticException("Уравнение не имеет корней."); // создать исключение

            x1 = (-b - Math.sqrt(d))/(2*a);
            x2 = (-b + Math.sqrt(d))/(2*a);

            System.out.println("x1 = " + x1);
            System.out.println("x2 = " + x2);
        }
        catch (ArithmeticException e) {
            System.out.println(e); // вывести исключение, созданное в блоке try
        }
    }
}

В методе Solution() перехватываются две исключительных ситуации:

• деление на 0;
• корень из отрицательного числа.

Для этого с помощью оператора throw создается соответствующий экземпляр класса ArithmeticException. Класс ArithmeticException есть подклассом класса RuntimeException. Класс ArithmeticException используется если возникла арифметическая ошибка. В нашем случае имеем арифметические ошибки двух видов:

• деление на 0;
• корень из отрицательного числа.

Поэтому, в блоке try создается соответствующий экземпляр исключения со строкой описания ошибки

...
// учесть деление на 0
if (a==0)
    throw new ArithmeticException("Деление на 0."); // создать исключение

// учесть корень из отрицательного числа
if (d<0)
    throw new ArithmeticException("Уравнение не имеет корней."); // создать исключение
...

Обработка любой из ошибок в операторе catch есть стандартной. Поэтому, просто выводится текст описания исключения

...
catch (ArithmeticException e) {
    System.out.println(e); // вывести исключение, созданное в блоке try
...

Ниже приводится демонстрация использования класса в коде

public class Train02 {
    public static void main(String[] args) {
        // создать екземпляр класса
        QuadraticEquation qE = new QuadraticEquation(1,1,1);
        qE.Solution(); // вызвать метод, решающий уравнение
        System.out.println("-------------------------");

        // создать другой екземпляр класса
        QuadraticEquation qE2 = new QuadraticEquation(0,3,5);
        qE2.Solution();
        System.out.println("-------------------------");

        QuadraticEquation qE3 = new QuadraticEquation(2,3,-5);
        qE3.Solution();
    }
}

Результат выполнения программы следующий:

java.lang.ArithmeticException: Уравнение не имеет корней.
-------------------------
java.lang.ArithmeticException: Деление на 0.
-------------------------
x1 = -2.5
x2 = 1.0

  ⇑

3. Какие типы запрещено использовать для генерирования исключений оператором throw?

Для генерирования исключений оператором throw запрещено использовать:

• примитивные типы (например int, char);
• классы, за исключением классов унаследованных от класса Throwable. Например, запрещено использовать класс String или другие классы.

  ⇑

4. Каким образом создать собственный класс исключения? Пример

Чтобы создать собственный класс исключения нужно, чтобы этот класс был унаследован от класса Exception. После того, как класс унаследован от класса Exception он уже есть частью системы исключений Java и его можно использовать как другие классы исключений (например ArithmeticException, ArrayIndexOfBoundsException и прочее).

Более подробно об использовании класса Exception и других классов описывается в теме:

• Классы Java для обработки исключительных ситуаций. Примеры использования.

Если класс унаследован от класса Exception, то не обязательно даже реализовывать некоторые дополнительные операции в этом классе. В любом случае, исключение, которое соответствует этому классу, будет корректно перехватываться в блоке catch.

Класс Exception не содержит методов. Однако, этот класс есть унаследованным от класса Throwable. В классе Throwable есть доступными ряд методов, которые можно переопределить в собственном классе исключения.

Пример. С целью демонстрации объявляется класс NegativeNumberException. В нашем случае этот класс представляет собой исключение, которое генерируется в случае, когда число есть отрицательным. В классе объявляются:

• внутренняя переменная value. Эта переменная есть необязательной и вводится с целью демонстрации;
• конструктор, который есть необязательным;
• метод toString(), переопределяющий одноименный метод класса Throwable. Этот метод выводит соответствующее сообщение.

// Объявить класс, который есть производным от класса Exception
// Данный класс есть частью системы исключений Java
class NegativeNumberException extends Exception {
    private double value;

    // некоторый конструктор класса
    NegativeNumberException(double _value) {
        value = _value;
    }

    // переопределенный метод toString() класса Throwable,
    // этот метод выводит информацию об исключении типа NegativeNumberException
    public String toString() {
        String msg = "Exception: " + value + " is a negative number!!!";
        return msg;
    }
}

public class Train04 {
    public static void main(String[] args) {
        // демонстрируется генерирование исключения типа NegativeNumberException
        double value;

        try {
            value = -5; // отрицательное число

            // если отрицательное значение,
            // то сгенерировать исключение типа NegativeNumberException
            if (value<0)
                throw new NegativeNumberException(value);
        }
        catch (NegativeNumberException e) {
            // вывести информацию об исключении
            // вызывается метод toString() класса NegativeNumberException
            System.out.println(e);
        }
    }
}

В вышеприведенном примере после объявления

class NegativeNumberException extends Exception {
    // ...
}

класс NegativeNumberException становится составной частью иерархии классов исключений Java. Поэтому можно его использовать в блоке catch конструкции try…catch.

В функции main() специально генерируется исключение типа NegativeNumberException в строке

...
if (value<0)
    throw new NegativeNumberException(value);
...

В результате программа переходит в блок catch, в котором выводится информация об исключении

...
catch (NegativeNumberException e) {
    System.out.println(e);
}
...

Фактически, вызывается метод toString() класса NegativeNumberException. Если бы метод toString() не был переопределен в классе NegativeNumberException, тогда был бы вызван метод toString() класса Throwable.

Результат выполнения программы

Exception: -5.0 is a negative number!!!

  ⇑

5. Какое назначение ключевого слова throws? Общая форма

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

• классов Error и RuntimeException;
• любых подклассов, которые унаследованы от классов Error и RuntimeException.

Общая форма использования оператора throws в методе имеет вид

type MethodName(parameters) throws exceptions_list {
    // ...
}

здесь

• type – тип, который возвращает метод MethodName();
• MethodName – имя метода;
• parameters – параметры метода;
• exception_list – перечень типов (классов) исключений разделенных запятой. Это есть перечень исключений, которые могут быть сгенерированы в методе MethodName().

  ⇑

6. Пример использования оператора throws для метода, который генерирует исключение

В примере объявляется класс NegativeNumberException производный от класса Exception. Этот класс есть классом исключения.

Также объявляется класс DemoThrows, который содержит метод SumItems(), способный вызвать исключение типа NegativeNumberException.

Программный код классов следующий

// Объявить класс, который есть производным от класса Exception
// После этого данный класс есть частью системы исключений Java
class NegativeNumberException extends Exception {
    private double value;

    // конструктор класса
    NegativeNumberException(double _value) {
        value = _value;
    }

    // переопределенный метод toString() класса Throwable,
    // этот метод виводит информацию об исключении типа NegativeNumberException
    public String toString() {
        String msg = "Exception: " + value + " is a negative number!!!";
        return msg;
    }
}

// демонстрация исключения
class DemoThrows {
    int SumItems(int A[]) throws NegativeNumberException {
        int i, sum=0;
        for (i=0; i<10; i++) {
            // если индекс за пределами массива, то сгенерировать исключение
            if (i>A.length)
                throw new ArrayIndexOutOfBoundsException("Индекс за пределами массива.");
            if (A[i]<0)
                throw new NegativeNumberException((double)A[i]);
            sum += A[i];
        }
        return sum;
    }
}

public class Train04 {
    public static void main(String[] args) {
        // вызов метода SumItems из класса DemoThrows
        int M[] = { 1, -2, 3, 4, 5, 6, 7 };
        DemoThrows dt = new DemoThrows(); // создать екземпляр класса DemoThrows
        int summ=0;

        try {
            // вызвать метод, в котором генерируется
            // исключение NegativeNumberException
            summ = dt.SumItems(M);
        }
        catch (NegativeNumberException e) {
            System.out.println("Отрицательное число: "+e);
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Перехвачено исключение: " + e);
        }
        finally {
            System.out.println("Summ = " + summ);
        }
    }
}

В методе может возникнуть исключительная ситуация, которая вызовет исключение типа NegativeNumberException. Поэтому в объявлении метода присутствует ключевое слово throws с именем исключения

...
int SumItems(int A[]) throws NegativeNumberException {
    ...
}
...

Результат работы программы

Отрицательное число: Exception: -2.0 is a negative number!!!
Summ = 0

  ⇑

Связанные темы

• Исключения. Исключительная ситуация. Ключевые слова try, catch, finally. Примеры

  ⇑

Предположим, что с вашей программой случилось нечто ужасное. У вас есть метод readData(), считывающий данные из файла, в заголовке которого указано следующиее:

Content-length: 1024

Однако посе воода 733 символов файл окончился. Вы считаете эту ситуацию настолько ненормальной, что решаете генерировать исключение. Теперь необходимо решить, какого типа должно быть исключение. Нам подходит одна из разновидностей класса IOException. Просматривая документацию, вы обнаруживайте описание исключения EOFException: «Сигнализирует о том, что во время ввода данных неожиданно обнаружен признак конца файла EOF». Отлично. Это исключение можно создать двумя способами:

или, если вам так больше нравится:

Итак, для решения задачи нужно написать следующий фрагмент кода:

В классе EOFException есть второй конструктор, получающий в качестве параметра строку. Его можно использовать для более подробного описания исключения.

String gripe = «Content-length: » + len», Received: +n;

throw new EOFException(gripe);

Задача облегчается, если один из существующих классов исключений подходит для вашей цели. В этом случае нужно сделать следующее.

1. Найти подходящий класс.
2. Создать экземпляр этого класса.
3. Генерировать исключение.

После генерации исключения управление уже не будет возвращено вызывающему методу. Это означает, что беспокоиться о возвращении значения, предусмотренного по умолчанию, или кода ошибки не нужно.

У вас проблемы с блоком питания ноутбука? Советуем  купить блок питания для ноутбука на сайте darrom.com.ua. Магазин Darrom.com.ua это место где вы можете купить оригинальные блоки питания по очень доступным ценам.