แฎแจแแ แแ แแฎแแแแแ แแแแแแแแแ แแแก, แ แแแแแแกแแช แแ แกแแแแแแ SOLID แแ แแแชแแแแแแก แจแแกแแฎแแ (แฉแแแ . โ แแแ แแแแ) แแ แแแแแฅแขแแ แแ แแแแขแแ แแแฃแแ แแ แแแ แแแแ แแแ (OOP), แแ แแกแแแแแแ แแแ แจแแกแแฎแแ, แแแแ แแ แแ แแแแแแงแแแแ แแกแแแ แแ แแฅแขแแแแจแ. แแก แกแขแแขแแ แแฆแฌแแ แก OOP แแ แแแชแแแแแแก แฃแแแ แแขแแกแแแแแก, แ แแแแแแแช แแฎแแแ แแแ แแแแแแแแแ แก แงแแแแแแฆแแฃแ แแฃแจแแแแแจแ. แแแแแแ แแ แแแแแแแ แแแ แแแ แแ แแก แชแแแแแแ, แกแฎแแแแ แแ แช แแกแ แแแแ แ, แแแแขแแ แกแขแแขแแ แแแแแแแแแแ แ แแแแ แช แแแแฌแงแแแแแแแแก, แแกแแแ แแแแแชแแแแ แแ แแแ แแแแกแขแแแแกแแแแก.
แจแแแแฎแกแแแแแ: Habr-แแก แงแแแแ แแแแแฎแแแแแกแแแแก - 10 แ แฃแแแแก แคแแกแแแแแแแ Skillbox-แแก แแแแแกแแแแ แแฃแ แกแแ Habr-แแก แกแแ แแแแแแ แแแแแก แแแแแงแแแแแแ แฉแแ แแชแฎแแแกแแก.
Skillbox แแแ แฉแแแ: แกแแแแแแแแแแแแแแ แแแแแแ แแฃแ แกแ .
แแจแ แแแ (แแ แแแแแแแ แ แกแแแฃแแแ แ แแแแ)
แกแแแแแแ แแแ แขแแแ แแ แแแชแแแ, แ แแแแแก แแ แกแ แแจแแแ แแ แกแแฎแแแแแแ: "แแฃ แแแแแแแ แแ แกแแแฃแแแ แแแแก". แแ แแแ แแแแกแขแแกแแแแก แแก แแแจแแแแก แแฃแแแแแแขแ แแแแแก แแแแแแแ แแชแแแแแแก แแฃแชแแแแแแแแแก, แแกแแแ แจแแกแแซแแแแแแแแก แแแแแแงแแแแก แแแกแขแ แแฅแชแแ แแแ แแฃแจแแแแแจแ.
แแฃ แแแแจแ แแ แ แแแแแแแ แแแแแ แแแแงแแคแแแแแแ, แแกแแแ แฃแแแ แแแแ แแแแแแแก แแ แ แแแแแแจแ. แแฃ แแงแแ แ แแแแแ แแแฃแแ แแแแจแแแแแแแ แแแแแแงแแแแแ แแ แแแ แแฎแแ, แฆแแ แก แแแกแ แแแแแแ แขแแชแแ แกแแฏแแ แ แแแแกแขแแแขแแ.
แแก แแฃแชแแแแแแแแ แแแแกแแแแแก, แ แแ แแแแแ แขแแแแแก แแแแ แแ แแแแแแแแแแก แแแกแ แจแแแแ แฉแฃแแแแ, แ แแช แแ แแก OOP-แแก แแแแแแ แ แแแแแแ. แแฅแแแ แแกแแแ แแ แฃแแแ แแแแแแงแแแแ แแแแจแแ แ แแแแแแขแแ, แ แแแแแ แแแแแ แแแแ แแแ แแแแแแแก แแแ แแคแแแแชแแแก แ แแแแ แช OrderId-แแ, แแกแแแ SSN-แแ.
แแแแแคแกแฃแแฃแ แ แชแแแแแแแแแ
แแแแแแแแแแแก แฃแแแขแแกแแแแก แแ แแแ แแแฃแแ แแ แแแฃแฅแขแแแ แแฃแแแแแแ แแแแแ แแแแ. แแก แแแจแแแแก, แ แแ แกแแญแแ แแ แชแแแแแแแแแแก แจแแขแแแ แแแแจแ, แกแแญแแ แแ แแแกแ แแฎแแ แแแญแแ แ. แแฅแแแ แจแแแแซแแแแ แแแแแแ แขแแแแ แแฅแแแแ แชแฎแแแ แแแ แแแแแคแกแฃแแแชแแแก แแแแแงแแแแแแ. แแก แกแแจแฃแแแแแแก แแแแชแแแ แฃแคแ แ แแคแแฅแขแฃแ แแ แจแแแแแฌแแแ แแ แจแแแแแฎแแ แแฅแแแแ แแ แกแแแฃแแ แแแแแก แแแแ. .
แฏแแแแจแ แแฃ แฌแแ , แแแจแแ .
แฆแแ/แแแฎแฃแ แฃแแ แแ แแแชแแแ
แแ แแ แแแชแแแแก แแแแแฎแกแแแ แแแ แจแแกแแซแแแแแแแ แจแแแแแแ แแแแชแฎแแแแแแก แฌแแแแแฎแแแ: โแแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแ แแแฃแแแแ (แแแแกแแแ, แแแแฃแแแแ, แคแฃแแฅแชแแแแ แแ แ.แจ.) แฆแแ แฃแแแ แแงแแก แแแคแแ แแแแแแกแแแแก, แแแแ แแ แแแฎแฃแ แฃแแ แแแแแคแแแแชแแแกแแแแกโ. แแ แแฅแขแแแแจแ, แแก แแแจแแแแก, แ แแ แแแ แจแแฃแซแแแแ แแแฃแจแแแ แแแแแแแแ แฅแชแแแแก แจแแชแแแ แฌแงแแ แแก แแแแแก แจแแชแแแแก แแแ แแจแ.
แแ แแแชแแแ แแแแจแแแแแแแแแแ, แ แแแแกแแช แกแแฌแงแแก แแแแจแ แชแแแแแแแแแ แแแแแฎแแแก แแแแแก แแแแแฎแแแแแก, แแ แแแฃแแแก แขแแกแขแแ แแแแก แแ แกแฎแแ แแ แแชแแแฃแ แแแก. แแแแ, แ แแแแแแช แแแฐแงแแแแ แฆแแ/แแแฎแฃแ แฃแ แแ แแแชแแแก, แแ แแชแแแแแ แแแคแแ แแแแแแกแแก, แแแแขแแ แแแกแจแ แแแชแแแแแแ แแแแแแแ แแ แแแแแแแ.
แแฅ แแแชแแแฃแแแ แแแแแก แแแแแแแแ, แ แแแแแแช แแ แฆแแแแก แแ แแ แแแชแแแก.
แแฃ แแแกแจแ แ แแฆแแชแแก แจแแชแแแ แแญแแ แแแแแ, แแแแก แแแแ แแ แ แแแกแญแแ แแแแ, แ แแแแแ แแแแแก แงแแแแ แแแแงแแคแแแแแ, แ แแแแแกแแช แแฅแแก แแแแจแแ แ แกแแกแฃแ แแแ แคแ แแแแแแขแแแ, แฃแแแ แจแแแชแแแแแก.
แกแฎแแแแ แจแแ แแก, แฆแแแแแ-แแแฎแฃแ แฃแแแแ SOLID-แแก แแ แ-แแ แแ แแ แแแชแแแแ.
แแ แแแแแ แแแกแฃแฎแแกแแแแแแแแแก แแ แแแชแแแ (SRP)
แแแแแ แแ แแ แแ แแแชแแแ SOLID แแแแ แแแแแแ. แแแกแจแ แแแแฅแแแแแ, แ แแ โแแ แกแแแแแก แแฎแแแแ แแ แแ แแแแแแ, แ แแแแแแช แแฌแแแแก แแแแกแแก แชแแแแแแแแกโ. แแแแกแ แฌแงแแแขแก แแฎแแแแ แแ แ แแ แแแแแแแก. แแแก แจแแแซแแแแ แฐแฅแแแแแก แ แแแแแแแแ แแแแแแ, แแแแ แแ แแแแแแฃแแ แแแแแแแ แแแแแแงแแแแแ แแฎแแแแ แกแแแ แแ แแ แแแแแแแก แแแแแกแแญแ แแแแ. แงแแแแ แแแแแแ แแ แแแแกแแแ แแฎแแแแ แแแแก แฃแแแ แแแกแแฎแฃแ แแแแแแก.
แแ แแ แแแชแแแแก แแแแจแแแแแแแ แแแแแแแ แแแแก แแแแจแ, แ แแ แแก แฎแกแแแก แแแฌแงแแแแแแแก แชแแแแแฃแ แแ แแแ แแแฃแ แแแแแแแแแขแกแ แแ แแแแก แจแแ แแก. แแฃ แแแแกแก แแ แแแ แแแข แคแฃแแฅแชแแแก แแแแแแขแแแ, แแก แฌแแ แแแแแแแแแ แฃแ แแแแ แแแแแก แแ แคแฃแแฅแชแแแก แจแแ แแก. แแแ แแแแ, แแฃ แแฅแแแ แจแแชแแแแ แแ แ-แแ แ แแแแแแแก, แแแแแ แจแแแกแ, แ แแ แแแแคแฃแญแแ แแแแ แ, แ แแแแแแช แแแแแแจแแ แแแฃแแแ แแแ แแแแแแ. แแ แแก แแแจแแแแก แขแแกแขแแ แแแแก แชแแแแแแแก แแแแ แแแก, แ แแแ แฌแแแแกแฌแแ แแแฎแแแก แงแแแแ แแ แแแแแแแก แแแแแขแแคแแชแแ แแแ.
แแแแแแแแแแฃแแแแแก แแแแแ แกแแแก แแ แแแชแแแ (DIP)
แแแแแ แแแชแแแฃแแแ แแแแแก แแแแแแแแ, แกแแแแช AppManager แแแแแแแแแแฃแแแ EventLogWriter-แแ, แ แแแแแแช แแแแแก แแฎแ แแ แแญแแแ แแ แแ แแก แแแแแแจแแ แแแฃแแ AppManager-แแแ. แแฃ แจแแขแงแแแแแแแแก แกแแฉแแแแแแแแ แกแฎแแ แแแ แแญแแ แแแแแ, แแฅแแแแ แแก push, SMS แแฃ แแแคแแกแขแ, แฃแแแ แจแแชแแแแแ AppManager แแแแกแ.
แแ แแแแแแแก แแแแแแ แแแ แจแแกแแซแแแแแแแ DIP-แแก แแแแแงแแแแแแ. แแกแ แ แแ, AppManager-แแก แแแชแแแแ, แแแแฎแแแ EventLogWriter, แ แแแแแแช แจแแแงแแแแแแ แคแ แแแแแ แแก แแแแแงแแแแแแ.
DIP แจแแกแแซแแแแแแก แฎแแแก แชแแแแแฃแแ แแแแฃแแแแแก แแแแแแแ แจแแชแแแแก แกแฎแแแแแ แแแแแแแแแแฃแแแแแก แแแแฃแแแก แจแแชแแแแ. แแก แจแแกแแซแแแแแแก แฎแแแก แแ แแ แแแแฃแแแก แจแแชแแแแก แกแฎแแแแแ แแแแแแแแก แแแ แแจแ.
แจแแแแแแแแแแแ แแแแแแแแ แแแแแก แแแชแแแแ
แแแแแก แฎแแแแฎแแ แแแแแงแแแแแแก แแ แ แซแแ แแแแแ แแแ แแ แกแแแแแก: แแแแแแแแ แแแแ แแ แแแแแแแแชแแ, แแ แแแแก แแฅแแก แแแแแกแ แแแแแแแแ แแ แฃแแ แงแแคแแแ แแฎแแ แแแแ. แ แแแแ แช แฌแแกแ, แแแแ แ แฃแแแ แแขแแกแแแแก แแแแญแแแแ, แ แแแแแ แแก แฃแคแ แ แแแฅแแแแแ.
แแแแแแแแชแแ แแแซแแแแ แจแแกแแซแแแแแแแแก แจแแชแแแแแ แแแแกแแก แฅแชแแแ แแแจแแแแแก แแ แแก แแแกแ แแแแกแแแแแแก แแแงแแแแแแ. แแแขแแ แคแแแกแแแแก แแแแแ แแแแกแแก แแแแแแงแแแแแ แแแแแแแ แคแแแแ, แ แแช แแซแแแแ แฃแคแ แ แแแฅแแแ แแแแฎแแ แชแแแแแแแก.
แฏแแจแฃแ แแแแฎแแก Effective Java-แกแแช แแ แแแแ แฉแแแก แแแแแแแแชแแแก แแ แฉแแแ แแแแแแแแ แแแแแ.
แแแ แแแ แ แแแกแแแแแก แฉแแแแชแแแแแแก แแ แแแชแแแ (LSP)
แแแแแ แแ แแ แแ แแแชแแแ SOLID แแแกแขแ แฃแแแแขแแ แแแแ แแแแแแ. แแแกแจแ แแแแฅแแแแแ, แ แแ แฅแแแขแแแแแ แฃแแแ แแงแแก แจแแกแแชแแแแแ แกแฃแแแ แขแแแแกแแแแก. แแแฃ แแแแแแแแกแ แแ แคแฃแแฅแชแแแแก, แ แแแแแแแช แแฃแจแแแแแ แกแฃแแแ แแแแกแแแ, แฃแแแ แจแแแซแแแ แแแฃแจแแแ แแ แแแแแแแแแก แแแ แแจแ แแแก แฅแแแแแแกแแแแแ.
LSP แแกแแชแแ แแแแ แ แแแแ แช แแ แแแแแ แแแกแฃแฎแแกแแแแแแแแแก แแ แแแชแแแแแ, แแกแแแ แกแแแแแ แ แแแกแฃแฎแแกแแแแแแแแแก แแ แแแชแแแแแ. แแฃ แแแแกแ แฃแแ แฃแแแแแงแแคแก แฃแคแ แ แแแข แคแฃแแฅแชแแแแแ แแแแก, แแแแ แ แฅแแแแแแกแ, แแแจแแ แแก แฃแแแแแกแแแแแ แแ แแแฃแญแแ แก แแฎแแ แก แแแแแแ แ แคแฃแแฅแชแแแก, แ แแช แแ แฆแแแแก แแ แแ แแแชแแแก.
แแฅ แแ แแก แแแแแก แแแฌแแแ, แ แแแแแแช แแฌแแแแแฆแแแแแแแ LSP-แก.
แคแแ แแแแ (Rectangle r) แแแแแแ แแแแแแก แแแ แแแฃแแฎแแแแก แคแแ แแแแก. แแ แแแ แแแ แฉแแแจแแแแ Square-แแก แจแแกแ แฃแแแแแก แจแแแแแ, แ แแแแแ แแแแแ แแขแ แแฅ แแ แแ แแก แแแ แแแฃแแฎแแแ. LSP แแ แแแชแแแแก แแแฎแแแแแ, แคแฃแแฅแชแแแแก, แ แแแแแแแช แแงแแแแแแ แแแแแแแแแแก แกแแแแแแกแ แแแแกแแแแ, แฃแแแ แจแแแซแแแ แแแแแแงแแแแ แแแฆแแแฃแแ แแแแกแแแแก แแแแแฅแขแแแ แแแแแขแแแแแ แแแกแขแ แฃแฅแชแแแแแก แแแ แแจแ.
แแก แแ แแแชแแแ, แ แแแแแแช แฌแแ แแแแแแแแก แฅแแแขแแแแก แกแแแชแแคแแแฃแ แแแแแแ แขแแแแก, แจแแแแแแแแแแแ แแแ แแแ แ แแแกแแแแแ 1987 แฌแแแก แแแแคแแ แแแชแแแก แแแแคแแ แแแชแแแแ แกแแแแฃแ แแ โแแแแแชแแแแ แแแกแขแ แแฅแชแแ แแ แแแ แแ แฅแแโ, แแฅแแแแ แแแแแแแแแแ แแแแก แแแกแ แกแแฎแแแ.
แแแขแแ แคแแแกแแก แแแงแแคแแก แแ แแแชแแแ (ISP)
แแแแแ แแ แแ แแงแแ แ แแ แแแชแแแ. แแแกแ แแฅแแแ, แแแขแแ แคแแแกแ, แ แแแแแแช แแ แแ แแก แแแแแงแแแแแฃแแ, แแ แฃแแแ แแแแฎแแ แชแแแแแแก. แแ แแ แแแชแแแแก แแแชแแ แแฎแแแ แแแ แกแแกแขแแแแก แแแ แฉแแก แแแฅแแแแ แแ แจแแกแแคแแ แแกแ แ แแคแแฅแขแแ แแชแแแกแแแแก, แ แแแแกแแช แชแแแแแแแแแ แฎแแแแ แแแแ แแชแแฃแ แแแแแแแจแ.
แงแแแแแแ แฎแจแแ แแ, แแก แกแแขแฃแแชแแ แฎแแแแ แแแจแแ, แ แแแแกแแช แแแขแแ แคแแแกแ แจแแแชแแแก แ แแแแแแแแ แคแฃแแฅแชแแแก แแ แแแ แแฃแแแ แแ แแแแแแขแก แกแญแแ แแแแ แแฎแแแแ แแ แแ แแแแแแแ.
แแแแก แแแแ, แ แแ แแแขแแ แคแแแกแแก แแแฌแแ แ แ แแฃแแ แแแแชแแแแ, แแแกแ แจแแชแแแ แกแแแฃแจแแแก แแแกแ แฃแแแแแก แจแแแแแ แแ แแคแ แแก แแแ แฆแแแแแก แแแ แแจแ แแฅแแแแ แแแแแฌแแแแ.
ISP แแ แแแชแแแแก แฃแแแ แแขแแกแแแ Java-แจแ แแ แแก แแก, แ แแ แงแแแแ แแแแแแ แฏแแ แฃแแแ แแแแฎแแ แชแแแแแแก แแ แแฎแแแแ แแแแก แจแแแแแ แจแแแซแแแแ แแแแ แแแแแงแแแแแ แแแแกแแแแก แแแแ . แแฅแแแแ แแแแแแแแแแ แ, แแ แแแชแแแ แจแแกแแซแแแแแแก แฎแแแก แแแแแแแแแก แ แแแแแแแแแก แจแแแชแแ แแแแก.
แแ แแแ แแแแ แแแ แแแขแแ แคแแแกแแกแแแแก แแ แแ แ แแแแฎแแ แชแแแแแแแกแแแแก
แแฅ แงแแแแแคแแ แ แแแกแแแแแแ แกแแฎแแแแแแ. แแ แแ แแแชแแแแก แแแแแงแแแแแ แแฌแแแแก แแแฅแแแแ แแแแแก แจแแฅแแแแก, แ แแแแแกแแช แจแแฃแซแแแ แแแฃแจแแแก แแแขแแ แคแแแกแแก แแแแแกแแแแ แแฎแแ แแแแฎแแ แชแแแแแแแกแแแ.
แแฅแแแ แฃแแแ แแแแแแงแแแแ แแแขแแ แคแแแกแแก แขแแแ แชแแแแแแแแก, แแแแ แฃแแแแแก แขแแแแแแกแแแแก แแ แแแแแแแก แแ แแฃแแแแขแแก แขแแแแกแแแแก. แแแแแแแแแ แแ แแก แกแฃแแแ แแแแกแแก แแแแแงแแแแแ แแ แแ แ แฅแแแแแแกแ.
แแแฃ:
แกแแแก แแแแ แแแ= getNumbers();
แแแแ แแ แแ แ:
ArrayList แแแแ แแแ = getNumbers();
แแฅ แแแชแแแฃแแแ แแแแแ แแแแฎแแแฃแแแก แแ แแฅแขแแแฃแแ แแแแฎแแ แชแแแแแแ.
แแแแแแแชแแแก แแ แแแชแแแ
แกแแแ แแ แแแแแแแแแ แฏแแแแจแ equals() แแ hashCode() แแแแแแแแ. แ แแแแกแแช แกแแญแแ แแ แแ แ แแแแแฅแขแแก แจแแแแ แแแ, แแก แแแฅแแแแแแ แแแแแแขแแก แแแชแแแแ แแแแแแชแแแ แจแแกแแแแแแก แแแแกแก.
แแ แแแชแแแแก แฃแแแ แแขแแกแแแ แแก แแ แแก, แ แแ แแแแแก แแฃแแแแ แแแ แแ แฎแแแแ แแ แฅแชแแแแก แจแแชแแแ แจแแแแ แแแแ แแแ แขแแแแ. แแก แแกแแแ แแฎแแแ แฆแแแแกแซแแแแแก แแแแแแแ แแแแก.
แงแแแแ แแก แแ แแแชแแแ แกแแจแฃแแแแแแก แแแซแแแแ แแแฌแแ แแ แฃแคแ แ แแแฅแแแแ, แแแแแแ แแ แกแแแแแแ แแแแ แแแฆแแแ แแแแแแแแแแ แแแแ แแ แแแแแแ แจแแแ แแแแแ. แ แ แแฅแแ แฃแแแ, แแแแ แแ แแแ แแแ, แแแแ แแ แแแแกแแแแก, แ แแ แแแแแแแแแ แแ แ แแแแฃแ แแ แแแแแแงแแแแก แแแฆแแแฃแแ แชแแแแ, แกแแญแแ แแ แแ แแฅแขแแแ. แแแก แจแแแแแ แ แแช แแแแแแกแแแ OOP แแ แแแชแแแแแก, แแฅแแแแ แจแแแแแแ แแแแแฏแ แจแแแซแแแแ แแงแแก แแแแแแแแก แจแแแแแแแแแก แกแฌแแแแ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแแแแ แแแแก แกแแแ แแ แแ แแแแแแแแแก แแแแแกแแญแ แแแแ.
Skillbox แแแ แฉแแแ:
- แแ แแฅแขแแแฃแแ แแฃแ แกแ .
- แแแแแ แแ แแแแแแ แแฃแ แกแก .
- แแ แฌแแแแแ แแ แแฅแขแแแฃแแ แแฃแ แกแ .
แฌแงแแ แ: www.habr.com