Java for Beginner
@Java_for_beginner_dev
672 subscribers
541 photos
155 videos
12 files
827 links
Канал от новичков для новичков!
Изучайте Java вместе с нами!
Здесь мы обмениваемся опытом и постоянно изучаем что-то новое!

Наш YouTube канал - https://www.youtube.com/@Java_Beginner-Dev

Наш канал на RUTube - https://rutube.ru/channel/37896292/
Download Telegram
About
Blog
Apps
Platform
Join
Java for Beginner
672 subscribers
Java for Beginner
Подписывайтесь на канал, мы расскажем как происходит на самом деле🤌

https://t.me/Java_for_beginner_dev

#Mems
224 viewsДен, edited  
Java for Beginner
Варианты ответа:
Anonymous Quiz
11%
The number is 10The number is 15
5%
The number is 10
84%
The number is 1015
0%
The number is 10 15
19 voters139 viewsДен, 
Java for Beginner
Что выведет код?

public class Main {
    public static void main(String[] args) {
        var number = 10;
        var text = "The number is ";
        var result = text + number;
        
        number += 5;
        result += number;

        System.out.println(result);
    }
}


#Tasks
138 viewsДен, 
Java for Beginner
Обработка исключений

В Java для обработки исключений используются блоки try, catch и finally. Эти блоки помогают управлять ошибками и выполнять очистку ресурсов.

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

Синтаксис try-catch:
try {
    // Код, который может вызвать исключение
} catch (ExceptionType e) {
    // Код для обработки исключения
}


Пример использования try-catch:
public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}


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

Синтаксис try-catch-finally:
try {
    // Код, который может вызвать исключение
} catch (ExceptionType e) {
    // Код для обработки исключения
} finally {
    // Код, который будет выполнен в любом случае
}


Пример использования try-catch-finally:
public class Main {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0);
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero!");
        } finally {
            System.out.println("Execution completed.");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}


Обработка нескольких исключений
Можно обработать несколько типов исключений, используя несколько блоков catch.

Пример обработки нескольких исключений:
public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds!");
        } catch (Exception e) {
            System.out.println("An error occurred!");
        }
    }
}


Множественные исключения в одном catch
С Java 7 можно обрабатывать несколько типов исключений в одном блоке catch, используя оператор |.

Пример использования одного catch для нескольких исключений:
public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}


#Java #Training #Exception #TryCatch
150 viewsДен, 
Java for Beginner
Java for Beginner
Давайте проверим сколько реально людей заглядывают на канал! Жмакайте, посчитаем)
Любопытно...
Из 80+ подписчиков данный пост посмотрело 37 человек...
Нажать на варианты ответа рискнуло всего 11...
Вопрос, где остальные?))))
142 viewsДен, 
Java for Beginner
Создание собственных исключений

Пользовательские исключения (custom exceptions) — это исключения, созданные разработчиком для обработки специфических условий ошибок в приложении. Они наследуются от классов Exception или RuntimeException.
Пользовательские исключения помогают сделать код более читаемым и понятным, предоставляя более конкретные сообщения об ошибках и улучшая обработку специфических ситуаций.

Создание пользовательского исключения

Для создания пользовательского исключения необходимо создать класс, который наследует от Exception (для checked исключений) или RuntimeException (для unchecked исключений).
public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
}


Пример создания unchecked исключения:
public class CustomUncheckedException extends RuntimeException {
    public CustomUncheckedException(String message) {
        super(message);
    }
}


Пример использования пользовательского исключения:
public class Main {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomCheckedException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomCheckedException {
        if (age < 18) {
            throw new CustomCheckedException("Age must be at least 18.");
        }
    }
}


Конструкторы пользовательских исключений

Пользовательские исключения могут иметь разные конструкторы для передачи различных параметров.
public class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }

    public CustomCheckedException(String message, Throwable cause) {
        super(message, cause);
    }

    public CustomCheckedException(Throwable cause) {
        super(cause);
    }
}


Исключения с собственными методами

Иногда может потребоваться добавить методы для обработки дополнительных данных в пользовательские исключения.
public class InvalidUserInputException extends Exception {
    private int errorCode;

    public InvalidUserInputException(String message, int errorCode) {
        super(message);
        this.errorCode = errorCode;
    }

    public int getErrorCode() {
        return errorCode;
    }
}


Использование исключения с собственными методами:
public class Main {
    public static void main(String[] args) {
        try {
            processInput(-1);
        } catch (InvalidUserInputException e) {
            System.out.println("Error: " + e.getMessage() + " (Error code: " + e.getErrorCode() + ")");
        }
    }

    public static void processInput(int value) throws InvalidUserInputException {
        if (value < 0) {
            throw new InvalidUserInputException("Input value must be non-negative", 1001);
        }
    }
}


#Java #Training #Exception
146 viewsДен, 
Java for Beginner
Что выведет код?

import java.util.*;

public class CollectionExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D", "E"));
        list.add(2, "X");
        Collections.sort(list, Comparator.reverseOrder());
        System.out.println(list);
    }
}


#Tasks
160 viewsДен, 
Java for Beginner
Варианты ответа:
Anonymous Quiz
26%
[A, B, C, D, E, X]
5%
[E, D, C, B, A, X]
63%
[X, E, D, C, B, A]
5%
[E, D, C, B, A]
19 voters163 viewsДен, 
Java for Beginner
Подписывайтесь на канал, мы знаем почему😎

https://t.me/Java_for_beginner_dev

#Mems
151 viewsДен, 
Java for Beginner
Вложенные и множественные catch блоки

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

Множественные catch блоки

В Java можно использовать несколько catch блоков для обработки различных типов исключений, возникающих в одном блоке try.
public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds!");
        } catch (ArithmeticException e) {
            System.out.println("Arithmetic exception occurred!");
        } catch (Exception e) {
            System.out.println("An unknown error occurred!");
        }
    }
}


Вложенные блоки try-catch

Вложенные блоки try-catch позволяют обрабатывать исключения на разных уровнях вложенности. Это может быть полезно, когда один блок try-catch находится внутри другого, и каждый из них обрабатывает свои собственные исключения.
public class Main {
    public static void main(String[] args) {
        try {
            try {
                int result = divide(10, 0);
            } catch (ArithmeticException e) {
                System.out.println("Inner catch: Cannot divide by zero!");
            }

            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Outer catch: Array index is out of bounds!");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // Бросает ArithmeticException при делении на ноль
    }
}


Множественные исключения в одном catch блоке

С Java 7 можно обрабатывать несколько типов исключений в одном catch блоке, используя оператор |. Это упрощает код, когда требуется одна и та же обработка для нескольких исключений.
public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}


Обработка исключений с полиморфизмом

Можно использовать полиморфизм для обработки исключений. Поскольку все исключения являются подтипами Exception, можно использовать один catch блок для обработки всех исключений, если не требуется специфическая обработка для каждого типа исключения.
public class Main {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}


#Java #Training #Exception
143 viewsДен, 
Java for Beginner
Строки: Основные операции

Строка (String) в Java — это последовательность символов. Класс String является неизменяемым (immutable), что означает, что после создания объекта строка не может быть изменена. Любые операции, изменяющие строку, создают новый объект.

Создание строк

Строки могут быть созданы несколькими способами:

Литералы строк:
String str1 = "Hello, World!";


Конструктор класса String:
String str2 = new String("Hello, World!");


Основные операции со строками

Конкатенация строк:
Конкатенация — это процесс объединения двух или более строк.

С оператором +:
String str1 = "Hello, ";
String str2 = "World!";
String result = str1 + str2; // "Hello, World!"


С методом concat:
String str1 = "Hello, ";
String str2 = "World!";
String result = str1.concat(str2); // "Hello, World!"


Длина строки:

Метод length() возвращает количество символов в строке.
String str = "Hello, World!";
int length = str.length(); // 13


Извлечение символов:

Метод charAt(int index) возвращает символ по указанному индексу (индексация начинается с нуля).
String str = "Hello, World!";
char ch = str.charAt(0); // 'H'


Извлечение подстроки:

Метод substring(int beginIndex) возвращает подстроку, начиная с указанного индекса до конца строки. Метод substring(int beginIndex, int endIndex) возвращает подстроку от beginIndex до endIndex (не включая endIndex).
String str = "Hello, World!";
String subStr1 = str.substring(7); // "World!"
String subStr2 = str.substring(7, 12); // "World"


Сравнение строк:

С методом equals:
String str1 = "Hello";
String str2 = "Hello";
boolean isEqual = str1.equals(str2); // true


С методом equalsIgnoreCase:
String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equalsIgnoreCase(str2); // true


С методом compareTo:
String str1 = "Hello";
String str2 = "World";
int result = str1.compareTo(str2); // Отрицательное значение, так как "Hello" меньше "World"


Преобразование регистра:

В верхний регистр:
String str = "Hello, World!";
String upperStr = str.toUpperCase(); // "HELLO, WORLD!"


В нижний регистр:
String str = "Hello, World!";
String lowerStr = str.toLowerCase(); // "hello, world!"


Замена символов и подстрок:

Замена символа:
String str = "Hello, World!";
String replacedStr = str.replace('o', 'a'); // "Hella, Warld!"


Замена подстроки:
String str = "Hello, World!";
String replacedStr = str.replace("World", "Java"); // "Hello, Java!"


Удаление пробелов:

Метод trim удаляет начальные и конечные пробелы:
String str = "   Hello, World!   ";
String trimmedStr = str.trim(); // "Hello, World!"


#Java #Training #String
141 viewsДен, 
Java for Beginner
Подписывайтесь на канал, у нас высыпаются😏

https://t.me/Java_for_beginner_dev

#Mems
146 viewsДен, 
Java for Beginner
Класс String и его методы

Класс String в Java является частью пакета java.lang и предоставляет множество методов для работы со строками. Строки в Java неизменяемы, что означает, что каждый метод, изменяющий строку, возвращает новый объект строки.

Основные методы класса String

Создание строки

Конструкторы класса String:
String str1 = new String();
String str2 = new String("Hello");
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str3 = new String(charArray);
byte[] byteArray = {72, 101, 108, 108, 111};
String str4 = new String(byteArray);


Получение символа по индексу

Метод charAt(int index):
String str = "Hello, World!";
char ch = str.charAt(0); // 'H'


Сравнение строк

Метод compareTo(String anotherString) и compareToIgnoreCase(String str):
String str1 = "Hello";
String str2 = "World";
int result = str1.compareTo(str2); // Отрицательное значение
int resultIgnoreCase = str1.compareToIgnoreCase(str2); // Отрицательное значение


Проверка наличия подстроки

Метод contains(CharSequence s):
String str = "Hello, World!";
boolean containsWorld = str.contains("World"); // true


Проверка начала и конца строки

Методы startsWith(String prefix) и endsWith(String suffix):
String str = "Hello, World!";
boolean startsWithHello = str.startsWith("Hello"); // true
boolean endsWithWorld = str.endsWith("World!"); // true


Разделение строки

Метод split(String regex):
String str = "Hello, World!";
String[] words = str.split(", "); // ["Hello", "World!"]


Соединение массива строк

Метод join(CharSequence delimiter, CharSequence... elements):
String[] words = {"Hello", "World"};
String joinedString = String.join(", ", words); // "Hello, World"


#Java #Training #String
187 viewsДен, 
Java for Beginner
StringBuilder и StringBuffer

StringBuilder и StringBuffer — это классы, предоставляющие изменяемые строки. Они позволяют изменять содержимое строки без создания новых объектов, что делает их более эффективными для частых операций изменения строк.

StringBuilder

Класс StringBuilder был введен в Java 5 и предназначен для создания и изменения строк в однопоточных приложениях. Он не синхронизирован, что делает его быстрее, но не безопасным для использования в многопоточной среде.

Основные методы StringBuilder

Создание объекта StringBuilder:
StringBuilder sb = new StringBuilder(); // Создает пустой StringBuilder
StringBuilder sbWithCapacity = new StringBuilder(50); // Создает StringBuilder с начальной емкостью 50 символов
StringBuilder sbWithString = new StringBuilder("Hello"); // Создает StringBuilder с начальной строкой "Hello"


Добавление текста (метод append):
StringBuilder sb = new StringBuilder("Hello");
sb.append(", World!"); // sb теперь содержит "Hello, World!"


Вставка текста (метод insert):
StringBuilder sb = new StringBuilder("Hello, !");
sb.insert(7, "World"); // sb теперь содержит "Hello, World!"


Замена текста (метод replace):
StringBuilder sb = new StringBuilder("Hello, World!");
sb.replace(7, 12, "Java"); // sb теперь содержит "Hello, Java!"


Удаление текста (метод delete):
StringBuilder sb = new StringBuilder("Hello, World!");
sb.delete(5, 7); // sb теперь содержит "HelloWorld!"


Реверс строки (метод reverse):
StringBuilder sb = new StringBuilder("Hello");
sb.reverse(); // sb теперь содержит "olleH"


Получение длины и емкости:
StringBuilder sb = new StringBuilder("Hello");
int length = sb.length(); // 5
int capacity = sb.capacity(); // Емкость по умолчанию + длина строки "Hello"


Получение подстроки (метод substring):
StringBuilder sb = new StringBuilder("Hello, World!");
String subStr = sb.substring(7, 12); // "World"


StringBuffer

Класс StringBuffer аналогичен StringBuilder, но синхронизирован, что делает его безопасным для использования в многопоточных средах. Из-за синхронизации StringBuffer несколько медленнее, чем StringBuilder.

Основные методы StringBuffer

Методы класса StringBuffer аналогичны методам класса StringBuilder, поэтому приведем лишь их примеры:

Создание объекта StringBuffer:
StringBuffer sb = new StringBuffer(); // Создает пустой StringBuffer
StringBuffer sbWithCapacity = new StringBuffer(50); // Создает StringBuffer с начальной емкостью 50 символов
StringBuffer sbWithString = new StringBuffer("Hello"); // Создает StringBuffer с начальной строкой "Hello"


Добавление текста (метод append):
StringBuffer sb = new StringBuffer("Hello");
sb.append(", World!"); // sb теперь содержит "Hello, World!"


Вставка текста (метод insert):
StringBuffer sb = new StringBuffer("Hello, !");
sb.insert(7, "World"); // sb теперь содержит "Hello, World!"


Замена текста (метод replace):
StringBuffer sb = new StringBuffer("Hello, World!");
sb.replace(7, 12, "Java"); // sb теперь содержит "Hello, Java!"


Удаление текста (метод delete):
StringBuffer sb = new StringBuffer("Hello, World!");
sb.delete(5, 7); // sb теперь содержит "HelloWorld!"


Реверс строки (метод reverse):
StringBuffer sb = new StringBuffer("Hello");
sb.reverse(); // sb теперь содержит "olleH"


Получение длины и емкости:
StringBuffer sb = new StringBuffer("Hello");
int length = sb.length(); // 5
int capacity = sb.capacity(); // Емкость по умолчанию + длина строки "Hello"


Получение подстроки (метод substring):
StringBuffer sb = new StringBuffer("Hello, World!");
String subStr = sb.substring(7, 12); // "World"


#Java #Training #String
155 viewsДен, 
Java for Beginner
Что выведет код?

public class StaticExample {
    static int count = 0;
    
    public StaticExample() {
        count++;
    }
    
    public static int getCount() {
        return count;
    }
    
    public static void main(String[] args) {
        StaticExample obj1 = new StaticExample();
        StaticExample obj2 = new StaticExample();
        StaticExample obj3 = new StaticExample();
        
        System.out.println(StaticExample.getCount());
    }
}


#Tasks
145 viewsДен, 
Java for Beginner
Варианты ответа:
Anonymous Quiz
15%
1
55%
3
15%
0
15%
2
20 voters136 viewsДен, 
Java for Beginner
Подписывайтесь на канал, мы знаем, что делать с багами🪲🔫

https://t.me/Java_for_beginner_dev

#Mems
1.7K viewsДен, 
Java for Beginner
Forwarded from CRYPTON Tech
Please open Telegram to view this post
VIEW IN TELEGRAM
Please open Telegram to view this post
VIEW IN TELEGRAM
121 viewsДен, 
Java for Beginner
Разница между String, StringBuilder и StringBuffer

Строки (String)

Неизменяемость: Объекты класса String неизменяемы. После создания строки, её содержимое не может быть изменено.
Потокобезопасность: String является потокобезопасным из-за своей неизменяемости. Разные потоки могут безопасно использовать один и тот же объект строки.
Использование памяти: Каждое изменение строки создает новый объект, что может привести к большому количеству временных объектов и нагрузке на сборщик мусора.

Пример использования:
String str = "Hello";
str = str + ", World!"; // Создается новый объект строки


StringBuilder

Изменяемость: Объекты класса StringBuilder изменяемы. Можно изменять содержимое объекта без создания новых объектов.
Потокобезопасность: StringBuilder не является потокобезопасным. Он не синхронизирован, что делает его быстрым, но небезопасным для использования в многопоточных средах.
Использование памяти: StringBuilder более эффективен с точки зрения использования памяти при частых изменениях строк, так как не создает множество временных объектов.

Пример использования:
StringBuilder sb = new StringBuilder("Hello");
sb.append(", World!"); // Изменяется текущий объект sb


StringBuffer

Изменяемость: Объекты класса StringBuffer изменяемы, как и StringBuilder.
Потокобезопасность: StringBuffer является потокобезопасным. Он синхронизирован, что делает его безопасным для использования в многопоточных средах, но более медленным по сравнению с StringBuilder.
Использование памяти: StringBuffer эффективен с точки зрения использования памяти при частых изменениях строк в многопоточных приложениях.

Пример использования:
StringBuffer sb = new StringBuffer("Hello");
sb.append(", World!"); // Изменяется текущий объект sb


Сравнение производительности

String: Создание новых объектов при каждом изменении строки делает String менее эффективным при частых изменениях.
StringBuilder: Не синхронизирован и поэтому быстрее, чем StringBuffer, при работе в однопоточных приложениях.
StringBuffer: Синхронизирован и, следовательно, медленнее, чем StringBuilder, но безопасен для использования в многопоточных приложениях.

Когда использовать каждый из классов?

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

Примеры использования:

String:
String str = "Hello";
str = str + ", World!"; // Создание нового объекта


StringBuilder:
StringBuilder sb = new StringBuilder("Hello");
sb.append(", World!"); // Изменение текущего объекта


StringBuffer:
StringBuffer sb = new StringBuffer("Hello");
sb.append(", World!"); // Изменение текущего объекта


#Java #Training #String
158 viewsДен, 
Java for Beginner
Станем ли мы и дальше организовывать встречи по выходным? И когда Вам удобнее?
Anonymous Poll
53%
Да! Я присоединюсь в любой день!
7%
Да, но мне удобнее по субботам
20%
Да, но мне удобнее по воскресениям
20%
Я не смогу прийти, хотя полностью за!
0%
Ерундой страдаете!
15 voters158 viewsДен, 
Java for Beginner
Всем доброго летнего утра и дня!

Рассказывайте, что у Вас нового и интересного!

Сегодня я запустил публикацию небольших видео на нашем ютуб канале - https://www.youtube.com/channel/UCPIFxEy9uf_LzstTSLrjPhw!

Видео там пока одно, но я думаю совместными усилиями мы сделаем из него что-то достойное!))

#YouTube
172 viewsДен,