Секреты Java

#test

Кошка говорит «мяу», собака говорит «гав», Java-разработчик говорит «кто-нибудь видел мой энергетик? А то мне еще баги исправлять». Да, быть разработчиком на Java непросто. Но нет ничего невозможного, если у вас есть желание разобраться и двухнедельный подготовительный курс от Хекслета за 990 рублей. ⏰ Начинаем уже 9 июля! – 62 онлайн-урока; – 4 живых вебинара; – практика с первого дня; – помощь наставника в закрытом чате. Нет опыта? Не беда! Как говорят в IT-среде: «А что, если попробовать так?» И мы тоже говорим вам “Попробуйте”!

✅ Shadowing или затенение Затенение (shadowing) переменных происходит, когда переменная с локальной областью видимости "перекрывает" переменную с глобальной областью видимости с таким же именем. На примере будет понятнее. Рассмотрим класс:

public class Shadowing {
    private int x = 10; // переменная на уровне класса
    
    public void printX() {
        int x = 20; // локальная переменная
        System.out.println(x);
        System.out.println(this.x);
    }
}

Вызов метода printX() которого выведет:

20
10

В примере хоть переменные и имеют одно имя, но они объявляются в разных областях видимости. Переменная "x" на уровне метода printX() перекрывает переменную "x" на уровне класса. А для доступа к переменной на уровне класса используется ключевое слово "this". Локальные переменные, которые объявляются внутри метода, блока, конструктора будут перекрывать переменные объявленные на уровне объекта или класса. А какой вывод будет тут после вызова метода printX() класса ShadowingInner , уверен, вы сами догадаетесь:

public class Shadowing {

    private int x = 10;

    class ShadowingInner {

        private int x = 20;

        public void printX() {
            int x = 30;
            System.out.println(x);
            System.out.println(this.x);
            System.out.println(Shadowing.this.x);
        }
    }
}

Затенение переменных может привести к определенной путанице и ошибкам в коде, поэтому рекомендуется избегать использования одинаковых имен переменных на разных уровнях. 🫡 Секреты Java #java #shadowing

Прокачай скиллы, чтобы получить заветный оффер Ребята из команды FAANG School собрали в одном месте гайды, шпаргалки, мануалы и чек-листы, в общем всё, что поможет стать сильными профессионалами. Основные концепции Docker, наборы команд в JetBrains, пошаговая RoadMap по Java и множество других полезных материалов будут всегда под рукой, помогут быстро справиться со сложными вопросами и тем самым приблизят вас к высокой зп. Библиотечный каталог постоянно пополняется, а значит, будет еще больше ценного контента. Бесплатно и навсегда! Переходи, заглядывай в библиотеку и сохраняй полезности, если хочешь увеличить шансы устроиться в Яндекс, Amazon, Google и другие. Попасть в библиотеку JAVA JUNIOR

#test

📚 Здесь собраны все вопросы, которые могут спросить на собеседовании. Теперь можно легко получить оффер, подготовившись к самым популярным вопросам. Просто выбери своё направление: 1. Frontend / JavaScript 2. Python 3. Java 4. Тестировщик QA 5. Data Science 6. DevOps 7. C# 8. С/C++ 9. Golang 10. PHP 11. Kotlin 12. Swift

✅ Spring аннотация @Lazy Как известно Spring создает бины сразу при поднятии контекста и со скоупом Singletone. Но бывают случаи, когда мы не хотим создавать его сразу. И Spring дает нам такую возможность с аннотацией @org.springframework.context.annotation.Lazy. Эта аннотация используется в Spring Framework для отложенной инициализации бина. Это означает, что бин будет создан только при первом обращении к нему. Мы можем использовать @Lazy над классом конфигурации:

@Lazy
@Configuration
public class MyConfiguration {

    @Bean
    public MyBean myBean() {
       return new MyBean();
    }
    
    ...
}

Это значит что все бины создаваемые в этом классе будут инициализироваться при первом обращении к ним. Либо мы можем повесить @Lazy на метод с @Bean, чтобы указать только один бин для ленивой загрузки. Рассмотрим пример с @Autowired:

@Lazy
@ToString
@Component
public class Apple {
    public Apple() {
        System.out.println(
            "Apple bean initialized");
    }
}

У нас есть класс с аннотацией @Lazy, который так же помечен как @Component. И есть класс куда мы инжектим этот бин:

@Component
public class Bag {

    public Apple apple;

    @Autowired
    public Bag(@Lazy Apple apple) {
        this.apple = apple;
        System.out.println(
            "Bag bean initialized");
    }
}

Обратите внимание, что @Lazy так же и над аргументом конструктора (если инжектим через него), это обязательно! Мы можем поднять контекст и посмотреть, что происходит:

@SpringBootApplication
public class Application {

    public static void main(String[] args) {

        var context = SpringApplication
            .run(Application.class, args);
        System.out.println("Context is up");
        Bag bag = context.getBean(Bag.class);
        System.out.println("Bag is gotten");
        System.out.println(bag.apple);
    }
}

Вывод будет следующим:

Bag bean initialized
Context is up
Bag is gotten
Apple bean initialized
Apple()

Как мы видим - сначала создастся бин класса Bag и поднимется контекст, и только после обращения к бину Apple через Bag, бин Apple проинициализируется. Использование аннотации @Lazy особенно полезно в больших приложениях, где не все бины нужны сразу и можно сэкономить ресурсы, инициализируя их только по мере необходимости. 🫡 Секреты Java #java #spring #lazy

Разбираем как решать задачи на LeetCode ✅ Примеры решений ✅ Пояснения Выбери своё направление: 1. Python 2. JavaScript 3. Java 4. C# 5. Golang 6. С/C++ 7. PHP 8. Kotlin 9. Swift