Master Dependency Inversion Principle -DSP (SOLID Principle with Java Code ) смотреть онлайн

In this video, we are going to look at the fifth entry in the famous SOLID principle. The Dependency Inversion Principle -DSP. We are going to dive into what it means, how it should change our programming practices, and how far we should take it.
Just Knowing how to program and type some code ... does not make you a good programmer. Anyone can learn to program. It’s easy. Anyone can create simple programs that work for them on their machines ..but hold on a minute is the program you are writing future proof
Can it be extended for future customer changes...well there is no point if you are just writing code with out thinking if the code is extensible and can be manageable.

Design phase of software application is an important phase in Software design life cycle or SDLC. There are quiet a few principles out there which helps you with Software design and one of the most important principle is SOLID principle. In object-oriented computer programming, SOLID is a acronym for five design principles intended to make software designs more understandable, flexible and maintainable Applying this Design principle in your day to day work will help you develop quality code and make you a better programmer

So in this course we will
1) We will do a deep dive into solid principles...for each principle we will look at its definition, symptoms of violation of design,
2) We will look at some sample applications with uml diagrams and scenarios
3) We Will look into and lots of code example which you can keep as reference can try it yourself ...and build on future projects… In these code examples we will look at a code without applying these principles. Look at pitfall and see how applying the principles makes the code more modular, manageable and flexible..To understand these principles better we will also look at how these principles can be related to real life analogies ..

SOLID Introduction
1. SOLID principles are the design principles that enable us manage most of the software design problems
2. The term SOLID is an acronym for five design principles intended to make software designs more understandable, flexible and maintainable
3. The principles are a subset of many principles promoted by Robert C. Martin
4. The SOLID acronym was first introduced by Michael Feathers


SOLID Acronym
S : Single Responsibility Principle (SRP)
O : Open closed Principle (OSP)
L : Liskov substitution Principle (LSP)
I : Interface Segregation Principle (ISP)
D : Dependency Inversion Principle (DIP)
Dependency Inversion Principle
1. One should “depend upon abstractions, [not] concretions"
2. Abstractions should not depend on the details whereas the details should depend on abstractions
3. High-level modules should not depend on low level modules

If we don’t follow SOLID Principles we
1. End up with tight or strong coupling of the code with many other modules/applications
2. Tight coupling causes time to implement any new requirement, features or any bug fixes and some times it creates unknown issues
3. End up with a code which is not testable
4. End up with duplication of code
5. End up creating new bugs by fixing another bug
6. End up with many unknown issues in the application development cycle

Following SOLID Principles helps us to
1. Achieve reduction in complexity of code
2. Increase readability, extensibility and maintenance
3. Reduce error and implement Reusability
4. Achieve Better testability
5. Reduce tight coupling