Велислав Крастев Блог

Шта су СОЛИД принципи?

Шта је принцип јединствене одговорности (СРП):

Одељење треба да има само једну одговорност.
Требало би да има само један разлог за промену.
Предности укључују лакше тестирање, ниже спајање и бољу организацију.
Пример:

Јава

јавна класа књига {
приватно име стринга;
приватни Стринг аутор;
приватни стринг текст;
// конструктори, геттери и сеттери
}

Шта је отворено-затворено начело (ОЦП):

Софтверски ентитети (класе, модули, функције) треба да буду отворени за проширење, али затворени за модификацију.
Постигните ово коришћењем интерфејса, апстрактних класа и наслеђивања.
Пример:
Јава

интерфејс Схапе {
двострука област();
}
цласс Цирцле имплементира Схапе { /* имплементацију / } класа Правоугаоник имплементира облик { / имплементација */ }

Шта је Лисков принцип замене (ЛСП):

Подтипови морају бити заменљиви за своје основне типове без промене исправности програма.
Прати однос “је-а”.
Пример:
Јава

класа птица { /* уобичајено понашање птица / } класа Врабац продужава птицу { / специфично понашање врапца */ }

Шта је принцип сегрегације интерфејса (ИСП):

Клијенте не треба присиљавати да зависе од интерфејса које не користе.
Поделите велике интерфејсе на мање, специфичније.
Пример:
Јава

интерфејс Воркер {
воид ворк();
}
интерфејс Еатер {
воид еат();
}
класа Робот имплементира Воркер { /* имплементација */ }

Шта је принцип инверзије зависности (ДИП):

Модули високог нивоа не би требало да зависе од модула ниског нивоа; оба треба да зависе од апстракција.
Апстракције не би требало да зависе од детаља; детаљи треба да зависе од апстракција.

// Абстракција
интерфејс МессагеСендер {
воид сендМессаге(Стринг порука);
}

// Модул високог нивоа
цласс НотифицатионСервице {
привате МессагеСендер мессагеСендер;

public NotificationService(MessageSender messageSender) {
    this.messageSender = messageSender;
}
public void send(String message) {
    messageSender.sendMessage(message);
}

}

// Модул ниског нивоа
цласс ЕмаилСендер имплементира МессагеСендер {
@Оверриде
публиц воид сендМессаге(Стринг порука) {
Систем.оут.принтлн(“Слање е-поште: ” + порука);
}
}

// Још један модул ниског нивоа
класа СмсСендер имплементира МессагеСендер {
@Оверриде
публиц воид сендМессаге(Стринг порука) {
Систем.оут.принтлн(“Слање СМС-а: ” + порука);
}
}

// Главна класа
јавна класа главна {
публиц статиц воид маин(Стринг[] аргс) {
// Користи ЕмаилСендер
МессагеСендер емаилСендер = нови ЕмаилСендер();
НотифицатионСервице нотифицатионСервице1 = нови НотифицатионСервице(емаилСендер);
нотифицатионСервице1.сенд(“Здраво путем е-поште!”);

    // Use SmsSender
    MessageSender smsSender = new SmsSender();
    NotificationService notificationService2 = new NotificationService(smsSender);
    notificationService2.send("Hello via SMS!");
}

}

МессагеСендер интерфејс служи као апстракција.
Модул високог нивоа НотифицатионСервице зависи од ове апстракције уместо од конкретних имплементација.
Модули ниског нивоа као што су ЕмаилСендер и СмсСендер такође зависе од апстракције имплементацијом МессагеСендер интерфејса.

Шта је нормализација СКЛ-а?

Шта је нормализација?
Нормализација подразумева структурирање података унутар релационе базе података како би се елиминисале аномалије као што је редундантност.
Он раставља велике, сложене табеле на мање док одржава односе података.
Зашто је нормализација важна?
Смањује редундантност: Поделом података у мање табеле избегавамо вишеструко складиштење истих информација.
Побољшава перформансе упита: Мање нормализоване табеле доводе до бржег извршавања упита.
Минимизира аномалије ажурирања: Ажурирања се могу вршити без утицаја на друге записе.
Побољшава интегритет података: Обезбеђује доследне и тачне податке.
Сценарији за нормализацију:
Интегритет података: Спречите недоследности приликом ажурирања података (нпр. промене старости купаца).
Ефикасно постављање упита: Поједноставите сложене упите разбијањем података.
Оптимизација складиштења: Уклоните непотребну сувишност да бисте уштедели простор.

Шта је монолит Мицросервицес?

Шта је монолит?

Монолитна апликација је изграђена као јединствена, уједињена јединица. Он чврсто повезује све компоненте (као што су кориснички интерфејс на страни клијента, база података и апликација на страни сервера) у једну базу кода.
Предности:
Лако постављање: Пошто је то једна извршна датотека или директоријум, имплементација је једноставна.
Брзина развоја: На почетку живота пројекта, монолити омогућавају брз развој због своје једноставности.
Перформансе: Централизовани код може да обрађује различите функције.

Шта су микроуслуге?

Микросервисе растављају апликацију на мање услуге које се могу независно применити. Свака услуга се фокусира на одређени пословни домен.
Предности:
Скалабилност: Микросервис омогућава независно скалирање појединачних компоненти.
Флексибилност: Програмери могу изабрати различите технологије за сваку услугу.
Изолација: Грешке у једној услузи не утичу на друге.
Изазови:
Сложеност: Управљање вишеструким услугама захтева снажну оркестрацију.
Мрежни проблеми: Комуникација између услуга доводи до кашњења.
Сложеност примене: Координација ажурирања у свим услугама може бити незгодна.

Шта је полиморфизам?

Замена метода:
Када поткласа обезбеђује специфичну имплементацију за метод који је већ дефинисан у његовој суперкласи.

Преоптерећење метода:
Када класа има више метода са истим именом, али различитим параметрима (различитим бројем или типовима аргумената).

Шта користе приватни конструктори?

–Приватни конструктори се користе у услужним класама или константним класама.
Ове класе садрже само статичке методе или чланове.

–Избегавање подкласирања

— Делегација конструктора:
Приватни конструктори дозвољавају делегирање конструктора, где специфични конструктори називају заједнички приватни конструктор.

— Синглетон Паттерн

О ЈВМ-у

–Компилација:
Када компајлирате .јава датотеку, Јава компајлер генерише датотеке .цласс које садрже бајт код (средња репрезентација).
Битецоде је независан од платформе и може да ради на било ком систему са компатибилним ЈВМ-ом.
— Подсистем за учитавање класе:
Одговоран за учитавање класа у меморију.
Чита .цласс датотеке, генерише бинарне податке и складишти их у области метода.
Креира објекат Цласс који представља учитану класу у меморији гомиле.
Пример: Студент с1 = нови Студент(); Класа ц1 = с1.гетЦласс();
–Повезивање:
Састоји се од три корака:
Верификација: Осигурава исправност .цласс датотеке.
Припрема: Додељује меморију за променљиве класе и иницијализује их.
Резолуција (опционо): Решава симболичке референце на друге класе или методе.
–Иницијализација:
Извршава статичке иницијализаторе (нпр. статичке блокове) и иницијализује статичке променљиве.
Променљиве инстанце се иницијализују када се објекат креира.
— Извршни механизам:
Конвертује бајт код у машински код.
Укључује Јуст-Ин-Тиме (ЈИТ) компилацију за оптимизацију перформанси.

— Укратко, ЈВМ дозвољава Јава програмима да се покрећу било где тумачењем бајткода и управљањем меморијом

Шта је Приват апстрактна метода?

— Случајеви употребе приватних метода у апстрактним класама:
Иако апстрактне методе не могу бити приватне, можете користити приватне методе унутар апстрактне класе у различите сврхе:
— Методе помоћи: Имплементирајте заједничку функционалност коју деле друге методе.
–Енкапсулација: Сакриј детаље имплементације из подкласа.
— Класе сличне структури: Креирајте мале класе са приватним методама које служе као контејнери података

Шта је сакупљач смећа?

— Хеап меморија:
Јава објекти се креирају у хрпи, наменској области меморије.
Неки објекти постају недоступни (више их не референцира програм).
— Сакупљач смећа (ГЦ):
ГЦ идентификује и брише некоришћене објекте да би ослободио меморију.
Покреће се аутоматски у позадини.
две врсте:
Мањи ГЦ: Уклања недоступне објекте у младој генерацији.
Главни ГЦ (Фулл ГЦ): Брише објекте старе генерације.
–Предности:
Програмери не морају експлицитно да бришу објекте.
ГЦ обезбеђује доступност меморије и спречава ОутОфМемориЕррорс

Шта је ООП?

Четири принципа ООП-а:
–Енкапсулација: Спајање података (атрибута) и метода (функција) заједно у оквиру класе да би се сакрили детаљи имплементације и обезбедио чист интерфејс.
–Наслеђивање: Креирање нових класа на основу постојећих, наслеђивање њихових атрибута и понашања. Промовише поновну употребу кода.
–Полиморфизам: омогућава да се објекти различитих класа третирају уједначено кроз заједнички интерфејс. Омогућава флексибилност и проширивост.
–Апстракција: Фокусирање на битне карактеристике уз скривање непотребних сложености. Апстракција поједностављује дизајн и чини га лакшим за управљање.

Шта је АЦИД својства играју кључну улогу у обезбеђивању поузданости и доследности трансакција.

–атомичност:
Трансакције се извршавају у потпуности или се уопште не извршавају.
Без делимичног извршења: Ако трансакција не успе на пола пута, све промене у бази података се поништавају.
Пример: Размислите о преносу 100 УСД са рачуна Кс на рачун И. Ако трансакција не успе након одбитка од Кс, али пре додавања у И, база података остаје конзистентна.
–Доследност:
База података мора да одржава ограничења интегритета пре и после трансакције.
Пример: Ако је укупан износ пре трансакције 700 УСД (Кс: 500 УСД, И: 200 УСД), требало би да остане исти након трансакције (Кс: 400 УСД, И: 300 УСД).
–Изолација:
Више трансакција се може одвијати истовремено без утицаја једна на другу.
Промене направљене једном трансакцијом нису видљиве другима док се не обаве.
Обезбеђује еквивалентне резултате као да се трансакције извршавају серијски.
Пример: Изоловање трансакција спречава недоследности услед испреплетаних операција.
–Издржљивост:
Када се трансакција изврши, њене промене су трајне.
Преживљава системске кварове или падове.
Обезбеђује постојаност података.
Пример: Чак и након поновног покретања система, унете промене остају нетакнуте.
Запамтите, својства АЦИД-а пружају основу за поуздане и доследне операције базе података! 🌟

Шта је стратешки образац?
Опис: Дефинише породицу алгоритама, инкапсулира сваки од њих и чини их заменљивим. Омогућава да се алгоритам разликује независно од клијената који га користе.
Пример:
Јава

// Интерфејс за понашање у исхрани
интерфејс ЕатБехавиор {
воид еат();
}

// Конкретне имплементације понашања у исхрани
цласс НормалДиет имплементира ЕатБехавиор {
@Оверриде
публиц воид еат() {
// Нормална храна
}
}

цласс ЛосингВеигхтДиет имплементира ЕатБехавиор {
@Оверриде
публиц воид еат() {
// Здрава храна
}
}

// Час мачака са понашањем у јелу
апстрактна класа Цат {
ЕатБехавиор еатБехавиор;

public void eat() {
    eatBehavior.eat();
}
public void setEatBehavior(EatBehavior eatBehavior) {
 this.eatBehavior = eatBehavior;
}

}

// Употреба
Цат цат = нев Цат();
цат.сетЕатБехавиор(нев ЛосингВеигхтДиет());
цат.еат(); // Мачка се храни здравијом исхраном

Креативни обрасци:
Ови обрасци се фокусирају на инстанцирање класе.
Примери укључени

— Фабрички метод,
Исказ проблема: Претпоставимо да желимо да креирамо различите типове производа (нпр. аутомобиле, бицикле, бицикле) без чврстог повезивања нашег кода са специфичним имплементацијама.
Кључне компоненте:
Производ: Апстрактна класа или интерфејс који дефинише уобичајене операције за објекте које ће фабрика креирати.
Бетонски производи: Стварне класе које имплементирају интерфејс производа и представљају специфичне типове објеката.
Креатор: апстрактна класа или интерфејс који декларише фабрички метод. Одговоран је за креирање објеката производа, али делегира стварну креацију на подкласе.
Конкретни креатори: Подкласе Креатора које имплементирају фабрички метод. Они одлучују који ће конкретни бетонски производ креирати на основу улазних параметара или конфигурације.
Фабрички метод: Метод дефинисан у класи Цреатор који креира објекте производа. Обично је декларисан као апстрактан у Креатору и имплементиран у Цонцрете Цреаторима.
Пример у Јави: Рецимо да имамо фабрику која производи различите типове возила. Ево поједностављеног примера:
Јава

// АбстрацтПродуцт
интерфејс Производ {
воид дисплаи();
}

// Бетонски производи
класа Опрема за аутомобиле Производ {
јавни воид дисплаи() {
Систем.оут.принтлн(“Аутомобил креиран”);
}
}

класа Прикључци за бицикле Производ {
јавни воид дисплаи() {
Систем.оут.принтлн(“Бицикл креиран”);
}
}

// Креатор (Фабрика)
Фабрика интерфејса {
Продуцт фацториМетход();
}

// Цонцрете Цреаторс
класа ЦонцретеФацториА имплементира Фацтори {
публиц Продуцт фацториМетход() {
ретурн нев Цар();
}
}

класа ЦонцретеФацториБ имплементира Фацтори {
публиц Продуцт фацториМетход() {
ретурн нев Бике();
}
}

јавна класа ФацториМетходЕкампле {
публиц статиц воид маин(Стринг[] аргс) {
Фацтори фацториА = нев ЦонцретеФацториА();
Производ производА = фацториА.фацториМетход();
продуцтА.дисплаи();

    Factory factoryB = new ConcreteFactoryB();
    Product productB = factoryB.factoryMethod();
    productB.display();
}

}

— Градитељ
Буилдер Паттерн је креативни образац дизајна који вам омогућава да конструишете сложене објекте корак по корак,
одвајајући њихову конструкцију од њихове репрезентације. Ево једноставног примера у Јави:
// Дефинишите класу коју желите да направите
цласс Пост {
приватни завршни назив стринга;
приватни завршни Стринг текст;
привате финал Стринг категорија;

Post(Builder builder) {
    this.title = builder.title;
    this.text = builder.text;
    this.category = builder.category;
}
// Getters for properties
public String getTitle() {
    return title;
}
public String getText() {
    return text;
}
public String getCategory() {
    return category;
}
// Builder class
public static class Builder {
    private String title;
    private String text;
    private String category;
    public Builder title(String title) {
        this.title = title;
        return this;
    }
    public Builder text(String text) {
        this.text = text;
        return this;
    }
    public Builder category(String category) {
        this.category = category;
        return this;
    }
    public Post build() {
        return new Post(this);
    }
}

}

// Употреба
јавна класа главна {
публиц статиц воид маин(Стринг[] аргс) {
Пост пост = нев Пост.Буилдер()
.титле(“Јава Буилдер образац”)
.тект(“Објашњавање како да се имплементира шаблон градитеља у Јави”)
.цатегори(“Узорци дизајна”)
.буилд();

    System.out.println("Title: " + post.getTitle());
    System.out.println("Text: " + post.getText());
    System.out.println("Category: " + post.getCategory());
}

}

–Прототип
Образац прототипа је креативни образац дизајна који вам омогућава да креирате нове објекте копирањем постојећег објекта.
Уместо да креирате нове инстанце од нуле, ви клонирате постојећи прототип, који може бити ефикаснији и флексибилнији. Хајде да заронимо у пример у Јави:
Дефинишите интерфејс прототипа: Прво, креирамо апстрактну класу или интерфејс под називом Дрво са апстрактном методом цопи():
Јава

јавна апстрактна класа дрво {
јавни сажетак Трее цопи();
}

Бетонски прототипови: Затим имплементирамо две конкретне класе које проширују дрво: ПластицТрее и ПинеТрее. Ове класе представљају специфичне типове стабала и обезбеђују сопствену имплементацију методе цопи():
Јава

јавна класа ПластицТрее ектендс Трее {
@Оверриде
јавна копија дрвета() {
ПластицТрее пластицТрееЦлоне = ново ПластицТрее(тхис.гетМасс(), тхис.гетХеигхт());
пластицТрееЦлоне.сетПоситион(тхис.гетПоситион());
ретурн пластицТрееЦлоне;
}
}

јавна класа ПинеТрее ектендс Трее {
@Оверриде
јавна копија дрвета() {
ПинеТрее пинеТрееЦлоне = ново ПинеТрее(тхис.гетМасс(), тхис.гетХеигхт());
пинеТрееЦлоне.сетПоситион(тхис.гетПоситион());
ретурн пинеТрееЦлоне;
}
}
У овим часовима прилагођавамо процес клонирања на основу специфичног типа стабла. На пример, копирамо масу, висину и позицију оригиналног дрвета.
Употреба: Сада, хајде да креирамо инстанце наших конкретних прототипова:
Јава

јавна класа главна {
публиц статиц воид маин(Стринг[] аргс) {
Дрво оригиналПластицТрее = ново ПластицТрее(10, 5);
Стабло клонираноПластицТрее = оригиналПластицТрее.цопи();

    Tree originalPineTree = new PineTree(15, 8);
    Tree clonedPineTree = originalPineTree.copy();

    // Use the cloned trees as needed
    // ...
}

}

Шта су структурни обрасци?
Ови обрасци се баве структуром и саставом класе.

–Узорак адаптера
Адаптер Паттерн је структурални образац дизајна који вам омогућава да два некомпатибилна интерфејса раде заједно.
Делује као мост између ових интерфејса, омогућавајући сарадњу без измене њиховог изворног кода.

Адаптер за објекте:
У овом приступу користимо композицију за делегирање логике адаптеру.
Адаптер садржи Адаптее и делегира метод рекуест() методу специфицРекуест() у Адаптее-у.
Јава

// Адаптиран (постојећа класа)
разред Адаптее {
воид специфицРекуест() {
Систем.оут.принтлн(“Специфичан захтев адаптираног”);
}
}

// Циљни интерфејс
интерфејс Таргет {
воид рекуест();
}

// Адаптер (користећи композицију)
класа Адаптер имплементира Таргет {
приватно финале Адаптее адаптее;

Adapter(Adaptee adaptee) {
    this.adaptee = adaptee;
}
@Override
public void request() {
    adaptee.specificRequest();
}

}

ЦлассАдаптер:
Захтева вишеструко наслеђивање (није директно могуће у Јави).
То можемо постићи коришћењем интерфејса са подразумеваним методама.
Адаптер проширује и класу Таргет и Адаптее.
Јава

// Циљни интерфејс
интерфејс Таргет {
воид рекуест();
}

// Адаптиран (постојећа класа)
разред Адаптее {
воид специфицРекуест() {
Систем.оут.принтлн(“Специфичан захтев адаптираног”);
}
}

// Адаптер (користећи наслеђивање класа)
цласс Адаптер ектендс Адаптее имплементира Таргет {
@Оверриде
јавни неважећи захтев() {
специфицРекуест();
}
}
Предности и компромиси:
Адаптер класе добро функционише за мапирање метода један-на-један.
Објецт Адаптер пружа већу флексибилност и избегава модификацију кода.

–Узорак декоратера
Декоратор шаблон је креативни образац дизајна који вам омогућава да динамички додате функционалност и понашање објекту без
утичући на понашање других постојећих објеката унутар исте класе. Посебно је корисно када желите да проширите објекат
способности без промене његове структуре.

Преглед:
Декоратор Паттерн пружа побољшани интерфејс оригиналном објекту тако што га умотава у додатну функционалност.
Преферирамо композицију над наслеђивањем да бисмо смањили трошкове поткласирања.
Декоратори се могу додати у току рада, што омогућава флексибилност.
Пример сценарија: Претпоставимо да имамо објекат божићно дрвце и желимо да га украсимо разним предметима попут венаца, шљокица и лампица са мехурићима. Пратићемо оригиналне конвенције дизајна Ганг оф Фоур:
Имплементација:
Прво направите интерфејс ЦхристмасТрее:
Јава

јавни интерфејс ЦхристмасТрее {
Стринг децорате();
}

Имплементирајте интерфејс са основним стаблом:
Јава

јавна класа ЦхристмасТрееИмпл имплементира ЦхристмасТрее {
@Оверриде
публиц Стринг децорате() {
вратити “Божићно дрво”;
}
}

Затим креирајте апстрактну класу ТрееДецоратор која имплементира ЦхристмасТрее и држи украшено дрво:
Јава

јавна апстрактна класа ТрееДецоратор имплементира ЦхристмасТрее {
приватно коначно божићно дрво;

public TreeDecorator(ChristmasTree tree) {
    this.tree = tree;
}
@Override
public String decorate() {
    return tree.decorate();
}

}

Сада креирајте специфичне декоратере. На пример, БубблеЛигхтс:
Јава

јавна класа БубблеЛигхтс проширује ТрееДецоратор {
публиц БубблеЛигхтс(ЦхристмасТрее трее) {
супер(дрво);
}

@Override
public String decorate() {
    return super.decorate() + " with Bubble Lights";
}

}

јавна класа Гарланд проширује ТрееДецоратор {
јавни герланд (божићно дрво) {
супер(дрво);
}

@Override
public String decorate() {
    return super.decorate() + " with Garland";
}

}
Употреба:
Направите украшено дрвеће:
Јава

јавна класа ДецораторПаттернДемо {
публиц статиц воид маин(Стринг[] аргс) {
ЦхристмасТрее трее1 = нев Гарланд(нев ЦхристмасТрееИмпл());
Систем.оут.принтлн(трее1.децорате()); // Излаз: “Божићно дрво са венцем”

    ChristmasTree tree2 = new BubbleLights(new Garland(new Garland(new ChristmasTreeImpl())));
    System.out.println(tree2.decorate()); // Output: "Christmas tree with Garland with Garland with Bubble Lights"
}

}
Шаблон омогућава додавање декоратера током рада, дајући флексибилност украшавању по потреби.
Запамтите, шаблон декоратора се широко користи у сценаријима у којима желите да побољшате понашање објекта без модификације његове основне структуре

— Узорак фасаде
Фасадни шаблон је структурални образац дизајна који поједностављује интеракцију са сложеним подсистемом обезбеђивањем јединственог интерфејса.
Делује као „улазна врата“ да би сакрила основну сложеност и олакшала клијентима да користе систем

–Цомпосите
Композитни образац је структурални образац дизајна који вам омогућава да саставите објекте у структуре стабла да бисте представили хијерархију део-целина.
Главна идеја иза композитног узорка је да се изгради структура стабла објеката, где појединачни објекти и композитни објекти деле заједнички интерфејс.

Основна компонента (одељење): Дефинисаћемо једноставан интерфејс одељења као нашу основну компоненту:
Јава

јавни интерфејс Департмент {
воид принтДепартментНаме();
}

Компоненте листа (ФинанциалДепартмент и СалесДепартмент): Хајде да креирамо класе за финансијска и продајна одељења, при чему обе имплементирају интерфејс одељења:
Јава

јавна класа Финансијски одељење имплементира Одељење {
// Детаљи имплементације (нпр. ИД, име)
публиц воид принтДепартментНаме() {
Систем.оут.принтлн(гетЦласс().гетСимплеНаме());
}
}

јавна класа Одељење продаје имплементира Одељење {
// Детаљи имплементације (нпр. ИД, име)
публиц воид принтДепартментНаме() {
Систем.оут.принтлн(гетЦласс().гетСимплеНаме());
}
}

Ове лисне класе имплементирају метод принтДепартментНаме() и не садрже референце на друге објекте Одељења.
Композитни елемент (ХеадДепартмент): Као композитна класа, хајде да направимо ХеадДепартмент који садржи колекцију компоненти одељења:
Јава

импорт јава.утил.АрраиЛист;
импорт јава.утил.Лист;

јавна класа шеф одељења имплементира одељење {
приватни Интегер ид;
приватно име стринга;
приватни Лист цхилдДепартментс;

public HeadDepartment(Integer id, String name) {
    this.id = id;
    this.name = name;
    this.childDepartments = new ArrayList<>();
}
public void printDepartmentName() {
    childDepartments.forEach(Department::printDepartmentName);
}
public void addDepartment(Department department) {
    childDepartments.add(department);
}
public void removeDepartment(Department department) {
    childDepartments.remove(department);
}

}

Класа ХеадДепартмент имплементира метод принтДепартментНаме() и обезбеђује методе за додавање и уклањање подређених одељења.
Употреба: Можете креирати инстанце одељења листа (нпр. Одељење за финансије, Одељење продаје) и сложено одељење (нпр. ХеадДепартмент). Додајте одељења листова у композит и одштампајте њихова имена.
Јава

јавна класа главна {
публиц статиц воид маин(Стринг[] аргс) {
Одељење за финансије = ново Финансијско одељење();
Одељење продаје = нови Одељење продаје();

    HeadDepartment headDepartment = new HeadDepartment(1, "Company Departments");
    headDepartment.addDepartment(finance);
    headDepartment.addDepartment(sales);

    headDepartment.printDepartmentName();
}

}

Излаз:
ФинанциалДепартмент
СалесДепартмент

Композитни узорак вам омогућава да креирате флексибилне структуре дрвета где
појединачни предмети и композиције (композити) могу се третирати једнообразно.

Шта је ХАСХ функција !!!

Хеш функција је математичка функција која узима улаз (или “поруку”) и враћа низ знакова фиксне величине,
што је типично низ бројева и слова. Овај излаз се назива „хеш вредност“ или једноставно „хеш“.
Хеш функције се обично користе у рачунарству и криптографији и имају неколико важних својстава:

=== Како бисте користили хеш функцију и како она функционише?

Детерминистички: Исти унос ће увек производити исти хеш.

Брзо: Функција може брзо да израчуна хеш вредност за било који дати улаз.
Јединствено (скоро): Два различита улаза би требало да произведу различите хешове (ово је познато као минимизирање „судара“).
Неповратно: С обзиром на хеш, требало би да буде рачунарски неизводљиво да се одреди оригинални унос.
Униформ: Хеш вредности су равномерно распоређене по излазном простору.

Хеш функције се широко користе у различитим апликацијама, као што су:

Интегритет података: Да би се осигурало да подаци нису промењени или лажирани, упоређивањем хеш вредности.
Складиштење лозинки: Безбедно складиштење хешираних лозинки уместо стварних лозинки.
Криптографија: Користи се у дигиталним потписима и другим криптографским алгоритмима.
Хеш табеле: За ефикасно проналажење података у програмирању.

=== Дајте ми пример хеш мапе, како бисте је користили?

СХА (Алгоритам безбедног хеширања):
Укључује варијанте као што су СХА-1, СХА-256, СХА-384 и СХА-512.
СХА-256 и СХА-512 се широко користе у криптографији и блоцкцхаин технологији (нпр. Битцоин).

импорт јава.сецурити.МессагеДигест;
импорт јава.сецурити.НоСуцхАлгоритхмЕкцептион;

јавна класа ХасхЕкампле {
публиц статиц воид маин(Стринг[] аргс) {
пробај {
// Улазни низ који се хешује
Стринг инпут = “Здраво, свет!”;

        // Create a MessageDigest instance for SHA-256
        MessageDigest digest = MessageDigest.getInstance("SHA-256");

        // Compute the hash
        byte[] hash = digest.digest(input.getBytes());

        // Convert the hash bytes to a hexadecimal string
        StringBuilder hexString = new StringBuilder();
        for (byte b : hash) {
            String hex = String.format("%02x", b);
            hexString.append(hex);
        }

        // Print the resulting hash
        System.out.println("SHA-256 Hash: " + hexString.toString());
    } catch (NoSuchAlgorithmException e) {
        System.err.println("Error: " + e.getMessage());
    }
}

}

Улазни подаци: Улазна променљива садржи податке које желите да хеширате.
Иницијализација МессагеДигест: Инстанца МессагеДигест се креира коришћењем гетИнстанце(“СХА-256”), који специфицира СХА-256 алгоритам хеширања.
Хеширање: Метода дигеста израчунава хеш улазних података.
Хексадецимална конверзија: Пошто је хеш у бинарном формату, користимо петљу да га претворимо у читљивији хексадецимални низ.

Ставити и закрпити? Када га користити?

И ПУТ и ПАТЦХ су ХТТП методе које се користе за ажурирање ресурса на серверу, али се разликују по начину на који обрађују ажурирања:

СТАВИТИ:
Потпуно ажурирање:
ПУТ се користи за потпуну замену постојећег ресурса.
У захтеву је потребно послати цео ресурс, чак и ако се мења само део.

Ако ресурс не постоји, ПУТ га често креира (иако ово понашање може да варира).

Идемпотент:

Поновљени ПУТ захтеви са истим подацима ће увек резултирати истим стањем ресурса.
Пример: Ажурирање профила корисника:

јсон
ПУТ /усерс/123
{
“име”: “Велислав”,
“емаил”: “ОЗИКС0З”,
“старост”: 30
}
Ако се промени само име, али адреса е-поште и старост остају исти, они и даље морају бити укључени у захтев.

ЗАкрпе:
Делимично ажурирање:

ПАТЦХ се користи за делимично ажурирање постојећег ресурса.
У захтеву је потребно послати само поља која се мењају.

Идемпотент (углавном):

Као и ПУТ, поновљени ПАТЦХ захтеви са истим подацима генерално резултирају истим стањем ресурса.
Међутим, понашање може зависити од имплементације сервера.

Пример: Ажурирање само имена корисника:

јсон
ПАТЦХ /усерс/123
{
“име”: “Велислав”
}
Овде се ажурира само поље имена, а остала поља остају непромењена.

Кључна разлика:
ПУТ замењује цео ресурс, док ПАТЦХ мења само одређена поља ресурса.

ХТТП методе са кратким описом.

ГЕТ: Користи се за преузимање података са сервера без њихове измене. Обично се користи за преузимање ресурса или информација.
ПОСТ: Користи се за слање података на сервер, обично за креирање новог ресурса. На пример, подношење обрасца или отпремање датотеке.
ПУТ: Користи се за ажурирање или потпуну замену постојећег ресурса на серверу. Ако ресурс не постоји, може бити креиран.
ПАТЦХ: Користи се за делимична ажурирања постојећег ресурса, мењајући само наведена поља.
ДЕЛЕТЕ: Користи се за брисање ресурса са сервера.
ХЕАД: Слично ГЕТ-у, користи се за преузимање заглавља без тела ресурса.
ОПЦИЈЕ: Говори које су ХТТП методе дозвољене.
ТРАЦЕ: Користи се углавном у дијагностичке сврхе тако што се захтев враћа клијенту
ЦОННЕЦТ: Успоставља тунел до сервера, који се често користи за ССЛ/ТЛС везе.

=========== Функционални интерфејс =====================================

Функционални интерфејс у ​​Јави је интерфејс који садржи тачно једну апстрактну методу. Ови интерфејси се првенствено користе у ламбда изразима и референцама метода, омогућавајући сажетије и читљивије функционално програмирање.

Кључне карактеристике:

1. Појединачни апстрактни метод: Функционални интерфејс има само један апстрактни метод. Ово је суштина његове функционалности.
2. Подразумеване и статичке методе: Функционални интерфејси могу укључивати подразумеване и статичке методе, али се оне не рачунају као појединачни апстрактни метод.
3. @ФунцтионалИнтерфаце Аннотатион: Иако је ова напомена опциона, она помаже тиме што сигнализира да је интерфејс намењен да буде функционалан. Ако се интерфејсу додају додатне апстрактне методе, компајлер испушта грешку.

Пример:

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}
// Using lambda expression
public class Main {
    public static void main(String[] args) {
        // Implementing the calculate method using a lambda
        Calculator addition = (a, b) -> a + b;
        Calculator multiplication = (a, b) -> a * b;
        System.out.println("Addition: " + addition.calculate(5, 3));  // Output: 8
        System.out.println("Multiplication: " + multiplication.calculate(5, 3));  // Output: 15
    }
}

Случај употребе:

Тхе Calculator интерфејс у ​​примеру има једну апстрактну методу calculate, што га чини функционалним интерфејсом.
Ово нам омогућава да користимо ламбда изразе за краткоћу и елеганцију у имплементацији.

Уобичајени функционални интерфејси у Јави:

Јава пружа неколико уграђених функционалних интерфејса у java.util.function пакети, као што су:

• Предикат: Узима улаз и враћа логички.
• Функција: Узима улаз и враћа излаз типа Р.
• Добављач: Пружа вредност без уноса.
• Цонсумер: Прихвата вредност и извршава радњу.

Функционални интерфејси поједностављују операције, посебно у сценаријима као што је рад са колекцијама, токовима или асинхроним задацима.

Они овлашћују Јаву да усвоји парадигме функционалног програмирања уз задржавање своје објектно оријентисане природе.

================ функција вишег реда је ==============================
Функција вишег реда је функција која или узима друге функције као аргументе или враћа функцију као резултат. Другим речима, ради на функцијама, третирајући их као „грађане првог реда“. Ово је моћна карактеристика у парадигмама функционалног програмирања, омогућавајући апстракцију, поновну употребу кода и композицију.

Пример функције вишег реда у Јави:

import java.util.function.Function;
public class Main {
    public static void main(String[] args) {
        // Higher-order function: applies a function to a value
        Function<Integer, Integer> squareFunction = x -> x * x;
        int result = applyFunction(5, squareFunction);
        System.out.println("Square of 5: " + result);  // Output: 25
    }
    public static int applyFunction(int value, Function<Integer, Integer> function) {
        return function.apply(value);
    }
}

У горњем примеру:

• Тхе applyFunction метода је функција вишег реда јер прихвата другу функцију (Function<Integer, Integer>) као параметар.

Карактеристике:

1. Прихвата функције као аргументе: Функције вишег реда могу узети друге функције као улаз за обављање специфичних операција.
2. Враћа функције: Они могу да генеришу и враћају нове функције динамички.
3. Подстиче поновну употребу кода: Промовише модуларни код који се може поново користити јер функције могу да се прослеђују и састављају заједно.

Случај употребе:

У Јави, функције вишег реда се обично користе у функционалном програмирању са токовима, ламбда и референцама метода. на пример:

List<String> names = Arrays.asList("John", "Jane", "Jake");
names.stream()
     .filter(name -> name.startsWith("J"))  // Takes a lambda function as argument
     .forEach(System.out::println);         // Takes a method reference as argument

Функције вишег реда доносе флексибилност и моћ Јава програмима, омогућавајући програмерима да пишу чист, концизан и изражајан код!

Овде су постављени неки одговори на интервју у стварном свету.

• Разуме основе као што су полиморфизам, статичке методе и скуп стрингова
• упознати са колекцијама (нпр. ХасхСет, ТрееСет) и случајевима њихове употребе.
• Тачно идентификује беан опсеге (синглетон, прототип)
• Свестан ињекције зависности и њене сврхе.
• зна како да имплементира релације много-према-више користећи спојне табеле.
• Разуме сврху индекса (иако површно)
• може разликовати монолитну и микросервисну архитектуру
• разуме основне компромисе (скалабилност, могућност одржавања)
• погрешно схвата Лисков принцип замене и инверзију зависности
• Бори се да пружи конкретне примере за принцип отвореног/затвореног.
• Недостаје дубина у управљању животним циклусом зрна
• Нејасно о напредној ињекцији зависности
• површно разумевање индекса (композитни индекси, оптимизација упита)
• Не познаје нивое изолације и оптимистичко/песимистичко закључавање

Предности:

• Радио је са старим кодом у огромном и сложеном систему
• Зна СОЛИД
• Познавање токова
• Објашњени индекси и АЦИД
• Добар ниво енглеског
  Против:
• Без одговорности за постављање или инфраструктуру, учешће у пројектовању архитектуре
• Има извесно знање о принципима ООП-а, али се заиста трудио да их објасни и погрешио је неке концепте
• Опште познавање колекција, али има празнина и веома је несигурно
• Не разуме разлику између истовремености и паралелизма, не баш добро познавање паралелизма
• Нисам се много бавио архитектуром микро сервиса
• Нејасно о неким концептима базе података (дискусија о индексима је била на површинском нивоу)
• Не могу да објасним ливелоцк
• Празнине у коначно блокирају разумевање
• Ограничено знање о специфичностима обраде изузетака
• Збуњени око модификатора приступа (заштићени у односу на приватни пакет)
  Консензус мишљење …..је
  није погодан за позицију програмера за Мид-Јава због недостатака у његовом техничком знању.

Прос
Добро објаснио СОЛИД
Добро објаснио ООП
Објашњена композиција (али се у почетку мало мучила)
Одлично разумевање колекција
Разлика између листа и скупова
Хасхсетс
Хасхмап
ЦонцуррентХасхмап
Добро разумевање структура података – стекове, редове, стабла
Добро познавање јвм архитектуре
Објашњена паралелност наспрам паралелизма, демонстрирано добро познавање вишенитних апликација
Добро разумевање РЕСТ-а
Добро објаснио дб индексе
Објаснио различите врсте спојева