Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
SOLID Principles (using Java) with a Former Amazon Engineer
Rating: 4.0 out of 5(17 ratings)
318 students

SOLID Principles (using Java) with a Former Amazon Engineer

Master the 5 SOLID principles with code examples, pros and cons, and real-world examples.
Created byArjun Thakur
Last updated 1/2024
English
English [Auto],

What you'll learn

  • Master each SOLID principle (SRP, OCP, LSP, ISP, and DIP) and their significance in software design.
  • Learn how to refactor and optimize code in Java (you can use any other language) by applying SOLID principles, resulting in more maintainable and scalable code.
  • Evaluate the benefits of applying each SOLID principle using code examples and understand when and how to implement them.
  • Enhance the quality of software design and development by implementing SOLID principles, resulting in code that is easier to understand, modify, and extend.

Course content

7 sections • 9 lectures • 1h 12m total length

  • Introduction3:26

    Meet Arjun Thakur in this introduction to solid principles for Java, covering five principles—single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion—and applying them through hands-on coding.

Requirements

  • Understanding of fundamental OOP concepts (classes, objects, inheritance, interfaces etc.).
  • Ability to navigate and use Integrated Development Environments (IDEs) for Java, such as IntelliJ IDEA, Eclipse, or NetBeans.
  • Basic understanding of Java programming and syntax.
  • Access to a computer or laptop for programming.

Description

Learn the SOLID principles of object-oriented programming (OOP) from a former Amazon engineer. This course covers all five principles in detail, with live code examples, pros and cons.

The SOLID principles are:

  • Single Responsibility Principle (SRP): Each class should have a single responsibility, and that responsibility should be completely encapsulated by the class.

Live code example: You will see a live code example of a class that follows the SRP, and a live code example of a class that does not follow the SRP. You will also see the pros and cons of each approach.

  • Open/Closed Principle (OCP): Classes should be open for extension, but closed for modification. This means that you should be able to add new functionality to your code without having to modify existing code.

Live code example: You will see a live code example of a class that follows the OCP, and a live code example of a class that does not follow the OCP. You will also see the pros and cons of each approach.

  • Liskov Substitution Principle (LSP): Subtypes should be substitutable for their base types without breaking the program. This means that you should be able to use a subtype anywhere you would use a base type, without any unexpected behavior.

Live code example: You will see a live code example of a class that follows the LSP, and a live code example of a class that does not follow the LSP. You will also see the pros and cons of each approach.

  • Interface Segregation Principle (ISP): Interfaces should be small and specific, so that they can be easily reused and combined.

Live code example: You will see a live code example of an interface that follows the ISP, and a live code example of an interface that does not follow the ISP. You will also see the pros and cons of each approach.

  • Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules. Both should depend on abstractions. This makes your code more decoupled and easier to test and maintain.

Live code example: You will see a live code example of a class that follows the DIP, and a live code example of a class that does not follow the DIP. You will also see the pros and cons of each approach.


Who this course is for:

  • This course is designed for individuals with varying levels of experience in Java programming and software development who are eager to enhance their understanding and application of SOLID principles. The intended learners for this course include:
  • Java Developers: Professionals already working with Java or individuals aspiring to become proficient in Java development will find immense value in understanding how to structure their code according to SOLID principles for improved maintainability and scalability.
  • Software Engineers/Developers: Those looking to elevate their software design skills and produce high-quality, robust code will benefit from learning how SOLID principles can guide them towards creating more maintainable and extensible software solutions.
  • Computer Science Students: Students studying computer science, software engineering, or related fields will find this course highly beneficial in supplementing their academic knowledge with practical insights into applying SOLID principles in real-world Java projects.
  • Technical Enthusiasts and Hobbyists: Individuals passionate about programming and eager to optimize their coding practices will gain valuable insights into SOLID principles, enabling them to write cleaner, more efficient code regardless of their level of professional experience.

Report abuse