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

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 #ООП

Тема выходного дня)

Интересные факты о Java

Java – это не просто язык программирования, а целая экосистема с богатой историей и множеством любопытных аспектов.

1. Название и кофе

Вы, возможно, задавались вопросом, почему язык программирования называется Java. История уходит корнями в 1995 год, когда команда разработчиков из Sun Microsystems разрабатывала новый язык. Первоначально проект назывался Oak (Дуб) в честь дерева, росшего за окном офиса Джеймса Гослинга, одного из создателей Java. Однако позже выяснилось, что название Oak уже использовалось другим языком программирования. Тогда команда выбрала название Java в честь любимого кофе, который они пили во время работы над проектом. Именно поэтому логотип Java представляет собой чашку горячего кофе с поднимающимся паром.

2. Виртуальная машина Java (JVM)

Одним из ключевых нововведений, сделавших Java популярным, является концепция виртуальной машины Java (JVM). Вместо компиляции кода в машинный код конкретной платформы, Java компилирует код в байт-код, который затем интерпретируется JVM. Это означает, что один и тот же байт-код может выполняться на любой платформе, для которой существует реализация JVM. Это свойство известно как принцип "Write Once, Run Anywhere" (WORA), что значительно облегчает разработку кроссплатформенных приложений. Независимо от того, работаете ли вы на Windows, macOS, Linux или даже на Android, Java-программы будут работать одинаково.

3. Появление Java в веб-браузерах

В середине 1990-х годов Java привлекла внимание широкой аудитории благодаря возможности создавать апплеты – небольшие программы, которые можно было встроить в веб-страницы и выполнять в браузерах. Это был революционный шаг, так как позволял разработчикам создавать интерактивные элементы для веб-страниц, такие как игры, визуализации данных и другие динамические компоненты, которые ранее были недоступны. Хотя сегодня апплеты практически вышли из употребления из-за соображений безопасности и развития других технологий (например, JavaScript и HTML5), их вклад в популяризацию Java трудно переоценить.

4. Проект Green и создание языков для бытовых устройств

Изначально проект Java, известный как "Green Project", был запущен в 1991 году Джеймсом Гослингом и его командой в Sun Microsystems. Целью проекта было создание языка программирования для интерактивных телевизоров и других бытовых устройств. Однако проект оказался слишком сложным для тогдашнего рынка бытовой электроники. Когда интернет стал набирать популярность, команда увидела потенциал использования Java в сети, и язык программирования был переориентирован на создание кроссплатформенных интернет-приложений.

5. Платформа Java EE

Java EE – это набор спецификаций и библиотек, который расширяет возможности базовой платформы Java SE (Standard Edition) для создания масштабируемых, надежных и безопасных корпоративных приложений. Java EE включает в себя технологии для работы с веб-сервисами, сервлетами, Enterprise JavaBeans (EJB), а также средства для управления транзакциями и безопасности. Множество крупных организаций используют Java EE для создания сложных систем, таких как банковские приложения, системы управления заказами и крупные веб-порталы.

6. Кроссплатформенная игровая разработка

Java известна не только своими корпоративными и мобильными приложениями, но и играми. Один из самых известных примеров – это игра Minecraft, созданная Маркусом Перссоном (Notch) и выпущенная в 2009 году. Minecraft написана на Java и благодаря этому легко запускается на различных платформах, включая Windows, macOS и Linux. Java также широко используется для создания серверных частей игр, обеспечивая надежность и масштабируемость.

#Java #OffTime

Ребят создам пост в котором предлагаю делиться своими pet-проектами)

Начну эстафету с себя)
Восстановил мини консольную игру которую писал как обучающий проект)
Ссылку на гит прилагаю, вроде должно все работать))
Конечно ж интересует Ваше мнение☺️

https://github.com/Oleborn/GameTest

#Java #PetProjects