Подумайте, что выведет программа в консоль.

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing Circle");
    }
}

class Square extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing Square");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Square();
        
        shape1.draw();
        shape2.draw();
    }
}

#Tasks

Статические и блоки инициализации

Статические блоки инициализации используются для инициализации статических полей класса. Они выполняются один раз при загрузке класса.

Пример:

public class StaticExample {
    static int staticValue;

    // Статический блок инициализации
    static {
        staticValue = 10;
        System.out.println("Static block executed");
    }

    public static void main(String[] args) {
        System.out.println("Static value: " + staticValue);
    }
}

При запуске программы выведется:

Static block executed
Static value: 10

Блоки инициализации

Блоки инициализации используются для инициализации полей объекта и выполняются при каждом создании объекта, перед вызовом конструктора.

Пример:

public class InitializationExample {
    int value;

    // Блок инициализации
    {
        value = 5;
        System.out.println("Initialization block executed");
    }

    public InitializationExample() {
        System.out.println("Constructor executed");
    }

    public static void main(String[] args) {
        InitializationExample example = new InitializationExample();
        System.out.println("Value: " + example.value);
    }
}

При запуске программы выведется:

Initialization block executed
Constructor executed
Value: 5

Использование статических блоков инициализации

Статические блоки инициализации полезны, когда нужно выполнить сложную логику инициализации статических полей.

Пример:

public class Configuration {
    static String config;

    static {
        // Имитация загрузки конфигурации
        config = loadConfig();
    }

    private static String loadConfig() {
        // Сложная логика загрузки конфигурации
        return "Loaded configuration";
    }

    public static void main(String[] args) {
        System.out.println("Configuration: " + config);
    }
}

Инициализация статических полей

Статические поля можно инициализировать непосредственно при их объявлении или в статическом блоке инициализации.

Пример:

public class StaticInitialization {
    static int staticValue = 10;

    static {
        staticValue = 20;
    }

    public static void main(String[] args) {
        System.out.println("Static value: " + staticValue); // Выведет "Static value: 20"
    }
}

Инициализация полей в блоках инициализации

Блоки инициализации позволяют выполнять инициализацию, которая не может быть выполнена в объявлении полей.

Пример:

public class InitializationBlockExample {
    int value;

    {
        value = calculateInitialValue();
    }

    private int calculateInitialValue() {
        // Сложная логика расчета начального значения
        return 42;
    }

    public static void main(String[] args) {
        InitializationBlockExample example = new InitializationBlockExample();
        System.out.println("Value: " + example.value); // Выведет "Value: 42"
    }
}

Разница между статическими и нестатическими блоками инициализации

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

#Java #Training

Доброе утро подписчики!

Вот Вам небольшое задание:

Написать метод который принимает в качестве параметра шанс (неважно чего, от 1 до 100) и в зависимости от переданного, рандомно выводит true/false.
уточнение - шанс просто int
Ну и соответственно чем выше шанс тем чаще выпадает true, кто не понял)

Жду ваши варианты в комментах!)

https://t.me/Java_for_beginner_dev

#Tasks

Дорогие участники канала!

Сегодня в 14 часов по МСК, мы хотим собраться в Яндекс.Телемост для знакомства и общения))

Кроме этого @MrAbhorrent проведет мини курс по созданию игры крестики-нолики!
Писать будем на Java без сторонних библиотек, что подойдет для любого новичка. После создания мы расскажем Вам как сохранить написанное в Git Hub, для портфолио (кому это нужно).

Ссылку ждите в нашем чате - https://t.me/Java_Beginner_chat

Ждем всех! Зовите и тех кого у нас еще нет на канале!)

Встреча пройдет в пробном формате, могут быть накладки. В целом если такой формат вам зайдет сделаем это регулярным!)

Надеюсь Вы готовы! Мы уже собираемся!
@MrAbhorrent уже разминает пальцы)))

https://t.me/Java_Beginner_chat - наш чат и именно там будет опубликована ссылка на Яндекс.Телемост)))

Повторюсь - ждем всех!!!

Спасибо за участие тем, кто был на встрече!
Было приятно познакомиться!)

К данному посту прикладываю видеозапись первой части кода игры @MrAbhorrent. 

Если что-то в процессе осталось непонятным, Вы всегда можете написать либо в комментариях под данным постом, либо в чате!)

Отдельная благодарность @MrAbhorrent, что взял на себя этот труд по лайфодингу!))
Код - https://github.com/MrAbhorrent/TicTacToe_study

Всем доброго утра!

Предлагаю сегодня не работать))) Кто как проводит выходные, делитесь!) Можно и фото)
Лучшее опубликуем!

Я жду новых подписчиков!

Английский ЖАждет вас😉

https://t.me/english_for_begginers

Инкапсуляция и модификаторы доступа

Инкапсуляция — один из основных принципов объектно-ориентированного программирования (ООП). Он заключается в сокрытии внутреннего состояния объекта и предоставлении доступа к нему только через методы. Это позволяет защитить данные от некорректного использования и изменения.

В Java инкапсуляция достигается с помощью:

Модификаторов доступа (access modifiers), таких как private, protected, и public.
Методов доступа (getter) и методов изменения (setter). (Рассматривали ранее)

Модификаторы доступа

private: Поле или метод доступен только внутри класса.
default (без модификатора): Поле или метод доступен внутри пакета.
protected: Поле или метод доступен внутри пакета и в подклассах.
public: Поле или метод доступен из любого места.

Пример инкапсуляции

Рассмотрим класс BankAccount, который демонстрирует инкапсуляцию.

public class BankAccount {
    private String accountNumber; // Поле доступно только внутри класса
    private double balance;

    // Конструктор для инициализации полей
    public BankAccount(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    // Getter для accountNumber
    public String getAccountNumber() {
        return accountNumber;
    }

    // Getter для balance
    public double getBalance() {
        return balance;
    }

    // Setter для balance с проверкой на отрицательное значение
    public void setBalance(double balance) {
        if (balance >= 0) {
            this.balance = balance;
        } else {
            System.out.println("Balance cannot be negative.");
        }
    }

    // Метод для депозита средств на счет
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            System.out.println("Deposit amount must be positive.");
        }
    }

    // Метод для снятия средств со счета
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Invalid withdrawal amount.");
        }
    }
}

Использование инкапсуляции:

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("12345678", 1000.0);

        // Доступ к полям осуществляется через методы
        System.out.println("Account Number: " + account.getAccountNumber());
        System.out.println("Balance: " + account.getBalance());

        account.deposit(500.0);
        System.out.println("Balance after deposit: " + account.getBalance());

        account.withdraw(200.0);
        System.out.println("Balance after withdrawal: " + account.getBalance());
    }
}

Преимущества инкапсуляции

Контроль доступа: Инкапсуляция ограничивает доступ к полям класса и позволяет контролировать их изменение.
Поддержка инвариантов: С помощью методов можно гарантировать, что объект всегда находится в корректном состоянии.
Сокрытие реализации: Внутренняя реализация класса скрыта от внешнего мира, что позволяет изменять её без воздействия на другие части программы.

#Java #Training #ООП #Инкапсуляция

Абстракция и примеры применения

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

Абстрактные классы

Абстрактные классы не могут быть инстанцированы и предназначены для предоставления общей функциональности подклассам. Они могут содержать как абстрактные методы (без реализации), так и методы с реализацией.

Пример абстрактного класса:

public abstract class Shape {
    // Абстрактный метод для вычисления площади
    public abstract double calculateArea();

    // Метод с реализацией
    public void display() {
        System.out.println("Shape area: " + calculateArea());
    }
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public double calculateArea() {
        return width * height;
    }
}

Использование абстракции:

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 6.0);

        circle.display(); // Выведет "Shape area: 78.53981633974483"
        rectangle.display(); // Выведет "Shape area: 24.0"
    }
}

Интерфейсы

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

Пример интерфейса:

public interface Animal {
    void makeSound(); // Абстрактный метод
}

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow! Meow!");
    }
}

Использование интерфейсов:

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.makeSound(); // Выведет "Woof! Woof!"
        cat.makeSound(); // Выведет "Meow! Meow!"
    }
}

Преимущества абстракции

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

#Java #Training #ООП #Абстракция

Наследование

Наследование — один из основных принципов объектно-ориентированного программирования (ООП), который позволяет одному классу (подклассу) унаследовать свойства и методы другого класса (суперкласса). Наследование способствует повторному использованию кода, созданию иерархий классов и упрощению программирования.

Основные концепции наследования

Суперкласс (родительский класс): Класс, от которого наследуется другой класс.
Подкласс (производный класс): Класс, который наследует свойства и методы суперкласса.

Пример наследования

Рассмотрим пример с классами Animal и Dog.

// Суперкласс
public class Animal {
    protected String name;

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

    public void makeSound() {
        System.out.println("Some generic animal sound");
    }

    public void eat() {
        System.out.println(name + " is eating");
    }
}

// Подкласс
public class Dog extends Animal {
    public Dog(String name) {
        super(name); // Вызов конструктора суперкласса
    }

    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }

    public void fetch() {
        System.out.println(name + " is fetching");
    }
}

Использование наследования

Создадим класс Main, чтобы протестировать наследование.

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");

        // Методы суперкласса
        dog.eat(); // Выведет "Buddy is eating"
        dog.makeSound(); // Выведет "Woof! Woof!"

        // Метод подкласса
        dog.fetch(); // Выведет "Buddy is fetching"
    }
}

Преимущества наследования

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

Подклассы наследуют все члены суперкласса, но не имеют доступа к приватным членам (private).
Защищенные члены (protected) доступны в подклассах и классах того же пакета.

Множественное наследование

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

Пример:

public interface Animal {
    void makeSound();
}

public interface Pet {
    void play();
}

public class Dog implements Animal, Pet {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }

    @Override
    public void play() {
        System.out.println("Dog is playing");
    }
}

#Java #Training #ООП #Наследование

Переопределение методов

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

Правила переопределения методов

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

Пример переопределения метода

Рассмотрим переопределение метода makeSound в классе Dog, который наследуется от класса Animal.

// Суперкласс
public class Animal {
    protected String name;

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

    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

// Подкласс
public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

Использование переопределения методов

Создадим класс Main, чтобы протестировать переопределение методов.

public class Main {
    public static void main(String[] args) {
        Animal genericAnimal = new Animal("Generic");
        Dog dog = new Dog("Buddy");

        genericAnimal.makeSound(); // Выведет "Some generic animal sound"
        dog.makeSound(); // Выведет "Woof! Woof!"
    }
}

Аннотация Override

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

@Override
public void makeSound() {
    System.out.println("Woof! Woof!");
}

Преимущества переопределения методов

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

Вызов метода суперкласса

В подклассе можно вызвать метод суперкласса с помощью ключевого слова super.

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        super.makeSound(); // Вызов метода суперкласса
        System.out.println("Woof! Woof!");
    }
}

#Java #Training #ООП