Java for Beginner
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
Пакеты и импорт

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

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

Пример создания пакета:
package com.example.myapp;


Структура пакетов
Пакеты организуются иерархически, как директории в файловой системе. Например, пакет com.example.myapp будет находиться в директории com/example/myapp.

Пример файловой структуры:
src
└── com
└── example
└── myapp
├── Main.java
└── Utils.java


Импорт пакетов
Для использования классов из других пакетов необходимо их импортировать. Импорт осуществляется с использованием ключевого слова import.

Пример импорта:
import com.example.myapp.Utils;


Можно импортировать все классы из пакета, используя *:
import com.example.myapp.*;


Полное имя класса

Классы можно использовать с полным именем (включая пакет), без необходимости импортировать их:
public class Main {
public static void main(String[] args) {
com.example.myapp.Utils.printHello();
}
}


Пример создания пакета и его использования:

Файл: com/example/myapp/Utils.java
package com.example.myapp;

public class Utils {
public static void printHello() {
System.out.println("Hello from Utils!");
}
}


Файл: com/example/myapp/Main.java
package com.example.myapp;

import com.example.myapp.Utils;

public class Main {
public static void main(String[] args) {
Utils.printHello();
}
}


Преимущества использования пакетов:

Организация кода: Пакеты помогают логически группировать связанные классы и интерфейсы.
Избежание конфликтов имен: Пакеты предотвращают конфликт имен, поскольку классы с одинаковыми именами могут существовать в разных пакетах.
Контроль доступа: Пакеты позволяют управлять доступом к классам и методам, используя модификаторы доступа (default и protected).
Упрощение навигации: Структурированные пакеты облегчают навигацию по проекту и поиск нужных классов.


#Java #Training
Подписывайтесь на канал, тут научат не говнокодить👍

https://t.me/Java_for_beginner_dev

#Mems
Что выведет код?
public class Main {
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "World";
String str3 = str1 + ", " + str2 + "!";
str1 = str1.replace("H", "J");
str2 = str2.substring(1, 4);
str3 = str1 + ", " + str2 + "!";
System.out.println(str3);
}
}

#Tasks
Варианты ответа:
Anonymous Quiz
5%
Hello, World!
84%
Jello, orl!
5%
Hello, orl!
5%
Jello, Wor!
Основные принципы организации классов и пакетов

Логическая группировка: Классы, которые связаны по функциональности, должны быть сгруппированы в один пакет. Например, все классы, связанные с работой с базой данных, могут быть помещены в пакет com.example.database.

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

Пример иерархической структуры пакетов:
src
└── com
└── example
├── main
│ └── Main.java
├── utils
│ └── Utils.java
└── database
├── DatabaseHelper.java
└── DatabaseConfig.java


Именование пакетов: Имена пакетов должны быть в нижнем регистре и отражать их содержимое. Принято начинать имя пакета с доменного имени организации в обратном порядке, например, com.example.

Разделение по слоям приложения: Организуйте пакеты согласно архитектурным слоям приложения, например, controller, service, repository, model.

Пример организации по слоям:
src
└── com
└── example
├── controller
│ └── UserController.java
├── service
│ └── UserService.java
├── repository
│ └── UserRepository.java
└── model
└── User.java


Использование подкаталогов: Разделяйте большие пакеты на подкаталоги для упрощения структуры.


Практические советы по организации классов и пакетов

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

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


Пример проекта с комментариями и структурой пакетов:
src
└── com
└── example
├── controller
│ └── UserController.java
├── service
│ └── UserService.java
├── repository
│ └── UserRepository.java
└── model
└── User.java


Файл: com/example/controller/UserController.java
package com.example.controller;

import com.example.service.UserService;

/**
* Контроллер для обработки запросов пользователей
*/
public class UserController {
private UserService userService;

public UserController() {
userService = new UserService();
}

public void handleRequest() {
userService.processUser();
}
}


Файл: com/example/service/UserService.java
package com.example.service;

import com.example.repository.UserRepository;

/
* Сервис для обработки логики пользователей
*/
public class UserService {
private UserRepository userRepository;

public UserService() {
userRepository = new UserRepository();
}

public void processUser() {
userRepository.saveUser();
}
}


Файл: com/example/repository/UserRepository.java
package com.example.repository;

/
* Репозиторий для работы с базой данных пользователей
*/
public class UserRepository {
public void saveUser() {
System.out.println("User saved to the database");
}
}


Файл: com/example/model/User.java
package com.example.model;

/**
* Модель данных пользователя
*/
public class User {
private String name;

public User(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}


#Java #Training
Исключения: Основы

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

Иерархия исключений

Иерархия классов исключений в Java начинается с класса Throwable, который делится на два подкласса: Error и Exception.

Error: Используется для обозначения серьёзных проблем, которые не могут быть обработаны приложением (например, ошибки виртуальной машины Java).
Exception: Используется для обозначения условий, которые приложение может попытаться обработать.


Иерархия классов исключений:
- Throwable
- Error
- Exception
- RuntimeException


Checked и Unchecked исключения

Checked исключения: Проверяемые исключения (checked exceptions) являются подтипами класса Exception, за исключением подтипов RuntimeException. Эти исключения проверяются во время компиляции. Пример: IOException.
Unchecked исключения: Непроверяемые исключения (unchecked exceptions) являются подтипами класса RuntimeException. Эти исключения не проверяются во время компиляции. Пример: NullPointerException.


Примеры исключений:

Checked исключение: FileNotFoundException, которое возникает, если файл не найден.
Unchecked исключение: ArrayIndexOutOfBoundsException, которое возникает при попытке доступа к несуществующему элементу массива.


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

Вы можете создать свои собственные исключения, расширяя класс Exception или RuntimeException.
public class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}


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

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


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

getMessage(): Возвращает описание исключения.
printStackTrace(): Выводит трассировку стека исключения.
getStackTrace(): Возвращает массив элементов стека, представляющий трассировку стека исключения.



Пример использования методов класса Throwable:
public class Main {
public static void main(String[] args) {
try {
int result = divide(10, 0);
} catch (ArithmeticException e) {
System.out.println("Exception: " + e.getMessage());
e.printStackTrace();
}
}

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


#Java #Training #Exception
Давайте проверим сколько реально людей заглядывают на канал! Жмакайте, посчитаем)
Anonymous Poll
96%
Я тут!!!
4%
Где я? Что это за группа?
Подписывайтесь на канал, мы расскажем как происходит на самом деле🤌

https://t.me/Java_for_beginner_dev

#Mems
Что выведет код?

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
Обработка исключений

В 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
Java for Beginner
Давайте проверим сколько реально людей заглядывают на канал! Жмакайте, посчитаем)
Любопытно...
Из 80+ подписчиков данный пост посмотрело 37 человек...
Нажать на варианты ответа рискнуло всего 11...
Вопрос, где остальные?))))
Создание собственных исключений

Пользовательские исключения (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
Что выведет код?

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
Подписывайтесь на канал, мы знаем почему😎

https://t.me/Java_for_beginner_dev

#Mems
Вложенные и множественные 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
Строки: Основные операции

Строка (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
Подписывайтесь на канал, у нас высыпаются😏

https://t.me/Java_for_beginner_dev

#Mems
Класс 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
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